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