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 static inline bool of_have_populated_dt(void) 163 { 164 return of_root != NULL; 165 } 166 167 static inline bool of_node_is_root(const struct device_node *node) 168 { 169 return node && (node->parent == NULL); 170 } 171 172 static inline int of_node_check_flag(struct device_node *n, unsigned long flag) 173 { 174 return test_bit(flag, &n->_flags); 175 } 176 177 static inline int of_node_test_and_set_flag(struct device_node *n, 178 unsigned long flag) 179 { 180 return test_and_set_bit(flag, &n->_flags); 181 } 182 183 static inline void of_node_set_flag(struct device_node *n, unsigned long flag) 184 { 185 set_bit(flag, &n->_flags); 186 } 187 188 static inline void of_node_clear_flag(struct device_node *n, unsigned long flag) 189 { 190 clear_bit(flag, &n->_flags); 191 } 192 193 static inline int of_property_check_flag(struct property *p, unsigned long flag) 194 { 195 return test_bit(flag, &p->_flags); 196 } 197 198 static inline void of_property_set_flag(struct property *p, unsigned long flag) 199 { 200 set_bit(flag, &p->_flags); 201 } 202 203 static inline void of_property_clear_flag(struct property *p, unsigned long flag) 204 { 205 clear_bit(flag, &p->_flags); 206 } 207 208 extern struct device_node *__of_find_all_nodes(struct device_node *prev); 209 extern struct device_node *of_find_all_nodes(struct device_node *prev); 210 211 /* 212 * OF address retrieval & translation 213 */ 214 215 /* Helper to read a big number; size is in cells (not bytes) */ 216 static inline u64 of_read_number(const __be32 *cell, int size) 217 { 218 u64 r = 0; 219 while (size--) 220 r = (r << 32) | be32_to_cpu(*(cell++)); 221 return r; 222 } 223 224 /* Like of_read_number, but we want an unsigned long result */ 225 static inline unsigned long of_read_ulong(const __be32 *cell, int size) 226 { 227 /* toss away upper bits if unsigned long is smaller than u64 */ 228 return of_read_number(cell, size); 229 } 230 231 #if defined(CONFIG_SPARC) 232 #include <asm/prom.h> 233 #endif 234 235 /* Default #address and #size cells. Allow arch asm/prom.h to override */ 236 #if !defined(OF_ROOT_NODE_ADDR_CELLS_DEFAULT) 237 #define OF_ROOT_NODE_ADDR_CELLS_DEFAULT 1 238 #define OF_ROOT_NODE_SIZE_CELLS_DEFAULT 1 239 #endif 240 241 /* Default string compare functions, Allow arch asm/prom.h to override */ 242 #if !defined(of_compat_cmp) 243 #define of_compat_cmp(s1, s2, l) strcasecmp((s1), (s2)) 244 #define of_prop_cmp(s1, s2) strcmp((s1), (s2)) 245 #define of_node_cmp(s1, s2) strcasecmp((s1), (s2)) 246 #endif 247 248 #define OF_IS_DYNAMIC(x) test_bit(OF_DYNAMIC, &x->_flags) 249 #define OF_MARK_DYNAMIC(x) set_bit(OF_DYNAMIC, &x->_flags) 250 251 static inline const char *of_node_full_name(const struct device_node *np) 252 { 253 return np ? np->full_name : "<no-node>"; 254 } 255 256 #define for_each_of_allnodes_from(from, dn) \ 257 for (dn = __of_find_all_nodes(from); dn; dn = __of_find_all_nodes(dn)) 258 #define for_each_of_allnodes(dn) for_each_of_allnodes_from(NULL, dn) 259 extern struct device_node *of_find_node_by_name(struct device_node *from, 260 const char *name); 261 extern struct device_node *of_find_node_by_type(struct device_node *from, 262 const char *type); 263 extern struct device_node *of_find_compatible_node(struct device_node *from, 264 const char *type, const char *compat); 265 extern struct device_node *of_find_matching_node_and_match( 266 struct device_node *from, 267 const struct of_device_id *matches, 268 const struct of_device_id **match); 269 270 extern struct device_node *of_find_node_opts_by_path(const char *path, 271 const char **opts); 272 static inline struct device_node *of_find_node_by_path(const char *path) 273 { 274 return of_find_node_opts_by_path(path, NULL); 275 } 276 277 extern struct device_node *of_find_node_by_phandle(phandle handle); 278 extern struct device_node *of_get_parent(const struct device_node *node); 279 extern struct device_node *of_get_next_parent(struct device_node *node); 280 extern struct device_node *of_get_next_child(const struct device_node *node, 281 struct device_node *prev); 282 extern struct device_node *of_get_next_available_child( 283 const struct device_node *node, struct device_node *prev); 284 285 extern struct device_node *of_get_child_by_name(const struct device_node *node, 286 const char *name); 287 288 /* cache lookup */ 289 extern struct device_node *of_find_next_cache_node(const struct device_node *); 290 extern struct device_node *of_find_node_with_property( 291 struct device_node *from, const char *prop_name); 292 293 extern struct property *of_find_property(const struct device_node *np, 294 const char *name, 295 int *lenp); 296 extern int of_property_count_elems_of_size(const struct device_node *np, 297 const char *propname, int elem_size); 298 extern int of_property_read_u32_index(const struct device_node *np, 299 const char *propname, 300 u32 index, u32 *out_value); 301 extern int of_property_read_u8_array(const struct device_node *np, 302 const char *propname, u8 *out_values, size_t sz); 303 extern int of_property_read_u16_array(const struct device_node *np, 304 const char *propname, u16 *out_values, size_t sz); 305 extern int of_property_read_u32_array(const struct device_node *np, 306 const char *propname, 307 u32 *out_values, 308 size_t sz); 309 extern int of_property_read_u64(const struct device_node *np, 310 const char *propname, u64 *out_value); 311 extern int of_property_read_u64_array(const struct device_node *np, 312 const char *propname, 313 u64 *out_values, 314 size_t sz); 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 bool of_device_is_available(const struct device_node *device); 328 extern bool of_device_is_big_endian(const struct device_node *device); 329 extern const void *of_get_property(const struct device_node *node, 330 const char *name, 331 int *lenp); 332 extern struct device_node *of_get_cpu_node(int cpu, unsigned int *thread); 333 #define for_each_property_of_node(dn, pp) \ 334 for (pp = dn->properties; pp != NULL; pp = pp->next) 335 336 extern int of_n_addr_cells(struct device_node *np); 337 extern int of_n_size_cells(struct device_node *np); 338 extern const struct of_device_id *of_match_node( 339 const struct of_device_id *matches, const struct device_node *node); 340 extern int of_modalias_node(struct device_node *node, char *modalias, int len); 341 extern void of_print_phandle_args(const char *msg, const struct of_phandle_args *args); 342 extern struct device_node *of_parse_phandle(const struct device_node *np, 343 const char *phandle_name, 344 int index); 345 extern int of_parse_phandle_with_args(const struct device_node *np, 346 const char *list_name, const char *cells_name, int index, 347 struct of_phandle_args *out_args); 348 extern int of_parse_phandle_with_fixed_args(const struct device_node *np, 349 const char *list_name, int cells_count, int index, 350 struct of_phandle_args *out_args); 351 extern int of_count_phandle_with_args(const struct device_node *np, 352 const char *list_name, const char *cells_name); 353 354 /* phandle iterator functions */ 355 extern int of_phandle_iterator_init(struct of_phandle_iterator *it, 356 const struct device_node *np, 357 const char *list_name, 358 const char *cells_name, 359 int cell_count); 360 361 extern int of_phandle_iterator_next(struct of_phandle_iterator *it); 362 extern int of_phandle_iterator_args(struct of_phandle_iterator *it, 363 uint32_t *args, 364 int size); 365 366 extern void of_alias_scan(void * (*dt_alloc)(u64 size, u64 align)); 367 extern int of_alias_get_id(struct device_node *np, const char *stem); 368 extern int of_alias_get_highest_id(const char *stem); 369 370 extern int of_machine_is_compatible(const char *compat); 371 372 extern int of_add_property(struct device_node *np, struct property *prop); 373 extern int of_remove_property(struct device_node *np, struct property *prop); 374 extern int of_update_property(struct device_node *np, struct property *newprop); 375 376 /* For updating the device tree at runtime */ 377 #define OF_RECONFIG_ATTACH_NODE 0x0001 378 #define OF_RECONFIG_DETACH_NODE 0x0002 379 #define OF_RECONFIG_ADD_PROPERTY 0x0003 380 #define OF_RECONFIG_REMOVE_PROPERTY 0x0004 381 #define OF_RECONFIG_UPDATE_PROPERTY 0x0005 382 383 extern int of_attach_node(struct device_node *); 384 extern int of_detach_node(struct device_node *); 385 386 #define of_match_ptr(_ptr) (_ptr) 387 388 /* 389 * struct property *prop; 390 * const __be32 *p; 391 * u32 u; 392 * 393 * of_property_for_each_u32(np, "propname", prop, p, u) 394 * printk("U32 value: %x\n", u); 395 */ 396 const __be32 *of_prop_next_u32(struct property *prop, const __be32 *cur, 397 u32 *pu); 398 /* 399 * struct property *prop; 400 * const char *s; 401 * 402 * of_property_for_each_string(np, "propname", prop, s) 403 * printk("String value: %s\n", s); 404 */ 405 const char *of_prop_next_string(struct property *prop, const char *cur); 406 407 bool of_console_check(struct device_node *dn, char *name, int index); 408 409 #else /* CONFIG_OF */ 410 411 static inline void of_core_init(void) 412 { 413 } 414 415 static inline bool is_of_node(struct fwnode_handle *fwnode) 416 { 417 return false; 418 } 419 420 static inline struct device_node *to_of_node(struct fwnode_handle *fwnode) 421 { 422 return NULL; 423 } 424 425 static inline const char* of_node_full_name(const struct device_node *np) 426 { 427 return "<no-node>"; 428 } 429 430 static inline struct device_node *of_find_node_by_name(struct device_node *from, 431 const char *name) 432 { 433 return NULL; 434 } 435 436 static inline struct device_node *of_find_node_by_type(struct device_node *from, 437 const char *type) 438 { 439 return NULL; 440 } 441 442 static inline struct device_node *of_find_matching_node_and_match( 443 struct device_node *from, 444 const struct of_device_id *matches, 445 const struct of_device_id **match) 446 { 447 return NULL; 448 } 449 450 static inline struct device_node *of_find_node_by_path(const char *path) 451 { 452 return NULL; 453 } 454 455 static inline struct device_node *of_find_node_opts_by_path(const char *path, 456 const char **opts) 457 { 458 return NULL; 459 } 460 461 static inline struct device_node *of_find_node_by_phandle(phandle handle) 462 { 463 return NULL; 464 } 465 466 static inline struct device_node *of_get_parent(const struct device_node *node) 467 { 468 return NULL; 469 } 470 471 static inline struct device_node *of_get_next_child( 472 const struct device_node *node, struct device_node *prev) 473 { 474 return NULL; 475 } 476 477 static inline struct device_node *of_get_next_available_child( 478 const struct device_node *node, struct device_node *prev) 479 { 480 return NULL; 481 } 482 483 static inline struct device_node *of_find_node_with_property( 484 struct device_node *from, const char *prop_name) 485 { 486 return NULL; 487 } 488 489 static inline bool of_have_populated_dt(void) 490 { 491 return false; 492 } 493 494 static inline struct device_node *of_get_child_by_name( 495 const struct device_node *node, 496 const char *name) 497 { 498 return NULL; 499 } 500 501 static inline int of_device_is_compatible(const struct device_node *device, 502 const char *name) 503 { 504 return 0; 505 } 506 507 static inline bool of_device_is_available(const struct device_node *device) 508 { 509 return false; 510 } 511 512 static inline bool of_device_is_big_endian(const struct device_node *device) 513 { 514 return false; 515 } 516 517 static inline struct property *of_find_property(const struct device_node *np, 518 const char *name, 519 int *lenp) 520 { 521 return NULL; 522 } 523 524 static inline struct device_node *of_find_compatible_node( 525 struct device_node *from, 526 const char *type, 527 const char *compat) 528 { 529 return NULL; 530 } 531 532 static inline int of_property_count_elems_of_size(const struct device_node *np, 533 const char *propname, int elem_size) 534 { 535 return -ENOSYS; 536 } 537 538 static inline int of_property_read_u32_index(const struct device_node *np, 539 const char *propname, u32 index, u32 *out_value) 540 { 541 return -ENOSYS; 542 } 543 544 static inline int of_property_read_u8_array(const struct device_node *np, 545 const char *propname, u8 *out_values, size_t sz) 546 { 547 return -ENOSYS; 548 } 549 550 static inline int of_property_read_u16_array(const struct device_node *np, 551 const char *propname, u16 *out_values, size_t sz) 552 { 553 return -ENOSYS; 554 } 555 556 static inline int of_property_read_u32_array(const struct device_node *np, 557 const char *propname, 558 u32 *out_values, size_t sz) 559 { 560 return -ENOSYS; 561 } 562 563 static inline int of_property_read_u64_array(const struct device_node *np, 564 const char *propname, 565 u64 *out_values, size_t sz) 566 { 567 return -ENOSYS; 568 } 569 570 static inline int of_property_read_string(const struct device_node *np, 571 const char *propname, 572 const char **out_string) 573 { 574 return -ENOSYS; 575 } 576 577 static inline int of_property_read_string_helper(const struct device_node *np, 578 const char *propname, 579 const char **out_strs, size_t sz, int index) 580 { 581 return -ENOSYS; 582 } 583 584 static inline const void *of_get_property(const struct device_node *node, 585 const char *name, 586 int *lenp) 587 { 588 return NULL; 589 } 590 591 static inline struct device_node *of_get_cpu_node(int cpu, 592 unsigned int *thread) 593 { 594 return NULL; 595 } 596 597 static inline int of_property_read_u64(const struct device_node *np, 598 const char *propname, u64 *out_value) 599 { 600 return -ENOSYS; 601 } 602 603 static inline int of_property_match_string(const struct device_node *np, 604 const char *propname, 605 const char *string) 606 { 607 return -ENOSYS; 608 } 609 610 static inline struct device_node *of_parse_phandle(const struct device_node *np, 611 const char *phandle_name, 612 int index) 613 { 614 return NULL; 615 } 616 617 static inline int of_parse_phandle_with_args(struct device_node *np, 618 const char *list_name, 619 const char *cells_name, 620 int index, 621 struct of_phandle_args *out_args) 622 { 623 return -ENOSYS; 624 } 625 626 static inline int of_parse_phandle_with_fixed_args(const struct device_node *np, 627 const char *list_name, int cells_count, int index, 628 struct of_phandle_args *out_args) 629 { 630 return -ENOSYS; 631 } 632 633 static inline int of_count_phandle_with_args(struct device_node *np, 634 const char *list_name, 635 const char *cells_name) 636 { 637 return -ENOSYS; 638 } 639 640 static inline int of_phandle_iterator_init(struct of_phandle_iterator *it, 641 const struct device_node *np, 642 const char *list_name, 643 const char *cells_name, 644 int cell_count) 645 { 646 return -ENOSYS; 647 } 648 649 static inline int of_phandle_iterator_next(struct of_phandle_iterator *it) 650 { 651 return -ENOSYS; 652 } 653 654 static inline int of_phandle_iterator_args(struct of_phandle_iterator *it, 655 uint32_t *args, 656 int size) 657 { 658 return 0; 659 } 660 661 static inline int of_alias_get_id(struct device_node *np, const char *stem) 662 { 663 return -ENOSYS; 664 } 665 666 static inline int of_alias_get_highest_id(const char *stem) 667 { 668 return -ENOSYS; 669 } 670 671 static inline int of_machine_is_compatible(const char *compat) 672 { 673 return 0; 674 } 675 676 static inline bool of_console_check(const struct device_node *dn, const char *name, int index) 677 { 678 return false; 679 } 680 681 static inline const __be32 *of_prop_next_u32(struct property *prop, 682 const __be32 *cur, u32 *pu) 683 { 684 return NULL; 685 } 686 687 static inline const char *of_prop_next_string(struct property *prop, 688 const char *cur) 689 { 690 return NULL; 691 } 692 693 static inline int of_node_check_flag(struct device_node *n, unsigned long flag) 694 { 695 return 0; 696 } 697 698 static inline int of_node_test_and_set_flag(struct device_node *n, 699 unsigned long flag) 700 { 701 return 0; 702 } 703 704 static inline void of_node_set_flag(struct device_node *n, unsigned long flag) 705 { 706 } 707 708 static inline void of_node_clear_flag(struct device_node *n, unsigned long flag) 709 { 710 } 711 712 static inline int of_property_check_flag(struct property *p, unsigned long flag) 713 { 714 return 0; 715 } 716 717 static inline void of_property_set_flag(struct property *p, unsigned long flag) 718 { 719 } 720 721 static inline void of_property_clear_flag(struct property *p, unsigned long flag) 722 { 723 } 724 725 #define of_match_ptr(_ptr) NULL 726 #define of_match_node(_matches, _node) NULL 727 #endif /* CONFIG_OF */ 728 729 #if defined(CONFIG_OF) && defined(CONFIG_NUMA) 730 extern int of_node_to_nid(struct device_node *np); 731 #else 732 static inline int of_node_to_nid(struct device_node *device) 733 { 734 return NUMA_NO_NODE; 735 } 736 #endif 737 738 #ifdef CONFIG_OF_NUMA 739 extern int of_numa_init(void); 740 #else 741 static inline int of_numa_init(void) 742 { 743 return -ENOSYS; 744 } 745 #endif 746 747 static inline struct device_node *of_find_matching_node( 748 struct device_node *from, 749 const struct of_device_id *matches) 750 { 751 return of_find_matching_node_and_match(from, matches, NULL); 752 } 753 754 /** 755 * of_property_count_u8_elems - Count the number of u8 elements in a property 756 * 757 * @np: device node from which the property value is to be read. 758 * @propname: name of the property to be searched. 759 * 760 * Search for a property in a device node and count the number of u8 elements 761 * in it. Returns number of elements on sucess, -EINVAL if the property does 762 * not exist or its length does not match a multiple of u8 and -ENODATA if the 763 * property does not have a value. 764 */ 765 static inline int of_property_count_u8_elems(const struct device_node *np, 766 const char *propname) 767 { 768 return of_property_count_elems_of_size(np, propname, sizeof(u8)); 769 } 770 771 /** 772 * of_property_count_u16_elems - Count the number of u16 elements in a property 773 * 774 * @np: device node from which the property value is to be read. 775 * @propname: name of the property to be searched. 776 * 777 * Search for a property in a device node and count the number of u16 elements 778 * in it. Returns number of elements on sucess, -EINVAL if the property does 779 * not exist or its length does not match a multiple of u16 and -ENODATA if the 780 * property does not have a value. 781 */ 782 static inline int of_property_count_u16_elems(const struct device_node *np, 783 const char *propname) 784 { 785 return of_property_count_elems_of_size(np, propname, sizeof(u16)); 786 } 787 788 /** 789 * of_property_count_u32_elems - Count the number of u32 elements in a property 790 * 791 * @np: device node from which the property value is to be read. 792 * @propname: name of the property to be searched. 793 * 794 * Search for a property in a device node and count the number of u32 elements 795 * in it. Returns number of elements on sucess, -EINVAL if the property does 796 * not exist or its length does not match a multiple of u32 and -ENODATA if the 797 * property does not have a value. 798 */ 799 static inline int of_property_count_u32_elems(const struct device_node *np, 800 const char *propname) 801 { 802 return of_property_count_elems_of_size(np, propname, sizeof(u32)); 803 } 804 805 /** 806 * of_property_count_u64_elems - Count the number of u64 elements in a property 807 * 808 * @np: device node from which the property value is to be read. 809 * @propname: name of the property to be searched. 810 * 811 * Search for a property in a device node and count the number of u64 elements 812 * in it. Returns number of elements on sucess, -EINVAL if the property does 813 * not exist or its length does not match a multiple of u64 and -ENODATA if the 814 * property does not have a value. 815 */ 816 static inline int of_property_count_u64_elems(const struct device_node *np, 817 const char *propname) 818 { 819 return of_property_count_elems_of_size(np, propname, sizeof(u64)); 820 } 821 822 /** 823 * of_property_read_string_array() - Read an array of strings from a multiple 824 * strings property. 825 * @np: device node from which the property value is to be read. 826 * @propname: name of the property to be searched. 827 * @out_strs: output array of string pointers. 828 * @sz: number of array elements to read. 829 * 830 * Search for a property in a device tree node and retrieve a list of 831 * terminated string values (pointer to data, not a copy) in that property. 832 * 833 * If @out_strs is NULL, the number of strings in the property is returned. 834 */ 835 static inline int of_property_read_string_array(const struct device_node *np, 836 const char *propname, const char **out_strs, 837 size_t sz) 838 { 839 return of_property_read_string_helper(np, propname, out_strs, sz, 0); 840 } 841 842 /** 843 * of_property_count_strings() - Find and return the number of strings from a 844 * multiple strings property. 845 * @np: device node from which the property value is to be read. 846 * @propname: name of the property to be searched. 847 * 848 * Search for a property in a device tree node and retrieve the number of null 849 * terminated string contain in it. Returns the number of strings on 850 * success, -EINVAL if the property does not exist, -ENODATA if property 851 * does not have a value, and -EILSEQ if the string is not null-terminated 852 * within the length of the property data. 853 */ 854 static inline int of_property_count_strings(const struct device_node *np, 855 const char *propname) 856 { 857 return of_property_read_string_helper(np, propname, NULL, 0, 0); 858 } 859 860 /** 861 * of_property_read_string_index() - Find and read a string from a multiple 862 * strings property. 863 * @np: device node from which the property value is to be read. 864 * @propname: name of the property to be searched. 865 * @index: index of the string in the list of strings 866 * @out_string: pointer to null terminated return string, modified only if 867 * return value is 0. 868 * 869 * Search for a property in a device tree node and retrieve a null 870 * terminated string value (pointer to data, not a copy) in the list of strings 871 * contained in that property. 872 * Returns 0 on success, -EINVAL if the property does not exist, -ENODATA if 873 * property does not have a value, and -EILSEQ if the string is not 874 * null-terminated within the length of the property data. 875 * 876 * The out_string pointer is modified only if a valid string can be decoded. 877 */ 878 static inline int of_property_read_string_index(const struct device_node *np, 879 const char *propname, 880 int index, const char **output) 881 { 882 int rc = of_property_read_string_helper(np, propname, output, 1, index); 883 return rc < 0 ? rc : 0; 884 } 885 886 /** 887 * of_property_read_bool - Findfrom a property 888 * @np: device node from which the property value is to be read. 889 * @propname: name of the property to be searched. 890 * 891 * Search for a property in a device node. 892 * Returns true if the property exists false otherwise. 893 */ 894 static inline bool of_property_read_bool(const struct device_node *np, 895 const char *propname) 896 { 897 struct property *prop = of_find_property(np, propname, NULL); 898 899 return prop ? true : false; 900 } 901 902 static inline int of_property_read_u8(const struct device_node *np, 903 const char *propname, 904 u8 *out_value) 905 { 906 return of_property_read_u8_array(np, propname, out_value, 1); 907 } 908 909 static inline int of_property_read_u16(const struct device_node *np, 910 const char *propname, 911 u16 *out_value) 912 { 913 return of_property_read_u16_array(np, propname, out_value, 1); 914 } 915 916 static inline int of_property_read_u32(const struct device_node *np, 917 const char *propname, 918 u32 *out_value) 919 { 920 return of_property_read_u32_array(np, propname, out_value, 1); 921 } 922 923 static inline int of_property_read_s32(const struct device_node *np, 924 const char *propname, 925 s32 *out_value) 926 { 927 return of_property_read_u32(np, propname, (u32*) out_value); 928 } 929 930 #define of_for_each_phandle(it, err, np, ln, cn, cc) \ 931 for (of_phandle_iterator_init((it), (np), (ln), (cn), (cc)), \ 932 err = of_phandle_iterator_next(it); \ 933 err == 0; \ 934 err = of_phandle_iterator_next(it)) 935 936 #define of_property_for_each_u32(np, propname, prop, p, u) \ 937 for (prop = of_find_property(np, propname, NULL), \ 938 p = of_prop_next_u32(prop, NULL, &u); \ 939 p; \ 940 p = of_prop_next_u32(prop, p, &u)) 941 942 #define of_property_for_each_string(np, propname, prop, s) \ 943 for (prop = of_find_property(np, propname, NULL), \ 944 s = of_prop_next_string(prop, NULL); \ 945 s; \ 946 s = of_prop_next_string(prop, s)) 947 948 #define for_each_node_by_name(dn, name) \ 949 for (dn = of_find_node_by_name(NULL, name); dn; \ 950 dn = of_find_node_by_name(dn, name)) 951 #define for_each_node_by_type(dn, type) \ 952 for (dn = of_find_node_by_type(NULL, type); dn; \ 953 dn = of_find_node_by_type(dn, type)) 954 #define for_each_compatible_node(dn, type, compatible) \ 955 for (dn = of_find_compatible_node(NULL, type, compatible); dn; \ 956 dn = of_find_compatible_node(dn, type, compatible)) 957 #define for_each_matching_node(dn, matches) \ 958 for (dn = of_find_matching_node(NULL, matches); dn; \ 959 dn = of_find_matching_node(dn, matches)) 960 #define for_each_matching_node_and_match(dn, matches, match) \ 961 for (dn = of_find_matching_node_and_match(NULL, matches, match); \ 962 dn; dn = of_find_matching_node_and_match(dn, matches, match)) 963 964 #define for_each_child_of_node(parent, child) \ 965 for (child = of_get_next_child(parent, NULL); child != NULL; \ 966 child = of_get_next_child(parent, child)) 967 #define for_each_available_child_of_node(parent, child) \ 968 for (child = of_get_next_available_child(parent, NULL); child != NULL; \ 969 child = of_get_next_available_child(parent, child)) 970 971 #define for_each_node_with_property(dn, prop_name) \ 972 for (dn = of_find_node_with_property(NULL, prop_name); dn; \ 973 dn = of_find_node_with_property(dn, prop_name)) 974 975 static inline int of_get_child_count(const struct device_node *np) 976 { 977 struct device_node *child; 978 int num = 0; 979 980 for_each_child_of_node(np, child) 981 num++; 982 983 return num; 984 } 985 986 static inline int of_get_available_child_count(const struct device_node *np) 987 { 988 struct device_node *child; 989 int num = 0; 990 991 for_each_available_child_of_node(np, child) 992 num++; 993 994 return num; 995 } 996 997 #if defined(CONFIG_OF) && !defined(MODULE) 998 #define _OF_DECLARE(table, name, compat, fn, fn_type) \ 999 static const struct of_device_id __of_table_##name \ 1000 __used __section(__##table##_of_table) \ 1001 = { .compatible = compat, \ 1002 .data = (fn == (fn_type)NULL) ? fn : fn } 1003 #else 1004 #define _OF_DECLARE(table, name, compat, fn, fn_type) \ 1005 static const struct of_device_id __of_table_##name \ 1006 __attribute__((unused)) \ 1007 = { .compatible = compat, \ 1008 .data = (fn == (fn_type)NULL) ? fn : fn } 1009 #endif 1010 1011 typedef int (*of_init_fn_2)(struct device_node *, struct device_node *); 1012 typedef void (*of_init_fn_1)(struct device_node *); 1013 1014 #define OF_DECLARE_1(table, name, compat, fn) \ 1015 _OF_DECLARE(table, name, compat, fn, of_init_fn_1) 1016 #define OF_DECLARE_2(table, name, compat, fn) \ 1017 _OF_DECLARE(table, name, compat, fn, of_init_fn_2) 1018 1019 /** 1020 * struct of_changeset_entry - Holds a changeset entry 1021 * 1022 * @node: list_head for the log list 1023 * @action: notifier action 1024 * @np: pointer to the device node affected 1025 * @prop: pointer to the property affected 1026 * @old_prop: hold a pointer to the original property 1027 * 1028 * Every modification of the device tree during a changeset 1029 * is held in a list of of_changeset_entry structures. 1030 * That way we can recover from a partial application, or we can 1031 * revert the changeset 1032 */ 1033 struct of_changeset_entry { 1034 struct list_head node; 1035 unsigned long action; 1036 struct device_node *np; 1037 struct property *prop; 1038 struct property *old_prop; 1039 }; 1040 1041 /** 1042 * struct of_changeset - changeset tracker structure 1043 * 1044 * @entries: list_head for the changeset entries 1045 * 1046 * changesets are a convenient way to apply bulk changes to the 1047 * live tree. In case of an error, changes are rolled-back. 1048 * changesets live on after initial application, and if not 1049 * destroyed after use, they can be reverted in one single call. 1050 */ 1051 struct of_changeset { 1052 struct list_head entries; 1053 }; 1054 1055 enum of_reconfig_change { 1056 OF_RECONFIG_NO_CHANGE = 0, 1057 OF_RECONFIG_CHANGE_ADD, 1058 OF_RECONFIG_CHANGE_REMOVE, 1059 }; 1060 1061 #ifdef CONFIG_OF_DYNAMIC 1062 extern int of_reconfig_notifier_register(struct notifier_block *); 1063 extern int of_reconfig_notifier_unregister(struct notifier_block *); 1064 extern int of_reconfig_notify(unsigned long, struct of_reconfig_data *rd); 1065 extern int of_reconfig_get_state_change(unsigned long action, 1066 struct of_reconfig_data *arg); 1067 1068 extern void of_changeset_init(struct of_changeset *ocs); 1069 extern void of_changeset_destroy(struct of_changeset *ocs); 1070 extern int of_changeset_apply(struct of_changeset *ocs); 1071 extern int of_changeset_revert(struct of_changeset *ocs); 1072 extern int of_changeset_action(struct of_changeset *ocs, 1073 unsigned long action, struct device_node *np, 1074 struct property *prop); 1075 1076 static inline int of_changeset_attach_node(struct of_changeset *ocs, 1077 struct device_node *np) 1078 { 1079 return of_changeset_action(ocs, OF_RECONFIG_ATTACH_NODE, np, NULL); 1080 } 1081 1082 static inline int of_changeset_detach_node(struct of_changeset *ocs, 1083 struct device_node *np) 1084 { 1085 return of_changeset_action(ocs, OF_RECONFIG_DETACH_NODE, np, NULL); 1086 } 1087 1088 static inline int of_changeset_add_property(struct of_changeset *ocs, 1089 struct device_node *np, struct property *prop) 1090 { 1091 return of_changeset_action(ocs, OF_RECONFIG_ADD_PROPERTY, np, prop); 1092 } 1093 1094 static inline int of_changeset_remove_property(struct of_changeset *ocs, 1095 struct device_node *np, struct property *prop) 1096 { 1097 return of_changeset_action(ocs, OF_RECONFIG_REMOVE_PROPERTY, np, prop); 1098 } 1099 1100 static inline int of_changeset_update_property(struct of_changeset *ocs, 1101 struct device_node *np, struct property *prop) 1102 { 1103 return of_changeset_action(ocs, OF_RECONFIG_UPDATE_PROPERTY, np, prop); 1104 } 1105 #else /* CONFIG_OF_DYNAMIC */ 1106 static inline int of_reconfig_notifier_register(struct notifier_block *nb) 1107 { 1108 return -EINVAL; 1109 } 1110 static inline int of_reconfig_notifier_unregister(struct notifier_block *nb) 1111 { 1112 return -EINVAL; 1113 } 1114 static inline int of_reconfig_notify(unsigned long action, 1115 struct of_reconfig_data *arg) 1116 { 1117 return -EINVAL; 1118 } 1119 static inline int of_reconfig_get_state_change(unsigned long action, 1120 struct of_reconfig_data *arg) 1121 { 1122 return -EINVAL; 1123 } 1124 #endif /* CONFIG_OF_DYNAMIC */ 1125 1126 /* CONFIG_OF_RESOLVE api */ 1127 extern int of_resolve_phandles(struct device_node *tree); 1128 1129 /** 1130 * of_device_is_system_power_controller - Tells if system-power-controller is found for device_node 1131 * @np: Pointer to the given device_node 1132 * 1133 * return true if present false otherwise 1134 */ 1135 static inline bool of_device_is_system_power_controller(const struct device_node *np) 1136 { 1137 return of_property_read_bool(np, "system-power-controller"); 1138 } 1139 1140 /** 1141 * Overlay support 1142 */ 1143 1144 #ifdef CONFIG_OF_OVERLAY 1145 1146 /* ID based overlays; the API for external users */ 1147 int of_overlay_create(struct device_node *tree); 1148 int of_overlay_destroy(int id); 1149 int of_overlay_destroy_all(void); 1150 1151 #else 1152 1153 static inline int of_overlay_create(struct device_node *tree) 1154 { 1155 return -ENOTSUPP; 1156 } 1157 1158 static inline int of_overlay_destroy(int id) 1159 { 1160 return -ENOTSUPP; 1161 } 1162 1163 static inline int of_overlay_destroy_all(void) 1164 { 1165 return -ENOTSUPP; 1166 } 1167 1168 #endif 1169 1170 #endif /* _LINUX_OF_H */ 1171