1 #ifndef _LINUX_OF_H 2 #define _LINUX_OF_H 3 /* 4 * Definitions for talking to the Open Firmware PROM on 5 * Power Macintosh and other computers. 6 * 7 * Copyright (C) 1996-2005 Paul Mackerras. 8 * 9 * Updates for PPC64 by Peter Bergner & David Engebretsen, IBM Corp. 10 * Updates for SPARC64 by David S. Miller 11 * Derived from PowerPC and Sparc prom.h files by Stephen Rothwell, IBM Corp. 12 * 13 * This program is free software; you can redistribute it and/or 14 * modify it under the terms of the GNU General Public License 15 * as published by the Free Software Foundation; either version 16 * 2 of the License, or (at your option) any later version. 17 */ 18 #include <linux/types.h> 19 #include <linux/bitops.h> 20 #include <linux/errno.h> 21 #include <linux/kobject.h> 22 #include <linux/mod_devicetable.h> 23 #include <linux/spinlock.h> 24 #include <linux/topology.h> 25 #include <linux/notifier.h> 26 #include <linux/property.h> 27 #include <linux/list.h> 28 29 #include <asm/byteorder.h> 30 #include <asm/errno.h> 31 32 typedef u32 phandle; 33 typedef u32 ihandle; 34 35 struct property { 36 char *name; 37 int length; 38 void *value; 39 struct property *next; 40 unsigned long _flags; 41 unsigned int unique_id; 42 struct bin_attribute attr; 43 }; 44 45 #if defined(CONFIG_SPARC) 46 struct of_irq_controller; 47 #endif 48 49 struct device_node { 50 const char *name; 51 const char *type; 52 phandle phandle; 53 const char *full_name; 54 struct fwnode_handle fwnode; 55 56 struct property *properties; 57 struct property *deadprops; /* removed properties */ 58 struct device_node *parent; 59 struct device_node *child; 60 struct device_node *sibling; 61 struct kobject kobj; 62 unsigned long _flags; 63 void *data; 64 #if defined(CONFIG_SPARC) 65 const char *path_component_name; 66 unsigned int unique_id; 67 struct of_irq_controller *irq_trans; 68 #endif 69 }; 70 71 #define MAX_PHANDLE_ARGS 16 72 struct of_phandle_args { 73 struct device_node *np; 74 int args_count; 75 uint32_t args[MAX_PHANDLE_ARGS]; 76 }; 77 78 struct of_phandle_iterator { 79 /* Common iterator information */ 80 const char *cells_name; 81 int cell_count; 82 const struct device_node *parent; 83 84 /* List size information */ 85 const __be32 *list_end; 86 const __be32 *phandle_end; 87 88 /* Current position state */ 89 const __be32 *cur; 90 uint32_t cur_count; 91 phandle phandle; 92 struct device_node *node; 93 }; 94 95 struct of_reconfig_data { 96 struct device_node *dn; 97 struct property *prop; 98 struct property *old_prop; 99 }; 100 101 /* initialize a node */ 102 extern struct kobj_type of_node_ktype; 103 static inline void of_node_init(struct device_node *node) 104 { 105 kobject_init(&node->kobj, &of_node_ktype); 106 node->fwnode.type = FWNODE_OF; 107 } 108 109 /* true when node is initialized */ 110 static inline int of_node_is_initialized(struct device_node *node) 111 { 112 return node && node->kobj.state_initialized; 113 } 114 115 /* true when node is attached (i.e. present on sysfs) */ 116 static inline int of_node_is_attached(struct device_node *node) 117 { 118 return node && node->kobj.state_in_sysfs; 119 } 120 121 #ifdef CONFIG_OF_DYNAMIC 122 extern struct device_node *of_node_get(struct device_node *node); 123 extern void of_node_put(struct device_node *node); 124 #else /* CONFIG_OF_DYNAMIC */ 125 /* Dummy ref counting routines - to be implemented later */ 126 static inline struct device_node *of_node_get(struct device_node *node) 127 { 128 return node; 129 } 130 static inline void of_node_put(struct device_node *node) { } 131 #endif /* !CONFIG_OF_DYNAMIC */ 132 133 /* Pointer for first entry in chain of all nodes. */ 134 extern struct device_node *of_root; 135 extern struct device_node *of_chosen; 136 extern struct device_node *of_aliases; 137 extern struct device_node *of_stdout; 138 extern raw_spinlock_t devtree_lock; 139 140 /* flag descriptions (need to be visible even when !CONFIG_OF) */ 141 #define OF_DYNAMIC 1 /* node and properties were allocated via kmalloc */ 142 #define OF_DETACHED 2 /* node has been detached from the device tree */ 143 #define OF_POPULATED 3 /* device already created for the node */ 144 #define OF_POPULATED_BUS 4 /* of_platform_populate recursed to children of this node */ 145 146 #define OF_BAD_ADDR ((u64)-1) 147 148 #ifdef CONFIG_OF 149 void of_core_init(void); 150 151 static inline bool is_of_node(struct fwnode_handle *fwnode) 152 { 153 return !IS_ERR_OR_NULL(fwnode) && fwnode->type == FWNODE_OF; 154 } 155 156 static inline struct device_node *to_of_node(struct fwnode_handle *fwnode) 157 { 158 return is_of_node(fwnode) ? 159 container_of(fwnode, struct device_node, fwnode) : NULL; 160 } 161 162 #define of_fwnode_handle(node) (&(node)->fwnode) 163 164 static inline bool of_have_populated_dt(void) 165 { 166 return of_root != NULL; 167 } 168 169 static inline bool of_node_is_root(const struct device_node *node) 170 { 171 return node && (node->parent == NULL); 172 } 173 174 static inline int of_node_check_flag(struct device_node *n, unsigned long flag) 175 { 176 return test_bit(flag, &n->_flags); 177 } 178 179 static inline int of_node_test_and_set_flag(struct device_node *n, 180 unsigned long flag) 181 { 182 return test_and_set_bit(flag, &n->_flags); 183 } 184 185 static inline void of_node_set_flag(struct device_node *n, unsigned long flag) 186 { 187 set_bit(flag, &n->_flags); 188 } 189 190 static inline void of_node_clear_flag(struct device_node *n, unsigned long flag) 191 { 192 clear_bit(flag, &n->_flags); 193 } 194 195 static inline int of_property_check_flag(struct property *p, unsigned long flag) 196 { 197 return test_bit(flag, &p->_flags); 198 } 199 200 static inline void of_property_set_flag(struct property *p, unsigned long flag) 201 { 202 set_bit(flag, &p->_flags); 203 } 204 205 static inline void of_property_clear_flag(struct property *p, unsigned long flag) 206 { 207 clear_bit(flag, &p->_flags); 208 } 209 210 extern struct device_node *__of_find_all_nodes(struct device_node *prev); 211 extern struct device_node *of_find_all_nodes(struct device_node *prev); 212 213 /* 214 * OF address retrieval & translation 215 */ 216 217 /* Helper to read a big number; size is in cells (not bytes) */ 218 static inline u64 of_read_number(const __be32 *cell, int size) 219 { 220 u64 r = 0; 221 while (size--) 222 r = (r << 32) | be32_to_cpu(*(cell++)); 223 return r; 224 } 225 226 /* Like of_read_number, but we want an unsigned long result */ 227 static inline unsigned long of_read_ulong(const __be32 *cell, int size) 228 { 229 /* toss away upper bits if unsigned long is smaller than u64 */ 230 return of_read_number(cell, size); 231 } 232 233 #if defined(CONFIG_SPARC) 234 #include <asm/prom.h> 235 #endif 236 237 /* Default #address and #size cells. Allow arch asm/prom.h to override */ 238 #if !defined(OF_ROOT_NODE_ADDR_CELLS_DEFAULT) 239 #define OF_ROOT_NODE_ADDR_CELLS_DEFAULT 1 240 #define OF_ROOT_NODE_SIZE_CELLS_DEFAULT 1 241 #endif 242 243 #define OF_IS_DYNAMIC(x) test_bit(OF_DYNAMIC, &x->_flags) 244 #define OF_MARK_DYNAMIC(x) set_bit(OF_DYNAMIC, &x->_flags) 245 246 static inline const char *of_node_full_name(const struct device_node *np) 247 { 248 return np ? np->full_name : "<no-node>"; 249 } 250 251 #define for_each_of_allnodes_from(from, dn) \ 252 for (dn = __of_find_all_nodes(from); dn; dn = __of_find_all_nodes(dn)) 253 #define for_each_of_allnodes(dn) for_each_of_allnodes_from(NULL, dn) 254 extern struct device_node *of_find_node_by_name(struct device_node *from, 255 const char *name); 256 extern struct device_node *of_find_node_by_type(struct device_node *from, 257 const char *type); 258 extern struct device_node *of_find_compatible_node(struct device_node *from, 259 const char *type, const char *compat); 260 extern struct device_node *of_find_matching_node_and_match( 261 struct device_node *from, 262 const struct of_device_id *matches, 263 const struct of_device_id **match); 264 265 extern struct device_node *of_find_node_opts_by_path(const char *path, 266 const char **opts); 267 static inline struct device_node *of_find_node_by_path(const char *path) 268 { 269 return of_find_node_opts_by_path(path, NULL); 270 } 271 272 extern struct device_node *of_find_node_by_phandle(phandle handle); 273 extern struct device_node *of_get_parent(const struct device_node *node); 274 extern struct device_node *of_get_next_parent(struct device_node *node); 275 extern struct device_node *of_get_next_child(const struct device_node *node, 276 struct device_node *prev); 277 extern struct device_node *of_get_next_available_child( 278 const struct device_node *node, struct device_node *prev); 279 280 extern struct device_node *of_get_child_by_name(const struct device_node *node, 281 const char *name); 282 283 /* cache lookup */ 284 extern struct device_node *of_find_next_cache_node(const struct device_node *); 285 extern int of_find_last_cache_level(unsigned int cpu); 286 extern struct device_node *of_find_node_with_property( 287 struct device_node *from, const char *prop_name); 288 289 extern struct property *of_find_property(const struct device_node *np, 290 const char *name, 291 int *lenp); 292 extern int of_property_count_elems_of_size(const struct device_node *np, 293 const char *propname, int elem_size); 294 extern int of_property_read_u32_index(const struct device_node *np, 295 const char *propname, 296 u32 index, u32 *out_value); 297 extern int of_property_read_u64_index(const struct device_node *np, 298 const char *propname, 299 u32 index, u64 *out_value); 300 extern int of_property_read_variable_u8_array(const struct device_node *np, 301 const char *propname, u8 *out_values, 302 size_t sz_min, size_t sz_max); 303 extern int of_property_read_variable_u16_array(const struct device_node *np, 304 const char *propname, u16 *out_values, 305 size_t sz_min, size_t sz_max); 306 extern int of_property_read_variable_u32_array(const struct device_node *np, 307 const char *propname, 308 u32 *out_values, 309 size_t sz_min, 310 size_t sz_max); 311 extern int of_property_read_u64(const struct device_node *np, 312 const char *propname, u64 *out_value); 313 extern int of_property_read_variable_u64_array(const struct device_node *np, 314 const char *propname, 315 u64 *out_values, 316 size_t sz_min, 317 size_t sz_max); 318 319 extern int of_property_read_string(const struct device_node *np, 320 const char *propname, 321 const char **out_string); 322 extern int of_property_match_string(const struct device_node *np, 323 const char *propname, 324 const char *string); 325 extern int of_property_read_string_helper(const struct device_node *np, 326 const char *propname, 327 const char **out_strs, size_t sz, int index); 328 extern int of_device_is_compatible(const struct device_node *device, 329 const char *); 330 extern int of_device_compatible_match(struct device_node *device, 331 const char *const *compat); 332 extern bool of_device_is_available(const struct device_node *device); 333 extern bool of_device_is_big_endian(const struct device_node *device); 334 extern const void *of_get_property(const struct device_node *node, 335 const char *name, 336 int *lenp); 337 extern struct device_node *of_get_cpu_node(int cpu, unsigned int *thread); 338 #define for_each_property_of_node(dn, pp) \ 339 for (pp = dn->properties; pp != NULL; pp = pp->next) 340 341 extern int of_n_addr_cells(struct device_node *np); 342 extern int of_n_size_cells(struct device_node *np); 343 extern const struct of_device_id *of_match_node( 344 const struct of_device_id *matches, const struct device_node *node); 345 extern int of_modalias_node(struct device_node *node, char *modalias, int len); 346 extern void of_print_phandle_args(const char *msg, const struct of_phandle_args *args); 347 extern struct device_node *of_parse_phandle(const struct device_node *np, 348 const char *phandle_name, 349 int index); 350 extern int of_parse_phandle_with_args(const struct device_node *np, 351 const char *list_name, const char *cells_name, int index, 352 struct of_phandle_args *out_args); 353 extern int of_parse_phandle_with_fixed_args(const struct device_node *np, 354 const char *list_name, int cells_count, int index, 355 struct of_phandle_args *out_args); 356 extern int of_count_phandle_with_args(const struct device_node *np, 357 const char *list_name, const char *cells_name); 358 359 /* phandle iterator functions */ 360 extern int of_phandle_iterator_init(struct of_phandle_iterator *it, 361 const struct device_node *np, 362 const char *list_name, 363 const char *cells_name, 364 int cell_count); 365 366 extern int of_phandle_iterator_next(struct of_phandle_iterator *it); 367 extern int of_phandle_iterator_args(struct of_phandle_iterator *it, 368 uint32_t *args, 369 int size); 370 371 extern void of_alias_scan(void * (*dt_alloc)(u64 size, u64 align)); 372 extern int of_alias_get_id(struct device_node *np, const char *stem); 373 extern int of_alias_get_highest_id(const char *stem); 374 375 extern int of_machine_is_compatible(const char *compat); 376 377 extern int of_add_property(struct device_node *np, struct property *prop); 378 extern int of_remove_property(struct device_node *np, struct property *prop); 379 extern int of_update_property(struct device_node *np, struct property *newprop); 380 381 /* For updating the device tree at runtime */ 382 #define OF_RECONFIG_ATTACH_NODE 0x0001 383 #define OF_RECONFIG_DETACH_NODE 0x0002 384 #define OF_RECONFIG_ADD_PROPERTY 0x0003 385 #define OF_RECONFIG_REMOVE_PROPERTY 0x0004 386 #define OF_RECONFIG_UPDATE_PROPERTY 0x0005 387 388 extern int of_attach_node(struct device_node *); 389 extern int of_detach_node(struct device_node *); 390 391 #define of_match_ptr(_ptr) (_ptr) 392 393 /** 394 * of_property_read_u8_array - Find and read an array of u8 from a property. 395 * 396 * @np: device node from which the property value is to be read. 397 * @propname: name of the property to be searched. 398 * @out_values: pointer to return value, modified only if return value is 0. 399 * @sz: number of array elements to read 400 * 401 * Search for a property in a device node and read 8-bit value(s) from 402 * it. Returns 0 on success, -EINVAL if the property does not exist, 403 * -ENODATA if property does not have a value, and -EOVERFLOW if the 404 * property data isn't large enough. 405 * 406 * dts entry of array should be like: 407 * property = /bits/ 8 <0x50 0x60 0x70>; 408 * 409 * The out_values is modified only if a valid u8 value can be decoded. 410 */ 411 static inline int of_property_read_u8_array(const struct device_node *np, 412 const char *propname, 413 u8 *out_values, size_t sz) 414 { 415 int ret = of_property_read_variable_u8_array(np, propname, out_values, 416 sz, 0); 417 if (ret >= 0) 418 return 0; 419 else 420 return ret; 421 } 422 423 /** 424 * of_property_read_u16_array - Find and read an array of u16 from a property. 425 * 426 * @np: device node from which the property value is to be read. 427 * @propname: name of the property to be searched. 428 * @out_values: pointer to return value, modified only if return value is 0. 429 * @sz: number of array elements to read 430 * 431 * Search for a property in a device node and read 16-bit value(s) from 432 * it. Returns 0 on success, -EINVAL if the property does not exist, 433 * -ENODATA if property does not have a value, and -EOVERFLOW if the 434 * property data isn't large enough. 435 * 436 * dts entry of array should be like: 437 * property = /bits/ 16 <0x5000 0x6000 0x7000>; 438 * 439 * The out_values is modified only if a valid u16 value can be decoded. 440 */ 441 static inline int of_property_read_u16_array(const struct device_node *np, 442 const char *propname, 443 u16 *out_values, size_t sz) 444 { 445 int ret = of_property_read_variable_u16_array(np, propname, out_values, 446 sz, 0); 447 if (ret >= 0) 448 return 0; 449 else 450 return ret; 451 } 452 453 /** 454 * of_property_read_u32_array - Find and read an array of 32 bit integers 455 * from a property. 456 * 457 * @np: device node from which the property value is to be read. 458 * @propname: name of the property to be searched. 459 * @out_values: pointer to return value, modified only if return value is 0. 460 * @sz: number of array elements to read 461 * 462 * Search for a property in a device node and read 32-bit value(s) from 463 * it. Returns 0 on success, -EINVAL if the property does not exist, 464 * -ENODATA if property does not have a value, and -EOVERFLOW if the 465 * property data isn't large enough. 466 * 467 * The out_values is modified only if a valid u32 value can be decoded. 468 */ 469 static inline int of_property_read_u32_array(const struct device_node *np, 470 const char *propname, 471 u32 *out_values, size_t sz) 472 { 473 int ret = of_property_read_variable_u32_array(np, propname, out_values, 474 sz, 0); 475 if (ret >= 0) 476 return 0; 477 else 478 return ret; 479 } 480 481 /** 482 * of_property_read_u64_array - Find and read an array of 64 bit integers 483 * from a property. 484 * 485 * @np: device node from which the property value is to be read. 486 * @propname: name of the property to be searched. 487 * @out_values: pointer to return value, modified only if return value is 0. 488 * @sz: number of array elements to read 489 * 490 * Search for a property in a device node and read 64-bit value(s) from 491 * it. Returns 0 on success, -EINVAL if the property does not exist, 492 * -ENODATA if property does not have a value, and -EOVERFLOW if the 493 * property data isn't large enough. 494 * 495 * The out_values is modified only if a valid u64 value can be decoded. 496 */ 497 static inline int of_property_read_u64_array(const struct device_node *np, 498 const char *propname, 499 u64 *out_values, size_t sz) 500 { 501 int ret = of_property_read_variable_u64_array(np, propname, out_values, 502 sz, 0); 503 if (ret >= 0) 504 return 0; 505 else 506 return ret; 507 } 508 509 /* 510 * struct property *prop; 511 * const __be32 *p; 512 * u32 u; 513 * 514 * of_property_for_each_u32(np, "propname", prop, p, u) 515 * printk("U32 value: %x\n", u); 516 */ 517 const __be32 *of_prop_next_u32(struct property *prop, const __be32 *cur, 518 u32 *pu); 519 /* 520 * struct property *prop; 521 * const char *s; 522 * 523 * of_property_for_each_string(np, "propname", prop, s) 524 * printk("String value: %s\n", s); 525 */ 526 const char *of_prop_next_string(struct property *prop, const char *cur); 527 528 bool of_console_check(struct device_node *dn, char *name, int index); 529 530 #else /* CONFIG_OF */ 531 532 static inline void of_core_init(void) 533 { 534 } 535 536 static inline bool is_of_node(struct fwnode_handle *fwnode) 537 { 538 return false; 539 } 540 541 static inline struct device_node *to_of_node(struct fwnode_handle *fwnode) 542 { 543 return NULL; 544 } 545 546 static inline const char* of_node_full_name(const struct device_node *np) 547 { 548 return "<no-node>"; 549 } 550 551 static inline struct device_node *of_find_node_by_name(struct device_node *from, 552 const char *name) 553 { 554 return NULL; 555 } 556 557 static inline struct device_node *of_find_node_by_type(struct device_node *from, 558 const char *type) 559 { 560 return NULL; 561 } 562 563 static inline struct device_node *of_find_matching_node_and_match( 564 struct device_node *from, 565 const struct of_device_id *matches, 566 const struct of_device_id **match) 567 { 568 return NULL; 569 } 570 571 static inline struct device_node *of_find_node_by_path(const char *path) 572 { 573 return NULL; 574 } 575 576 static inline struct device_node *of_find_node_opts_by_path(const char *path, 577 const char **opts) 578 { 579 return NULL; 580 } 581 582 static inline struct device_node *of_find_node_by_phandle(phandle handle) 583 { 584 return NULL; 585 } 586 587 static inline struct device_node *of_get_parent(const struct device_node *node) 588 { 589 return NULL; 590 } 591 592 static inline struct device_node *of_get_next_child( 593 const struct device_node *node, struct device_node *prev) 594 { 595 return NULL; 596 } 597 598 static inline struct device_node *of_get_next_available_child( 599 const struct device_node *node, struct device_node *prev) 600 { 601 return NULL; 602 } 603 604 static inline struct device_node *of_find_node_with_property( 605 struct device_node *from, const char *prop_name) 606 { 607 return NULL; 608 } 609 610 #define of_fwnode_handle(node) NULL 611 612 static inline bool of_have_populated_dt(void) 613 { 614 return false; 615 } 616 617 static inline struct device_node *of_get_child_by_name( 618 const struct device_node *node, 619 const char *name) 620 { 621 return NULL; 622 } 623 624 static inline int of_device_is_compatible(const struct device_node *device, 625 const char *name) 626 { 627 return 0; 628 } 629 630 static inline bool of_device_is_available(const struct device_node *device) 631 { 632 return false; 633 } 634 635 static inline bool of_device_is_big_endian(const struct device_node *device) 636 { 637 return false; 638 } 639 640 static inline struct property *of_find_property(const struct device_node *np, 641 const char *name, 642 int *lenp) 643 { 644 return NULL; 645 } 646 647 static inline struct device_node *of_find_compatible_node( 648 struct device_node *from, 649 const char *type, 650 const char *compat) 651 { 652 return NULL; 653 } 654 655 static inline int of_property_count_elems_of_size(const struct device_node *np, 656 const char *propname, int elem_size) 657 { 658 return -ENOSYS; 659 } 660 661 static inline int of_property_read_u32_index(const struct device_node *np, 662 const char *propname, u32 index, u32 *out_value) 663 { 664 return -ENOSYS; 665 } 666 667 static inline int of_property_read_u8_array(const struct device_node *np, 668 const char *propname, u8 *out_values, size_t sz) 669 { 670 return -ENOSYS; 671 } 672 673 static inline int of_property_read_u16_array(const struct device_node *np, 674 const char *propname, u16 *out_values, size_t sz) 675 { 676 return -ENOSYS; 677 } 678 679 static inline int of_property_read_u32_array(const struct device_node *np, 680 const char *propname, 681 u32 *out_values, size_t sz) 682 { 683 return -ENOSYS; 684 } 685 686 static inline int of_property_read_u64_array(const struct device_node *np, 687 const char *propname, 688 u64 *out_values, size_t sz) 689 { 690 return -ENOSYS; 691 } 692 693 static inline int of_property_read_string(const struct device_node *np, 694 const char *propname, 695 const char **out_string) 696 { 697 return -ENOSYS; 698 } 699 700 static inline int of_property_read_string_helper(const struct device_node *np, 701 const char *propname, 702 const char **out_strs, size_t sz, int index) 703 { 704 return -ENOSYS; 705 } 706 707 static inline const void *of_get_property(const struct device_node *node, 708 const char *name, 709 int *lenp) 710 { 711 return NULL; 712 } 713 714 static inline struct device_node *of_get_cpu_node(int cpu, 715 unsigned int *thread) 716 { 717 return NULL; 718 } 719 720 static inline int of_property_read_u64(const struct device_node *np, 721 const char *propname, u64 *out_value) 722 { 723 return -ENOSYS; 724 } 725 726 static inline int of_property_match_string(const struct device_node *np, 727 const char *propname, 728 const char *string) 729 { 730 return -ENOSYS; 731 } 732 733 static inline struct device_node *of_parse_phandle(const struct device_node *np, 734 const char *phandle_name, 735 int index) 736 { 737 return NULL; 738 } 739 740 static inline int of_parse_phandle_with_args(const struct device_node *np, 741 const char *list_name, 742 const char *cells_name, 743 int index, 744 struct of_phandle_args *out_args) 745 { 746 return -ENOSYS; 747 } 748 749 static inline int of_parse_phandle_with_fixed_args(const struct device_node *np, 750 const char *list_name, int cells_count, int index, 751 struct of_phandle_args *out_args) 752 { 753 return -ENOSYS; 754 } 755 756 static inline int of_count_phandle_with_args(struct device_node *np, 757 const char *list_name, 758 const char *cells_name) 759 { 760 return -ENOSYS; 761 } 762 763 static inline int of_phandle_iterator_init(struct of_phandle_iterator *it, 764 const struct device_node *np, 765 const char *list_name, 766 const char *cells_name, 767 int cell_count) 768 { 769 return -ENOSYS; 770 } 771 772 static inline int of_phandle_iterator_next(struct of_phandle_iterator *it) 773 { 774 return -ENOSYS; 775 } 776 777 static inline int of_phandle_iterator_args(struct of_phandle_iterator *it, 778 uint32_t *args, 779 int size) 780 { 781 return 0; 782 } 783 784 static inline int of_alias_get_id(struct device_node *np, const char *stem) 785 { 786 return -ENOSYS; 787 } 788 789 static inline int of_alias_get_highest_id(const char *stem) 790 { 791 return -ENOSYS; 792 } 793 794 static inline int of_machine_is_compatible(const char *compat) 795 { 796 return 0; 797 } 798 799 static inline bool of_console_check(const struct device_node *dn, const char *name, int index) 800 { 801 return false; 802 } 803 804 static inline const __be32 *of_prop_next_u32(struct property *prop, 805 const __be32 *cur, u32 *pu) 806 { 807 return NULL; 808 } 809 810 static inline const char *of_prop_next_string(struct property *prop, 811 const char *cur) 812 { 813 return NULL; 814 } 815 816 static inline int of_node_check_flag(struct device_node *n, unsigned long flag) 817 { 818 return 0; 819 } 820 821 static inline int of_node_test_and_set_flag(struct device_node *n, 822 unsigned long flag) 823 { 824 return 0; 825 } 826 827 static inline void of_node_set_flag(struct device_node *n, unsigned long flag) 828 { 829 } 830 831 static inline void of_node_clear_flag(struct device_node *n, unsigned long flag) 832 { 833 } 834 835 static inline int of_property_check_flag(struct property *p, unsigned long flag) 836 { 837 return 0; 838 } 839 840 static inline void of_property_set_flag(struct property *p, unsigned long flag) 841 { 842 } 843 844 static inline void of_property_clear_flag(struct property *p, unsigned long flag) 845 { 846 } 847 848 #define of_match_ptr(_ptr) NULL 849 #define of_match_node(_matches, _node) NULL 850 #endif /* CONFIG_OF */ 851 852 /* Default string compare functions, Allow arch asm/prom.h to override */ 853 #if !defined(of_compat_cmp) 854 #define of_compat_cmp(s1, s2, l) strcasecmp((s1), (s2)) 855 #define of_prop_cmp(s1, s2) strcmp((s1), (s2)) 856 #define of_node_cmp(s1, s2) strcasecmp((s1), (s2)) 857 #endif 858 859 #if defined(CONFIG_OF) && defined(CONFIG_NUMA) 860 extern int of_node_to_nid(struct device_node *np); 861 #else 862 static inline int of_node_to_nid(struct device_node *device) 863 { 864 return NUMA_NO_NODE; 865 } 866 #endif 867 868 #ifdef CONFIG_OF_NUMA 869 extern int of_numa_init(void); 870 #else 871 static inline int of_numa_init(void) 872 { 873 return -ENOSYS; 874 } 875 #endif 876 877 static inline struct device_node *of_find_matching_node( 878 struct device_node *from, 879 const struct of_device_id *matches) 880 { 881 return of_find_matching_node_and_match(from, matches, NULL); 882 } 883 884 /** 885 * of_property_count_u8_elems - Count the number of u8 elements in a property 886 * 887 * @np: device node from which the property value is to be read. 888 * @propname: name of the property to be searched. 889 * 890 * Search for a property in a device node and count the number of u8 elements 891 * in it. Returns number of elements on sucess, -EINVAL if the property does 892 * not exist or its length does not match a multiple of u8 and -ENODATA if the 893 * property does not have a value. 894 */ 895 static inline int of_property_count_u8_elems(const struct device_node *np, 896 const char *propname) 897 { 898 return of_property_count_elems_of_size(np, propname, sizeof(u8)); 899 } 900 901 /** 902 * of_property_count_u16_elems - Count the number of u16 elements in a property 903 * 904 * @np: device node from which the property value is to be read. 905 * @propname: name of the property to be searched. 906 * 907 * Search for a property in a device node and count the number of u16 elements 908 * in it. Returns number of elements on sucess, -EINVAL if the property does 909 * not exist or its length does not match a multiple of u16 and -ENODATA if the 910 * property does not have a value. 911 */ 912 static inline int of_property_count_u16_elems(const struct device_node *np, 913 const char *propname) 914 { 915 return of_property_count_elems_of_size(np, propname, sizeof(u16)); 916 } 917 918 /** 919 * of_property_count_u32_elems - Count the number of u32 elements in a property 920 * 921 * @np: device node from which the property value is to be read. 922 * @propname: name of the property to be searched. 923 * 924 * Search for a property in a device node and count the number of u32 elements 925 * in it. Returns number of elements on sucess, -EINVAL if the property does 926 * not exist or its length does not match a multiple of u32 and -ENODATA if the 927 * property does not have a value. 928 */ 929 static inline int of_property_count_u32_elems(const struct device_node *np, 930 const char *propname) 931 { 932 return of_property_count_elems_of_size(np, propname, sizeof(u32)); 933 } 934 935 /** 936 * of_property_count_u64_elems - Count the number of u64 elements in a property 937 * 938 * @np: device node from which the property value is to be read. 939 * @propname: name of the property to be searched. 940 * 941 * Search for a property in a device node and count the number of u64 elements 942 * in it. Returns number of elements on sucess, -EINVAL if the property does 943 * not exist or its length does not match a multiple of u64 and -ENODATA if the 944 * property does not have a value. 945 */ 946 static inline int of_property_count_u64_elems(const struct device_node *np, 947 const char *propname) 948 { 949 return of_property_count_elems_of_size(np, propname, sizeof(u64)); 950 } 951 952 /** 953 * of_property_read_string_array() - Read an array of strings from a multiple 954 * strings property. 955 * @np: device node from which the property value is to be read. 956 * @propname: name of the property to be searched. 957 * @out_strs: output array of string pointers. 958 * @sz: number of array elements to read. 959 * 960 * Search for a property in a device tree node and retrieve a list of 961 * terminated string values (pointer to data, not a copy) in that property. 962 * 963 * If @out_strs is NULL, the number of strings in the property is returned. 964 */ 965 static inline int of_property_read_string_array(const struct device_node *np, 966 const char *propname, const char **out_strs, 967 size_t sz) 968 { 969 return of_property_read_string_helper(np, propname, out_strs, sz, 0); 970 } 971 972 /** 973 * of_property_count_strings() - Find and return the number of strings from a 974 * multiple strings property. 975 * @np: device node from which the property value is to be read. 976 * @propname: name of the property to be searched. 977 * 978 * Search for a property in a device tree node and retrieve the number of null 979 * terminated string contain in it. Returns the number of strings on 980 * success, -EINVAL if the property does not exist, -ENODATA if property 981 * does not have a value, and -EILSEQ if the string is not null-terminated 982 * within the length of the property data. 983 */ 984 static inline int of_property_count_strings(const struct device_node *np, 985 const char *propname) 986 { 987 return of_property_read_string_helper(np, propname, NULL, 0, 0); 988 } 989 990 /** 991 * of_property_read_string_index() - Find and read a string from a multiple 992 * strings property. 993 * @np: device node from which the property value is to be read. 994 * @propname: name of the property to be searched. 995 * @index: index of the string in the list of strings 996 * @out_string: pointer to null terminated return string, modified only if 997 * return value is 0. 998 * 999 * Search for a property in a device tree node and retrieve a null 1000 * terminated string value (pointer to data, not a copy) in the list of strings 1001 * contained in that property. 1002 * Returns 0 on success, -EINVAL if the property does not exist, -ENODATA if 1003 * property does not have a value, and -EILSEQ if the string is not 1004 * null-terminated within the length of the property data. 1005 * 1006 * The out_string pointer is modified only if a valid string can be decoded. 1007 */ 1008 static inline int of_property_read_string_index(const struct device_node *np, 1009 const char *propname, 1010 int index, const char **output) 1011 { 1012 int rc = of_property_read_string_helper(np, propname, output, 1, index); 1013 return rc < 0 ? rc : 0; 1014 } 1015 1016 /** 1017 * of_property_read_bool - Findfrom a property 1018 * @np: device node from which the property value is to be read. 1019 * @propname: name of the property to be searched. 1020 * 1021 * Search for a property in a device node. 1022 * Returns true if the property exists false otherwise. 1023 */ 1024 static inline bool of_property_read_bool(const struct device_node *np, 1025 const char *propname) 1026 { 1027 struct property *prop = of_find_property(np, propname, NULL); 1028 1029 return prop ? true : false; 1030 } 1031 1032 static inline int of_property_read_u8(const struct device_node *np, 1033 const char *propname, 1034 u8 *out_value) 1035 { 1036 return of_property_read_u8_array(np, propname, out_value, 1); 1037 } 1038 1039 static inline int of_property_read_u16(const struct device_node *np, 1040 const char *propname, 1041 u16 *out_value) 1042 { 1043 return of_property_read_u16_array(np, propname, out_value, 1); 1044 } 1045 1046 static inline int of_property_read_u32(const struct device_node *np, 1047 const char *propname, 1048 u32 *out_value) 1049 { 1050 return of_property_read_u32_array(np, propname, out_value, 1); 1051 } 1052 1053 static inline int of_property_read_s32(const struct device_node *np, 1054 const char *propname, 1055 s32 *out_value) 1056 { 1057 return of_property_read_u32(np, propname, (u32*) out_value); 1058 } 1059 1060 #define of_for_each_phandle(it, err, np, ln, cn, cc) \ 1061 for (of_phandle_iterator_init((it), (np), (ln), (cn), (cc)), \ 1062 err = of_phandle_iterator_next(it); \ 1063 err == 0; \ 1064 err = of_phandle_iterator_next(it)) 1065 1066 #define of_property_for_each_u32(np, propname, prop, p, u) \ 1067 for (prop = of_find_property(np, propname, NULL), \ 1068 p = of_prop_next_u32(prop, NULL, &u); \ 1069 p; \ 1070 p = of_prop_next_u32(prop, p, &u)) 1071 1072 #define of_property_for_each_string(np, propname, prop, s) \ 1073 for (prop = of_find_property(np, propname, NULL), \ 1074 s = of_prop_next_string(prop, NULL); \ 1075 s; \ 1076 s = of_prop_next_string(prop, s)) 1077 1078 #define for_each_node_by_name(dn, name) \ 1079 for (dn = of_find_node_by_name(NULL, name); dn; \ 1080 dn = of_find_node_by_name(dn, name)) 1081 #define for_each_node_by_type(dn, type) \ 1082 for (dn = of_find_node_by_type(NULL, type); dn; \ 1083 dn = of_find_node_by_type(dn, type)) 1084 #define for_each_compatible_node(dn, type, compatible) \ 1085 for (dn = of_find_compatible_node(NULL, type, compatible); dn; \ 1086 dn = of_find_compatible_node(dn, type, compatible)) 1087 #define for_each_matching_node(dn, matches) \ 1088 for (dn = of_find_matching_node(NULL, matches); dn; \ 1089 dn = of_find_matching_node(dn, matches)) 1090 #define for_each_matching_node_and_match(dn, matches, match) \ 1091 for (dn = of_find_matching_node_and_match(NULL, matches, match); \ 1092 dn; dn = of_find_matching_node_and_match(dn, matches, match)) 1093 1094 #define for_each_child_of_node(parent, child) \ 1095 for (child = of_get_next_child(parent, NULL); child != NULL; \ 1096 child = of_get_next_child(parent, child)) 1097 #define for_each_available_child_of_node(parent, child) \ 1098 for (child = of_get_next_available_child(parent, NULL); child != NULL; \ 1099 child = of_get_next_available_child(parent, child)) 1100 1101 #define for_each_node_with_property(dn, prop_name) \ 1102 for (dn = of_find_node_with_property(NULL, prop_name); dn; \ 1103 dn = of_find_node_with_property(dn, prop_name)) 1104 1105 static inline int of_get_child_count(const struct device_node *np) 1106 { 1107 struct device_node *child; 1108 int num = 0; 1109 1110 for_each_child_of_node(np, child) 1111 num++; 1112 1113 return num; 1114 } 1115 1116 static inline int of_get_available_child_count(const struct device_node *np) 1117 { 1118 struct device_node *child; 1119 int num = 0; 1120 1121 for_each_available_child_of_node(np, child) 1122 num++; 1123 1124 return num; 1125 } 1126 1127 #if defined(CONFIG_OF) && !defined(MODULE) 1128 #define _OF_DECLARE(table, name, compat, fn, fn_type) \ 1129 static const struct of_device_id __of_table_##name \ 1130 __used __section(__##table##_of_table) \ 1131 = { .compatible = compat, \ 1132 .data = (fn == (fn_type)NULL) ? fn : fn } 1133 #else 1134 #define _OF_DECLARE(table, name, compat, fn, fn_type) \ 1135 static const struct of_device_id __of_table_##name \ 1136 __attribute__((unused)) \ 1137 = { .compatible = compat, \ 1138 .data = (fn == (fn_type)NULL) ? fn : fn } 1139 #endif 1140 1141 typedef int (*of_init_fn_2)(struct device_node *, struct device_node *); 1142 typedef int (*of_init_fn_1_ret)(struct device_node *); 1143 typedef void (*of_init_fn_1)(struct device_node *); 1144 1145 #define OF_DECLARE_1(table, name, compat, fn) \ 1146 _OF_DECLARE(table, name, compat, fn, of_init_fn_1) 1147 #define OF_DECLARE_1_RET(table, name, compat, fn) \ 1148 _OF_DECLARE(table, name, compat, fn, of_init_fn_1_ret) 1149 #define OF_DECLARE_2(table, name, compat, fn) \ 1150 _OF_DECLARE(table, name, compat, fn, of_init_fn_2) 1151 1152 /** 1153 * struct of_changeset_entry - Holds a changeset entry 1154 * 1155 * @node: list_head for the log list 1156 * @action: notifier action 1157 * @np: pointer to the device node affected 1158 * @prop: pointer to the property affected 1159 * @old_prop: hold a pointer to the original property 1160 * 1161 * Every modification of the device tree during a changeset 1162 * is held in a list of of_changeset_entry structures. 1163 * That way we can recover from a partial application, or we can 1164 * revert the changeset 1165 */ 1166 struct of_changeset_entry { 1167 struct list_head node; 1168 unsigned long action; 1169 struct device_node *np; 1170 struct property *prop; 1171 struct property *old_prop; 1172 }; 1173 1174 /** 1175 * struct of_changeset - changeset tracker structure 1176 * 1177 * @entries: list_head for the changeset entries 1178 * 1179 * changesets are a convenient way to apply bulk changes to the 1180 * live tree. In case of an error, changes are rolled-back. 1181 * changesets live on after initial application, and if not 1182 * destroyed after use, they can be reverted in one single call. 1183 */ 1184 struct of_changeset { 1185 struct list_head entries; 1186 }; 1187 1188 enum of_reconfig_change { 1189 OF_RECONFIG_NO_CHANGE = 0, 1190 OF_RECONFIG_CHANGE_ADD, 1191 OF_RECONFIG_CHANGE_REMOVE, 1192 }; 1193 1194 #ifdef CONFIG_OF_DYNAMIC 1195 extern int of_reconfig_notifier_register(struct notifier_block *); 1196 extern int of_reconfig_notifier_unregister(struct notifier_block *); 1197 extern int of_reconfig_notify(unsigned long, struct of_reconfig_data *rd); 1198 extern int of_reconfig_get_state_change(unsigned long action, 1199 struct of_reconfig_data *arg); 1200 1201 extern void of_changeset_init(struct of_changeset *ocs); 1202 extern void of_changeset_destroy(struct of_changeset *ocs); 1203 extern int of_changeset_apply(struct of_changeset *ocs); 1204 extern int of_changeset_revert(struct of_changeset *ocs); 1205 extern int of_changeset_action(struct of_changeset *ocs, 1206 unsigned long action, struct device_node *np, 1207 struct property *prop); 1208 1209 static inline int of_changeset_attach_node(struct of_changeset *ocs, 1210 struct device_node *np) 1211 { 1212 return of_changeset_action(ocs, OF_RECONFIG_ATTACH_NODE, np, NULL); 1213 } 1214 1215 static inline int of_changeset_detach_node(struct of_changeset *ocs, 1216 struct device_node *np) 1217 { 1218 return of_changeset_action(ocs, OF_RECONFIG_DETACH_NODE, np, NULL); 1219 } 1220 1221 static inline int of_changeset_add_property(struct of_changeset *ocs, 1222 struct device_node *np, struct property *prop) 1223 { 1224 return of_changeset_action(ocs, OF_RECONFIG_ADD_PROPERTY, np, prop); 1225 } 1226 1227 static inline int of_changeset_remove_property(struct of_changeset *ocs, 1228 struct device_node *np, struct property *prop) 1229 { 1230 return of_changeset_action(ocs, OF_RECONFIG_REMOVE_PROPERTY, np, prop); 1231 } 1232 1233 static inline int of_changeset_update_property(struct of_changeset *ocs, 1234 struct device_node *np, struct property *prop) 1235 { 1236 return of_changeset_action(ocs, OF_RECONFIG_UPDATE_PROPERTY, np, prop); 1237 } 1238 #else /* CONFIG_OF_DYNAMIC */ 1239 static inline int of_reconfig_notifier_register(struct notifier_block *nb) 1240 { 1241 return -EINVAL; 1242 } 1243 static inline int of_reconfig_notifier_unregister(struct notifier_block *nb) 1244 { 1245 return -EINVAL; 1246 } 1247 static inline int of_reconfig_notify(unsigned long action, 1248 struct of_reconfig_data *arg) 1249 { 1250 return -EINVAL; 1251 } 1252 static inline int of_reconfig_get_state_change(unsigned long action, 1253 struct of_reconfig_data *arg) 1254 { 1255 return -EINVAL; 1256 } 1257 #endif /* CONFIG_OF_DYNAMIC */ 1258 1259 /* CONFIG_OF_RESOLVE api */ 1260 extern int of_resolve_phandles(struct device_node *tree); 1261 1262 /** 1263 * of_device_is_system_power_controller - Tells if system-power-controller is found for device_node 1264 * @np: Pointer to the given device_node 1265 * 1266 * return true if present false otherwise 1267 */ 1268 static inline bool of_device_is_system_power_controller(const struct device_node *np) 1269 { 1270 return of_property_read_bool(np, "system-power-controller"); 1271 } 1272 1273 /** 1274 * Overlay support 1275 */ 1276 1277 enum of_overlay_notify_action { 1278 OF_OVERLAY_PRE_APPLY, 1279 OF_OVERLAY_POST_APPLY, 1280 OF_OVERLAY_PRE_REMOVE, 1281 OF_OVERLAY_POST_REMOVE, 1282 }; 1283 1284 struct of_overlay_notify_data { 1285 struct device_node *overlay; 1286 struct device_node *target; 1287 }; 1288 1289 #ifdef CONFIG_OF_OVERLAY 1290 1291 /* ID based overlays; the API for external users */ 1292 int of_overlay_create(struct device_node *tree); 1293 int of_overlay_destroy(int id); 1294 int of_overlay_destroy_all(void); 1295 1296 int of_overlay_notifier_register(struct notifier_block *nb); 1297 int of_overlay_notifier_unregister(struct notifier_block *nb); 1298 1299 #else 1300 1301 static inline int of_overlay_create(struct device_node *tree) 1302 { 1303 return -ENOTSUPP; 1304 } 1305 1306 static inline int of_overlay_destroy(int id) 1307 { 1308 return -ENOTSUPP; 1309 } 1310 1311 static inline int of_overlay_destroy_all(void) 1312 { 1313 return -ENOTSUPP; 1314 } 1315 1316 static inline int of_overlay_notifier_register(struct notifier_block *nb) 1317 { 1318 return 0; 1319 } 1320 1321 static inline int of_overlay_notifier_unregister(struct notifier_block *nb) 1322 { 1323 return 0; 1324 } 1325 1326 #endif 1327 1328 #endif /* _LINUX_OF_H */ 1329