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 struct device_node *of_find_node_with_property( 284 struct device_node *from, const char *prop_name); 285 286 extern struct property *of_find_property(const struct device_node *np, 287 const char *name, 288 int *lenp); 289 extern int of_property_count_elems_of_size(const struct device_node *np, 290 const char *propname, int elem_size); 291 extern int of_property_read_u32_index(const struct device_node *np, 292 const char *propname, 293 u32 index, u32 *out_value); 294 extern int of_property_read_variable_u8_array(const struct device_node *np, 295 const char *propname, u8 *out_values, 296 size_t sz_min, size_t sz_max); 297 extern int of_property_read_variable_u16_array(const struct device_node *np, 298 const char *propname, u16 *out_values, 299 size_t sz_min, size_t sz_max); 300 extern int of_property_read_variable_u32_array(const struct device_node *np, 301 const char *propname, 302 u32 *out_values, 303 size_t sz_min, 304 size_t sz_max); 305 extern int of_property_read_u64(const struct device_node *np, 306 const char *propname, u64 *out_value); 307 extern int of_property_read_variable_u64_array(const struct device_node *np, 308 const char *propname, 309 u64 *out_values, 310 size_t sz_min, 311 size_t sz_max); 312 313 extern int of_property_read_string(const struct device_node *np, 314 const char *propname, 315 const char **out_string); 316 extern int of_property_match_string(const struct device_node *np, 317 const char *propname, 318 const char *string); 319 extern int of_property_read_string_helper(const struct device_node *np, 320 const char *propname, 321 const char **out_strs, size_t sz, int index); 322 extern int of_device_is_compatible(const struct device_node *device, 323 const char *); 324 extern int of_device_compatible_match(struct device_node *device, 325 const char *const *compat); 326 extern bool of_device_is_available(const struct device_node *device); 327 extern bool of_device_is_big_endian(const struct device_node *device); 328 extern const void *of_get_property(const struct device_node *node, 329 const char *name, 330 int *lenp); 331 extern struct device_node *of_get_cpu_node(int cpu, unsigned int *thread); 332 #define for_each_property_of_node(dn, pp) \ 333 for (pp = dn->properties; pp != NULL; pp = pp->next) 334 335 extern int of_n_addr_cells(struct device_node *np); 336 extern int of_n_size_cells(struct device_node *np); 337 extern const struct of_device_id *of_match_node( 338 const struct of_device_id *matches, const struct device_node *node); 339 extern int of_modalias_node(struct device_node *node, char *modalias, int len); 340 extern void of_print_phandle_args(const char *msg, const struct of_phandle_args *args); 341 extern struct device_node *of_parse_phandle(const struct device_node *np, 342 const char *phandle_name, 343 int index); 344 extern int of_parse_phandle_with_args(const struct device_node *np, 345 const char *list_name, const char *cells_name, int index, 346 struct of_phandle_args *out_args); 347 extern int of_parse_phandle_with_fixed_args(const struct device_node *np, 348 const char *list_name, int cells_count, int index, 349 struct of_phandle_args *out_args); 350 extern int of_count_phandle_with_args(const struct device_node *np, 351 const char *list_name, const char *cells_name); 352 353 /* phandle iterator functions */ 354 extern int of_phandle_iterator_init(struct of_phandle_iterator *it, 355 const struct device_node *np, 356 const char *list_name, 357 const char *cells_name, 358 int cell_count); 359 360 extern int of_phandle_iterator_next(struct of_phandle_iterator *it); 361 extern int of_phandle_iterator_args(struct of_phandle_iterator *it, 362 uint32_t *args, 363 int size); 364 365 extern void of_alias_scan(void * (*dt_alloc)(u64 size, u64 align)); 366 extern int of_alias_get_id(struct device_node *np, const char *stem); 367 extern int of_alias_get_highest_id(const char *stem); 368 369 extern int of_machine_is_compatible(const char *compat); 370 371 extern int of_add_property(struct device_node *np, struct property *prop); 372 extern int of_remove_property(struct device_node *np, struct property *prop); 373 extern int of_update_property(struct device_node *np, struct property *newprop); 374 375 /* For updating the device tree at runtime */ 376 #define OF_RECONFIG_ATTACH_NODE 0x0001 377 #define OF_RECONFIG_DETACH_NODE 0x0002 378 #define OF_RECONFIG_ADD_PROPERTY 0x0003 379 #define OF_RECONFIG_REMOVE_PROPERTY 0x0004 380 #define OF_RECONFIG_UPDATE_PROPERTY 0x0005 381 382 extern int of_attach_node(struct device_node *); 383 extern int of_detach_node(struct device_node *); 384 385 #define of_match_ptr(_ptr) (_ptr) 386 387 /** 388 * of_property_read_u8_array - Find and read an array of u8 from a property. 389 * 390 * @np: device node from which the property value is to be read. 391 * @propname: name of the property to be searched. 392 * @out_values: pointer to return value, modified only if return value is 0. 393 * @sz: number of array elements to read 394 * 395 * Search for a property in a device node and read 8-bit value(s) from 396 * it. Returns 0 on success, -EINVAL if the property does not exist, 397 * -ENODATA if property does not have a value, and -EOVERFLOW if the 398 * property data isn't large enough. 399 * 400 * dts entry of array should be like: 401 * property = /bits/ 8 <0x50 0x60 0x70>; 402 * 403 * The out_values is modified only if a valid u8 value can be decoded. 404 */ 405 static inline int of_property_read_u8_array(const struct device_node *np, 406 const char *propname, 407 u8 *out_values, size_t sz) 408 { 409 int ret = of_property_read_variable_u8_array(np, propname, out_values, 410 sz, 0); 411 if (ret >= 0) 412 return 0; 413 else 414 return ret; 415 } 416 417 /** 418 * of_property_read_u16_array - Find and read an array of u16 from a property. 419 * 420 * @np: device node from which the property value is to be read. 421 * @propname: name of the property to be searched. 422 * @out_values: pointer to return value, modified only if return value is 0. 423 * @sz: number of array elements to read 424 * 425 * Search for a property in a device node and read 16-bit value(s) from 426 * it. Returns 0 on success, -EINVAL if the property does not exist, 427 * -ENODATA if property does not have a value, and -EOVERFLOW if the 428 * property data isn't large enough. 429 * 430 * dts entry of array should be like: 431 * property = /bits/ 16 <0x5000 0x6000 0x7000>; 432 * 433 * The out_values is modified only if a valid u16 value can be decoded. 434 */ 435 static inline int of_property_read_u16_array(const struct device_node *np, 436 const char *propname, 437 u16 *out_values, size_t sz) 438 { 439 int ret = of_property_read_variable_u16_array(np, propname, out_values, 440 sz, 0); 441 if (ret >= 0) 442 return 0; 443 else 444 return ret; 445 } 446 447 /** 448 * of_property_read_u32_array - Find and read an array of 32 bit integers 449 * from a property. 450 * 451 * @np: device node from which the property value is to be read. 452 * @propname: name of the property to be searched. 453 * @out_values: pointer to return value, modified only if return value is 0. 454 * @sz: number of array elements to read 455 * 456 * Search for a property in a device node and read 32-bit value(s) from 457 * it. Returns 0 on success, -EINVAL if the property does not exist, 458 * -ENODATA if property does not have a value, and -EOVERFLOW if the 459 * property data isn't large enough. 460 * 461 * The out_values is modified only if a valid u32 value can be decoded. 462 */ 463 static inline int of_property_read_u32_array(const struct device_node *np, 464 const char *propname, 465 u32 *out_values, size_t sz) 466 { 467 int ret = of_property_read_variable_u32_array(np, propname, out_values, 468 sz, 0); 469 if (ret >= 0) 470 return 0; 471 else 472 return ret; 473 } 474 475 /** 476 * of_property_read_u64_array - Find and read an array of 64 bit integers 477 * from a property. 478 * 479 * @np: device node from which the property value is to be read. 480 * @propname: name of the property to be searched. 481 * @out_values: pointer to return value, modified only if return value is 0. 482 * @sz: number of array elements to read 483 * 484 * Search for a property in a device node and read 64-bit value(s) from 485 * it. Returns 0 on success, -EINVAL if the property does not exist, 486 * -ENODATA if property does not have a value, and -EOVERFLOW if the 487 * property data isn't large enough. 488 * 489 * The out_values is modified only if a valid u64 value can be decoded. 490 */ 491 static inline int of_property_read_u64_array(const struct device_node *np, 492 const char *propname, 493 u64 *out_values, size_t sz) 494 { 495 int ret = of_property_read_variable_u64_array(np, propname, out_values, 496 sz, 0); 497 if (ret >= 0) 498 return 0; 499 else 500 return ret; 501 } 502 503 /* 504 * struct property *prop; 505 * const __be32 *p; 506 * u32 u; 507 * 508 * of_property_for_each_u32(np, "propname", prop, p, u) 509 * printk("U32 value: %x\n", u); 510 */ 511 const __be32 *of_prop_next_u32(struct property *prop, const __be32 *cur, 512 u32 *pu); 513 /* 514 * struct property *prop; 515 * const char *s; 516 * 517 * of_property_for_each_string(np, "propname", prop, s) 518 * printk("String value: %s\n", s); 519 */ 520 const char *of_prop_next_string(struct property *prop, const char *cur); 521 522 bool of_console_check(struct device_node *dn, char *name, int index); 523 524 #else /* CONFIG_OF */ 525 526 static inline void of_core_init(void) 527 { 528 } 529 530 static inline bool is_of_node(struct fwnode_handle *fwnode) 531 { 532 return false; 533 } 534 535 static inline struct device_node *to_of_node(struct fwnode_handle *fwnode) 536 { 537 return NULL; 538 } 539 540 static inline const char* of_node_full_name(const struct device_node *np) 541 { 542 return "<no-node>"; 543 } 544 545 static inline struct device_node *of_find_node_by_name(struct device_node *from, 546 const char *name) 547 { 548 return NULL; 549 } 550 551 static inline struct device_node *of_find_node_by_type(struct device_node *from, 552 const char *type) 553 { 554 return NULL; 555 } 556 557 static inline struct device_node *of_find_matching_node_and_match( 558 struct device_node *from, 559 const struct of_device_id *matches, 560 const struct of_device_id **match) 561 { 562 return NULL; 563 } 564 565 static inline struct device_node *of_find_node_by_path(const char *path) 566 { 567 return NULL; 568 } 569 570 static inline struct device_node *of_find_node_opts_by_path(const char *path, 571 const char **opts) 572 { 573 return NULL; 574 } 575 576 static inline struct device_node *of_find_node_by_phandle(phandle handle) 577 { 578 return NULL; 579 } 580 581 static inline struct device_node *of_get_parent(const struct device_node *node) 582 { 583 return NULL; 584 } 585 586 static inline struct device_node *of_get_next_child( 587 const struct device_node *node, struct device_node *prev) 588 { 589 return NULL; 590 } 591 592 static inline struct device_node *of_get_next_available_child( 593 const struct device_node *node, struct device_node *prev) 594 { 595 return NULL; 596 } 597 598 static inline struct device_node *of_find_node_with_property( 599 struct device_node *from, const char *prop_name) 600 { 601 return NULL; 602 } 603 604 static inline bool of_have_populated_dt(void) 605 { 606 return false; 607 } 608 609 static inline struct device_node *of_get_child_by_name( 610 const struct device_node *node, 611 const char *name) 612 { 613 return NULL; 614 } 615 616 static inline int of_device_is_compatible(const struct device_node *device, 617 const char *name) 618 { 619 return 0; 620 } 621 622 static inline bool of_device_is_available(const struct device_node *device) 623 { 624 return false; 625 } 626 627 static inline bool of_device_is_big_endian(const struct device_node *device) 628 { 629 return false; 630 } 631 632 static inline struct property *of_find_property(const struct device_node *np, 633 const char *name, 634 int *lenp) 635 { 636 return NULL; 637 } 638 639 static inline struct device_node *of_find_compatible_node( 640 struct device_node *from, 641 const char *type, 642 const char *compat) 643 { 644 return NULL; 645 } 646 647 static inline int of_property_count_elems_of_size(const struct device_node *np, 648 const char *propname, int elem_size) 649 { 650 return -ENOSYS; 651 } 652 653 static inline int of_property_read_u32_index(const struct device_node *np, 654 const char *propname, u32 index, u32 *out_value) 655 { 656 return -ENOSYS; 657 } 658 659 static inline int of_property_read_u8_array(const struct device_node *np, 660 const char *propname, u8 *out_values, size_t sz) 661 { 662 return -ENOSYS; 663 } 664 665 static inline int of_property_read_u16_array(const struct device_node *np, 666 const char *propname, u16 *out_values, size_t sz) 667 { 668 return -ENOSYS; 669 } 670 671 static inline int of_property_read_u32_array(const struct device_node *np, 672 const char *propname, 673 u32 *out_values, size_t sz) 674 { 675 return -ENOSYS; 676 } 677 678 static inline int of_property_read_u64_array(const struct device_node *np, 679 const char *propname, 680 u64 *out_values, size_t sz) 681 { 682 return -ENOSYS; 683 } 684 685 static inline int of_property_read_string(const struct device_node *np, 686 const char *propname, 687 const char **out_string) 688 { 689 return -ENOSYS; 690 } 691 692 static inline int of_property_read_string_helper(const struct device_node *np, 693 const char *propname, 694 const char **out_strs, size_t sz, int index) 695 { 696 return -ENOSYS; 697 } 698 699 static inline const void *of_get_property(const struct device_node *node, 700 const char *name, 701 int *lenp) 702 { 703 return NULL; 704 } 705 706 static inline struct device_node *of_get_cpu_node(int cpu, 707 unsigned int *thread) 708 { 709 return NULL; 710 } 711 712 static inline int of_property_read_u64(const struct device_node *np, 713 const char *propname, u64 *out_value) 714 { 715 return -ENOSYS; 716 } 717 718 static inline int of_property_match_string(const struct device_node *np, 719 const char *propname, 720 const char *string) 721 { 722 return -ENOSYS; 723 } 724 725 static inline struct device_node *of_parse_phandle(const struct device_node *np, 726 const char *phandle_name, 727 int index) 728 { 729 return NULL; 730 } 731 732 static inline int of_parse_phandle_with_args(const struct device_node *np, 733 const char *list_name, 734 const char *cells_name, 735 int index, 736 struct of_phandle_args *out_args) 737 { 738 return -ENOSYS; 739 } 740 741 static inline int of_parse_phandle_with_fixed_args(const struct device_node *np, 742 const char *list_name, int cells_count, int index, 743 struct of_phandle_args *out_args) 744 { 745 return -ENOSYS; 746 } 747 748 static inline int of_count_phandle_with_args(struct device_node *np, 749 const char *list_name, 750 const char *cells_name) 751 { 752 return -ENOSYS; 753 } 754 755 static inline int of_phandle_iterator_init(struct of_phandle_iterator *it, 756 const struct device_node *np, 757 const char *list_name, 758 const char *cells_name, 759 int cell_count) 760 { 761 return -ENOSYS; 762 } 763 764 static inline int of_phandle_iterator_next(struct of_phandle_iterator *it) 765 { 766 return -ENOSYS; 767 } 768 769 static inline int of_phandle_iterator_args(struct of_phandle_iterator *it, 770 uint32_t *args, 771 int size) 772 { 773 return 0; 774 } 775 776 static inline int of_alias_get_id(struct device_node *np, const char *stem) 777 { 778 return -ENOSYS; 779 } 780 781 static inline int of_alias_get_highest_id(const char *stem) 782 { 783 return -ENOSYS; 784 } 785 786 static inline int of_machine_is_compatible(const char *compat) 787 { 788 return 0; 789 } 790 791 static inline bool of_console_check(const struct device_node *dn, const char *name, int index) 792 { 793 return false; 794 } 795 796 static inline const __be32 *of_prop_next_u32(struct property *prop, 797 const __be32 *cur, u32 *pu) 798 { 799 return NULL; 800 } 801 802 static inline const char *of_prop_next_string(struct property *prop, 803 const char *cur) 804 { 805 return NULL; 806 } 807 808 static inline int of_node_check_flag(struct device_node *n, unsigned long flag) 809 { 810 return 0; 811 } 812 813 static inline int of_node_test_and_set_flag(struct device_node *n, 814 unsigned long flag) 815 { 816 return 0; 817 } 818 819 static inline void of_node_set_flag(struct device_node *n, unsigned long flag) 820 { 821 } 822 823 static inline void of_node_clear_flag(struct device_node *n, unsigned long flag) 824 { 825 } 826 827 static inline int of_property_check_flag(struct property *p, unsigned long flag) 828 { 829 return 0; 830 } 831 832 static inline void of_property_set_flag(struct property *p, unsigned long flag) 833 { 834 } 835 836 static inline void of_property_clear_flag(struct property *p, unsigned long flag) 837 { 838 } 839 840 #define of_match_ptr(_ptr) NULL 841 #define of_match_node(_matches, _node) NULL 842 #endif /* CONFIG_OF */ 843 844 /* Default string compare functions, Allow arch asm/prom.h to override */ 845 #if !defined(of_compat_cmp) 846 #define of_compat_cmp(s1, s2, l) strcasecmp((s1), (s2)) 847 #define of_prop_cmp(s1, s2) strcmp((s1), (s2)) 848 #define of_node_cmp(s1, s2) strcasecmp((s1), (s2)) 849 #endif 850 851 #if defined(CONFIG_OF) && defined(CONFIG_NUMA) 852 extern int of_node_to_nid(struct device_node *np); 853 #else 854 static inline int of_node_to_nid(struct device_node *device) 855 { 856 return NUMA_NO_NODE; 857 } 858 #endif 859 860 #ifdef CONFIG_OF_NUMA 861 extern int of_numa_init(void); 862 #else 863 static inline int of_numa_init(void) 864 { 865 return -ENOSYS; 866 } 867 #endif 868 869 static inline struct device_node *of_find_matching_node( 870 struct device_node *from, 871 const struct of_device_id *matches) 872 { 873 return of_find_matching_node_and_match(from, matches, NULL); 874 } 875 876 /** 877 * of_property_count_u8_elems - Count the number of u8 elements in a property 878 * 879 * @np: device node from which the property value is to be read. 880 * @propname: name of the property to be searched. 881 * 882 * Search for a property in a device node and count the number of u8 elements 883 * in it. Returns number of elements on sucess, -EINVAL if the property does 884 * not exist or its length does not match a multiple of u8 and -ENODATA if the 885 * property does not have a value. 886 */ 887 static inline int of_property_count_u8_elems(const struct device_node *np, 888 const char *propname) 889 { 890 return of_property_count_elems_of_size(np, propname, sizeof(u8)); 891 } 892 893 /** 894 * of_property_count_u16_elems - Count the number of u16 elements in a property 895 * 896 * @np: device node from which the property value is to be read. 897 * @propname: name of the property to be searched. 898 * 899 * Search for a property in a device node and count the number of u16 elements 900 * in it. Returns number of elements on sucess, -EINVAL if the property does 901 * not exist or its length does not match a multiple of u16 and -ENODATA if the 902 * property does not have a value. 903 */ 904 static inline int of_property_count_u16_elems(const struct device_node *np, 905 const char *propname) 906 { 907 return of_property_count_elems_of_size(np, propname, sizeof(u16)); 908 } 909 910 /** 911 * of_property_count_u32_elems - Count the number of u32 elements in a property 912 * 913 * @np: device node from which the property value is to be read. 914 * @propname: name of the property to be searched. 915 * 916 * Search for a property in a device node and count the number of u32 elements 917 * in it. Returns number of elements on sucess, -EINVAL if the property does 918 * not exist or its length does not match a multiple of u32 and -ENODATA if the 919 * property does not have a value. 920 */ 921 static inline int of_property_count_u32_elems(const struct device_node *np, 922 const char *propname) 923 { 924 return of_property_count_elems_of_size(np, propname, sizeof(u32)); 925 } 926 927 /** 928 * of_property_count_u64_elems - Count the number of u64 elements in a property 929 * 930 * @np: device node from which the property value is to be read. 931 * @propname: name of the property to be searched. 932 * 933 * Search for a property in a device node and count the number of u64 elements 934 * in it. Returns number of elements on sucess, -EINVAL if the property does 935 * not exist or its length does not match a multiple of u64 and -ENODATA if the 936 * property does not have a value. 937 */ 938 static inline int of_property_count_u64_elems(const struct device_node *np, 939 const char *propname) 940 { 941 return of_property_count_elems_of_size(np, propname, sizeof(u64)); 942 } 943 944 /** 945 * of_property_read_string_array() - Read an array of strings from a multiple 946 * strings property. 947 * @np: device node from which the property value is to be read. 948 * @propname: name of the property to be searched. 949 * @out_strs: output array of string pointers. 950 * @sz: number of array elements to read. 951 * 952 * Search for a property in a device tree node and retrieve a list of 953 * terminated string values (pointer to data, not a copy) in that property. 954 * 955 * If @out_strs is NULL, the number of strings in the property is returned. 956 */ 957 static inline int of_property_read_string_array(const struct device_node *np, 958 const char *propname, const char **out_strs, 959 size_t sz) 960 { 961 return of_property_read_string_helper(np, propname, out_strs, sz, 0); 962 } 963 964 /** 965 * of_property_count_strings() - Find and return the number of strings from a 966 * multiple strings property. 967 * @np: device node from which the property value is to be read. 968 * @propname: name of the property to be searched. 969 * 970 * Search for a property in a device tree node and retrieve the number of null 971 * terminated string contain in it. Returns the number of strings on 972 * success, -EINVAL if the property does not exist, -ENODATA if property 973 * does not have a value, and -EILSEQ if the string is not null-terminated 974 * within the length of the property data. 975 */ 976 static inline int of_property_count_strings(const struct device_node *np, 977 const char *propname) 978 { 979 return of_property_read_string_helper(np, propname, NULL, 0, 0); 980 } 981 982 /** 983 * of_property_read_string_index() - Find and read a string from a multiple 984 * strings property. 985 * @np: device node from which the property value is to be read. 986 * @propname: name of the property to be searched. 987 * @index: index of the string in the list of strings 988 * @out_string: pointer to null terminated return string, modified only if 989 * return value is 0. 990 * 991 * Search for a property in a device tree node and retrieve a null 992 * terminated string value (pointer to data, not a copy) in the list of strings 993 * contained in that property. 994 * Returns 0 on success, -EINVAL if the property does not exist, -ENODATA if 995 * property does not have a value, and -EILSEQ if the string is not 996 * null-terminated within the length of the property data. 997 * 998 * The out_string pointer is modified only if a valid string can be decoded. 999 */ 1000 static inline int of_property_read_string_index(const struct device_node *np, 1001 const char *propname, 1002 int index, const char **output) 1003 { 1004 int rc = of_property_read_string_helper(np, propname, output, 1, index); 1005 return rc < 0 ? rc : 0; 1006 } 1007 1008 /** 1009 * of_property_read_bool - Findfrom a property 1010 * @np: device node from which the property value is to be read. 1011 * @propname: name of the property to be searched. 1012 * 1013 * Search for a property in a device node. 1014 * Returns true if the property exists false otherwise. 1015 */ 1016 static inline bool of_property_read_bool(const struct device_node *np, 1017 const char *propname) 1018 { 1019 struct property *prop = of_find_property(np, propname, NULL); 1020 1021 return prop ? true : false; 1022 } 1023 1024 static inline int of_property_read_u8(const struct device_node *np, 1025 const char *propname, 1026 u8 *out_value) 1027 { 1028 return of_property_read_u8_array(np, propname, out_value, 1); 1029 } 1030 1031 static inline int of_property_read_u16(const struct device_node *np, 1032 const char *propname, 1033 u16 *out_value) 1034 { 1035 return of_property_read_u16_array(np, propname, out_value, 1); 1036 } 1037 1038 static inline int of_property_read_u32(const struct device_node *np, 1039 const char *propname, 1040 u32 *out_value) 1041 { 1042 return of_property_read_u32_array(np, propname, out_value, 1); 1043 } 1044 1045 static inline int of_property_read_s32(const struct device_node *np, 1046 const char *propname, 1047 s32 *out_value) 1048 { 1049 return of_property_read_u32(np, propname, (u32*) out_value); 1050 } 1051 1052 #define of_for_each_phandle(it, err, np, ln, cn, cc) \ 1053 for (of_phandle_iterator_init((it), (np), (ln), (cn), (cc)), \ 1054 err = of_phandle_iterator_next(it); \ 1055 err == 0; \ 1056 err = of_phandle_iterator_next(it)) 1057 1058 #define of_property_for_each_u32(np, propname, prop, p, u) \ 1059 for (prop = of_find_property(np, propname, NULL), \ 1060 p = of_prop_next_u32(prop, NULL, &u); \ 1061 p; \ 1062 p = of_prop_next_u32(prop, p, &u)) 1063 1064 #define of_property_for_each_string(np, propname, prop, s) \ 1065 for (prop = of_find_property(np, propname, NULL), \ 1066 s = of_prop_next_string(prop, NULL); \ 1067 s; \ 1068 s = of_prop_next_string(prop, s)) 1069 1070 #define for_each_node_by_name(dn, name) \ 1071 for (dn = of_find_node_by_name(NULL, name); dn; \ 1072 dn = of_find_node_by_name(dn, name)) 1073 #define for_each_node_by_type(dn, type) \ 1074 for (dn = of_find_node_by_type(NULL, type); dn; \ 1075 dn = of_find_node_by_type(dn, type)) 1076 #define for_each_compatible_node(dn, type, compatible) \ 1077 for (dn = of_find_compatible_node(NULL, type, compatible); dn; \ 1078 dn = of_find_compatible_node(dn, type, compatible)) 1079 #define for_each_matching_node(dn, matches) \ 1080 for (dn = of_find_matching_node(NULL, matches); dn; \ 1081 dn = of_find_matching_node(dn, matches)) 1082 #define for_each_matching_node_and_match(dn, matches, match) \ 1083 for (dn = of_find_matching_node_and_match(NULL, matches, match); \ 1084 dn; dn = of_find_matching_node_and_match(dn, matches, match)) 1085 1086 #define for_each_child_of_node(parent, child) \ 1087 for (child = of_get_next_child(parent, NULL); child != NULL; \ 1088 child = of_get_next_child(parent, child)) 1089 #define for_each_available_child_of_node(parent, child) \ 1090 for (child = of_get_next_available_child(parent, NULL); child != NULL; \ 1091 child = of_get_next_available_child(parent, child)) 1092 1093 #define for_each_node_with_property(dn, prop_name) \ 1094 for (dn = of_find_node_with_property(NULL, prop_name); dn; \ 1095 dn = of_find_node_with_property(dn, prop_name)) 1096 1097 static inline int of_get_child_count(const struct device_node *np) 1098 { 1099 struct device_node *child; 1100 int num = 0; 1101 1102 for_each_child_of_node(np, child) 1103 num++; 1104 1105 return num; 1106 } 1107 1108 static inline int of_get_available_child_count(const struct device_node *np) 1109 { 1110 struct device_node *child; 1111 int num = 0; 1112 1113 for_each_available_child_of_node(np, child) 1114 num++; 1115 1116 return num; 1117 } 1118 1119 #if defined(CONFIG_OF) && !defined(MODULE) 1120 #define _OF_DECLARE(table, name, compat, fn, fn_type) \ 1121 static const struct of_device_id __of_table_##name \ 1122 __used __section(__##table##_of_table) \ 1123 = { .compatible = compat, \ 1124 .data = (fn == (fn_type)NULL) ? fn : fn } 1125 #else 1126 #define _OF_DECLARE(table, name, compat, fn, fn_type) \ 1127 static const struct of_device_id __of_table_##name \ 1128 __attribute__((unused)) \ 1129 = { .compatible = compat, \ 1130 .data = (fn == (fn_type)NULL) ? fn : fn } 1131 #endif 1132 1133 typedef int (*of_init_fn_2)(struct device_node *, struct device_node *); 1134 typedef int (*of_init_fn_1_ret)(struct device_node *); 1135 typedef void (*of_init_fn_1)(struct device_node *); 1136 1137 #define OF_DECLARE_1(table, name, compat, fn) \ 1138 _OF_DECLARE(table, name, compat, fn, of_init_fn_1) 1139 #define OF_DECLARE_1_RET(table, name, compat, fn) \ 1140 _OF_DECLARE(table, name, compat, fn, of_init_fn_1_ret) 1141 #define OF_DECLARE_2(table, name, compat, fn) \ 1142 _OF_DECLARE(table, name, compat, fn, of_init_fn_2) 1143 1144 /** 1145 * struct of_changeset_entry - Holds a changeset entry 1146 * 1147 * @node: list_head for the log list 1148 * @action: notifier action 1149 * @np: pointer to the device node affected 1150 * @prop: pointer to the property affected 1151 * @old_prop: hold a pointer to the original property 1152 * 1153 * Every modification of the device tree during a changeset 1154 * is held in a list of of_changeset_entry structures. 1155 * That way we can recover from a partial application, or we can 1156 * revert the changeset 1157 */ 1158 struct of_changeset_entry { 1159 struct list_head node; 1160 unsigned long action; 1161 struct device_node *np; 1162 struct property *prop; 1163 struct property *old_prop; 1164 }; 1165 1166 /** 1167 * struct of_changeset - changeset tracker structure 1168 * 1169 * @entries: list_head for the changeset entries 1170 * 1171 * changesets are a convenient way to apply bulk changes to the 1172 * live tree. In case of an error, changes are rolled-back. 1173 * changesets live on after initial application, and if not 1174 * destroyed after use, they can be reverted in one single call. 1175 */ 1176 struct of_changeset { 1177 struct list_head entries; 1178 }; 1179 1180 enum of_reconfig_change { 1181 OF_RECONFIG_NO_CHANGE = 0, 1182 OF_RECONFIG_CHANGE_ADD, 1183 OF_RECONFIG_CHANGE_REMOVE, 1184 }; 1185 1186 #ifdef CONFIG_OF_DYNAMIC 1187 extern int of_reconfig_notifier_register(struct notifier_block *); 1188 extern int of_reconfig_notifier_unregister(struct notifier_block *); 1189 extern int of_reconfig_notify(unsigned long, struct of_reconfig_data *rd); 1190 extern int of_reconfig_get_state_change(unsigned long action, 1191 struct of_reconfig_data *arg); 1192 1193 extern void of_changeset_init(struct of_changeset *ocs); 1194 extern void of_changeset_destroy(struct of_changeset *ocs); 1195 extern int of_changeset_apply(struct of_changeset *ocs); 1196 extern int of_changeset_revert(struct of_changeset *ocs); 1197 extern int of_changeset_action(struct of_changeset *ocs, 1198 unsigned long action, struct device_node *np, 1199 struct property *prop); 1200 1201 static inline int of_changeset_attach_node(struct of_changeset *ocs, 1202 struct device_node *np) 1203 { 1204 return of_changeset_action(ocs, OF_RECONFIG_ATTACH_NODE, np, NULL); 1205 } 1206 1207 static inline int of_changeset_detach_node(struct of_changeset *ocs, 1208 struct device_node *np) 1209 { 1210 return of_changeset_action(ocs, OF_RECONFIG_DETACH_NODE, np, NULL); 1211 } 1212 1213 static inline int of_changeset_add_property(struct of_changeset *ocs, 1214 struct device_node *np, struct property *prop) 1215 { 1216 return of_changeset_action(ocs, OF_RECONFIG_ADD_PROPERTY, np, prop); 1217 } 1218 1219 static inline int of_changeset_remove_property(struct of_changeset *ocs, 1220 struct device_node *np, struct property *prop) 1221 { 1222 return of_changeset_action(ocs, OF_RECONFIG_REMOVE_PROPERTY, np, prop); 1223 } 1224 1225 static inline int of_changeset_update_property(struct of_changeset *ocs, 1226 struct device_node *np, struct property *prop) 1227 { 1228 return of_changeset_action(ocs, OF_RECONFIG_UPDATE_PROPERTY, np, prop); 1229 } 1230 #else /* CONFIG_OF_DYNAMIC */ 1231 static inline int of_reconfig_notifier_register(struct notifier_block *nb) 1232 { 1233 return -EINVAL; 1234 } 1235 static inline int of_reconfig_notifier_unregister(struct notifier_block *nb) 1236 { 1237 return -EINVAL; 1238 } 1239 static inline int of_reconfig_notify(unsigned long action, 1240 struct of_reconfig_data *arg) 1241 { 1242 return -EINVAL; 1243 } 1244 static inline int of_reconfig_get_state_change(unsigned long action, 1245 struct of_reconfig_data *arg) 1246 { 1247 return -EINVAL; 1248 } 1249 #endif /* CONFIG_OF_DYNAMIC */ 1250 1251 /* CONFIG_OF_RESOLVE api */ 1252 extern int of_resolve_phandles(struct device_node *tree); 1253 1254 /** 1255 * of_device_is_system_power_controller - Tells if system-power-controller is found for device_node 1256 * @np: Pointer to the given device_node 1257 * 1258 * return true if present false otherwise 1259 */ 1260 static inline bool of_device_is_system_power_controller(const struct device_node *np) 1261 { 1262 return of_property_read_bool(np, "system-power-controller"); 1263 } 1264 1265 /** 1266 * Overlay support 1267 */ 1268 1269 enum of_overlay_notify_action { 1270 OF_OVERLAY_PRE_APPLY, 1271 OF_OVERLAY_POST_APPLY, 1272 OF_OVERLAY_PRE_REMOVE, 1273 OF_OVERLAY_POST_REMOVE, 1274 }; 1275 1276 struct of_overlay_notify_data { 1277 struct device_node *overlay; 1278 struct device_node *target; 1279 }; 1280 1281 #ifdef CONFIG_OF_OVERLAY 1282 1283 /* ID based overlays; the API for external users */ 1284 int of_overlay_create(struct device_node *tree); 1285 int of_overlay_destroy(int id); 1286 int of_overlay_destroy_all(void); 1287 1288 int of_overlay_notifier_register(struct notifier_block *nb); 1289 int of_overlay_notifier_unregister(struct notifier_block *nb); 1290 1291 #else 1292 1293 static inline int of_overlay_create(struct device_node *tree) 1294 { 1295 return -ENOTSUPP; 1296 } 1297 1298 static inline int of_overlay_destroy(int id) 1299 { 1300 return -ENOTSUPP; 1301 } 1302 1303 static inline int of_overlay_destroy_all(void) 1304 { 1305 return -ENOTSUPP; 1306 } 1307 1308 static inline int of_overlay_notifier_register(struct notifier_block *nb) 1309 { 1310 return 0; 1311 } 1312 1313 static inline int of_overlay_notifier_unregister(struct notifier_block *nb) 1314 { 1315 return 0; 1316 } 1317 1318 #endif 1319 1320 #endif /* _LINUX_OF_H */ 1321