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