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_variable_u8_array(const struct device_node *np, 298 const char *propname, u8 *out_values, 299 size_t sz_min, size_t sz_max); 300 extern int of_property_read_variable_u16_array(const struct device_node *np, 301 const char *propname, u16 *out_values, 302 size_t sz_min, size_t sz_max); 303 extern int of_property_read_variable_u32_array(const struct device_node *np, 304 const char *propname, 305 u32 *out_values, 306 size_t sz_min, 307 size_t sz_max); 308 extern int of_property_read_u64(const struct device_node *np, 309 const char *propname, u64 *out_value); 310 extern int of_property_read_variable_u64_array(const struct device_node *np, 311 const char *propname, 312 u64 *out_values, 313 size_t sz_min, 314 size_t sz_max); 315 316 extern int of_property_read_string(const struct device_node *np, 317 const char *propname, 318 const char **out_string); 319 extern int of_property_match_string(const struct device_node *np, 320 const char *propname, 321 const char *string); 322 extern int of_property_read_string_helper(const struct device_node *np, 323 const char *propname, 324 const char **out_strs, size_t sz, int index); 325 extern int of_device_is_compatible(const struct device_node *device, 326 const char *); 327 extern int of_device_compatible_match(struct device_node *device, 328 const char *const *compat); 329 extern bool of_device_is_available(const struct device_node *device); 330 extern bool of_device_is_big_endian(const struct device_node *device); 331 extern const void *of_get_property(const struct device_node *node, 332 const char *name, 333 int *lenp); 334 extern struct device_node *of_get_cpu_node(int cpu, unsigned int *thread); 335 #define for_each_property_of_node(dn, pp) \ 336 for (pp = dn->properties; pp != NULL; pp = pp->next) 337 338 extern int of_n_addr_cells(struct device_node *np); 339 extern int of_n_size_cells(struct device_node *np); 340 extern const struct of_device_id *of_match_node( 341 const struct of_device_id *matches, const struct device_node *node); 342 extern int of_modalias_node(struct device_node *node, char *modalias, int len); 343 extern void of_print_phandle_args(const char *msg, const struct of_phandle_args *args); 344 extern struct device_node *of_parse_phandle(const struct device_node *np, 345 const char *phandle_name, 346 int index); 347 extern int of_parse_phandle_with_args(const struct device_node *np, 348 const char *list_name, const char *cells_name, int index, 349 struct of_phandle_args *out_args); 350 extern int of_parse_phandle_with_fixed_args(const struct device_node *np, 351 const char *list_name, int cells_count, int index, 352 struct of_phandle_args *out_args); 353 extern int of_count_phandle_with_args(const struct device_node *np, 354 const char *list_name, const char *cells_name); 355 356 /* phandle iterator functions */ 357 extern int of_phandle_iterator_init(struct of_phandle_iterator *it, 358 const struct device_node *np, 359 const char *list_name, 360 const char *cells_name, 361 int cell_count); 362 363 extern int of_phandle_iterator_next(struct of_phandle_iterator *it); 364 extern int of_phandle_iterator_args(struct of_phandle_iterator *it, 365 uint32_t *args, 366 int size); 367 368 extern void of_alias_scan(void * (*dt_alloc)(u64 size, u64 align)); 369 extern int of_alias_get_id(struct device_node *np, const char *stem); 370 extern int of_alias_get_highest_id(const char *stem); 371 372 extern int of_machine_is_compatible(const char *compat); 373 374 extern int of_add_property(struct device_node *np, struct property *prop); 375 extern int of_remove_property(struct device_node *np, struct property *prop); 376 extern int of_update_property(struct device_node *np, struct property *newprop); 377 378 /* For updating the device tree at runtime */ 379 #define OF_RECONFIG_ATTACH_NODE 0x0001 380 #define OF_RECONFIG_DETACH_NODE 0x0002 381 #define OF_RECONFIG_ADD_PROPERTY 0x0003 382 #define OF_RECONFIG_REMOVE_PROPERTY 0x0004 383 #define OF_RECONFIG_UPDATE_PROPERTY 0x0005 384 385 extern int of_attach_node(struct device_node *); 386 extern int of_detach_node(struct device_node *); 387 388 #define of_match_ptr(_ptr) (_ptr) 389 390 /** 391 * of_property_read_u8_array - Find and read an array of u8 from a property. 392 * 393 * @np: device node from which the property value is to be read. 394 * @propname: name of the property to be searched. 395 * @out_values: pointer to return value, modified only if return value is 0. 396 * @sz: number of array elements to read 397 * 398 * Search for a property in a device node and read 8-bit value(s) from 399 * it. Returns 0 on success, -EINVAL if the property does not exist, 400 * -ENODATA if property does not have a value, and -EOVERFLOW if the 401 * property data isn't large enough. 402 * 403 * dts entry of array should be like: 404 * property = /bits/ 8 <0x50 0x60 0x70>; 405 * 406 * The out_values is modified only if a valid u8 value can be decoded. 407 */ 408 static inline int of_property_read_u8_array(const struct device_node *np, 409 const char *propname, 410 u8 *out_values, size_t sz) 411 { 412 int ret = of_property_read_variable_u8_array(np, propname, out_values, 413 sz, 0); 414 if (ret >= 0) 415 return 0; 416 else 417 return ret; 418 } 419 420 /** 421 * of_property_read_u16_array - Find and read an array of u16 from a property. 422 * 423 * @np: device node from which the property value is to be read. 424 * @propname: name of the property to be searched. 425 * @out_values: pointer to return value, modified only if return value is 0. 426 * @sz: number of array elements to read 427 * 428 * Search for a property in a device node and read 16-bit value(s) from 429 * it. Returns 0 on success, -EINVAL if the property does not exist, 430 * -ENODATA if property does not have a value, and -EOVERFLOW if the 431 * property data isn't large enough. 432 * 433 * dts entry of array should be like: 434 * property = /bits/ 16 <0x5000 0x6000 0x7000>; 435 * 436 * The out_values is modified only if a valid u16 value can be decoded. 437 */ 438 static inline int of_property_read_u16_array(const struct device_node *np, 439 const char *propname, 440 u16 *out_values, size_t sz) 441 { 442 int ret = of_property_read_variable_u16_array(np, propname, out_values, 443 sz, 0); 444 if (ret >= 0) 445 return 0; 446 else 447 return ret; 448 } 449 450 /** 451 * of_property_read_u32_array - Find and read an array of 32 bit integers 452 * from a property. 453 * 454 * @np: device node from which the property value is to be read. 455 * @propname: name of the property to be searched. 456 * @out_values: pointer to return value, modified only if return value is 0. 457 * @sz: number of array elements to read 458 * 459 * Search for a property in a device node and read 32-bit value(s) from 460 * it. Returns 0 on success, -EINVAL if the property does not exist, 461 * -ENODATA if property does not have a value, and -EOVERFLOW if the 462 * property data isn't large enough. 463 * 464 * The out_values is modified only if a valid u32 value can be decoded. 465 */ 466 static inline int of_property_read_u32_array(const struct device_node *np, 467 const char *propname, 468 u32 *out_values, size_t sz) 469 { 470 int ret = of_property_read_variable_u32_array(np, propname, out_values, 471 sz, 0); 472 if (ret >= 0) 473 return 0; 474 else 475 return ret; 476 } 477 478 /** 479 * of_property_read_u64_array - Find and read an array of 64 bit integers 480 * from a property. 481 * 482 * @np: device node from which the property value is to be read. 483 * @propname: name of the property to be searched. 484 * @out_values: pointer to return value, modified only if return value is 0. 485 * @sz: number of array elements to read 486 * 487 * Search for a property in a device node and read 64-bit value(s) from 488 * it. Returns 0 on success, -EINVAL if the property does not exist, 489 * -ENODATA if property does not have a value, and -EOVERFLOW if the 490 * property data isn't large enough. 491 * 492 * The out_values is modified only if a valid u64 value can be decoded. 493 */ 494 static inline int of_property_read_u64_array(const struct device_node *np, 495 const char *propname, 496 u64 *out_values, size_t sz) 497 { 498 int ret = of_property_read_variable_u64_array(np, propname, out_values, 499 sz, 0); 500 if (ret >= 0) 501 return 0; 502 else 503 return ret; 504 } 505 506 /* 507 * struct property *prop; 508 * const __be32 *p; 509 * u32 u; 510 * 511 * of_property_for_each_u32(np, "propname", prop, p, u) 512 * printk("U32 value: %x\n", u); 513 */ 514 const __be32 *of_prop_next_u32(struct property *prop, const __be32 *cur, 515 u32 *pu); 516 /* 517 * struct property *prop; 518 * const char *s; 519 * 520 * of_property_for_each_string(np, "propname", prop, s) 521 * printk("String value: %s\n", s); 522 */ 523 const char *of_prop_next_string(struct property *prop, const char *cur); 524 525 bool of_console_check(struct device_node *dn, char *name, int index); 526 527 #else /* CONFIG_OF */ 528 529 static inline void of_core_init(void) 530 { 531 } 532 533 static inline bool is_of_node(struct fwnode_handle *fwnode) 534 { 535 return false; 536 } 537 538 static inline struct device_node *to_of_node(struct fwnode_handle *fwnode) 539 { 540 return NULL; 541 } 542 543 static inline const char* of_node_full_name(const struct device_node *np) 544 { 545 return "<no-node>"; 546 } 547 548 static inline struct device_node *of_find_node_by_name(struct device_node *from, 549 const char *name) 550 { 551 return NULL; 552 } 553 554 static inline struct device_node *of_find_node_by_type(struct device_node *from, 555 const char *type) 556 { 557 return NULL; 558 } 559 560 static inline struct device_node *of_find_matching_node_and_match( 561 struct device_node *from, 562 const struct of_device_id *matches, 563 const struct of_device_id **match) 564 { 565 return NULL; 566 } 567 568 static inline struct device_node *of_find_node_by_path(const char *path) 569 { 570 return NULL; 571 } 572 573 static inline struct device_node *of_find_node_opts_by_path(const char *path, 574 const char **opts) 575 { 576 return NULL; 577 } 578 579 static inline struct device_node *of_find_node_by_phandle(phandle handle) 580 { 581 return NULL; 582 } 583 584 static inline struct device_node *of_get_parent(const struct device_node *node) 585 { 586 return NULL; 587 } 588 589 static inline struct device_node *of_get_next_child( 590 const struct device_node *node, struct device_node *prev) 591 { 592 return NULL; 593 } 594 595 static inline struct device_node *of_get_next_available_child( 596 const struct device_node *node, struct device_node *prev) 597 { 598 return NULL; 599 } 600 601 static inline struct device_node *of_find_node_with_property( 602 struct device_node *from, const char *prop_name) 603 { 604 return NULL; 605 } 606 607 #define of_fwnode_handle(node) NULL 608 609 static inline bool of_have_populated_dt(void) 610 { 611 return false; 612 } 613 614 static inline struct device_node *of_get_child_by_name( 615 const struct device_node *node, 616 const char *name) 617 { 618 return NULL; 619 } 620 621 static inline int of_device_is_compatible(const struct device_node *device, 622 const char *name) 623 { 624 return 0; 625 } 626 627 static inline bool of_device_is_available(const struct device_node *device) 628 { 629 return false; 630 } 631 632 static inline bool of_device_is_big_endian(const struct device_node *device) 633 { 634 return false; 635 } 636 637 static inline struct property *of_find_property(const struct device_node *np, 638 const char *name, 639 int *lenp) 640 { 641 return NULL; 642 } 643 644 static inline struct device_node *of_find_compatible_node( 645 struct device_node *from, 646 const char *type, 647 const char *compat) 648 { 649 return NULL; 650 } 651 652 static inline int of_property_count_elems_of_size(const struct device_node *np, 653 const char *propname, int elem_size) 654 { 655 return -ENOSYS; 656 } 657 658 static inline int of_property_read_u32_index(const struct device_node *np, 659 const char *propname, u32 index, u32 *out_value) 660 { 661 return -ENOSYS; 662 } 663 664 static inline int of_property_read_u8_array(const struct device_node *np, 665 const char *propname, u8 *out_values, size_t sz) 666 { 667 return -ENOSYS; 668 } 669 670 static inline int of_property_read_u16_array(const struct device_node *np, 671 const char *propname, u16 *out_values, size_t sz) 672 { 673 return -ENOSYS; 674 } 675 676 static inline int of_property_read_u32_array(const struct device_node *np, 677 const char *propname, 678 u32 *out_values, size_t sz) 679 { 680 return -ENOSYS; 681 } 682 683 static inline int of_property_read_u64_array(const struct device_node *np, 684 const char *propname, 685 u64 *out_values, size_t sz) 686 { 687 return -ENOSYS; 688 } 689 690 static inline int of_property_read_string(const struct device_node *np, 691 const char *propname, 692 const char **out_string) 693 { 694 return -ENOSYS; 695 } 696 697 static inline int of_property_read_string_helper(const struct device_node *np, 698 const char *propname, 699 const char **out_strs, size_t sz, int index) 700 { 701 return -ENOSYS; 702 } 703 704 static inline const void *of_get_property(const struct device_node *node, 705 const char *name, 706 int *lenp) 707 { 708 return NULL; 709 } 710 711 static inline struct device_node *of_get_cpu_node(int cpu, 712 unsigned int *thread) 713 { 714 return NULL; 715 } 716 717 static inline int of_property_read_u64(const struct device_node *np, 718 const char *propname, u64 *out_value) 719 { 720 return -ENOSYS; 721 } 722 723 static inline int of_property_match_string(const struct device_node *np, 724 const char *propname, 725 const char *string) 726 { 727 return -ENOSYS; 728 } 729 730 static inline struct device_node *of_parse_phandle(const struct device_node *np, 731 const char *phandle_name, 732 int index) 733 { 734 return NULL; 735 } 736 737 static inline int of_parse_phandle_with_args(const struct device_node *np, 738 const char *list_name, 739 const char *cells_name, 740 int index, 741 struct of_phandle_args *out_args) 742 { 743 return -ENOSYS; 744 } 745 746 static inline int of_parse_phandle_with_fixed_args(const struct device_node *np, 747 const char *list_name, int cells_count, int index, 748 struct of_phandle_args *out_args) 749 { 750 return -ENOSYS; 751 } 752 753 static inline int of_count_phandle_with_args(struct device_node *np, 754 const char *list_name, 755 const char *cells_name) 756 { 757 return -ENOSYS; 758 } 759 760 static inline int of_phandle_iterator_init(struct of_phandle_iterator *it, 761 const struct device_node *np, 762 const char *list_name, 763 const char *cells_name, 764 int cell_count) 765 { 766 return -ENOSYS; 767 } 768 769 static inline int of_phandle_iterator_next(struct of_phandle_iterator *it) 770 { 771 return -ENOSYS; 772 } 773 774 static inline int of_phandle_iterator_args(struct of_phandle_iterator *it, 775 uint32_t *args, 776 int size) 777 { 778 return 0; 779 } 780 781 static inline int of_alias_get_id(struct device_node *np, const char *stem) 782 { 783 return -ENOSYS; 784 } 785 786 static inline int of_alias_get_highest_id(const char *stem) 787 { 788 return -ENOSYS; 789 } 790 791 static inline int of_machine_is_compatible(const char *compat) 792 { 793 return 0; 794 } 795 796 static inline bool of_console_check(const struct device_node *dn, const char *name, int index) 797 { 798 return false; 799 } 800 801 static inline const __be32 *of_prop_next_u32(struct property *prop, 802 const __be32 *cur, u32 *pu) 803 { 804 return NULL; 805 } 806 807 static inline const char *of_prop_next_string(struct property *prop, 808 const char *cur) 809 { 810 return NULL; 811 } 812 813 static inline int of_node_check_flag(struct device_node *n, unsigned long flag) 814 { 815 return 0; 816 } 817 818 static inline int of_node_test_and_set_flag(struct device_node *n, 819 unsigned long flag) 820 { 821 return 0; 822 } 823 824 static inline void of_node_set_flag(struct device_node *n, unsigned long flag) 825 { 826 } 827 828 static inline void of_node_clear_flag(struct device_node *n, unsigned long flag) 829 { 830 } 831 832 static inline int of_property_check_flag(struct property *p, unsigned long flag) 833 { 834 return 0; 835 } 836 837 static inline void of_property_set_flag(struct property *p, unsigned long flag) 838 { 839 } 840 841 static inline void of_property_clear_flag(struct property *p, unsigned long flag) 842 { 843 } 844 845 #define of_match_ptr(_ptr) NULL 846 #define of_match_node(_matches, _node) NULL 847 #endif /* CONFIG_OF */ 848 849 /* Default string compare functions, Allow arch asm/prom.h to override */ 850 #if !defined(of_compat_cmp) 851 #define of_compat_cmp(s1, s2, l) strcasecmp((s1), (s2)) 852 #define of_prop_cmp(s1, s2) strcmp((s1), (s2)) 853 #define of_node_cmp(s1, s2) strcasecmp((s1), (s2)) 854 #endif 855 856 #if defined(CONFIG_OF) && defined(CONFIG_NUMA) 857 extern int of_node_to_nid(struct device_node *np); 858 #else 859 static inline int of_node_to_nid(struct device_node *device) 860 { 861 return NUMA_NO_NODE; 862 } 863 #endif 864 865 #ifdef CONFIG_OF_NUMA 866 extern int of_numa_init(void); 867 #else 868 static inline int of_numa_init(void) 869 { 870 return -ENOSYS; 871 } 872 #endif 873 874 static inline struct device_node *of_find_matching_node( 875 struct device_node *from, 876 const struct of_device_id *matches) 877 { 878 return of_find_matching_node_and_match(from, matches, NULL); 879 } 880 881 /** 882 * of_property_count_u8_elems - Count the number of u8 elements in a property 883 * 884 * @np: device node from which the property value is to be read. 885 * @propname: name of the property to be searched. 886 * 887 * Search for a property in a device node and count the number of u8 elements 888 * in it. Returns number of elements on sucess, -EINVAL if the property does 889 * not exist or its length does not match a multiple of u8 and -ENODATA if the 890 * property does not have a value. 891 */ 892 static inline int of_property_count_u8_elems(const struct device_node *np, 893 const char *propname) 894 { 895 return of_property_count_elems_of_size(np, propname, sizeof(u8)); 896 } 897 898 /** 899 * of_property_count_u16_elems - Count the number of u16 elements in a property 900 * 901 * @np: device node from which the property value is to be read. 902 * @propname: name of the property to be searched. 903 * 904 * Search for a property in a device node and count the number of u16 elements 905 * in it. Returns number of elements on sucess, -EINVAL if the property does 906 * not exist or its length does not match a multiple of u16 and -ENODATA if the 907 * property does not have a value. 908 */ 909 static inline int of_property_count_u16_elems(const struct device_node *np, 910 const char *propname) 911 { 912 return of_property_count_elems_of_size(np, propname, sizeof(u16)); 913 } 914 915 /** 916 * of_property_count_u32_elems - Count the number of u32 elements in a property 917 * 918 * @np: device node from which the property value is to be read. 919 * @propname: name of the property to be searched. 920 * 921 * Search for a property in a device node and count the number of u32 elements 922 * in it. Returns number of elements on sucess, -EINVAL if the property does 923 * not exist or its length does not match a multiple of u32 and -ENODATA if the 924 * property does not have a value. 925 */ 926 static inline int of_property_count_u32_elems(const struct device_node *np, 927 const char *propname) 928 { 929 return of_property_count_elems_of_size(np, propname, sizeof(u32)); 930 } 931 932 /** 933 * of_property_count_u64_elems - Count the number of u64 elements in a property 934 * 935 * @np: device node from which the property value is to be read. 936 * @propname: name of the property to be searched. 937 * 938 * Search for a property in a device node and count the number of u64 elements 939 * in it. Returns number of elements on sucess, -EINVAL if the property does 940 * not exist or its length does not match a multiple of u64 and -ENODATA if the 941 * property does not have a value. 942 */ 943 static inline int of_property_count_u64_elems(const struct device_node *np, 944 const char *propname) 945 { 946 return of_property_count_elems_of_size(np, propname, sizeof(u64)); 947 } 948 949 /** 950 * of_property_read_string_array() - Read an array of strings from a multiple 951 * strings property. 952 * @np: device node from which the property value is to be read. 953 * @propname: name of the property to be searched. 954 * @out_strs: output array of string pointers. 955 * @sz: number of array elements to read. 956 * 957 * Search for a property in a device tree node and retrieve a list of 958 * terminated string values (pointer to data, not a copy) in that property. 959 * 960 * If @out_strs is NULL, the number of strings in the property is returned. 961 */ 962 static inline int of_property_read_string_array(const struct device_node *np, 963 const char *propname, const char **out_strs, 964 size_t sz) 965 { 966 return of_property_read_string_helper(np, propname, out_strs, sz, 0); 967 } 968 969 /** 970 * of_property_count_strings() - Find and return the number of strings from a 971 * multiple strings property. 972 * @np: device node from which the property value is to be read. 973 * @propname: name of the property to be searched. 974 * 975 * Search for a property in a device tree node and retrieve the number of null 976 * terminated string contain in it. Returns the number of strings on 977 * success, -EINVAL if the property does not exist, -ENODATA if property 978 * does not have a value, and -EILSEQ if the string is not null-terminated 979 * within the length of the property data. 980 */ 981 static inline int of_property_count_strings(const struct device_node *np, 982 const char *propname) 983 { 984 return of_property_read_string_helper(np, propname, NULL, 0, 0); 985 } 986 987 /** 988 * of_property_read_string_index() - Find and read a string from a multiple 989 * strings property. 990 * @np: device node from which the property value is to be read. 991 * @propname: name of the property to be searched. 992 * @index: index of the string in the list of strings 993 * @out_string: pointer to null terminated return string, modified only if 994 * return value is 0. 995 * 996 * Search for a property in a device tree node and retrieve a null 997 * terminated string value (pointer to data, not a copy) in the list of strings 998 * contained in that property. 999 * Returns 0 on success, -EINVAL if the property does not exist, -ENODATA if 1000 * property does not have a value, and -EILSEQ if the string is not 1001 * null-terminated within the length of the property data. 1002 * 1003 * The out_string pointer is modified only if a valid string can be decoded. 1004 */ 1005 static inline int of_property_read_string_index(const struct device_node *np, 1006 const char *propname, 1007 int index, const char **output) 1008 { 1009 int rc = of_property_read_string_helper(np, propname, output, 1, index); 1010 return rc < 0 ? rc : 0; 1011 } 1012 1013 /** 1014 * of_property_read_bool - Findfrom a property 1015 * @np: device node from which the property value is to be read. 1016 * @propname: name of the property to be searched. 1017 * 1018 * Search for a property in a device node. 1019 * Returns true if the property exists false otherwise. 1020 */ 1021 static inline bool of_property_read_bool(const struct device_node *np, 1022 const char *propname) 1023 { 1024 struct property *prop = of_find_property(np, propname, NULL); 1025 1026 return prop ? true : false; 1027 } 1028 1029 static inline int of_property_read_u8(const struct device_node *np, 1030 const char *propname, 1031 u8 *out_value) 1032 { 1033 return of_property_read_u8_array(np, propname, out_value, 1); 1034 } 1035 1036 static inline int of_property_read_u16(const struct device_node *np, 1037 const char *propname, 1038 u16 *out_value) 1039 { 1040 return of_property_read_u16_array(np, propname, out_value, 1); 1041 } 1042 1043 static inline int of_property_read_u32(const struct device_node *np, 1044 const char *propname, 1045 u32 *out_value) 1046 { 1047 return of_property_read_u32_array(np, propname, out_value, 1); 1048 } 1049 1050 static inline int of_property_read_s32(const struct device_node *np, 1051 const char *propname, 1052 s32 *out_value) 1053 { 1054 return of_property_read_u32(np, propname, (u32*) out_value); 1055 } 1056 1057 #define of_for_each_phandle(it, err, np, ln, cn, cc) \ 1058 for (of_phandle_iterator_init((it), (np), (ln), (cn), (cc)), \ 1059 err = of_phandle_iterator_next(it); \ 1060 err == 0; \ 1061 err = of_phandle_iterator_next(it)) 1062 1063 #define of_property_for_each_u32(np, propname, prop, p, u) \ 1064 for (prop = of_find_property(np, propname, NULL), \ 1065 p = of_prop_next_u32(prop, NULL, &u); \ 1066 p; \ 1067 p = of_prop_next_u32(prop, p, &u)) 1068 1069 #define of_property_for_each_string(np, propname, prop, s) \ 1070 for (prop = of_find_property(np, propname, NULL), \ 1071 s = of_prop_next_string(prop, NULL); \ 1072 s; \ 1073 s = of_prop_next_string(prop, s)) 1074 1075 #define for_each_node_by_name(dn, name) \ 1076 for (dn = of_find_node_by_name(NULL, name); dn; \ 1077 dn = of_find_node_by_name(dn, name)) 1078 #define for_each_node_by_type(dn, type) \ 1079 for (dn = of_find_node_by_type(NULL, type); dn; \ 1080 dn = of_find_node_by_type(dn, type)) 1081 #define for_each_compatible_node(dn, type, compatible) \ 1082 for (dn = of_find_compatible_node(NULL, type, compatible); dn; \ 1083 dn = of_find_compatible_node(dn, type, compatible)) 1084 #define for_each_matching_node(dn, matches) \ 1085 for (dn = of_find_matching_node(NULL, matches); dn; \ 1086 dn = of_find_matching_node(dn, matches)) 1087 #define for_each_matching_node_and_match(dn, matches, match) \ 1088 for (dn = of_find_matching_node_and_match(NULL, matches, match); \ 1089 dn; dn = of_find_matching_node_and_match(dn, matches, match)) 1090 1091 #define for_each_child_of_node(parent, child) \ 1092 for (child = of_get_next_child(parent, NULL); child != NULL; \ 1093 child = of_get_next_child(parent, child)) 1094 #define for_each_available_child_of_node(parent, child) \ 1095 for (child = of_get_next_available_child(parent, NULL); child != NULL; \ 1096 child = of_get_next_available_child(parent, child)) 1097 1098 #define for_each_node_with_property(dn, prop_name) \ 1099 for (dn = of_find_node_with_property(NULL, prop_name); dn; \ 1100 dn = of_find_node_with_property(dn, prop_name)) 1101 1102 static inline int of_get_child_count(const struct device_node *np) 1103 { 1104 struct device_node *child; 1105 int num = 0; 1106 1107 for_each_child_of_node(np, child) 1108 num++; 1109 1110 return num; 1111 } 1112 1113 static inline int of_get_available_child_count(const struct device_node *np) 1114 { 1115 struct device_node *child; 1116 int num = 0; 1117 1118 for_each_available_child_of_node(np, child) 1119 num++; 1120 1121 return num; 1122 } 1123 1124 #if defined(CONFIG_OF) && !defined(MODULE) 1125 #define _OF_DECLARE(table, name, compat, fn, fn_type) \ 1126 static const struct of_device_id __of_table_##name \ 1127 __used __section(__##table##_of_table) \ 1128 = { .compatible = compat, \ 1129 .data = (fn == (fn_type)NULL) ? fn : fn } 1130 #else 1131 #define _OF_DECLARE(table, name, compat, fn, fn_type) \ 1132 static const struct of_device_id __of_table_##name \ 1133 __attribute__((unused)) \ 1134 = { .compatible = compat, \ 1135 .data = (fn == (fn_type)NULL) ? fn : fn } 1136 #endif 1137 1138 typedef int (*of_init_fn_2)(struct device_node *, struct device_node *); 1139 typedef int (*of_init_fn_1_ret)(struct device_node *); 1140 typedef void (*of_init_fn_1)(struct device_node *); 1141 1142 #define OF_DECLARE_1(table, name, compat, fn) \ 1143 _OF_DECLARE(table, name, compat, fn, of_init_fn_1) 1144 #define OF_DECLARE_1_RET(table, name, compat, fn) \ 1145 _OF_DECLARE(table, name, compat, fn, of_init_fn_1_ret) 1146 #define OF_DECLARE_2(table, name, compat, fn) \ 1147 _OF_DECLARE(table, name, compat, fn, of_init_fn_2) 1148 1149 /** 1150 * struct of_changeset_entry - Holds a changeset entry 1151 * 1152 * @node: list_head for the log list 1153 * @action: notifier action 1154 * @np: pointer to the device node affected 1155 * @prop: pointer to the property affected 1156 * @old_prop: hold a pointer to the original property 1157 * 1158 * Every modification of the device tree during a changeset 1159 * is held in a list of of_changeset_entry structures. 1160 * That way we can recover from a partial application, or we can 1161 * revert the changeset 1162 */ 1163 struct of_changeset_entry { 1164 struct list_head node; 1165 unsigned long action; 1166 struct device_node *np; 1167 struct property *prop; 1168 struct property *old_prop; 1169 }; 1170 1171 /** 1172 * struct of_changeset - changeset tracker structure 1173 * 1174 * @entries: list_head for the changeset entries 1175 * 1176 * changesets are a convenient way to apply bulk changes to the 1177 * live tree. In case of an error, changes are rolled-back. 1178 * changesets live on after initial application, and if not 1179 * destroyed after use, they can be reverted in one single call. 1180 */ 1181 struct of_changeset { 1182 struct list_head entries; 1183 }; 1184 1185 enum of_reconfig_change { 1186 OF_RECONFIG_NO_CHANGE = 0, 1187 OF_RECONFIG_CHANGE_ADD, 1188 OF_RECONFIG_CHANGE_REMOVE, 1189 }; 1190 1191 #ifdef CONFIG_OF_DYNAMIC 1192 extern int of_reconfig_notifier_register(struct notifier_block *); 1193 extern int of_reconfig_notifier_unregister(struct notifier_block *); 1194 extern int of_reconfig_notify(unsigned long, struct of_reconfig_data *rd); 1195 extern int of_reconfig_get_state_change(unsigned long action, 1196 struct of_reconfig_data *arg); 1197 1198 extern void of_changeset_init(struct of_changeset *ocs); 1199 extern void of_changeset_destroy(struct of_changeset *ocs); 1200 extern int of_changeset_apply(struct of_changeset *ocs); 1201 extern int of_changeset_revert(struct of_changeset *ocs); 1202 extern int of_changeset_action(struct of_changeset *ocs, 1203 unsigned long action, struct device_node *np, 1204 struct property *prop); 1205 1206 static inline int of_changeset_attach_node(struct of_changeset *ocs, 1207 struct device_node *np) 1208 { 1209 return of_changeset_action(ocs, OF_RECONFIG_ATTACH_NODE, np, NULL); 1210 } 1211 1212 static inline int of_changeset_detach_node(struct of_changeset *ocs, 1213 struct device_node *np) 1214 { 1215 return of_changeset_action(ocs, OF_RECONFIG_DETACH_NODE, np, NULL); 1216 } 1217 1218 static inline int of_changeset_add_property(struct of_changeset *ocs, 1219 struct device_node *np, struct property *prop) 1220 { 1221 return of_changeset_action(ocs, OF_RECONFIG_ADD_PROPERTY, np, prop); 1222 } 1223 1224 static inline int of_changeset_remove_property(struct of_changeset *ocs, 1225 struct device_node *np, struct property *prop) 1226 { 1227 return of_changeset_action(ocs, OF_RECONFIG_REMOVE_PROPERTY, np, prop); 1228 } 1229 1230 static inline int of_changeset_update_property(struct of_changeset *ocs, 1231 struct device_node *np, struct property *prop) 1232 { 1233 return of_changeset_action(ocs, OF_RECONFIG_UPDATE_PROPERTY, np, prop); 1234 } 1235 #else /* CONFIG_OF_DYNAMIC */ 1236 static inline int of_reconfig_notifier_register(struct notifier_block *nb) 1237 { 1238 return -EINVAL; 1239 } 1240 static inline int of_reconfig_notifier_unregister(struct notifier_block *nb) 1241 { 1242 return -EINVAL; 1243 } 1244 static inline int of_reconfig_notify(unsigned long action, 1245 struct of_reconfig_data *arg) 1246 { 1247 return -EINVAL; 1248 } 1249 static inline int of_reconfig_get_state_change(unsigned long action, 1250 struct of_reconfig_data *arg) 1251 { 1252 return -EINVAL; 1253 } 1254 #endif /* CONFIG_OF_DYNAMIC */ 1255 1256 /* CONFIG_OF_RESOLVE api */ 1257 extern int of_resolve_phandles(struct device_node *tree); 1258 1259 /** 1260 * of_device_is_system_power_controller - Tells if system-power-controller is found for device_node 1261 * @np: Pointer to the given device_node 1262 * 1263 * return true if present false otherwise 1264 */ 1265 static inline bool of_device_is_system_power_controller(const struct device_node *np) 1266 { 1267 return of_property_read_bool(np, "system-power-controller"); 1268 } 1269 1270 /** 1271 * Overlay support 1272 */ 1273 1274 enum of_overlay_notify_action { 1275 OF_OVERLAY_PRE_APPLY, 1276 OF_OVERLAY_POST_APPLY, 1277 OF_OVERLAY_PRE_REMOVE, 1278 OF_OVERLAY_POST_REMOVE, 1279 }; 1280 1281 struct of_overlay_notify_data { 1282 struct device_node *overlay; 1283 struct device_node *target; 1284 }; 1285 1286 #ifdef CONFIG_OF_OVERLAY 1287 1288 /* ID based overlays; the API for external users */ 1289 int of_overlay_create(struct device_node *tree); 1290 int of_overlay_destroy(int id); 1291 int of_overlay_destroy_all(void); 1292 1293 int of_overlay_notifier_register(struct notifier_block *nb); 1294 int of_overlay_notifier_unregister(struct notifier_block *nb); 1295 1296 #else 1297 1298 static inline int of_overlay_create(struct device_node *tree) 1299 { 1300 return -ENOTSUPP; 1301 } 1302 1303 static inline int of_overlay_destroy(int id) 1304 { 1305 return -ENOTSUPP; 1306 } 1307 1308 static inline int of_overlay_destroy_all(void) 1309 { 1310 return -ENOTSUPP; 1311 } 1312 1313 static inline int of_overlay_notifier_register(struct notifier_block *nb) 1314 { 1315 return 0; 1316 } 1317 1318 static inline int of_overlay_notifier_unregister(struct notifier_block *nb) 1319 { 1320 return 0; 1321 } 1322 1323 #endif 1324 1325 #endif /* _LINUX_OF_H */ 1326