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