1 /* $NetBSD: ofw_subr.c,v 1.13 2007/11/07 19:26:45 garbled Exp $ */ 2 3 /* 4 * Copyright 1998 5 * Digital Equipment Corporation. All rights reserved. 6 * 7 * This software is furnished under license and may be used and 8 * copied only in accordance with the following terms and conditions. 9 * Subject to these conditions, you may download, copy, install, 10 * use, modify and distribute this software in source and/or binary 11 * form. No title or ownership is transferred hereby. 12 * 13 * 1) Any source code used, modified or distributed must reproduce 14 * and retain this copyright notice and list of conditions as 15 * they appear in the source file. 16 * 17 * 2) No right is granted to use any trade name, trademark, or logo of 18 * Digital Equipment Corporation. Neither the "Digital Equipment 19 * Corporation" name nor any trademark or logo of Digital Equipment 20 * Corporation may be used to endorse or promote products derived 21 * from this software without the prior written permission of 22 * Digital Equipment Corporation. 23 * 24 * 3) This software is provided "AS-IS" and any express or implied 25 * warranties, including but not limited to, any implied warranties 26 * of merchantability, fitness for a particular purpose, or 27 * non-infringement are disclaimed. In no event shall DIGITAL be 28 * liable for any damages whatsoever, and in particular, DIGITAL 29 * shall not be liable for special, indirect, consequential, or 30 * incidental damages or damages for lost profits, loss of 31 * revenue or loss of use, whether such damages arise in contract, 32 * negligence, tort, under statute, in equity, at law or otherwise, 33 * even if advised of the possibility of such damage. 34 */ 35 36 #include <sys/cdefs.h> 37 __KERNEL_RCSID(0, "$NetBSD: ofw_subr.c,v 1.13 2007/11/07 19:26:45 garbled Exp $"); 38 39 #include <sys/param.h> 40 #include <sys/systm.h> 41 #include <sys/malloc.h> 42 #include <dev/ofw/openfirm.h> 43 44 #define OFW_MAX_STACK_BUF_SIZE 256 45 #define OFW_PATH_BUF_SIZE 512 46 47 /* 48 * int of_decode_int(p) 49 * 50 * This routine converts OFW encoded-int datums 51 * into the integer format of the host machine. 52 * 53 * It is primarily used to convert integer properties 54 * returned by the OF_getprop routine. 55 * 56 * Arguments: 57 * p pointer to unsigned char array which is an 58 * OFW-encoded integer. 59 * 60 * Return Value: 61 * Decoded integer value of argument p. 62 * 63 * Side Effects: 64 * None. 65 */ 66 int 67 of_decode_int(p) 68 const unsigned char *p; 69 { 70 unsigned int i = *p++ << 8; 71 i = (i + *p++) << 8; 72 i = (i + *p++) << 8; 73 return (i + *p); 74 } 75 76 /* 77 * int of_compatible(phandle, strings) 78 * 79 * This routine checks an OFW node's "compatible" entry to see if 80 * it matches any of the provided strings. 81 * 82 * It should be used when determining whether a driver can drive 83 * a partcular device. 84 * 85 * Arguments: 86 * phandle OFW phandle of device to be checked for 87 * compatibility. 88 * strings Array of containing expected "compatibility" 89 * property values, presence of any of which 90 * indicates compatibility. 91 * 92 * Return Value: 93 * -1 if none of the strings are found in phandle's "compatibility" 94 * property, or the index of the string in "strings" of the first 95 * string found in phandle's "compatibility" property. 96 * 97 * Side Effects: 98 * None. 99 */ 100 int 101 of_compatible(int phandle, const char * const *strings) 102 { 103 int len, allocated, rv; 104 char *buf; 105 const char *sp, *nsp; 106 107 len = OF_getproplen(phandle, "compatible"); 108 if (len <= 0) 109 return (-1); 110 111 if (len > OFW_MAX_STACK_BUF_SIZE) { 112 buf = malloc(len, M_TEMP, M_WAITOK); 113 allocated = 1; 114 } else { 115 buf = alloca(len); 116 allocated = 0; 117 } 118 119 /* 'compatible' size should not change. */ 120 if (OF_getprop(phandle, "compatible", buf, len) != len) { 121 rv = -1; 122 goto out; 123 } 124 125 sp = buf; 126 while (len && (nsp = memchr(sp, 0, len)) != NULL) { 127 /* look for a match among the strings provided */ 128 for (rv = 0; strings[rv] != NULL; rv++) 129 if (strcmp(sp, strings[rv]) == 0) 130 goto out; 131 132 nsp++; /* skip over NUL char */ 133 len -= (nsp - sp); 134 sp = nsp; 135 } 136 rv = -1; 137 138 out: 139 if (allocated) 140 free(buf, M_TEMP); 141 return (rv); 142 143 } 144 145 /* 146 * int of_packagename(phandle, buf, bufsize) 147 * 148 * This routine places the last component of an OFW node's name 149 * into a user-provided buffer. 150 * 151 * It can be used during autoconfiguration to make printing of 152 * device names more informative. 153 * 154 * Arguments: 155 * phandle OFW phandle of device whose name name is 156 * desired. 157 * buf Buffer to contain device name, provided by 158 * caller. (For now, must be at least 4 159 * bytes long.) 160 * bufsize Length of buffer referenced by 'buf', in 161 * bytes. 162 * 163 * Return Value: 164 * -1 if the device path name could not be obtained or would 165 * not fit in the allocated temporary buffer, or zero otherwise 166 * (meaning that the leaf node name was successfully extracted). 167 * 168 * Side Effects: 169 * If the leaf node name was successfully extracted, 'buf' is 170 * filled in with at most 'bufsize' bytes of the leaf node 171 * name. If the leaf node was not successfully extracted, a 172 * somewhat meaningful string is placed in the buffer. In 173 * either case, the contents of 'buf' will be NUL-terminated. 174 */ 175 int 176 of_packagename(int phandle, char *buf, int bufsize) 177 { 178 char *pbuf; 179 const char *lastslash; 180 int l, rv; 181 182 pbuf = malloc(OFW_PATH_BUF_SIZE, M_TEMP, M_WAITOK); 183 l = OF_package_to_path(phandle, pbuf, OFW_PATH_BUF_SIZE); 184 185 /* check that we could get the name, and that it's not too long. */ 186 if (l < 0 || 187 (l == OFW_PATH_BUF_SIZE && pbuf[OFW_PATH_BUF_SIZE - 1] != '\0')) { 188 if (bufsize >= 25) 189 snprintf(buf, bufsize, "??? (phandle 0x%x)", phandle); 190 else if (bufsize >= 4) 191 strlcpy(buf, "???", bufsize); 192 else 193 panic("of_packagename: bufsize = %d is silly", 194 bufsize); 195 rv = -1; 196 } else { 197 pbuf[l] = '\0'; 198 lastslash = strrchr(pbuf, '/'); 199 strlcpy(buf, (lastslash == NULL) ? pbuf : (lastslash + 1), 200 bufsize); 201 rv = 0; 202 } 203 204 free(pbuf, M_TEMP); 205 return (rv); 206 } 207 208 /* 209 * Find the first child of a given node that matches name. Does not recurse. 210 */ 211 int 212 of_find_firstchild_byname(int node, const char *name) 213 { 214 char namex[32]; 215 int nn; 216 217 for (nn = OF_child(node); nn; nn = OF_peer(nn)) { 218 memset(namex, 0, sizeof(namex)); 219 if (OF_getprop(nn, "name", namex, sizeof(namex)) == -1) 220 continue; 221 if (strcmp(name, namex) == 0) 222 return nn; 223 } 224 return -1; 225 } 226 227 /* 228 * Find a give node by name. Recurses, and seems to walk upwards too. 229 */ 230 231 int 232 of_getnode_byname(int start, const char *target) 233 { 234 int node, next; 235 char name[64]; 236 237 if (start == 0) 238 start = OF_peer(0); 239 240 for (node = start; node; node = next) { 241 memset(name, 0, sizeof name); 242 OF_getprop(node, "name", name, sizeof name - 1); 243 if (strcmp(name, target) == 0) 244 break; 245 246 if ((next = OF_child(node)) != 0) 247 continue; 248 249 while (node) { 250 if ((next = OF_peer(node)) != 0) 251 break; 252 node = OF_parent(node); 253 } 254 } 255 256 /* XXX is this correct? */ 257 return node; 258 } 259 260 /* 261 * Create a uint32_t integer property from an OFW node property. 262 */ 263 264 boolean_t 265 of_to_uint32_prop(prop_dictionary_t dict, int node, const char *ofname, 266 const char *propname) 267 { 268 uint32_t prop; 269 270 if (OF_getprop(node, ofname, &prop, sizeof(prop)) != sizeof(prop)) 271 return FALSE; 272 273 return(prop_dictionary_set_uint32(dict, propname, prop)); 274 } 275 276 /* 277 * Create a data property from an OFW node property. Max size of 256bytes. 278 */ 279 280 boolean_t 281 of_to_dataprop(prop_dictionary_t dict, int node, const char *ofname, 282 const char *propname) 283 { 284 prop_data_t data; 285 int len; 286 uint8_t prop[256]; 287 288 len = OF_getprop(node, ofname, prop, 256); 289 if (len < 1) 290 return FALSE; 291 292 data = prop_data_create_data(prop, len); 293 return(prop_dictionary_set(dict, propname, data)); 294 } 295