1 /*- 2 * Copyright (c) 2009-2010 The FreeBSD Foundation 3 * All rights reserved. 4 * 5 * This software was developed by Semihalf under sponsorship from 6 * the FreeBSD Foundation. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 */ 29 30 #include <sys/cdefs.h> 31 __FBSDID("$FreeBSD$"); 32 33 #include <sys/param.h> 34 #include <sys/kernel.h> 35 #include <sys/malloc.h> 36 #include <sys/systm.h> 37 38 #include <contrib/libfdt/libfdt.h> 39 40 #include <machine/stdarg.h> 41 42 #include <dev/fdt/fdt_common.h> 43 #include <dev/ofw/ofwvar.h> 44 #include <dev/ofw/openfirm.h> 45 46 #include "ofw_if.h" 47 48 #ifdef DEBUG 49 #define debugf(fmt, args...) do { printf("%s(): ", __func__); \ 50 printf(fmt,##args); } while (0) 51 #else 52 #define debugf(fmt, args...) 53 #endif 54 55 static int ofw_fdt_init(ofw_t, void *); 56 static phandle_t ofw_fdt_peer(ofw_t, phandle_t); 57 static phandle_t ofw_fdt_child(ofw_t, phandle_t); 58 static phandle_t ofw_fdt_parent(ofw_t, phandle_t); 59 static phandle_t ofw_fdt_instance_to_package(ofw_t, ihandle_t); 60 static ssize_t ofw_fdt_getproplen(ofw_t, phandle_t, const char *); 61 static ssize_t ofw_fdt_getprop(ofw_t, phandle_t, const char *, void *, size_t); 62 static int ofw_fdt_nextprop(ofw_t, phandle_t, const char *, char *, size_t); 63 static int ofw_fdt_setprop(ofw_t, phandle_t, const char *, const void *, 64 size_t); 65 static ssize_t ofw_fdt_canon(ofw_t, const char *, char *, size_t); 66 static phandle_t ofw_fdt_finddevice(ofw_t, const char *); 67 static ssize_t ofw_fdt_instance_to_path(ofw_t, ihandle_t, char *, size_t); 68 static ssize_t ofw_fdt_package_to_path(ofw_t, phandle_t, char *, size_t); 69 static int ofw_fdt_interpret(ofw_t, const char *, int, cell_t *); 70 71 static ofw_method_t ofw_fdt_methods[] = { 72 OFWMETHOD(ofw_init, ofw_fdt_init), 73 OFWMETHOD(ofw_peer, ofw_fdt_peer), 74 OFWMETHOD(ofw_child, ofw_fdt_child), 75 OFWMETHOD(ofw_parent, ofw_fdt_parent), 76 OFWMETHOD(ofw_instance_to_package, ofw_fdt_instance_to_package), 77 OFWMETHOD(ofw_getproplen, ofw_fdt_getproplen), 78 OFWMETHOD(ofw_getprop, ofw_fdt_getprop), 79 OFWMETHOD(ofw_nextprop, ofw_fdt_nextprop), 80 OFWMETHOD(ofw_setprop, ofw_fdt_setprop), 81 OFWMETHOD(ofw_canon, ofw_fdt_canon), 82 OFWMETHOD(ofw_finddevice, ofw_fdt_finddevice), 83 OFWMETHOD(ofw_instance_to_path, ofw_fdt_instance_to_path), 84 OFWMETHOD(ofw_package_to_path, ofw_fdt_package_to_path), 85 OFWMETHOD(ofw_interpret, ofw_fdt_interpret), 86 { 0, 0 } 87 }; 88 89 static ofw_def_t ofw_fdt = { 90 OFW_FDT, 91 ofw_fdt_methods, 92 0 93 }; 94 OFW_DEF(ofw_fdt); 95 96 static void *fdtp = NULL; 97 98 static int 99 ofw_fdt_init(ofw_t ofw, void *data) 100 { 101 int err; 102 103 /* Check FDT blob integrity */ 104 if ((err = fdt_check_header(data)) != 0) 105 return (err); 106 107 fdtp = data; 108 return (0); 109 } 110 111 /* 112 * Device tree functions. 113 * 114 * We use the offset from fdtp to the node as the 'phandle' in OF interface. 115 * 116 * phandle is a u32 value, therefore we cannot use the pointer to node as 117 * phandle in 64 bit. We also do not use the usual fdt offset as phandle, 118 * as it can be 0, and the OF interface has special meaning for phandle 0. 119 */ 120 121 static phandle_t 122 fdt_offset_phandle(int offset) 123 { 124 if (offset < 0) 125 return (0); 126 return ((phandle_t)offset + fdt_off_dt_struct(fdtp)); 127 } 128 129 static int 130 fdt_phandle_offset(phandle_t p) 131 { 132 int pint = (int)p; 133 int dtoff = fdt_off_dt_struct(fdtp); 134 135 if (pint < dtoff) 136 return (-1); 137 return (pint - dtoff); 138 } 139 140 /* Return the next sibling of this node or 0. */ 141 static phandle_t 142 ofw_fdt_peer(ofw_t ofw, phandle_t node) 143 { 144 int depth, offset; 145 146 if (node == 0) { 147 /* Find root node */ 148 offset = fdt_path_offset(fdtp, "/"); 149 150 return (fdt_offset_phandle(offset)); 151 } 152 153 offset = fdt_phandle_offset(node); 154 if (offset < 0) 155 return (0); 156 157 for (depth = 1, offset = fdt_next_node(fdtp, offset, &depth); 158 offset >= 0; 159 offset = fdt_next_node(fdtp, offset, &depth)) { 160 if (depth < 0) 161 return (0); 162 if (depth == 1) 163 return (fdt_offset_phandle(offset)); 164 } 165 166 return (0); 167 } 168 169 /* Return the first child of this node or 0. */ 170 static phandle_t 171 ofw_fdt_child(ofw_t ofw, phandle_t node) 172 { 173 int depth, offset; 174 175 offset = fdt_phandle_offset(node); 176 if (offset < 0) 177 return (0); 178 179 for (depth = 0, offset = fdt_next_node(fdtp, offset, &depth); 180 (offset >= 0) && (depth > 0); 181 offset = fdt_next_node(fdtp, offset, &depth)) { 182 if (depth < 0) 183 return (0); 184 if (depth == 1) 185 return (fdt_offset_phandle(offset)); 186 } 187 188 return (0); 189 } 190 191 /* Return the parent of this node or 0. */ 192 static phandle_t 193 ofw_fdt_parent(ofw_t ofw, phandle_t node) 194 { 195 int offset, paroffset; 196 197 offset = fdt_phandle_offset(node); 198 if (offset < 0) 199 return (0); 200 201 paroffset = fdt_parent_offset(fdtp, offset); 202 return (fdt_offset_phandle(paroffset)); 203 } 204 205 /* Return the package handle that corresponds to an instance handle. */ 206 static phandle_t 207 ofw_fdt_instance_to_package(ofw_t ofw, ihandle_t instance) 208 { 209 210 /* Where real OF uses ihandles in the tree, FDT uses xref phandles */ 211 return (OF_node_from_xref(instance)); 212 } 213 214 /* Get the length of a property of a package. */ 215 static ssize_t 216 ofw_fdt_getproplen(ofw_t ofw, phandle_t package, const char *propname) 217 { 218 const struct fdt_property *prop; 219 int offset, len; 220 221 offset = fdt_phandle_offset(package); 222 if (offset < 0) 223 return (-1); 224 225 len = -1; 226 prop = fdt_get_property(fdtp, offset, propname, &len); 227 228 if (prop == NULL && strcmp(propname, "name") == 0) { 229 /* Emulate the 'name' property */ 230 fdt_get_name(fdtp, offset, &len); 231 return (len + 1); 232 } 233 234 if (prop == NULL && offset == fdt_path_offset(fdtp, "/chosen")) { 235 if (strcmp(propname, "fdtbootcpu") == 0) 236 return (sizeof(cell_t)); 237 if (strcmp(propname, "fdtmemreserv") == 0) 238 return (sizeof(uint64_t)*2*fdt_num_mem_rsv(fdtp)); 239 } 240 241 return (len); 242 } 243 244 /* Get the value of a property of a package. */ 245 static ssize_t 246 ofw_fdt_getprop(ofw_t ofw, phandle_t package, const char *propname, void *buf, 247 size_t buflen) 248 { 249 const void *prop; 250 const char *name; 251 int len, offset; 252 uint32_t cpuid; 253 254 offset = fdt_phandle_offset(package); 255 if (offset < 0) 256 return (-1); 257 258 prop = fdt_getprop(fdtp, offset, propname, &len); 259 260 if (prop == NULL && strcmp(propname, "name") == 0) { 261 /* Emulate the 'name' property */ 262 name = fdt_get_name(fdtp, offset, &len); 263 strncpy(buf, name, buflen); 264 if (len + 1 > buflen) 265 len = buflen; 266 return (len + 1); 267 } 268 269 if (prop == NULL && offset == fdt_path_offset(fdtp, "/chosen")) { 270 if (strcmp(propname, "fdtbootcpu") == 0) { 271 cpuid = cpu_to_fdt32(fdt_boot_cpuid_phys(fdtp)); 272 len = sizeof(cpuid); 273 prop = &cpuid; 274 } 275 if (strcmp(propname, "fdtmemreserv") == 0) { 276 prop = (char *)fdtp + fdt_off_mem_rsvmap(fdtp); 277 len = sizeof(uint64_t)*2*fdt_num_mem_rsv(fdtp); 278 } 279 } 280 281 if (prop == NULL) 282 return (-1); 283 284 if (len > buflen) 285 len = buflen; 286 bcopy(prop, buf, len); 287 return (len); 288 } 289 290 /* 291 * Get the next property of a package. Return values: 292 * -1: package or previous property does not exist 293 * 0: no more properties 294 * 1: success 295 */ 296 static int 297 ofw_fdt_nextprop(ofw_t ofw, phandle_t package, const char *previous, char *buf, 298 size_t size) 299 { 300 const struct fdt_property *prop; 301 const char *name; 302 int offset; 303 304 offset = fdt_phandle_offset(package); 305 if (offset < 0) 306 return (-1); 307 308 /* Find the first prop in the node */ 309 offset = fdt_first_property_offset(fdtp, offset); 310 if (offset < 0) 311 return (0); /* No properties */ 312 313 if (previous != NULL) { 314 while (offset >= 0) { 315 prop = fdt_get_property_by_offset(fdtp, offset, NULL); 316 if (prop == NULL) 317 return (-1); /* Internal error */ 318 319 offset = fdt_next_property_offset(fdtp, offset); 320 if (offset < 0) 321 return (0); /* No more properties */ 322 323 /* Check if the last one was the one we wanted */ 324 name = fdt_string(fdtp, fdt32_to_cpu(prop->nameoff)); 325 if (strcmp(name, previous) == 0) 326 break; 327 } 328 } 329 330 prop = fdt_get_property_by_offset(fdtp, offset, &offset); 331 if (prop == NULL) 332 return (-1); /* Internal error */ 333 334 strncpy(buf, fdt_string(fdtp, fdt32_to_cpu(prop->nameoff)), size); 335 336 return (1); 337 } 338 339 /* Set the value of a property of a package. */ 340 static int 341 ofw_fdt_setprop(ofw_t ofw, phandle_t package, const char *propname, 342 const void *buf, size_t len) 343 { 344 int offset; 345 346 offset = fdt_phandle_offset(package); 347 if (offset < 0) 348 return (-1); 349 350 return (fdt_setprop_inplace(fdtp, offset, propname, buf, len)); 351 } 352 353 /* Convert a device specifier to a fully qualified pathname. */ 354 static ssize_t 355 ofw_fdt_canon(ofw_t ofw, const char *device, char *buf, size_t len) 356 { 357 358 return (-1); 359 } 360 361 /* Return a package handle for the specified device. */ 362 static phandle_t 363 ofw_fdt_finddevice(ofw_t ofw, const char *device) 364 { 365 int offset; 366 367 offset = fdt_path_offset(fdtp, device); 368 if (offset < 0) 369 return (-1); 370 return (fdt_offset_phandle(offset)); 371 } 372 373 /* Return the fully qualified pathname corresponding to an instance. */ 374 static ssize_t 375 ofw_fdt_instance_to_path(ofw_t ofw, ihandle_t instance, char *buf, size_t len) 376 { 377 phandle_t phandle; 378 379 phandle = OF_instance_to_package(instance); 380 if (phandle == -1) 381 return (-1); 382 383 return (OF_package_to_path(phandle, buf, len)); 384 } 385 386 /* Return the fully qualified pathname corresponding to a package. */ 387 static ssize_t 388 ofw_fdt_package_to_path(ofw_t ofw, phandle_t package, char *buf, size_t len) 389 { 390 391 return (-1); 392 } 393 394 static int 395 ofw_fdt_fixup(ofw_t ofw) 396 { 397 #define FDT_MODEL_LEN 80 398 char model[FDT_MODEL_LEN]; 399 phandle_t root; 400 ssize_t len; 401 int i; 402 403 if ((root = ofw_fdt_finddevice(ofw, "/")) == -1) 404 return (ENODEV); 405 406 if ((len = ofw_fdt_getproplen(ofw, root, "model")) <= 0) 407 return (0); 408 409 bzero(model, FDT_MODEL_LEN); 410 if (ofw_fdt_getprop(ofw, root, "model", model, FDT_MODEL_LEN) <= 0) 411 return (0); 412 413 /* 414 * Search fixup table and call handler if appropriate. 415 */ 416 for (i = 0; fdt_fixup_table[i].model != NULL; i++) { 417 if (strncmp(model, fdt_fixup_table[i].model, 418 FDT_MODEL_LEN) != 0) 419 continue; 420 421 if (fdt_fixup_table[i].handler != NULL) 422 (*fdt_fixup_table[i].handler)(root); 423 } 424 425 return (0); 426 } 427 428 static int 429 ofw_fdt_interpret(ofw_t ofw, const char *cmd, int nret, cell_t *retvals) 430 { 431 int rv; 432 433 /* 434 * Note: FDT does not have the possibility to 'interpret' commands, 435 * but we abuse the interface a bit to use it for doing non-standard 436 * operations on the device tree blob. 437 * 438 * Currently the only supported 'command' is to trigger performing 439 * fixups. 440 */ 441 if (strncmp("perform-fixup", cmd, 13) != 0) 442 return (0); 443 444 rv = ofw_fdt_fixup(ofw); 445 if (nret > 0) 446 retvals[0] = rv; 447 448 return (rv); 449 } 450