1 #ifndef _LINUX_OF_H 2 #define _LINUX_OF_H 3 /* 4 * Definitions for talking to the Open Firmware PROM on 5 * Power Macintosh and other computers. 6 * 7 * Copyright (C) 1996-2005 Paul Mackerras. 8 * 9 * Updates for PPC64 by Peter Bergner & David Engebretsen, IBM Corp. 10 * Updates for SPARC64 by David S. Miller 11 * Derived from PowerPC and Sparc prom.h files by Stephen Rothwell, IBM Corp. 12 * 13 * This program is free software; you can redistribute it and/or 14 * modify it under the terms of the GNU General Public License 15 * as published by the Free Software Foundation; either version 16 * 2 of the License, or (at your option) any later version. 17 */ 18 #include <linux/types.h> 19 #include <linux/bitops.h> 20 #include <linux/errno.h> 21 #include <linux/kobject.h> 22 #include <linux/mod_devicetable.h> 23 #include <linux/spinlock.h> 24 #include <linux/topology.h> 25 #include <linux/notifier.h> 26 #include <linux/property.h> 27 #include <linux/list.h> 28 29 #include <asm/byteorder.h> 30 #include <asm/errno.h> 31 32 typedef u32 phandle; 33 typedef u32 ihandle; 34 35 struct property { 36 char *name; 37 int length; 38 void *value; 39 struct property *next; 40 unsigned long _flags; 41 unsigned int unique_id; 42 struct bin_attribute attr; 43 }; 44 45 #if defined(CONFIG_SPARC) 46 struct of_irq_controller; 47 #endif 48 49 struct device_node { 50 const char *name; 51 const char *type; 52 phandle phandle; 53 const char *full_name; 54 struct fwnode_handle fwnode; 55 56 struct property *properties; 57 struct property *deadprops; /* removed properties */ 58 struct device_node *parent; 59 struct device_node *child; 60 struct device_node *sibling; 61 struct kobject kobj; 62 unsigned long _flags; 63 void *data; 64 #if defined(CONFIG_SPARC) 65 const char *path_component_name; 66 unsigned int unique_id; 67 struct of_irq_controller *irq_trans; 68 #endif 69 }; 70 71 #define MAX_PHANDLE_ARGS 16 72 struct of_phandle_args { 73 struct device_node *np; 74 int args_count; 75 uint32_t args[MAX_PHANDLE_ARGS]; 76 }; 77 78 struct of_phandle_iterator { 79 /* Common iterator information */ 80 const char *cells_name; 81 int cell_count; 82 const struct device_node *parent; 83 84 /* List size information */ 85 const __be32 *list_end; 86 const __be32 *phandle_end; 87 88 /* Current position state */ 89 const __be32 *cur; 90 uint32_t cur_count; 91 phandle phandle; 92 struct device_node *node; 93 }; 94 95 struct of_reconfig_data { 96 struct device_node *dn; 97 struct property *prop; 98 struct property *old_prop; 99 }; 100 101 /* initialize a node */ 102 extern struct kobj_type of_node_ktype; 103 extern const struct fwnode_operations of_fwnode_ops; 104 static inline void of_node_init(struct device_node *node) 105 { 106 kobject_init(&node->kobj, &of_node_ktype); 107 node->fwnode.type = FWNODE_OF; 108 node->fwnode.ops = &of_fwnode_ops; 109 } 110 111 /* true when node is initialized */ 112 static inline int of_node_is_initialized(struct device_node *node) 113 { 114 return node && node->kobj.state_initialized; 115 } 116 117 /* true when node is attached (i.e. present on sysfs) */ 118 static inline int of_node_is_attached(struct device_node *node) 119 { 120 return node && node->kobj.state_in_sysfs; 121 } 122 123 #ifdef CONFIG_OF_DYNAMIC 124 extern struct device_node *of_node_get(struct device_node *node); 125 extern void of_node_put(struct device_node *node); 126 #else /* CONFIG_OF_DYNAMIC */ 127 /* Dummy ref counting routines - to be implemented later */ 128 static inline struct device_node *of_node_get(struct device_node *node) 129 { 130 return node; 131 } 132 static inline void of_node_put(struct device_node *node) { } 133 #endif /* !CONFIG_OF_DYNAMIC */ 134 135 /* Pointer for first entry in chain of all nodes. */ 136 extern struct device_node *of_root; 137 extern struct device_node *of_chosen; 138 extern struct device_node *of_aliases; 139 extern struct device_node *of_stdout; 140 extern raw_spinlock_t devtree_lock; 141 142 /* flag descriptions (need to be visible even when !CONFIG_OF) */ 143 #define OF_DYNAMIC 1 /* node and properties were allocated via kmalloc */ 144 #define OF_DETACHED 2 /* node has been detached from the device tree */ 145 #define OF_POPULATED 3 /* device already created for the node */ 146 #define OF_POPULATED_BUS 4 /* of_platform_populate recursed to children of this node */ 147 148 #define OF_BAD_ADDR ((u64)-1) 149 150 #ifdef CONFIG_OF 151 void of_core_init(void); 152 153 static inline bool is_of_node(const struct fwnode_handle *fwnode) 154 { 155 return !IS_ERR_OR_NULL(fwnode) && fwnode->type == FWNODE_OF; 156 } 157 158 #define to_of_node(__fwnode) \ 159 ({ \ 160 typeof(__fwnode) __to_of_node_fwnode = (__fwnode); \ 161 \ 162 is_of_node(__to_of_node_fwnode) ? \ 163 container_of(__to_of_node_fwnode, \ 164 struct device_node, fwnode) : \ 165 NULL; \ 166 }) 167 168 #define of_fwnode_handle(node) \ 169 ({ \ 170 typeof(node) __of_fwnode_handle_node = (node); \ 171 \ 172 __of_fwnode_handle_node ? \ 173 &__of_fwnode_handle_node->fwnode : NULL; \ 174 }) 175 176 static inline bool of_have_populated_dt(void) 177 { 178 return of_root != NULL; 179 } 180 181 static inline bool of_node_is_root(const struct device_node *node) 182 { 183 return node && (node->parent == NULL); 184 } 185 186 static inline int of_node_check_flag(struct device_node *n, unsigned long flag) 187 { 188 return test_bit(flag, &n->_flags); 189 } 190 191 static inline int of_node_test_and_set_flag(struct device_node *n, 192 unsigned long flag) 193 { 194 return test_and_set_bit(flag, &n->_flags); 195 } 196 197 static inline void of_node_set_flag(struct device_node *n, unsigned long flag) 198 { 199 set_bit(flag, &n->_flags); 200 } 201 202 static inline void of_node_clear_flag(struct device_node *n, unsigned long flag) 203 { 204 clear_bit(flag, &n->_flags); 205 } 206 207 static inline int of_property_check_flag(struct property *p, unsigned long flag) 208 { 209 return test_bit(flag, &p->_flags); 210 } 211 212 static inline void of_property_set_flag(struct property *p, unsigned long flag) 213 { 214 set_bit(flag, &p->_flags); 215 } 216 217 static inline void of_property_clear_flag(struct property *p, unsigned long flag) 218 { 219 clear_bit(flag, &p->_flags); 220 } 221 222 extern struct device_node *__of_find_all_nodes(struct device_node *prev); 223 extern struct device_node *of_find_all_nodes(struct device_node *prev); 224 225 /* 226 * OF address retrieval & translation 227 */ 228 229 /* Helper to read a big number; size is in cells (not bytes) */ 230 static inline u64 of_read_number(const __be32 *cell, int size) 231 { 232 u64 r = 0; 233 while (size--) 234 r = (r << 32) | be32_to_cpu(*(cell++)); 235 return r; 236 } 237 238 /* Like of_read_number, but we want an unsigned long result */ 239 static inline unsigned long of_read_ulong(const __be32 *cell, int size) 240 { 241 /* toss away upper bits if unsigned long is smaller than u64 */ 242 return of_read_number(cell, size); 243 } 244 245 #if defined(CONFIG_SPARC) 246 #include <asm/prom.h> 247 #endif 248 249 /* Default #address and #size cells. Allow arch asm/prom.h to override */ 250 #if !defined(OF_ROOT_NODE_ADDR_CELLS_DEFAULT) 251 #define OF_ROOT_NODE_ADDR_CELLS_DEFAULT 1 252 #define OF_ROOT_NODE_SIZE_CELLS_DEFAULT 1 253 #endif 254 255 #define OF_IS_DYNAMIC(x) test_bit(OF_DYNAMIC, &x->_flags) 256 #define OF_MARK_DYNAMIC(x) set_bit(OF_DYNAMIC, &x->_flags) 257 258 static inline const char *of_node_full_name(const struct device_node *np) 259 { 260 return np ? np->full_name : "<no-node>"; 261 } 262 263 #define for_each_of_allnodes_from(from, dn) \ 264 for (dn = __of_find_all_nodes(from); dn; dn = __of_find_all_nodes(dn)) 265 #define for_each_of_allnodes(dn) for_each_of_allnodes_from(NULL, dn) 266 extern struct device_node *of_find_node_by_name(struct device_node *from, 267 const char *name); 268 extern struct device_node *of_find_node_by_type(struct device_node *from, 269 const char *type); 270 extern struct device_node *of_find_compatible_node(struct device_node *from, 271 const char *type, const char *compat); 272 extern struct device_node *of_find_matching_node_and_match( 273 struct device_node *from, 274 const struct of_device_id *matches, 275 const struct of_device_id **match); 276 277 extern struct device_node *of_find_node_opts_by_path(const char *path, 278 const char **opts); 279 static inline struct device_node *of_find_node_by_path(const char *path) 280 { 281 return of_find_node_opts_by_path(path, NULL); 282 } 283 284 extern struct device_node *of_find_node_by_phandle(phandle handle); 285 extern struct device_node *of_get_parent(const struct device_node *node); 286 extern struct device_node *of_get_next_parent(struct device_node *node); 287 extern struct device_node *of_get_next_child(const struct device_node *node, 288 struct device_node *prev); 289 extern struct device_node *of_get_next_available_child( 290 const struct device_node *node, struct device_node *prev); 291 292 extern struct device_node *of_get_child_by_name(const struct device_node *node, 293 const char *name); 294 295 /* cache lookup */ 296 extern struct device_node *of_find_next_cache_node(const struct device_node *); 297 extern int of_find_last_cache_level(unsigned int cpu); 298 extern struct device_node *of_find_node_with_property( 299 struct device_node *from, const char *prop_name); 300 301 extern struct property *of_find_property(const struct device_node *np, 302 const char *name, 303 int *lenp); 304 extern int of_property_count_elems_of_size(const struct device_node *np, 305 const char *propname, int elem_size); 306 extern int of_property_read_u32_index(const struct device_node *np, 307 const char *propname, 308 u32 index, u32 *out_value); 309 extern int of_property_read_u64_index(const struct device_node *np, 310 const char *propname, 311 u32 index, u64 *out_value); 312 extern int of_property_read_variable_u8_array(const struct device_node *np, 313 const char *propname, u8 *out_values, 314 size_t sz_min, size_t sz_max); 315 extern int of_property_read_variable_u16_array(const struct device_node *np, 316 const char *propname, u16 *out_values, 317 size_t sz_min, size_t sz_max); 318 extern int of_property_read_variable_u32_array(const struct device_node *np, 319 const char *propname, 320 u32 *out_values, 321 size_t sz_min, 322 size_t sz_max); 323 extern int of_property_read_u64(const struct device_node *np, 324 const char *propname, u64 *out_value); 325 extern int of_property_read_variable_u64_array(const struct device_node *np, 326 const char *propname, 327 u64 *out_values, 328 size_t sz_min, 329 size_t sz_max); 330 331 extern int of_property_read_string(const struct device_node *np, 332 const char *propname, 333 const char **out_string); 334 extern int of_property_match_string(const struct device_node *np, 335 const char *propname, 336 const char *string); 337 extern int of_property_read_string_helper(const struct device_node *np, 338 const char *propname, 339 const char **out_strs, size_t sz, int index); 340 extern int of_device_is_compatible(const struct device_node *device, 341 const char *); 342 extern int of_device_compatible_match(struct device_node *device, 343 const char *const *compat); 344 extern bool of_device_is_available(const struct device_node *device); 345 extern bool of_device_is_big_endian(const struct device_node *device); 346 extern const void *of_get_property(const struct device_node *node, 347 const char *name, 348 int *lenp); 349 extern struct device_node *of_get_cpu_node(int cpu, unsigned int *thread); 350 #define for_each_property_of_node(dn, pp) \ 351 for (pp = dn->properties; pp != NULL; pp = pp->next) 352 353 extern int of_n_addr_cells(struct device_node *np); 354 extern int of_n_size_cells(struct device_node *np); 355 extern const struct of_device_id *of_match_node( 356 const struct of_device_id *matches, const struct device_node *node); 357 extern int of_modalias_node(struct device_node *node, char *modalias, int len); 358 extern void of_print_phandle_args(const char *msg, const struct of_phandle_args *args); 359 extern struct device_node *of_parse_phandle(const struct device_node *np, 360 const char *phandle_name, 361 int index); 362 extern int of_parse_phandle_with_args(const struct device_node *np, 363 const char *list_name, const char *cells_name, int index, 364 struct of_phandle_args *out_args); 365 extern int of_parse_phandle_with_fixed_args(const struct device_node *np, 366 const char *list_name, int cells_count, int index, 367 struct of_phandle_args *out_args); 368 extern int of_count_phandle_with_args(const struct device_node *np, 369 const char *list_name, const char *cells_name); 370 371 /* phandle iterator functions */ 372 extern int of_phandle_iterator_init(struct of_phandle_iterator *it, 373 const struct device_node *np, 374 const char *list_name, 375 const char *cells_name, 376 int cell_count); 377 378 extern int of_phandle_iterator_next(struct of_phandle_iterator *it); 379 extern int of_phandle_iterator_args(struct of_phandle_iterator *it, 380 uint32_t *args, 381 int size); 382 383 extern void of_alias_scan(void * (*dt_alloc)(u64 size, u64 align)); 384 extern int of_alias_get_id(struct device_node *np, const char *stem); 385 extern int of_alias_get_highest_id(const char *stem); 386 387 extern int of_machine_is_compatible(const char *compat); 388 389 extern int of_add_property(struct device_node *np, struct property *prop); 390 extern int of_remove_property(struct device_node *np, struct property *prop); 391 extern int of_update_property(struct device_node *np, struct property *newprop); 392 393 /* For updating the device tree at runtime */ 394 #define OF_RECONFIG_ATTACH_NODE 0x0001 395 #define OF_RECONFIG_DETACH_NODE 0x0002 396 #define OF_RECONFIG_ADD_PROPERTY 0x0003 397 #define OF_RECONFIG_REMOVE_PROPERTY 0x0004 398 #define OF_RECONFIG_UPDATE_PROPERTY 0x0005 399 400 extern int of_attach_node(struct device_node *); 401 extern int of_detach_node(struct device_node *); 402 403 #define of_match_ptr(_ptr) (_ptr) 404 405 /** 406 * of_property_read_u8_array - Find and read an array of u8 from a property. 407 * 408 * @np: device node from which the property value is to be read. 409 * @propname: name of the property to be searched. 410 * @out_values: pointer to return value, modified only if return value is 0. 411 * @sz: number of array elements to read 412 * 413 * Search for a property in a device node and read 8-bit value(s) from 414 * it. Returns 0 on success, -EINVAL if the property does not exist, 415 * -ENODATA if property does not have a value, and -EOVERFLOW if the 416 * property data isn't large enough. 417 * 418 * dts entry of array should be like: 419 * property = /bits/ 8 <0x50 0x60 0x70>; 420 * 421 * The out_values is modified only if a valid u8 value can be decoded. 422 */ 423 static inline int of_property_read_u8_array(const struct device_node *np, 424 const char *propname, 425 u8 *out_values, size_t sz) 426 { 427 int ret = of_property_read_variable_u8_array(np, propname, out_values, 428 sz, 0); 429 if (ret >= 0) 430 return 0; 431 else 432 return ret; 433 } 434 435 /** 436 * of_property_read_u16_array - Find and read an array of u16 from a property. 437 * 438 * @np: device node from which the property value is to be read. 439 * @propname: name of the property to be searched. 440 * @out_values: pointer to return value, modified only if return value is 0. 441 * @sz: number of array elements to read 442 * 443 * Search for a property in a device node and read 16-bit value(s) from 444 * it. Returns 0 on success, -EINVAL if the property does not exist, 445 * -ENODATA if property does not have a value, and -EOVERFLOW if the 446 * property data isn't large enough. 447 * 448 * dts entry of array should be like: 449 * property = /bits/ 16 <0x5000 0x6000 0x7000>; 450 * 451 * The out_values is modified only if a valid u16 value can be decoded. 452 */ 453 static inline int of_property_read_u16_array(const struct device_node *np, 454 const char *propname, 455 u16 *out_values, size_t sz) 456 { 457 int ret = of_property_read_variable_u16_array(np, propname, out_values, 458 sz, 0); 459 if (ret >= 0) 460 return 0; 461 else 462 return ret; 463 } 464 465 /** 466 * of_property_read_u32_array - Find and read an array of 32 bit integers 467 * from a property. 468 * 469 * @np: device node from which the property value is to be read. 470 * @propname: name of the property to be searched. 471 * @out_values: pointer to return value, modified only if return value is 0. 472 * @sz: number of array elements to read 473 * 474 * Search for a property in a device node and read 32-bit value(s) from 475 * it. Returns 0 on success, -EINVAL if the property does not exist, 476 * -ENODATA if property does not have a value, and -EOVERFLOW if the 477 * property data isn't large enough. 478 * 479 * The out_values is modified only if a valid u32 value can be decoded. 480 */ 481 static inline int of_property_read_u32_array(const struct device_node *np, 482 const char *propname, 483 u32 *out_values, size_t sz) 484 { 485 int ret = of_property_read_variable_u32_array(np, propname, out_values, 486 sz, 0); 487 if (ret >= 0) 488 return 0; 489 else 490 return ret; 491 } 492 493 /** 494 * of_property_read_u64_array - Find and read an array of 64 bit integers 495 * from a property. 496 * 497 * @np: device node from which the property value is to be read. 498 * @propname: name of the property to be searched. 499 * @out_values: pointer to return value, modified only if return value is 0. 500 * @sz: number of array elements to read 501 * 502 * Search for a property in a device node and read 64-bit value(s) from 503 * it. Returns 0 on success, -EINVAL if the property does not exist, 504 * -ENODATA if property does not have a value, and -EOVERFLOW if the 505 * property data isn't large enough. 506 * 507 * The out_values is modified only if a valid u64 value can be decoded. 508 */ 509 static inline int of_property_read_u64_array(const struct device_node *np, 510 const char *propname, 511 u64 *out_values, size_t sz) 512 { 513 int ret = of_property_read_variable_u64_array(np, propname, out_values, 514 sz, 0); 515 if (ret >= 0) 516 return 0; 517 else 518 return ret; 519 } 520 521 /* 522 * struct property *prop; 523 * const __be32 *p; 524 * u32 u; 525 * 526 * of_property_for_each_u32(np, "propname", prop, p, u) 527 * printk("U32 value: %x\n", u); 528 */ 529 const __be32 *of_prop_next_u32(struct property *prop, const __be32 *cur, 530 u32 *pu); 531 /* 532 * struct property *prop; 533 * const char *s; 534 * 535 * of_property_for_each_string(np, "propname", prop, s) 536 * printk("String value: %s\n", s); 537 */ 538 const char *of_prop_next_string(struct property *prop, const char *cur); 539 540 bool of_console_check(struct device_node *dn, char *name, int index); 541 542 #else /* CONFIG_OF */ 543 544 static inline void of_core_init(void) 545 { 546 } 547 548 static inline bool is_of_node(const struct fwnode_handle *fwnode) 549 { 550 return false; 551 } 552 553 static inline struct device_node *to_of_node(const struct fwnode_handle *fwnode) 554 { 555 return NULL; 556 } 557 558 static inline const char* of_node_full_name(const struct device_node *np) 559 { 560 return "<no-node>"; 561 } 562 563 static inline struct device_node *of_find_node_by_name(struct device_node *from, 564 const char *name) 565 { 566 return NULL; 567 } 568 569 static inline struct device_node *of_find_node_by_type(struct device_node *from, 570 const char *type) 571 { 572 return NULL; 573 } 574 575 static inline struct device_node *of_find_matching_node_and_match( 576 struct device_node *from, 577 const struct of_device_id *matches, 578 const struct of_device_id **match) 579 { 580 return NULL; 581 } 582 583 static inline struct device_node *of_find_node_by_path(const char *path) 584 { 585 return NULL; 586 } 587 588 static inline struct device_node *of_find_node_opts_by_path(const char *path, 589 const char **opts) 590 { 591 return NULL; 592 } 593 594 static inline struct device_node *of_find_node_by_phandle(phandle handle) 595 { 596 return NULL; 597 } 598 599 static inline struct device_node *of_get_parent(const struct device_node *node) 600 { 601 return NULL; 602 } 603 604 static inline struct device_node *of_get_next_child( 605 const struct device_node *node, struct device_node *prev) 606 { 607 return NULL; 608 } 609 610 static inline struct device_node *of_get_next_available_child( 611 const struct device_node *node, struct device_node *prev) 612 { 613 return NULL; 614 } 615 616 static inline struct device_node *of_find_node_with_property( 617 struct device_node *from, const char *prop_name) 618 { 619 return NULL; 620 } 621 622 #define of_fwnode_handle(node) NULL 623 624 static inline bool of_have_populated_dt(void) 625 { 626 return false; 627 } 628 629 static inline struct device_node *of_get_child_by_name( 630 const struct device_node *node, 631 const char *name) 632 { 633 return NULL; 634 } 635 636 static inline int of_device_is_compatible(const struct device_node *device, 637 const char *name) 638 { 639 return 0; 640 } 641 642 static inline int of_device_compatible_match(struct device_node *device, 643 const char *const *compat) 644 { 645 return 0; 646 } 647 648 static inline bool of_device_is_available(const struct device_node *device) 649 { 650 return false; 651 } 652 653 static inline bool of_device_is_big_endian(const struct device_node *device) 654 { 655 return false; 656 } 657 658 static inline struct property *of_find_property(const struct device_node *np, 659 const char *name, 660 int *lenp) 661 { 662 return NULL; 663 } 664 665 static inline struct device_node *of_find_compatible_node( 666 struct device_node *from, 667 const char *type, 668 const char *compat) 669 { 670 return NULL; 671 } 672 673 static inline int of_property_count_elems_of_size(const struct device_node *np, 674 const char *propname, int elem_size) 675 { 676 return -ENOSYS; 677 } 678 679 static inline int of_property_read_u32_index(const struct device_node *np, 680 const char *propname, u32 index, u32 *out_value) 681 { 682 return -ENOSYS; 683 } 684 685 static inline int of_property_read_u8_array(const struct device_node *np, 686 const char *propname, u8 *out_values, size_t sz) 687 { 688 return -ENOSYS; 689 } 690 691 static inline int of_property_read_u16_array(const struct device_node *np, 692 const char *propname, u16 *out_values, size_t sz) 693 { 694 return -ENOSYS; 695 } 696 697 static inline int of_property_read_u32_array(const struct device_node *np, 698 const char *propname, 699 u32 *out_values, size_t sz) 700 { 701 return -ENOSYS; 702 } 703 704 static inline int of_property_read_u64_array(const struct device_node *np, 705 const char *propname, 706 u64 *out_values, size_t sz) 707 { 708 return -ENOSYS; 709 } 710 711 static inline int of_property_read_string(const struct device_node *np, 712 const char *propname, 713 const char **out_string) 714 { 715 return -ENOSYS; 716 } 717 718 static inline int of_property_read_string_helper(const struct device_node *np, 719 const char *propname, 720 const char **out_strs, size_t sz, int index) 721 { 722 return -ENOSYS; 723 } 724 725 static inline const void *of_get_property(const struct device_node *node, 726 const char *name, 727 int *lenp) 728 { 729 return NULL; 730 } 731 732 static inline struct device_node *of_get_cpu_node(int cpu, 733 unsigned int *thread) 734 { 735 return NULL; 736 } 737 738 static inline int of_property_read_u64(const struct device_node *np, 739 const char *propname, u64 *out_value) 740 { 741 return -ENOSYS; 742 } 743 744 static inline int of_property_match_string(const struct device_node *np, 745 const char *propname, 746 const char *string) 747 { 748 return -ENOSYS; 749 } 750 751 static inline struct device_node *of_parse_phandle(const struct device_node *np, 752 const char *phandle_name, 753 int index) 754 { 755 return NULL; 756 } 757 758 static inline int of_parse_phandle_with_args(const struct device_node *np, 759 const char *list_name, 760 const char *cells_name, 761 int index, 762 struct of_phandle_args *out_args) 763 { 764 return -ENOSYS; 765 } 766 767 static inline int of_parse_phandle_with_fixed_args(const struct device_node *np, 768 const char *list_name, int cells_count, int index, 769 struct of_phandle_args *out_args) 770 { 771 return -ENOSYS; 772 } 773 774 static inline int of_count_phandle_with_args(struct device_node *np, 775 const char *list_name, 776 const char *cells_name) 777 { 778 return -ENOSYS; 779 } 780 781 static inline int of_phandle_iterator_init(struct of_phandle_iterator *it, 782 const struct device_node *np, 783 const char *list_name, 784 const char *cells_name, 785 int cell_count) 786 { 787 return -ENOSYS; 788 } 789 790 static inline int of_phandle_iterator_next(struct of_phandle_iterator *it) 791 { 792 return -ENOSYS; 793 } 794 795 static inline int of_phandle_iterator_args(struct of_phandle_iterator *it, 796 uint32_t *args, 797 int size) 798 { 799 return 0; 800 } 801 802 static inline int of_alias_get_id(struct device_node *np, const char *stem) 803 { 804 return -ENOSYS; 805 } 806 807 static inline int of_alias_get_highest_id(const char *stem) 808 { 809 return -ENOSYS; 810 } 811 812 static inline int of_machine_is_compatible(const char *compat) 813 { 814 return 0; 815 } 816 817 static inline bool of_console_check(const struct device_node *dn, const char *name, int index) 818 { 819 return false; 820 } 821 822 static inline const __be32 *of_prop_next_u32(struct property *prop, 823 const __be32 *cur, u32 *pu) 824 { 825 return NULL; 826 } 827 828 static inline const char *of_prop_next_string(struct property *prop, 829 const char *cur) 830 { 831 return NULL; 832 } 833 834 static inline int of_node_check_flag(struct device_node *n, unsigned long flag) 835 { 836 return 0; 837 } 838 839 static inline int of_node_test_and_set_flag(struct device_node *n, 840 unsigned long flag) 841 { 842 return 0; 843 } 844 845 static inline void of_node_set_flag(struct device_node *n, unsigned long flag) 846 { 847 } 848 849 static inline void of_node_clear_flag(struct device_node *n, unsigned long flag) 850 { 851 } 852 853 static inline int of_property_check_flag(struct property *p, unsigned long flag) 854 { 855 return 0; 856 } 857 858 static inline void of_property_set_flag(struct property *p, unsigned long flag) 859 { 860 } 861 862 static inline void of_property_clear_flag(struct property *p, unsigned long flag) 863 { 864 } 865 866 #define of_match_ptr(_ptr) NULL 867 #define of_match_node(_matches, _node) NULL 868 #endif /* CONFIG_OF */ 869 870 /* Default string compare functions, Allow arch asm/prom.h to override */ 871 #if !defined(of_compat_cmp) 872 #define of_compat_cmp(s1, s2, l) strcasecmp((s1), (s2)) 873 #define of_prop_cmp(s1, s2) strcmp((s1), (s2)) 874 #define of_node_cmp(s1, s2) strcasecmp((s1), (s2)) 875 #endif 876 877 #if defined(CONFIG_OF) && defined(CONFIG_NUMA) 878 extern int of_node_to_nid(struct device_node *np); 879 #else 880 static inline int of_node_to_nid(struct device_node *device) 881 { 882 return NUMA_NO_NODE; 883 } 884 #endif 885 886 #ifdef CONFIG_OF_NUMA 887 extern int of_numa_init(void); 888 #else 889 static inline int of_numa_init(void) 890 { 891 return -ENOSYS; 892 } 893 #endif 894 895 static inline struct device_node *of_find_matching_node( 896 struct device_node *from, 897 const struct of_device_id *matches) 898 { 899 return of_find_matching_node_and_match(from, matches, NULL); 900 } 901 902 /** 903 * of_property_count_u8_elems - Count the number of u8 elements in a property 904 * 905 * @np: device node from which the property value is to be read. 906 * @propname: name of the property to be searched. 907 * 908 * Search for a property in a device node and count the number of u8 elements 909 * in it. Returns number of elements on sucess, -EINVAL if the property does 910 * not exist or its length does not match a multiple of u8 and -ENODATA if the 911 * property does not have a value. 912 */ 913 static inline int of_property_count_u8_elems(const struct device_node *np, 914 const char *propname) 915 { 916 return of_property_count_elems_of_size(np, propname, sizeof(u8)); 917 } 918 919 /** 920 * of_property_count_u16_elems - Count the number of u16 elements in a property 921 * 922 * @np: device node from which the property value is to be read. 923 * @propname: name of the property to be searched. 924 * 925 * Search for a property in a device node and count the number of u16 elements 926 * in it. Returns number of elements on sucess, -EINVAL if the property does 927 * not exist or its length does not match a multiple of u16 and -ENODATA if the 928 * property does not have a value. 929 */ 930 static inline int of_property_count_u16_elems(const struct device_node *np, 931 const char *propname) 932 { 933 return of_property_count_elems_of_size(np, propname, sizeof(u16)); 934 } 935 936 /** 937 * of_property_count_u32_elems - Count the number of u32 elements in a property 938 * 939 * @np: device node from which the property value is to be read. 940 * @propname: name of the property to be searched. 941 * 942 * Search for a property in a device node and count the number of u32 elements 943 * in it. Returns number of elements on sucess, -EINVAL if the property does 944 * not exist or its length does not match a multiple of u32 and -ENODATA if the 945 * property does not have a value. 946 */ 947 static inline int of_property_count_u32_elems(const struct device_node *np, 948 const char *propname) 949 { 950 return of_property_count_elems_of_size(np, propname, sizeof(u32)); 951 } 952 953 /** 954 * of_property_count_u64_elems - Count the number of u64 elements in a property 955 * 956 * @np: device node from which the property value is to be read. 957 * @propname: name of the property to be searched. 958 * 959 * Search for a property in a device node and count the number of u64 elements 960 * in it. Returns number of elements on sucess, -EINVAL if the property does 961 * not exist or its length does not match a multiple of u64 and -ENODATA if the 962 * property does not have a value. 963 */ 964 static inline int of_property_count_u64_elems(const struct device_node *np, 965 const char *propname) 966 { 967 return of_property_count_elems_of_size(np, propname, sizeof(u64)); 968 } 969 970 /** 971 * of_property_read_string_array() - Read an array of strings from a multiple 972 * strings property. 973 * @np: device node from which the property value is to be read. 974 * @propname: name of the property to be searched. 975 * @out_strs: output array of string pointers. 976 * @sz: number of array elements to read. 977 * 978 * Search for a property in a device tree node and retrieve a list of 979 * terminated string values (pointer to data, not a copy) in that property. 980 * 981 * If @out_strs is NULL, the number of strings in the property is returned. 982 */ 983 static inline int of_property_read_string_array(const struct device_node *np, 984 const char *propname, const char **out_strs, 985 size_t sz) 986 { 987 return of_property_read_string_helper(np, propname, out_strs, sz, 0); 988 } 989 990 /** 991 * of_property_count_strings() - Find and return the number of strings from a 992 * multiple strings property. 993 * @np: device node from which the property value is to be read. 994 * @propname: name of the property to be searched. 995 * 996 * Search for a property in a device tree node and retrieve the number of null 997 * terminated string contain in it. Returns the number of strings on 998 * success, -EINVAL if the property does not exist, -ENODATA if property 999 * does not have a value, and -EILSEQ if the string is not null-terminated 1000 * within the length of the property data. 1001 */ 1002 static inline int of_property_count_strings(const struct device_node *np, 1003 const char *propname) 1004 { 1005 return of_property_read_string_helper(np, propname, NULL, 0, 0); 1006 } 1007 1008 /** 1009 * of_property_read_string_index() - Find and read a string from a multiple 1010 * strings property. 1011 * @np: device node from which the property value is to be read. 1012 * @propname: name of the property to be searched. 1013 * @index: index of the string in the list of strings 1014 * @out_string: pointer to null terminated return string, modified only if 1015 * return value is 0. 1016 * 1017 * Search for a property in a device tree node and retrieve a null 1018 * terminated string value (pointer to data, not a copy) in the list of strings 1019 * contained in that property. 1020 * Returns 0 on success, -EINVAL if the property does not exist, -ENODATA if 1021 * property does not have a value, and -EILSEQ if the string is not 1022 * null-terminated within the length of the property data. 1023 * 1024 * The out_string pointer is modified only if a valid string can be decoded. 1025 */ 1026 static inline int of_property_read_string_index(const struct device_node *np, 1027 const char *propname, 1028 int index, const char **output) 1029 { 1030 int rc = of_property_read_string_helper(np, propname, output, 1, index); 1031 return rc < 0 ? rc : 0; 1032 } 1033 1034 /** 1035 * of_property_read_bool - Findfrom a property 1036 * @np: device node from which the property value is to be read. 1037 * @propname: name of the property to be searched. 1038 * 1039 * Search for a property in a device node. 1040 * Returns true if the property exists false otherwise. 1041 */ 1042 static inline bool of_property_read_bool(const struct device_node *np, 1043 const char *propname) 1044 { 1045 struct property *prop = of_find_property(np, propname, NULL); 1046 1047 return prop ? true : false; 1048 } 1049 1050 static inline int of_property_read_u8(const struct device_node *np, 1051 const char *propname, 1052 u8 *out_value) 1053 { 1054 return of_property_read_u8_array(np, propname, out_value, 1); 1055 } 1056 1057 static inline int of_property_read_u16(const struct device_node *np, 1058 const char *propname, 1059 u16 *out_value) 1060 { 1061 return of_property_read_u16_array(np, propname, out_value, 1); 1062 } 1063 1064 static inline int of_property_read_u32(const struct device_node *np, 1065 const char *propname, 1066 u32 *out_value) 1067 { 1068 return of_property_read_u32_array(np, propname, out_value, 1); 1069 } 1070 1071 static inline int of_property_read_s32(const struct device_node *np, 1072 const char *propname, 1073 s32 *out_value) 1074 { 1075 return of_property_read_u32(np, propname, (u32*) out_value); 1076 } 1077 1078 #define of_for_each_phandle(it, err, np, ln, cn, cc) \ 1079 for (of_phandle_iterator_init((it), (np), (ln), (cn), (cc)), \ 1080 err = of_phandle_iterator_next(it); \ 1081 err == 0; \ 1082 err = of_phandle_iterator_next(it)) 1083 1084 #define of_property_for_each_u32(np, propname, prop, p, u) \ 1085 for (prop = of_find_property(np, propname, NULL), \ 1086 p = of_prop_next_u32(prop, NULL, &u); \ 1087 p; \ 1088 p = of_prop_next_u32(prop, p, &u)) 1089 1090 #define of_property_for_each_string(np, propname, prop, s) \ 1091 for (prop = of_find_property(np, propname, NULL), \ 1092 s = of_prop_next_string(prop, NULL); \ 1093 s; \ 1094 s = of_prop_next_string(prop, s)) 1095 1096 #define for_each_node_by_name(dn, name) \ 1097 for (dn = of_find_node_by_name(NULL, name); dn; \ 1098 dn = of_find_node_by_name(dn, name)) 1099 #define for_each_node_by_type(dn, type) \ 1100 for (dn = of_find_node_by_type(NULL, type); dn; \ 1101 dn = of_find_node_by_type(dn, type)) 1102 #define for_each_compatible_node(dn, type, compatible) \ 1103 for (dn = of_find_compatible_node(NULL, type, compatible); dn; \ 1104 dn = of_find_compatible_node(dn, type, compatible)) 1105 #define for_each_matching_node(dn, matches) \ 1106 for (dn = of_find_matching_node(NULL, matches); dn; \ 1107 dn = of_find_matching_node(dn, matches)) 1108 #define for_each_matching_node_and_match(dn, matches, match) \ 1109 for (dn = of_find_matching_node_and_match(NULL, matches, match); \ 1110 dn; dn = of_find_matching_node_and_match(dn, matches, match)) 1111 1112 #define for_each_child_of_node(parent, child) \ 1113 for (child = of_get_next_child(parent, NULL); child != NULL; \ 1114 child = of_get_next_child(parent, child)) 1115 #define for_each_available_child_of_node(parent, child) \ 1116 for (child = of_get_next_available_child(parent, NULL); child != NULL; \ 1117 child = of_get_next_available_child(parent, child)) 1118 1119 #define for_each_node_with_property(dn, prop_name) \ 1120 for (dn = of_find_node_with_property(NULL, prop_name); dn; \ 1121 dn = of_find_node_with_property(dn, prop_name)) 1122 1123 static inline int of_get_child_count(const struct device_node *np) 1124 { 1125 struct device_node *child; 1126 int num = 0; 1127 1128 for_each_child_of_node(np, child) 1129 num++; 1130 1131 return num; 1132 } 1133 1134 static inline int of_get_available_child_count(const struct device_node *np) 1135 { 1136 struct device_node *child; 1137 int num = 0; 1138 1139 for_each_available_child_of_node(np, child) 1140 num++; 1141 1142 return num; 1143 } 1144 1145 #if defined(CONFIG_OF) && !defined(MODULE) 1146 #define _OF_DECLARE(table, name, compat, fn, fn_type) \ 1147 static const struct of_device_id __of_table_##name \ 1148 __used __section(__##table##_of_table) \ 1149 = { .compatible = compat, \ 1150 .data = (fn == (fn_type)NULL) ? fn : fn } 1151 #else 1152 #define _OF_DECLARE(table, name, compat, fn, fn_type) \ 1153 static const struct of_device_id __of_table_##name \ 1154 __attribute__((unused)) \ 1155 = { .compatible = compat, \ 1156 .data = (fn == (fn_type)NULL) ? fn : fn } 1157 #endif 1158 1159 typedef int (*of_init_fn_2)(struct device_node *, struct device_node *); 1160 typedef int (*of_init_fn_1_ret)(struct device_node *); 1161 typedef void (*of_init_fn_1)(struct device_node *); 1162 1163 #define OF_DECLARE_1(table, name, compat, fn) \ 1164 _OF_DECLARE(table, name, compat, fn, of_init_fn_1) 1165 #define OF_DECLARE_1_RET(table, name, compat, fn) \ 1166 _OF_DECLARE(table, name, compat, fn, of_init_fn_1_ret) 1167 #define OF_DECLARE_2(table, name, compat, fn) \ 1168 _OF_DECLARE(table, name, compat, fn, of_init_fn_2) 1169 1170 /** 1171 * struct of_changeset_entry - Holds a changeset entry 1172 * 1173 * @node: list_head for the log list 1174 * @action: notifier action 1175 * @np: pointer to the device node affected 1176 * @prop: pointer to the property affected 1177 * @old_prop: hold a pointer to the original property 1178 * 1179 * Every modification of the device tree during a changeset 1180 * is held in a list of of_changeset_entry structures. 1181 * That way we can recover from a partial application, or we can 1182 * revert the changeset 1183 */ 1184 struct of_changeset_entry { 1185 struct list_head node; 1186 unsigned long action; 1187 struct device_node *np; 1188 struct property *prop; 1189 struct property *old_prop; 1190 }; 1191 1192 /** 1193 * struct of_changeset - changeset tracker structure 1194 * 1195 * @entries: list_head for the changeset entries 1196 * 1197 * changesets are a convenient way to apply bulk changes to the 1198 * live tree. In case of an error, changes are rolled-back. 1199 * changesets live on after initial application, and if not 1200 * destroyed after use, they can be reverted in one single call. 1201 */ 1202 struct of_changeset { 1203 struct list_head entries; 1204 }; 1205 1206 enum of_reconfig_change { 1207 OF_RECONFIG_NO_CHANGE = 0, 1208 OF_RECONFIG_CHANGE_ADD, 1209 OF_RECONFIG_CHANGE_REMOVE, 1210 }; 1211 1212 #ifdef CONFIG_OF_DYNAMIC 1213 extern int of_reconfig_notifier_register(struct notifier_block *); 1214 extern int of_reconfig_notifier_unregister(struct notifier_block *); 1215 extern int of_reconfig_notify(unsigned long, struct of_reconfig_data *rd); 1216 extern int of_reconfig_get_state_change(unsigned long action, 1217 struct of_reconfig_data *arg); 1218 1219 extern void of_changeset_init(struct of_changeset *ocs); 1220 extern void of_changeset_destroy(struct of_changeset *ocs); 1221 extern int of_changeset_apply(struct of_changeset *ocs); 1222 extern int of_changeset_revert(struct of_changeset *ocs); 1223 extern int of_changeset_action(struct of_changeset *ocs, 1224 unsigned long action, struct device_node *np, 1225 struct property *prop); 1226 1227 static inline int of_changeset_attach_node(struct of_changeset *ocs, 1228 struct device_node *np) 1229 { 1230 return of_changeset_action(ocs, OF_RECONFIG_ATTACH_NODE, np, NULL); 1231 } 1232 1233 static inline int of_changeset_detach_node(struct of_changeset *ocs, 1234 struct device_node *np) 1235 { 1236 return of_changeset_action(ocs, OF_RECONFIG_DETACH_NODE, np, NULL); 1237 } 1238 1239 static inline int of_changeset_add_property(struct of_changeset *ocs, 1240 struct device_node *np, struct property *prop) 1241 { 1242 return of_changeset_action(ocs, OF_RECONFIG_ADD_PROPERTY, np, prop); 1243 } 1244 1245 static inline int of_changeset_remove_property(struct of_changeset *ocs, 1246 struct device_node *np, struct property *prop) 1247 { 1248 return of_changeset_action(ocs, OF_RECONFIG_REMOVE_PROPERTY, np, prop); 1249 } 1250 1251 static inline int of_changeset_update_property(struct of_changeset *ocs, 1252 struct device_node *np, struct property *prop) 1253 { 1254 return of_changeset_action(ocs, OF_RECONFIG_UPDATE_PROPERTY, np, prop); 1255 } 1256 #else /* CONFIG_OF_DYNAMIC */ 1257 static inline int of_reconfig_notifier_register(struct notifier_block *nb) 1258 { 1259 return -EINVAL; 1260 } 1261 static inline int of_reconfig_notifier_unregister(struct notifier_block *nb) 1262 { 1263 return -EINVAL; 1264 } 1265 static inline int of_reconfig_notify(unsigned long action, 1266 struct of_reconfig_data *arg) 1267 { 1268 return -EINVAL; 1269 } 1270 static inline int of_reconfig_get_state_change(unsigned long action, 1271 struct of_reconfig_data *arg) 1272 { 1273 return -EINVAL; 1274 } 1275 #endif /* CONFIG_OF_DYNAMIC */ 1276 1277 /* CONFIG_OF_RESOLVE api */ 1278 extern int of_resolve_phandles(struct device_node *tree); 1279 1280 /** 1281 * of_device_is_system_power_controller - Tells if system-power-controller is found for device_node 1282 * @np: Pointer to the given device_node 1283 * 1284 * return true if present false otherwise 1285 */ 1286 static inline bool of_device_is_system_power_controller(const struct device_node *np) 1287 { 1288 return of_property_read_bool(np, "system-power-controller"); 1289 } 1290 1291 /** 1292 * Overlay support 1293 */ 1294 1295 enum of_overlay_notify_action { 1296 OF_OVERLAY_PRE_APPLY, 1297 OF_OVERLAY_POST_APPLY, 1298 OF_OVERLAY_PRE_REMOVE, 1299 OF_OVERLAY_POST_REMOVE, 1300 }; 1301 1302 struct of_overlay_notify_data { 1303 struct device_node *overlay; 1304 struct device_node *target; 1305 }; 1306 1307 #ifdef CONFIG_OF_OVERLAY 1308 1309 /* ID based overlays; the API for external users */ 1310 int of_overlay_create(struct device_node *tree); 1311 int of_overlay_destroy(int id); 1312 int of_overlay_destroy_all(void); 1313 1314 int of_overlay_notifier_register(struct notifier_block *nb); 1315 int of_overlay_notifier_unregister(struct notifier_block *nb); 1316 1317 #else 1318 1319 static inline int of_overlay_create(struct device_node *tree) 1320 { 1321 return -ENOTSUPP; 1322 } 1323 1324 static inline int of_overlay_destroy(int id) 1325 { 1326 return -ENOTSUPP; 1327 } 1328 1329 static inline int of_overlay_destroy_all(void) 1330 { 1331 return -ENOTSUPP; 1332 } 1333 1334 static inline int of_overlay_notifier_register(struct notifier_block *nb) 1335 { 1336 return 0; 1337 } 1338 1339 static inline int of_overlay_notifier_unregister(struct notifier_block *nb) 1340 { 1341 return 0; 1342 } 1343 1344 #endif 1345 1346 #endif /* _LINUX_OF_H */ 1347