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 32typedef u32 phandle; 33typedef u32 ihandle; 34 35struct 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) 46struct of_irq_controller; 47#endif 48 49struct 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 72struct of_phandle_args { 73 struct device_node *np; 74 int args_count; 75 uint32_t args[MAX_PHANDLE_ARGS]; 76}; 77 78struct of_reconfig_data { 79 struct device_node *dn; 80 struct property *prop; 81 struct property *old_prop; 82}; 83 84/* initialize a node */ 85extern struct kobj_type of_node_ktype; 86static 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 */ 93static 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) */ 99static 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 105extern struct device_node *of_node_get(struct device_node *node); 106extern void of_node_put(struct device_node *node); 107#else /* CONFIG_OF_DYNAMIC */ 108/* Dummy ref counting routines - to be implemented later */ 109static inline struct device_node *of_node_get(struct device_node *node) 110{ 111 return node; 112} 113static 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. */ 117extern struct device_node *of_root; 118extern struct device_node *of_chosen; 119extern struct device_node *of_aliases; 120extern struct device_node *of_stdout; 121extern 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 132void of_core_init(void); 133 134static inline bool is_of_node(struct fwnode_handle *fwnode) 135{ 136 return fwnode && fwnode->type == FWNODE_OF; 137} 138 139static 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 145static inline bool of_have_populated_dt(void) 146{ 147 return of_root != NULL; 148} 149 150static inline bool of_node_is_root(const struct device_node *node) 151{ 152 return node && (node->parent == NULL); 153} 154 155static inline int of_node_check_flag(struct device_node *n, unsigned long flag) 156{ 157 return test_bit(flag, &n->_flags); 158} 159 160static 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 166static inline void of_node_set_flag(struct device_node *n, unsigned long flag) 167{ 168 set_bit(flag, &n->_flags); 169} 170 171static inline void of_node_clear_flag(struct device_node *n, unsigned long flag) 172{ 173 clear_bit(flag, &n->_flags); 174} 175 176static inline int of_property_check_flag(struct property *p, unsigned long flag) 177{ 178 return test_bit(flag, &p->_flags); 179} 180 181static inline void of_property_set_flag(struct property *p, unsigned long flag) 182{ 183 set_bit(flag, &p->_flags); 184} 185 186static inline void of_property_clear_flag(struct property *p, unsigned long flag) 187{ 188 clear_bit(flag, &p->_flags); 189} 190 191extern struct device_node *__of_find_all_nodes(struct device_node *prev); 192extern 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) */ 199static 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 */ 208static 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 234static 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) 242extern struct device_node *of_find_node_by_name(struct device_node *from, 243 const char *name); 244extern struct device_node *of_find_node_by_type(struct device_node *from, 245 const char *type); 246extern struct device_node *of_find_compatible_node(struct device_node *from, 247 const char *type, const char *compat); 248extern 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 253extern struct device_node *of_find_node_opts_by_path(const char *path, 254 const char **opts); 255static 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 260extern struct device_node *of_find_node_by_phandle(phandle handle); 261extern struct device_node *of_get_parent(const struct device_node *node); 262extern struct device_node *of_get_next_parent(struct device_node *node); 263extern struct device_node *of_get_next_child(const struct device_node *node, 264 struct device_node *prev); 265extern struct device_node *of_get_next_available_child( 266 const struct device_node *node, struct device_node *prev); 267 268extern struct device_node *of_get_child_by_name(const struct device_node *node, 269 const char *name); 270 271/* cache lookup */ 272extern struct device_node *of_find_next_cache_node(const struct device_node *); 273extern struct device_node *of_find_node_with_property( 274 struct device_node *from, const char *prop_name); 275 276extern struct property *of_find_property(const struct device_node *np, 277 const char *name, 278 int *lenp); 279extern int of_property_count_elems_of_size(const struct device_node *np, 280 const char *propname, int elem_size); 281extern int of_property_read_u32_index(const struct device_node *np, 282 const char *propname, 283 u32 index, u32 *out_value); 284extern int of_property_read_u8_array(const struct device_node *np, 285 const char *propname, u8 *out_values, size_t sz); 286extern int of_property_read_u16_array(const struct device_node *np, 287 const char *propname, u16 *out_values, size_t sz); 288extern int of_property_read_u32_array(const struct device_node *np, 289 const char *propname, 290 u32 *out_values, 291 size_t sz); 292extern int of_property_read_u64(const struct device_node *np, 293 const char *propname, u64 *out_value); 294extern int of_property_read_u64_array(const struct device_node *np, 295 const char *propname, 296 u64 *out_values, 297 size_t sz); 298 299extern int of_property_read_string(struct device_node *np, 300 const char *propname, 301 const char **out_string); 302extern int of_property_match_string(struct device_node *np, 303 const char *propname, 304 const char *string); 305extern int of_property_read_string_helper(struct device_node *np, 306 const char *propname, 307 const char **out_strs, size_t sz, int index); 308extern int of_device_is_compatible(const struct device_node *device, 309 const char *); 310extern bool of_device_is_available(const struct device_node *device); 311extern bool of_device_is_big_endian(const struct device_node *device); 312extern const void *of_get_property(const struct device_node *node, 313 const char *name, 314 int *lenp); 315extern 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 319extern int of_n_addr_cells(struct device_node *np); 320extern int of_n_size_cells(struct device_node *np); 321extern const struct of_device_id *of_match_node( 322 const struct of_device_id *matches, const struct device_node *node); 323extern int of_modalias_node(struct device_node *node, char *modalias, int len); 324extern void of_print_phandle_args(const char *msg, const struct of_phandle_args *args); 325extern struct device_node *of_parse_phandle(const struct device_node *np, 326 const char *phandle_name, 327 int index); 328extern 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); 331extern 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); 334extern int of_count_phandle_with_args(const struct device_node *np, 335 const char *list_name, const char *cells_name); 336 337extern void of_alias_scan(void * (*dt_alloc)(u64 size, u64 align)); 338extern int of_alias_get_id(struct device_node *np, const char *stem); 339extern int of_alias_get_highest_id(const char *stem); 340 341extern int of_machine_is_compatible(const char *compat); 342 343extern int of_add_property(struct device_node *np, struct property *prop); 344extern int of_remove_property(struct device_node *np, struct property *prop); 345extern 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 354extern int of_attach_node(struct device_node *); 355extern 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 */ 367const __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 */ 376const char *of_prop_next_string(struct property *prop, const char *cur); 377 378bool of_console_check(struct device_node *dn, char *name, int index); 379 380#else /* CONFIG_OF */ 381 382static inline void of_core_init(void) 383{ 384} 385 386static inline bool is_of_node(struct fwnode_handle *fwnode) 387{ 388 return false; 389} 390 391static inline struct device_node *to_of_node(struct fwnode_handle *fwnode) 392{ 393 return NULL; 394} 395 396static inline const char* of_node_full_name(const struct device_node *np) 397{ 398 return "<no-node>"; 399} 400 401static inline struct device_node *of_find_node_by_name(struct device_node *from, 402 const char *name) 403{ 404 return NULL; 405} 406 407static inline struct device_node *of_find_node_by_type(struct device_node *from, 408 const char *type) 409{ 410 return NULL; 411} 412 413static 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 421static inline struct device_node *of_find_node_by_path(const char *path) 422{ 423 return NULL; 424} 425 426static inline struct device_node *of_find_node_opts_by_path(const char *path, 427 const char **opts) 428{ 429 return NULL; 430} 431 432static inline struct device_node *of_find_node_by_phandle(phandle handle) 433{ 434 return NULL; 435} 436 437static inline struct device_node *of_get_parent(const struct device_node *node) 438{ 439 return NULL; 440} 441 442static inline struct device_node *of_get_next_child( 443 const struct device_node *node, struct device_node *prev) 444{ 445 return NULL; 446} 447 448static 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 454static inline struct device_node *of_find_node_with_property( 455 struct device_node *from, const char *prop_name) 456{ 457 return NULL; 458} 459 460static inline bool of_have_populated_dt(void) 461{ 462 return false; 463} 464 465static 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 472static inline int of_device_is_compatible(const struct device_node *device, 473 const char *name) 474{ 475 return 0; 476} 477 478static inline bool of_device_is_available(const struct device_node *device) 479{ 480 return false; 481} 482 483static inline bool of_device_is_big_endian(const struct device_node *device) 484{ 485 return false; 486} 487 488static inline struct property *of_find_property(const struct device_node *np, 489 const char *name, 490 int *lenp) 491{ 492 return NULL; 493} 494 495static 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 503static 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 509static 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 515static 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 521static 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 527static 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 534static 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 541static inline int of_property_read_string(struct device_node *np, 542 const char *propname, 543 const char **out_string) 544{ 545 return -ENOSYS; 546} 547 548static inline int of_property_read_string_helper(struct device_node *np, 549 const char *propname, 550 const char **out_strs, size_t sz, int index) 551{ 552 return -ENOSYS; 553} 554 555static inline const void *of_get_property(const struct device_node *node, 556 const char *name, 557 int *lenp) 558{ 559 return NULL; 560} 561 562static inline struct device_node *of_get_cpu_node(int cpu, 563 unsigned int *thread) 564{ 565 return NULL; 566} 567 568static inline int of_property_read_u64(const struct device_node *np, 569 const char *propname, u64 *out_value) 570{ 571 return -ENOSYS; 572} 573 574static inline int of_property_match_string(struct device_node *np, 575 const char *propname, 576 const char *string) 577{ 578 return -ENOSYS; 579} 580 581static 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 588static 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 597static 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 604static 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 611static inline int of_alias_get_id(struct device_node *np, const char *stem) 612{ 613 return -ENOSYS; 614} 615 616static inline int of_alias_get_highest_id(const char *stem) 617{ 618 return -ENOSYS; 619} 620 621static inline int of_machine_is_compatible(const char *compat) 622{ 623 return 0; 624} 625 626static inline bool of_console_check(const struct device_node *dn, const char *name, int index) 627{ 628 return false; 629} 630 631static inline const __be32 *of_prop_next_u32(struct property *prop, 632 const __be32 *cur, u32 *pu) 633{ 634 return NULL; 635} 636 637static inline const char *of_prop_next_string(struct property *prop, 638 const char *cur) 639{ 640 return NULL; 641} 642 643static inline int of_node_check_flag(struct device_node *n, unsigned long flag) 644{ 645 return 0; 646} 647 648static inline int of_node_test_and_set_flag(struct device_node *n, 649 unsigned long flag) 650{ 651 return 0; 652} 653 654static inline void of_node_set_flag(struct device_node *n, unsigned long flag) 655{ 656} 657 658static inline void of_node_clear_flag(struct device_node *n, unsigned long flag) 659{ 660} 661 662static inline int of_property_check_flag(struct property *p, unsigned long flag) 663{ 664 return 0; 665} 666 667static inline void of_property_set_flag(struct property *p, unsigned long flag) 668{ 669} 670 671static 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) 680extern int of_node_to_nid(struct device_node *np); 681#else 682static inline int of_node_to_nid(struct device_node *device) 683{ 684 return NUMA_NO_NODE; 685} 686#endif 687 688static 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 */ 706static 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 */ 723static 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 */ 740static 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 */ 757static 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 */ 776static inline int of_property_read_string_array(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 */ 795static inline int of_property_count_strings(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 */ 819static inline int of_property_read_string_index(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 */ 835static 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 843static 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 850static 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 857static 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 864static 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 910static 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 921static 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#ifdef CONFIG_OF 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 946typedef int (*of_init_fn_2)(struct device_node *, struct device_node *); 947typedef 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 */ 968struct 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 */ 986struct of_changeset { 987 struct list_head entries; 988}; 989 990enum 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 997extern int of_reconfig_notifier_register(struct notifier_block *); 998extern int of_reconfig_notifier_unregister(struct notifier_block *); 999extern int of_reconfig_notify(unsigned long, struct of_reconfig_data *rd); 1000extern int of_reconfig_get_state_change(unsigned long action, 1001 struct of_reconfig_data *arg); 1002 1003extern void of_changeset_init(struct of_changeset *ocs); 1004extern void of_changeset_destroy(struct of_changeset *ocs); 1005extern int of_changeset_apply(struct of_changeset *ocs); 1006extern int of_changeset_revert(struct of_changeset *ocs); 1007extern int of_changeset_action(struct of_changeset *ocs, 1008 unsigned long action, struct device_node *np, 1009 struct property *prop); 1010 1011static 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 1017static 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 1023static 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 1029static 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 1035static 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 */ 1041static inline int of_reconfig_notifier_register(struct notifier_block *nb) 1042{ 1043 return -EINVAL; 1044} 1045static inline int of_reconfig_notifier_unregister(struct notifier_block *nb) 1046{ 1047 return -EINVAL; 1048} 1049static inline int of_reconfig_notify(unsigned long action, 1050 struct of_reconfig_data *arg) 1051{ 1052 return -EINVAL; 1053} 1054static 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 */ 1062extern 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 */ 1070static 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 */ 1082int of_overlay_create(struct device_node *tree); 1083int of_overlay_destroy(int id); 1084int of_overlay_destroy_all(void); 1085 1086#else 1087 1088static inline int of_overlay_create(struct device_node *tree) 1089{ 1090 return -ENOTSUPP; 1091} 1092 1093static inline int of_overlay_destroy(int id) 1094{ 1095 return -ENOTSUPP; 1096} 1097 1098static inline int of_overlay_destroy_all(void) 1099{ 1100 return -ENOTSUPP; 1101} 1102 1103#endif 1104 1105#endif /* _LINUX_OF_H */ 1106