ofw_fdt.c revision 265959
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: stable/10/sys/dev/ofw/ofw_fdt.c 265959 2014-05-13 17:12:07Z ian $"); 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 55static int ofw_fdt_init(ofw_t, void *); 56static phandle_t ofw_fdt_peer(ofw_t, phandle_t); 57static phandle_t ofw_fdt_child(ofw_t, phandle_t); 58static phandle_t ofw_fdt_parent(ofw_t, phandle_t); 59static phandle_t ofw_fdt_instance_to_package(ofw_t, ihandle_t); 60static ssize_t ofw_fdt_getproplen(ofw_t, phandle_t, const char *); 61static ssize_t ofw_fdt_getprop(ofw_t, phandle_t, const char *, void *, size_t); 62static int ofw_fdt_nextprop(ofw_t, phandle_t, const char *, char *, size_t); 63static int ofw_fdt_setprop(ofw_t, phandle_t, const char *, const void *, 64 size_t); 65static ssize_t ofw_fdt_canon(ofw_t, const char *, char *, size_t); 66static phandle_t ofw_fdt_finddevice(ofw_t, const char *); 67static ssize_t ofw_fdt_instance_to_path(ofw_t, ihandle_t, char *, size_t); 68static ssize_t ofw_fdt_package_to_path(ofw_t, phandle_t, char *, size_t); 69static int ofw_fdt_interpret(ofw_t, const char *, int, cell_t *); 70 71static 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 89static ofw_def_t ofw_fdt = { 90 OFW_FDT, 91 ofw_fdt_methods, 92 0 93}; 94OFW_DEF(ofw_fdt); 95 96static void *fdtp = NULL; 97 98static int 99ofw_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 121static phandle_t 122fdt_offset_phandle(int offset) 123{ 124 if (offset < 0) 125 return (0); 126 return ((phandle_t)offset + fdt_off_dt_struct(fdtp)); 127} 128 129static int 130fdt_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 140static int 141fdt_pointer_offset(const void *ptr) 142{ 143 uintptr_t dt_struct, p; 144 int offset; 145 146 p = (uintptr_t)ptr; 147 dt_struct = (uintptr_t)fdtp + fdt_off_dt_struct(fdtp); 148 149 if ((p < dt_struct) || 150 p > (dt_struct + fdt_size_dt_struct(fdtp))) 151 return (-1); 152 153 offset = p - dt_struct; 154 if (offset < 0) 155 return (-1); 156 157 return (offset); 158} 159 160/* Return the next sibling of this node or 0. */ 161static phandle_t 162ofw_fdt_peer(ofw_t ofw, phandle_t node) 163{ 164 int depth, offset; 165 166 if (node == 0) { 167 /* Find root node */ 168 offset = fdt_path_offset(fdtp, "/"); 169 170 return (fdt_offset_phandle(offset)); 171 } 172 173 offset = fdt_phandle_offset(node); 174 if (offset < 0) 175 return (0); 176 177 for (depth = 1, offset = fdt_next_node(fdtp, offset, &depth); 178 offset >= 0; 179 offset = fdt_next_node(fdtp, offset, &depth)) { 180 if (depth < 0) 181 return (0); 182 if (depth == 1) 183 return (fdt_offset_phandle(offset)); 184 } 185 186 return (0); 187} 188 189/* Return the first child of this node or 0. */ 190static phandle_t 191ofw_fdt_child(ofw_t ofw, phandle_t node) 192{ 193 int depth, offset; 194 195 offset = fdt_phandle_offset(node); 196 if (offset < 0) 197 return (0); 198 199 for (depth = 0, offset = fdt_next_node(fdtp, offset, &depth); 200 (offset >= 0) && (depth > 0); 201 offset = fdt_next_node(fdtp, offset, &depth)) { 202 if (depth < 0) 203 return (0); 204 if (depth == 1) 205 return (fdt_offset_phandle(offset)); 206 } 207 208 return (0); 209} 210 211/* Return the parent of this node or 0. */ 212static phandle_t 213ofw_fdt_parent(ofw_t ofw, phandle_t node) 214{ 215 int offset, paroffset; 216 217 offset = fdt_phandle_offset(node); 218 if (offset < 0) 219 return (0); 220 221 paroffset = fdt_parent_offset(fdtp, offset); 222 return (fdt_offset_phandle(paroffset)); 223} 224 225/* Return the package handle that corresponds to an instance handle. */ 226static phandle_t 227ofw_fdt_instance_to_package(ofw_t ofw, ihandle_t instance) 228{ 229 int offset; 230 231 /* 232 * Note: FDT does not have the notion of instances, but we somewhat 233 * abuse the semantics and let treat as 'instance' the internal 234 * 'phandle' prop, so that ofw I/F consumers have a uniform way of 235 * translation between internal representation (which appear in some 236 * contexts as property values) and effective phandles. 237 */ 238 offset = fdt_node_offset_by_phandle(fdtp, instance); 239 if (offset < 0) 240 return (-1); 241 242 return (fdt_offset_phandle(offset)); 243} 244 245/* Get the length of a property of a package. */ 246static ssize_t 247ofw_fdt_getproplen(ofw_t ofw, phandle_t package, const char *propname) 248{ 249 const struct fdt_property *prop; 250 int offset, len; 251 252 offset = fdt_phandle_offset(package); 253 if (offset < 0) 254 return (-1); 255 256 if (strcmp(propname, "name") == 0) { 257 /* Emulate the 'name' property */ 258 fdt_get_name(fdtp, offset, &len); 259 return (len + 1); 260 } 261 262 len = -1; 263 prop = fdt_get_property(fdtp, offset, propname, &len); 264 265 return (len); 266} 267 268/* Get the value of a property of a package. */ 269static ssize_t 270ofw_fdt_getprop(ofw_t ofw, phandle_t package, const char *propname, void *buf, 271 size_t buflen) 272{ 273 const void *prop; 274 const char *name; 275 int len, offset; 276 277 offset = fdt_phandle_offset(package); 278 if (offset < 0) 279 return (-1); 280 281 if (strcmp(propname, "name") == 0) { 282 /* Emulate the 'name' property */ 283 name = fdt_get_name(fdtp, offset, &len); 284 strncpy(buf, name, buflen); 285 if (len + 1 > buflen) 286 len = buflen; 287 return (len + 1); 288 } 289 290 prop = fdt_getprop(fdtp, offset, propname, &len); 291 if (prop == NULL) 292 return (-1); 293 294 if (len > buflen) 295 len = buflen; 296 bcopy(prop, buf, len); 297 return (len); 298} 299 300static int 301fdt_nextprop(int offset, char *buf, size_t size) 302{ 303 const struct fdt_property *prop; 304 const char *name; 305 uint32_t tag; 306 int nextoffset, depth; 307 308 depth = 0; 309 tag = fdt_next_tag(fdtp, offset, &nextoffset); 310 311 /* Find the next prop */ 312 do { 313 offset = nextoffset; 314 tag = fdt_next_tag(fdtp, offset, &nextoffset); 315 316 if (tag == FDT_BEGIN_NODE) 317 depth++; 318 else if (tag == FDT_END_NODE) 319 depth--; 320 else if ((tag == FDT_PROP) && (depth == 0)) { 321 prop = 322 (const struct fdt_property *)fdt_offset_ptr(fdtp, 323 offset, sizeof(*prop)); 324 name = fdt_string(fdtp, 325 fdt32_to_cpu(prop->nameoff)); 326 strncpy(buf, name, size); 327 return (strlen(name)); 328 } else 329 depth = -1; 330 } while (depth >= 0); 331 332 return (0); 333} 334 335/* 336 * Get the next property of a package. Return the actual len of retrieved 337 * prop name. 338 */ 339static int 340ofw_fdt_nextprop(ofw_t ofw, phandle_t package, const char *previous, char *buf, 341 size_t size) 342{ 343 const struct fdt_property *prop; 344 int offset, rv; 345 346 offset = fdt_phandle_offset(package); 347 if (offset < 0) 348 return (-1); 349 350 if (previous == NULL) 351 /* Find the first prop in the node */ 352 return (fdt_nextprop(offset, buf, size)); 353 354 /* 355 * Advance to the previous prop 356 */ 357 prop = fdt_get_property(fdtp, offset, previous, NULL); 358 if (prop == NULL) 359 return (-1); 360 361 offset = fdt_pointer_offset(prop); 362 rv = fdt_nextprop(offset, buf, size); 363 return (rv); 364} 365 366/* Set the value of a property of a package. */ 367static int 368ofw_fdt_setprop(ofw_t ofw, phandle_t package, const char *propname, 369 const void *buf, size_t len) 370{ 371 int offset; 372 373 offset = fdt_phandle_offset(package); 374 if (offset < 0) 375 return (-1); 376 377 return (fdt_setprop_inplace(fdtp, offset, propname, buf, len)); 378} 379 380/* Convert a device specifier to a fully qualified pathname. */ 381static ssize_t 382ofw_fdt_canon(ofw_t ofw, const char *device, char *buf, size_t len) 383{ 384 385 return (-1); 386} 387 388/* Return a package handle for the specified device. */ 389static phandle_t 390ofw_fdt_finddevice(ofw_t ofw, const char *device) 391{ 392 int offset; 393 394 offset = fdt_path_offset(fdtp, device); 395 if (offset < 0) 396 return (-1); 397 return (fdt_offset_phandle(offset)); 398} 399 400/* Return the fully qualified pathname corresponding to an instance. */ 401static ssize_t 402ofw_fdt_instance_to_path(ofw_t ofw, ihandle_t instance, char *buf, size_t len) 403{ 404 405 return (-1); 406} 407 408/* Return the fully qualified pathname corresponding to a package. */ 409static ssize_t 410ofw_fdt_package_to_path(ofw_t ofw, phandle_t package, char *buf, size_t len) 411{ 412 413 return (-1); 414} 415 416static int 417ofw_fdt_fixup(ofw_t ofw) 418{ 419#define FDT_MODEL_LEN 80 420 char model[FDT_MODEL_LEN]; 421 phandle_t root; 422 ssize_t len; 423 int i; 424 425 if ((root = ofw_fdt_finddevice(ofw, "/")) == -1) 426 return (ENODEV); 427 428 if ((len = ofw_fdt_getproplen(ofw, root, "model")) <= 0) 429 return (0); 430 431 bzero(model, FDT_MODEL_LEN); 432 if (ofw_fdt_getprop(ofw, root, "model", model, FDT_MODEL_LEN) <= 0) 433 return (0); 434 435 /* 436 * Search fixup table and call handler if appropriate. 437 */ 438 for (i = 0; fdt_fixup_table[i].model != NULL; i++) { 439 if (strncmp(model, fdt_fixup_table[i].model, 440 FDT_MODEL_LEN) != 0) 441 continue; 442 443 if (fdt_fixup_table[i].handler != NULL) 444 (*fdt_fixup_table[i].handler)(root); 445 } 446 447 return (0); 448} 449 450static int 451ofw_fdt_interpret(ofw_t ofw, const char *cmd, int nret, cell_t *retvals) 452{ 453 int rv; 454 455 /* 456 * Note: FDT does not have the possibility to 'interpret' commands, 457 * but we abuse the interface a bit to use it for doing non-standard 458 * operations on the device tree blob. 459 * 460 * Currently the only supported 'command' is to trigger performing 461 * fixups. 462 */ 463 if (strncmp("perform-fixup", cmd, 13) != 0) 464 return (0); 465 466 rv = ofw_fdt_fixup(ofw); 467 if (nret > 0) 468 retvals[0] = rv; 469 470 return (rv); 471} 472