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