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 phandle phandle; 54 const char *full_name; 55 struct fwnode_handle fwnode; 56 57 struct property *properties; 58 struct property *deadprops; /* removed properties */ 59 struct device_node *parent; 60 struct device_node *child; 61 struct device_node *sibling; 62 #if defined(CONFIG_OF_KOBJ) 63 struct kobject kobj; 64 #endif 65 unsigned long _flags; 66 void *data; 67 #if defined(CONFIG_SPARC) 68 unsigned int unique_id; 69 struct of_irq_controller *irq_trans; 70 #endif 71 }; 72 73 #define MAX_PHANDLE_ARGS 16 74 struct of_phandle_args { 75 struct device_node *np; 76 int args_count; 77 uint32_t args[MAX_PHANDLE_ARGS]; 78 }; 79 80 struct of_phandle_iterator { 81 /* Common iterator information */ 82 const char *cells_name; 83 int cell_count; 84 const struct device_node *parent; 85 86 /* List size information */ 87 const __be32 *list_end; 88 const __be32 *phandle_end; 89 90 /* Current position state */ 91 const __be32 *cur; 92 uint32_t cur_count; 93 phandle phandle; 94 struct device_node *node; 95 }; 96 97 struct of_reconfig_data { 98 struct device_node *dn; 99 struct property *prop; 100 struct property *old_prop; 101 }; 102 103 /* initialize a node */ 104 extern struct kobj_type of_node_ktype; 105 extern const struct fwnode_operations of_fwnode_ops; 106 static inline void of_node_init(struct device_node *node) 107 { 108 #if defined(CONFIG_OF_KOBJ) 109 kobject_init(&node->kobj, &of_node_ktype); 110 #endif 111 fwnode_init(&node->fwnode, &of_fwnode_ops); 112 } 113 114 #if defined(CONFIG_OF_KOBJ) 115 #define of_node_kobj(n) (&(n)->kobj) 116 #else 117 #define of_node_kobj(n) NULL 118 #endif 119 120 #ifdef CONFIG_OF_DYNAMIC 121 extern struct device_node *of_node_get(struct device_node *node); 122 extern void of_node_put(struct device_node *node); 123 #else /* CONFIG_OF_DYNAMIC */ 124 /* Dummy ref counting routines - to be implemented later */ 125 static inline struct device_node *of_node_get(struct device_node *node) 126 { 127 return node; 128 } 129 static inline void of_node_put(struct device_node *node) { } 130 #endif /* !CONFIG_OF_DYNAMIC */ 131 132 /* Pointer for first entry in chain of all nodes. */ 133 extern struct device_node *of_root; 134 extern struct device_node *of_chosen; 135 extern struct device_node *of_aliases; 136 extern struct device_node *of_stdout; 137 extern raw_spinlock_t devtree_lock; 138 139 /* 140 * struct device_node flag descriptions 141 * (need to be visible even when !CONFIG_OF) 142 */ 143 #define OF_DYNAMIC 1 /* (and properties) allocated via kmalloc */ 144 #define OF_DETACHED 2 /* detached from the device tree */ 145 #define OF_POPULATED 3 /* device already created */ 146 #define OF_POPULATED_BUS 4 /* platform bus created for children */ 147 #define OF_OVERLAY 5 /* allocated for an overlay */ 148 #define OF_OVERLAY_FREE_CSET 6 /* in overlay cset being freed */ 149 150 #define OF_BAD_ADDR ((u64)-1) 151 152 #ifdef CONFIG_OF 153 void of_core_init(void); 154 155 static inline bool is_of_node(const struct fwnode_handle *fwnode) 156 { 157 return !IS_ERR_OR_NULL(fwnode) && fwnode->ops == &of_fwnode_ops; 158 } 159 160 #define to_of_node(__fwnode) \ 161 ({ \ 162 typeof(__fwnode) __to_of_node_fwnode = (__fwnode); \ 163 \ 164 is_of_node(__to_of_node_fwnode) ? \ 165 container_of(__to_of_node_fwnode, \ 166 struct device_node, fwnode) : \ 167 NULL; \ 168 }) 169 170 #define of_fwnode_handle(node) \ 171 ({ \ 172 typeof(node) __of_fwnode_handle_node = (node); \ 173 \ 174 __of_fwnode_handle_node ? \ 175 &__of_fwnode_handle_node->fwnode : NULL; \ 176 }) 177 178 static inline bool of_have_populated_dt(void) 179 { 180 return of_root != NULL; 181 } 182 183 static inline bool of_node_is_root(const struct device_node *node) 184 { 185 return node && (node->parent == NULL); 186 } 187 188 static inline int of_node_check_flag(const struct device_node *n, unsigned long flag) 189 { 190 return test_bit(flag, &n->_flags); 191 } 192 193 static inline int of_node_test_and_set_flag(struct device_node *n, 194 unsigned long flag) 195 { 196 return test_and_set_bit(flag, &n->_flags); 197 } 198 199 static inline void of_node_set_flag(struct device_node *n, unsigned long flag) 200 { 201 set_bit(flag, &n->_flags); 202 } 203 204 static inline void of_node_clear_flag(struct device_node *n, unsigned long flag) 205 { 206 clear_bit(flag, &n->_flags); 207 } 208 209 #if defined(CONFIG_OF_DYNAMIC) || defined(CONFIG_SPARC) 210 static inline int of_property_check_flag(const struct property *p, unsigned long flag) 211 { 212 return test_bit(flag, &p->_flags); 213 } 214 215 static inline void of_property_set_flag(struct property *p, unsigned long flag) 216 { 217 set_bit(flag, &p->_flags); 218 } 219 220 static inline void of_property_clear_flag(struct property *p, unsigned long flag) 221 { 222 clear_bit(flag, &p->_flags); 223 } 224 #endif 225 226 extern struct device_node *__of_find_all_nodes(struct device_node *prev); 227 extern struct device_node *of_find_all_nodes(struct device_node *prev); 228 229 /* 230 * OF address retrieval & translation 231 */ 232 233 /* Helper to read a big number; size is in cells (not bytes) */ 234 static inline u64 of_read_number(const __be32 *cell, int size) 235 { 236 u64 r = 0; 237 for (; size--; cell++) 238 r = (r << 32) | be32_to_cpu(*cell); 239 return r; 240 } 241 242 /* Like of_read_number, but we want an unsigned long result */ 243 static inline unsigned long of_read_ulong(const __be32 *cell, int size) 244 { 245 /* toss away upper bits if unsigned long is smaller than u64 */ 246 return of_read_number(cell, size); 247 } 248 249 #if defined(CONFIG_SPARC) 250 #include <asm/prom.h> 251 #endif 252 253 #define OF_IS_DYNAMIC(x) test_bit(OF_DYNAMIC, &x->_flags) 254 #define OF_MARK_DYNAMIC(x) set_bit(OF_DYNAMIC, &x->_flags) 255 256 extern bool of_node_name_eq(const struct device_node *np, const char *name); 257 extern bool of_node_name_prefix(const struct device_node *np, const char *prefix); 258 259 static inline const char *of_node_full_name(const struct device_node *np) 260 { 261 return np ? np->full_name : "<no-node>"; 262 } 263 264 #define for_each_of_allnodes_from(from, dn) \ 265 for (dn = __of_find_all_nodes(from); dn; dn = __of_find_all_nodes(dn)) 266 #define for_each_of_allnodes(dn) for_each_of_allnodes_from(NULL, dn) 267 extern struct device_node *of_find_node_by_name(struct device_node *from, 268 const char *name); 269 extern struct device_node *of_find_node_by_type(struct device_node *from, 270 const char *type); 271 extern struct device_node *of_find_compatible_node(struct device_node *from, 272 const char *type, const char *compat); 273 extern struct device_node *of_find_matching_node_and_match( 274 struct device_node *from, 275 const struct of_device_id *matches, 276 const struct of_device_id **match); 277 278 extern struct device_node *of_find_node_opts_by_path(const char *path, 279 const char **opts); 280 static inline struct device_node *of_find_node_by_path(const char *path) 281 { 282 return of_find_node_opts_by_path(path, NULL); 283 } 284 285 extern struct device_node *of_find_node_by_phandle(phandle handle); 286 extern struct device_node *of_get_parent(const struct device_node *node); 287 extern struct device_node *of_get_next_parent(struct device_node *node); 288 extern struct device_node *of_get_next_child(const struct device_node *node, 289 struct device_node *prev); 290 extern struct device_node *of_get_next_available_child( 291 const struct device_node *node, struct device_node *prev); 292 293 extern struct device_node *of_get_compatible_child(const struct device_node *parent, 294 const char *compatible); 295 extern struct device_node *of_get_child_by_name(const struct device_node *node, 296 const char *name); 297 298 /* cache lookup */ 299 extern struct device_node *of_find_next_cache_node(const struct device_node *); 300 extern int of_find_last_cache_level(unsigned int cpu); 301 extern struct device_node *of_find_node_with_property( 302 struct device_node *from, const char *prop_name); 303 304 extern struct property *of_find_property(const struct device_node *np, 305 const char *name, 306 int *lenp); 307 extern int of_property_count_elems_of_size(const struct device_node *np, 308 const char *propname, int elem_size); 309 extern int of_property_read_u32_index(const struct device_node *np, 310 const char *propname, 311 u32 index, u32 *out_value); 312 extern int of_property_read_u64_index(const struct device_node *np, 313 const char *propname, 314 u32 index, u64 *out_value); 315 extern int of_property_read_variable_u8_array(const struct device_node *np, 316 const char *propname, u8 *out_values, 317 size_t sz_min, size_t sz_max); 318 extern int of_property_read_variable_u16_array(const struct device_node *np, 319 const char *propname, u16 *out_values, 320 size_t sz_min, size_t sz_max); 321 extern int of_property_read_variable_u32_array(const struct device_node *np, 322 const char *propname, 323 u32 *out_values, 324 size_t sz_min, 325 size_t sz_max); 326 extern int of_property_read_u64(const struct device_node *np, 327 const char *propname, u64 *out_value); 328 extern int of_property_read_variable_u64_array(const struct device_node *np, 329 const char *propname, 330 u64 *out_values, 331 size_t sz_min, 332 size_t sz_max); 333 334 extern int of_property_read_string(const struct device_node *np, 335 const char *propname, 336 const char **out_string); 337 extern int of_property_match_string(const struct device_node *np, 338 const char *propname, 339 const char *string); 340 extern int of_property_read_string_helper(const struct device_node *np, 341 const char *propname, 342 const char **out_strs, size_t sz, int index); 343 extern int of_device_is_compatible(const struct device_node *device, 344 const char *); 345 extern int of_device_compatible_match(const struct device_node *device, 346 const char *const *compat); 347 extern bool of_device_is_available(const struct device_node *device); 348 extern bool of_device_is_big_endian(const struct device_node *device); 349 extern const void *of_get_property(const struct device_node *node, 350 const char *name, 351 int *lenp); 352 extern struct device_node *of_get_cpu_node(int cpu, unsigned int *thread); 353 extern struct device_node *of_get_next_cpu_node(struct device_node *prev); 354 extern struct device_node *of_get_cpu_state_node(struct device_node *cpu_node, 355 int index); 356 extern u64 of_get_cpu_hwid(struct device_node *cpun, unsigned int thread); 357 358 #define for_each_property_of_node(dn, pp) \ 359 for (pp = dn->properties; pp != NULL; pp = pp->next) 360 361 extern int of_n_addr_cells(struct device_node *np); 362 extern int of_n_size_cells(struct device_node *np); 363 extern const struct of_device_id *of_match_node( 364 const struct of_device_id *matches, const struct device_node *node); 365 extern int of_modalias_node(struct device_node *node, char *modalias, int len); 366 extern void of_print_phandle_args(const char *msg, const struct of_phandle_args *args); 367 extern int __of_parse_phandle_with_args(const struct device_node *np, 368 const char *list_name, const char *cells_name, int cell_count, 369 int index, struct of_phandle_args *out_args); 370 extern int of_parse_phandle_with_args_map(const struct device_node *np, 371 const char *list_name, const char *stem_name, 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 * struct property *prop; 412 * const __be32 *p; 413 * u32 u; 414 * 415 * of_property_for_each_u32(np, "propname", prop, p, u) 416 * printk("U32 value: %x\n", u); 417 */ 418 const __be32 *of_prop_next_u32(struct property *prop, const __be32 *cur, 419 u32 *pu); 420 /* 421 * struct property *prop; 422 * const char *s; 423 * 424 * of_property_for_each_string(np, "propname", prop, s) 425 * printk("String value: %s\n", s); 426 */ 427 const char *of_prop_next_string(struct property *prop, const char *cur); 428 429 bool of_console_check(struct device_node *dn, char *name, int index); 430 431 extern int of_cpu_node_to_id(struct device_node *np); 432 433 int of_map_id(struct device_node *np, u32 id, 434 const char *map_name, const char *map_mask_name, 435 struct device_node **target, u32 *id_out); 436 437 phys_addr_t of_dma_get_max_cpu_address(struct device_node *np); 438 439 struct kimage; 440 void *of_kexec_alloc_and_setup_fdt(const struct kimage *image, 441 unsigned long initrd_load_addr, 442 unsigned long initrd_len, 443 const char *cmdline, size_t extra_fdt_size); 444 #else /* CONFIG_OF */ 445 446 static inline void of_core_init(void) 447 { 448 } 449 450 static inline bool is_of_node(const struct fwnode_handle *fwnode) 451 { 452 return false; 453 } 454 455 static inline struct device_node *to_of_node(const struct fwnode_handle *fwnode) 456 { 457 return NULL; 458 } 459 460 static inline bool of_node_name_eq(const struct device_node *np, const char *name) 461 { 462 return false; 463 } 464 465 static inline bool of_node_name_prefix(const struct device_node *np, const char *prefix) 466 { 467 return false; 468 } 469 470 static inline const char* of_node_full_name(const struct device_node *np) 471 { 472 return "<no-node>"; 473 } 474 475 static inline struct device_node *of_find_node_by_name(struct device_node *from, 476 const char *name) 477 { 478 return NULL; 479 } 480 481 static inline struct device_node *of_find_node_by_type(struct device_node *from, 482 const char *type) 483 { 484 return NULL; 485 } 486 487 static inline struct device_node *of_find_matching_node_and_match( 488 struct device_node *from, 489 const struct of_device_id *matches, 490 const struct of_device_id **match) 491 { 492 return NULL; 493 } 494 495 static inline struct device_node *of_find_node_by_path(const char *path) 496 { 497 return NULL; 498 } 499 500 static inline struct device_node *of_find_node_opts_by_path(const char *path, 501 const char **opts) 502 { 503 return NULL; 504 } 505 506 static inline struct device_node *of_find_node_by_phandle(phandle handle) 507 { 508 return NULL; 509 } 510 511 static inline struct device_node *of_get_parent(const struct device_node *node) 512 { 513 return NULL; 514 } 515 516 static inline struct device_node *of_get_next_parent(struct device_node *node) 517 { 518 return NULL; 519 } 520 521 static inline struct device_node *of_get_next_child( 522 const struct device_node *node, struct device_node *prev) 523 { 524 return NULL; 525 } 526 527 static inline struct device_node *of_get_next_available_child( 528 const struct device_node *node, struct device_node *prev) 529 { 530 return NULL; 531 } 532 533 static inline struct device_node *of_find_node_with_property( 534 struct device_node *from, const char *prop_name) 535 { 536 return NULL; 537 } 538 539 #define of_fwnode_handle(node) NULL 540 541 static inline bool of_have_populated_dt(void) 542 { 543 return false; 544 } 545 546 static inline struct device_node *of_get_compatible_child(const struct device_node *parent, 547 const char *compatible) 548 { 549 return NULL; 550 } 551 552 static inline struct device_node *of_get_child_by_name( 553 const struct device_node *node, 554 const char *name) 555 { 556 return NULL; 557 } 558 559 static inline int of_device_is_compatible(const struct device_node *device, 560 const char *name) 561 { 562 return 0; 563 } 564 565 static inline int of_device_compatible_match(const struct device_node *device, 566 const char *const *compat) 567 { 568 return 0; 569 } 570 571 static inline bool of_device_is_available(const struct device_node *device) 572 { 573 return false; 574 } 575 576 static inline bool of_device_is_big_endian(const struct device_node *device) 577 { 578 return false; 579 } 580 581 static inline struct property *of_find_property(const struct device_node *np, 582 const char *name, 583 int *lenp) 584 { 585 return NULL; 586 } 587 588 static inline struct device_node *of_find_compatible_node( 589 struct device_node *from, 590 const char *type, 591 const char *compat) 592 { 593 return NULL; 594 } 595 596 static inline int of_property_count_elems_of_size(const struct device_node *np, 597 const char *propname, int elem_size) 598 { 599 return -ENOSYS; 600 } 601 602 static inline int of_property_read_u32_index(const struct device_node *np, 603 const char *propname, u32 index, u32 *out_value) 604 { 605 return -ENOSYS; 606 } 607 608 static inline int of_property_read_u64_index(const struct device_node *np, 609 const char *propname, u32 index, u64 *out_value) 610 { 611 return -ENOSYS; 612 } 613 614 static inline const void *of_get_property(const struct device_node *node, 615 const char *name, 616 int *lenp) 617 { 618 return NULL; 619 } 620 621 static inline struct device_node *of_get_cpu_node(int cpu, 622 unsigned int *thread) 623 { 624 return NULL; 625 } 626 627 static inline struct device_node *of_get_next_cpu_node(struct device_node *prev) 628 { 629 return NULL; 630 } 631 632 static inline struct device_node *of_get_cpu_state_node(struct device_node *cpu_node, 633 int index) 634 { 635 return NULL; 636 } 637 638 static inline int of_n_addr_cells(struct device_node *np) 639 { 640 return 0; 641 642 } 643 static inline int of_n_size_cells(struct device_node *np) 644 { 645 return 0; 646 } 647 648 static inline int of_property_read_variable_u8_array(const struct device_node *np, 649 const char *propname, u8 *out_values, 650 size_t sz_min, size_t sz_max) 651 { 652 return -ENOSYS; 653 } 654 655 static inline int of_property_read_variable_u16_array(const struct device_node *np, 656 const char *propname, u16 *out_values, 657 size_t sz_min, size_t sz_max) 658 { 659 return -ENOSYS; 660 } 661 662 static inline int of_property_read_variable_u32_array(const struct device_node *np, 663 const char *propname, 664 u32 *out_values, 665 size_t sz_min, 666 size_t sz_max) 667 { 668 return -ENOSYS; 669 } 670 671 static inline int of_property_read_u64(const struct device_node *np, 672 const char *propname, u64 *out_value) 673 { 674 return -ENOSYS; 675 } 676 677 static inline int of_property_read_variable_u64_array(const struct device_node *np, 678 const char *propname, 679 u64 *out_values, 680 size_t sz_min, 681 size_t sz_max) 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_match_string(const struct device_node *np, 694 const char *propname, 695 const char *string) 696 { 697 return -ENOSYS; 698 } 699 700 static inline int of_property_read_string_helper(const struct device_node *np, 701 const char *propname, 702 const char **out_strs, size_t sz, int index) 703 { 704 return -ENOSYS; 705 } 706 707 static inline int __of_parse_phandle_with_args(const struct device_node *np, 708 const char *list_name, 709 const char *cells_name, 710 int cell_count, 711 int index, 712 struct of_phandle_args *out_args) 713 { 714 return -ENOSYS; 715 } 716 717 static inline int of_parse_phandle_with_args_map(const struct device_node *np, 718 const char *list_name, 719 const char *stem_name, 720 int index, 721 struct of_phandle_args *out_args) 722 { 723 return -ENOSYS; 724 } 725 726 static inline int of_count_phandle_with_args(const struct device_node *np, 727 const char *list_name, 728 const char *cells_name) 729 { 730 return -ENOSYS; 731 } 732 733 static inline int of_phandle_iterator_init(struct of_phandle_iterator *it, 734 const struct device_node *np, 735 const char *list_name, 736 const char *cells_name, 737 int cell_count) 738 { 739 return -ENOSYS; 740 } 741 742 static inline int of_phandle_iterator_next(struct of_phandle_iterator *it) 743 { 744 return -ENOSYS; 745 } 746 747 static inline int of_phandle_iterator_args(struct of_phandle_iterator *it, 748 uint32_t *args, 749 int size) 750 { 751 return 0; 752 } 753 754 static inline int of_alias_get_id(struct device_node *np, const char *stem) 755 { 756 return -ENOSYS; 757 } 758 759 static inline int of_alias_get_highest_id(const char *stem) 760 { 761 return -ENOSYS; 762 } 763 764 static inline int of_machine_is_compatible(const char *compat) 765 { 766 return 0; 767 } 768 769 static inline int of_add_property(struct device_node *np, struct property *prop) 770 { 771 return 0; 772 } 773 774 static inline int of_remove_property(struct device_node *np, struct property *prop) 775 { 776 return 0; 777 } 778 779 static inline bool of_console_check(const struct device_node *dn, const char *name, int index) 780 { 781 return false; 782 } 783 784 static inline const __be32 *of_prop_next_u32(struct property *prop, 785 const __be32 *cur, u32 *pu) 786 { 787 return NULL; 788 } 789 790 static inline const char *of_prop_next_string(struct property *prop, 791 const char *cur) 792 { 793 return NULL; 794 } 795 796 static inline int of_node_check_flag(struct device_node *n, unsigned long flag) 797 { 798 return 0; 799 } 800 801 static inline int of_node_test_and_set_flag(struct device_node *n, 802 unsigned long flag) 803 { 804 return 0; 805 } 806 807 static inline void of_node_set_flag(struct device_node *n, unsigned long flag) 808 { 809 } 810 811 static inline void of_node_clear_flag(struct device_node *n, unsigned long flag) 812 { 813 } 814 815 static inline int of_property_check_flag(const struct property *p, 816 unsigned long flag) 817 { 818 return 0; 819 } 820 821 static inline void of_property_set_flag(struct property *p, unsigned long flag) 822 { 823 } 824 825 static inline void of_property_clear_flag(struct property *p, unsigned long flag) 826 { 827 } 828 829 static inline int of_cpu_node_to_id(struct device_node *np) 830 { 831 return -ENODEV; 832 } 833 834 static inline int of_map_id(struct device_node *np, u32 id, 835 const char *map_name, const char *map_mask_name, 836 struct device_node **target, u32 *id_out) 837 { 838 return -EINVAL; 839 } 840 841 static inline phys_addr_t of_dma_get_max_cpu_address(struct device_node *np) 842 { 843 return PHYS_ADDR_MAX; 844 } 845 846 #define of_match_ptr(_ptr) NULL 847 #define of_match_node(_matches, _node) NULL 848 #endif /* CONFIG_OF */ 849 850 /* Default string compare functions, Allow arch asm/prom.h to override */ 851 #if !defined(of_compat_cmp) 852 #define of_compat_cmp(s1, s2, l) strcasecmp((s1), (s2)) 853 #define of_prop_cmp(s1, s2) strcmp((s1), (s2)) 854 #define of_node_cmp(s1, s2) strcasecmp((s1), (s2)) 855 #endif 856 857 static inline int of_prop_val_eq(struct property *p1, struct property *p2) 858 { 859 return p1->length == p2->length && 860 !memcmp(p1->value, p2->value, (size_t)p1->length); 861 } 862 863 #if defined(CONFIG_OF) && defined(CONFIG_NUMA) 864 extern int of_node_to_nid(struct device_node *np); 865 #else 866 static inline int of_node_to_nid(struct device_node *device) 867 { 868 return NUMA_NO_NODE; 869 } 870 #endif 871 872 #ifdef CONFIG_OF_NUMA 873 extern int of_numa_init(void); 874 #else 875 static inline int of_numa_init(void) 876 { 877 return -ENOSYS; 878 } 879 #endif 880 881 static inline struct device_node *of_find_matching_node( 882 struct device_node *from, 883 const struct of_device_id *matches) 884 { 885 return of_find_matching_node_and_match(from, matches, NULL); 886 } 887 888 static inline const char *of_node_get_device_type(const struct device_node *np) 889 { 890 return of_get_property(np, "device_type", NULL); 891 } 892 893 static inline bool of_node_is_type(const struct device_node *np, const char *type) 894 { 895 const char *match = of_node_get_device_type(np); 896 897 return np && match && type && !strcmp(match, type); 898 } 899 900 /** 901 * of_parse_phandle - Resolve a phandle property to a device_node pointer 902 * @np: Pointer to device node holding phandle property 903 * @phandle_name: Name of property holding a phandle value 904 * @index: For properties holding a table of phandles, this is the index into 905 * the table 906 * 907 * Return: The device_node pointer with refcount incremented. Use 908 * of_node_put() on it when done. 909 */ 910 static inline struct device_node *of_parse_phandle(const struct device_node *np, 911 const char *phandle_name, 912 int index) 913 { 914 struct of_phandle_args args; 915 916 if (__of_parse_phandle_with_args(np, phandle_name, NULL, 0, 917 index, &args)) 918 return NULL; 919 920 return args.np; 921 } 922 923 /** 924 * of_parse_phandle_with_args() - Find a node pointed by phandle in a list 925 * @np: pointer to a device tree node containing a list 926 * @list_name: property name that contains a list 927 * @cells_name: property name that specifies phandles' arguments count 928 * @index: index of a phandle to parse out 929 * @out_args: optional pointer to output arguments structure (will be filled) 930 * 931 * This function is useful to parse lists of phandles and their arguments. 932 * Returns 0 on success and fills out_args, on error returns appropriate 933 * errno value. 934 * 935 * Caller is responsible to call of_node_put() on the returned out_args->np 936 * pointer. 937 * 938 * Example:: 939 * 940 * phandle1: node1 { 941 * #list-cells = <2>; 942 * }; 943 * 944 * phandle2: node2 { 945 * #list-cells = <1>; 946 * }; 947 * 948 * node3 { 949 * list = <&phandle1 1 2 &phandle2 3>; 950 * }; 951 * 952 * To get a device_node of the ``node2`` node you may call this: 953 * of_parse_phandle_with_args(node3, "list", "#list-cells", 1, &args); 954 */ 955 static inline int of_parse_phandle_with_args(const struct device_node *np, 956 const char *list_name, 957 const char *cells_name, 958 int index, 959 struct of_phandle_args *out_args) 960 { 961 int cell_count = -1; 962 963 /* If cells_name is NULL we assume a cell count of 0 */ 964 if (!cells_name) 965 cell_count = 0; 966 967 return __of_parse_phandle_with_args(np, list_name, cells_name, 968 cell_count, index, out_args); 969 } 970 971 /** 972 * of_parse_phandle_with_fixed_args() - Find a node pointed by phandle in a list 973 * @np: pointer to a device tree node containing a list 974 * @list_name: property name that contains a list 975 * @cell_count: number of argument cells following the phandle 976 * @index: index of a phandle to parse out 977 * @out_args: optional pointer to output arguments structure (will be filled) 978 * 979 * This function is useful to parse lists of phandles and their arguments. 980 * Returns 0 on success and fills out_args, on error returns appropriate 981 * errno value. 982 * 983 * Caller is responsible to call of_node_put() on the returned out_args->np 984 * pointer. 985 * 986 * Example:: 987 * 988 * phandle1: node1 { 989 * }; 990 * 991 * phandle2: node2 { 992 * }; 993 * 994 * node3 { 995 * list = <&phandle1 0 2 &phandle2 2 3>; 996 * }; 997 * 998 * To get a device_node of the ``node2`` node you may call this: 999 * of_parse_phandle_with_fixed_args(node3, "list", 2, 1, &args); 1000 */ 1001 static inline int of_parse_phandle_with_fixed_args(const struct device_node *np, 1002 const char *list_name, 1003 int cell_count, 1004 int index, 1005 struct of_phandle_args *out_args) 1006 { 1007 return __of_parse_phandle_with_args(np, list_name, NULL, cell_count, 1008 index, out_args); 1009 } 1010 1011 /** 1012 * of_property_count_u8_elems - Count the number of u8 elements in a property 1013 * 1014 * @np: device node from which the property value is to be read. 1015 * @propname: name of the property to be searched. 1016 * 1017 * Search for a property in a device node and count the number of u8 elements 1018 * in it. 1019 * 1020 * Return: The number of elements on sucess, -EINVAL if the property does 1021 * not exist or its length does not match a multiple of u8 and -ENODATA if the 1022 * property does not have a value. 1023 */ 1024 static inline int of_property_count_u8_elems(const struct device_node *np, 1025 const char *propname) 1026 { 1027 return of_property_count_elems_of_size(np, propname, sizeof(u8)); 1028 } 1029 1030 /** 1031 * of_property_count_u16_elems - Count the number of u16 elements in a property 1032 * 1033 * @np: device node from which the property value is to be read. 1034 * @propname: name of the property to be searched. 1035 * 1036 * Search for a property in a device node and count the number of u16 elements 1037 * in it. 1038 * 1039 * Return: The number of elements on sucess, -EINVAL if the property does 1040 * not exist or its length does not match a multiple of u16 and -ENODATA if the 1041 * property does not have a value. 1042 */ 1043 static inline int of_property_count_u16_elems(const struct device_node *np, 1044 const char *propname) 1045 { 1046 return of_property_count_elems_of_size(np, propname, sizeof(u16)); 1047 } 1048 1049 /** 1050 * of_property_count_u32_elems - Count the number of u32 elements in a property 1051 * 1052 * @np: device node from which the property value is to be read. 1053 * @propname: name of the property to be searched. 1054 * 1055 * Search for a property in a device node and count the number of u32 elements 1056 * in it. 1057 * 1058 * Return: The number of elements on sucess, -EINVAL if the property does 1059 * not exist or its length does not match a multiple of u32 and -ENODATA if the 1060 * property does not have a value. 1061 */ 1062 static inline int of_property_count_u32_elems(const struct device_node *np, 1063 const char *propname) 1064 { 1065 return of_property_count_elems_of_size(np, propname, sizeof(u32)); 1066 } 1067 1068 /** 1069 * of_property_count_u64_elems - Count the number of u64 elements in a property 1070 * 1071 * @np: device node from which the property value is to be read. 1072 * @propname: name of the property to be searched. 1073 * 1074 * Search for a property in a device node and count the number of u64 elements 1075 * in it. 1076 * 1077 * Return: The number of elements on sucess, -EINVAL if the property does 1078 * not exist or its length does not match a multiple of u64 and -ENODATA if the 1079 * property does not have a value. 1080 */ 1081 static inline int of_property_count_u64_elems(const struct device_node *np, 1082 const char *propname) 1083 { 1084 return of_property_count_elems_of_size(np, propname, sizeof(u64)); 1085 } 1086 1087 /** 1088 * of_property_read_string_array() - Read an array of strings from a multiple 1089 * strings property. 1090 * @np: device node from which the property value is to be read. 1091 * @propname: name of the property to be searched. 1092 * @out_strs: output array of string pointers. 1093 * @sz: number of array elements to read. 1094 * 1095 * Search for a property in a device tree node and retrieve a list of 1096 * terminated string values (pointer to data, not a copy) in that property. 1097 * 1098 * Return: If @out_strs is NULL, the number of strings in the property is returned. 1099 */ 1100 static inline int of_property_read_string_array(const struct device_node *np, 1101 const char *propname, const char **out_strs, 1102 size_t sz) 1103 { 1104 return of_property_read_string_helper(np, propname, out_strs, sz, 0); 1105 } 1106 1107 /** 1108 * of_property_count_strings() - Find and return the number of strings from a 1109 * multiple strings property. 1110 * @np: device node from which the property value is to be read. 1111 * @propname: name of the property to be searched. 1112 * 1113 * Search for a property in a device tree node and retrieve the number of null 1114 * terminated string contain in it. 1115 * 1116 * Return: The number of strings on success, -EINVAL if the property does not 1117 * exist, -ENODATA if property does not have a value, and -EILSEQ if the string 1118 * is not null-terminated within the length of the property data. 1119 */ 1120 static inline int of_property_count_strings(const struct device_node *np, 1121 const char *propname) 1122 { 1123 return of_property_read_string_helper(np, propname, NULL, 0, 0); 1124 } 1125 1126 /** 1127 * of_property_read_string_index() - Find and read a string from a multiple 1128 * strings property. 1129 * @np: device node from which the property value is to be read. 1130 * @propname: name of the property to be searched. 1131 * @index: index of the string in the list of strings 1132 * @output: pointer to null terminated return string, modified only if 1133 * return value is 0. 1134 * 1135 * Search for a property in a device tree node and retrieve a null 1136 * terminated string value (pointer to data, not a copy) in the list of strings 1137 * contained in that property. 1138 * 1139 * Return: 0 on success, -EINVAL if the property does not exist, -ENODATA if 1140 * property does not have a value, and -EILSEQ if the string is not 1141 * null-terminated within the length of the property data. 1142 * 1143 * The out_string pointer is modified only if a valid string can be decoded. 1144 */ 1145 static inline int of_property_read_string_index(const struct device_node *np, 1146 const char *propname, 1147 int index, const char **output) 1148 { 1149 int rc = of_property_read_string_helper(np, propname, output, 1, index); 1150 return rc < 0 ? rc : 0; 1151 } 1152 1153 /** 1154 * of_property_read_bool - Find a property 1155 * @np: device node from which the property value is to be read. 1156 * @propname: name of the property to be searched. 1157 * 1158 * Search for a property in a device node. 1159 * 1160 * Return: true if the property exists false otherwise. 1161 */ 1162 static inline bool of_property_read_bool(const struct device_node *np, 1163 const char *propname) 1164 { 1165 struct property *prop = of_find_property(np, propname, NULL); 1166 1167 return prop ? true : false; 1168 } 1169 1170 /** 1171 * of_property_read_u8_array - Find and read an array of u8 from a property. 1172 * 1173 * @np: device node from which the property value is to be read. 1174 * @propname: name of the property to be searched. 1175 * @out_values: pointer to return value, modified only if return value is 0. 1176 * @sz: number of array elements to read 1177 * 1178 * Search for a property in a device node and read 8-bit value(s) from 1179 * it. 1180 * 1181 * dts entry of array should be like: 1182 * ``property = /bits/ 8 <0x50 0x60 0x70>;`` 1183 * 1184 * Return: 0 on success, -EINVAL if the property does not exist, 1185 * -ENODATA if property does not have a value, and -EOVERFLOW if the 1186 * property data isn't large enough. 1187 * 1188 * The out_values is modified only if a valid u8 value can be decoded. 1189 */ 1190 static inline int of_property_read_u8_array(const struct device_node *np, 1191 const char *propname, 1192 u8 *out_values, size_t sz) 1193 { 1194 int ret = of_property_read_variable_u8_array(np, propname, out_values, 1195 sz, 0); 1196 if (ret >= 0) 1197 return 0; 1198 else 1199 return ret; 1200 } 1201 1202 /** 1203 * of_property_read_u16_array - Find and read an array of u16 from a property. 1204 * 1205 * @np: device node from which the property value is to be read. 1206 * @propname: name of the property to be searched. 1207 * @out_values: pointer to return value, modified only if return value is 0. 1208 * @sz: number of array elements to read 1209 * 1210 * Search for a property in a device node and read 16-bit value(s) from 1211 * it. 1212 * 1213 * dts entry of array should be like: 1214 * ``property = /bits/ 16 <0x5000 0x6000 0x7000>;`` 1215 * 1216 * Return: 0 on success, -EINVAL if the property does not exist, 1217 * -ENODATA if property does not have a value, and -EOVERFLOW if the 1218 * property data isn't large enough. 1219 * 1220 * The out_values is modified only if a valid u16 value can be decoded. 1221 */ 1222 static inline int of_property_read_u16_array(const struct device_node *np, 1223 const char *propname, 1224 u16 *out_values, size_t sz) 1225 { 1226 int ret = of_property_read_variable_u16_array(np, propname, out_values, 1227 sz, 0); 1228 if (ret >= 0) 1229 return 0; 1230 else 1231 return ret; 1232 } 1233 1234 /** 1235 * of_property_read_u32_array - Find and read an array of 32 bit integers 1236 * from a property. 1237 * 1238 * @np: device node from which the property value is to be read. 1239 * @propname: name of the property to be searched. 1240 * @out_values: pointer to return value, modified only if return value is 0. 1241 * @sz: number of array elements to read 1242 * 1243 * Search for a property in a device node and read 32-bit value(s) from 1244 * it. 1245 * 1246 * Return: 0 on success, -EINVAL if the property does not exist, 1247 * -ENODATA if property does not have a value, and -EOVERFLOW if the 1248 * property data isn't large enough. 1249 * 1250 * The out_values is modified only if a valid u32 value can be decoded. 1251 */ 1252 static inline int of_property_read_u32_array(const struct device_node *np, 1253 const char *propname, 1254 u32 *out_values, size_t sz) 1255 { 1256 int ret = of_property_read_variable_u32_array(np, propname, out_values, 1257 sz, 0); 1258 if (ret >= 0) 1259 return 0; 1260 else 1261 return ret; 1262 } 1263 1264 /** 1265 * of_property_read_u64_array - Find and read an array of 64 bit integers 1266 * from a property. 1267 * 1268 * @np: device node from which the property value is to be read. 1269 * @propname: name of the property to be searched. 1270 * @out_values: pointer to return value, modified only if return value is 0. 1271 * @sz: number of array elements to read 1272 * 1273 * Search for a property in a device node and read 64-bit value(s) from 1274 * it. 1275 * 1276 * Return: 0 on success, -EINVAL if the property does not exist, 1277 * -ENODATA if property does not have a value, and -EOVERFLOW if the 1278 * property data isn't large enough. 1279 * 1280 * The out_values is modified only if a valid u64 value can be decoded. 1281 */ 1282 static inline int of_property_read_u64_array(const struct device_node *np, 1283 const char *propname, 1284 u64 *out_values, size_t sz) 1285 { 1286 int ret = of_property_read_variable_u64_array(np, propname, out_values, 1287 sz, 0); 1288 if (ret >= 0) 1289 return 0; 1290 else 1291 return ret; 1292 } 1293 1294 static inline int of_property_read_u8(const struct device_node *np, 1295 const char *propname, 1296 u8 *out_value) 1297 { 1298 return of_property_read_u8_array(np, propname, out_value, 1); 1299 } 1300 1301 static inline int of_property_read_u16(const struct device_node *np, 1302 const char *propname, 1303 u16 *out_value) 1304 { 1305 return of_property_read_u16_array(np, propname, out_value, 1); 1306 } 1307 1308 static inline int of_property_read_u32(const struct device_node *np, 1309 const char *propname, 1310 u32 *out_value) 1311 { 1312 return of_property_read_u32_array(np, propname, out_value, 1); 1313 } 1314 1315 static inline int of_property_read_s32(const struct device_node *np, 1316 const char *propname, 1317 s32 *out_value) 1318 { 1319 return of_property_read_u32(np, propname, (u32*) out_value); 1320 } 1321 1322 #define of_for_each_phandle(it, err, np, ln, cn, cc) \ 1323 for (of_phandle_iterator_init((it), (np), (ln), (cn), (cc)), \ 1324 err = of_phandle_iterator_next(it); \ 1325 err == 0; \ 1326 err = of_phandle_iterator_next(it)) 1327 1328 #define of_property_for_each_u32(np, propname, prop, p, u) \ 1329 for (prop = of_find_property(np, propname, NULL), \ 1330 p = of_prop_next_u32(prop, NULL, &u); \ 1331 p; \ 1332 p = of_prop_next_u32(prop, p, &u)) 1333 1334 #define of_property_for_each_string(np, propname, prop, s) \ 1335 for (prop = of_find_property(np, propname, NULL), \ 1336 s = of_prop_next_string(prop, NULL); \ 1337 s; \ 1338 s = of_prop_next_string(prop, s)) 1339 1340 #define for_each_node_by_name(dn, name) \ 1341 for (dn = of_find_node_by_name(NULL, name); dn; \ 1342 dn = of_find_node_by_name(dn, name)) 1343 #define for_each_node_by_type(dn, type) \ 1344 for (dn = of_find_node_by_type(NULL, type); dn; \ 1345 dn = of_find_node_by_type(dn, type)) 1346 #define for_each_compatible_node(dn, type, compatible) \ 1347 for (dn = of_find_compatible_node(NULL, type, compatible); dn; \ 1348 dn = of_find_compatible_node(dn, type, compatible)) 1349 #define for_each_matching_node(dn, matches) \ 1350 for (dn = of_find_matching_node(NULL, matches); dn; \ 1351 dn = of_find_matching_node(dn, matches)) 1352 #define for_each_matching_node_and_match(dn, matches, match) \ 1353 for (dn = of_find_matching_node_and_match(NULL, matches, match); \ 1354 dn; dn = of_find_matching_node_and_match(dn, matches, match)) 1355 1356 #define for_each_child_of_node(parent, child) \ 1357 for (child = of_get_next_child(parent, NULL); child != NULL; \ 1358 child = of_get_next_child(parent, child)) 1359 #define for_each_available_child_of_node(parent, child) \ 1360 for (child = of_get_next_available_child(parent, NULL); child != NULL; \ 1361 child = of_get_next_available_child(parent, child)) 1362 1363 #define for_each_of_cpu_node(cpu) \ 1364 for (cpu = of_get_next_cpu_node(NULL); cpu != NULL; \ 1365 cpu = of_get_next_cpu_node(cpu)) 1366 1367 #define for_each_node_with_property(dn, prop_name) \ 1368 for (dn = of_find_node_with_property(NULL, prop_name); dn; \ 1369 dn = of_find_node_with_property(dn, prop_name)) 1370 1371 static inline int of_get_child_count(const struct device_node *np) 1372 { 1373 struct device_node *child; 1374 int num = 0; 1375 1376 for_each_child_of_node(np, child) 1377 num++; 1378 1379 return num; 1380 } 1381 1382 static inline int of_get_available_child_count(const struct device_node *np) 1383 { 1384 struct device_node *child; 1385 int num = 0; 1386 1387 for_each_available_child_of_node(np, child) 1388 num++; 1389 1390 return num; 1391 } 1392 1393 #define _OF_DECLARE_STUB(table, name, compat, fn, fn_type) \ 1394 static const struct of_device_id __of_table_##name \ 1395 __attribute__((unused)) \ 1396 = { .compatible = compat, \ 1397 .data = (fn == (fn_type)NULL) ? fn : fn } 1398 1399 #if defined(CONFIG_OF) && !defined(MODULE) 1400 #define _OF_DECLARE(table, name, compat, fn, fn_type) \ 1401 static const struct of_device_id __of_table_##name \ 1402 __used __section("__" #table "_of_table") \ 1403 __aligned(__alignof__(struct of_device_id)) \ 1404 = { .compatible = compat, \ 1405 .data = (fn == (fn_type)NULL) ? fn : fn } 1406 #else 1407 #define _OF_DECLARE(table, name, compat, fn, fn_type) \ 1408 _OF_DECLARE_STUB(table, name, compat, fn, fn_type) 1409 #endif 1410 1411 typedef int (*of_init_fn_2)(struct device_node *, struct device_node *); 1412 typedef int (*of_init_fn_1_ret)(struct device_node *); 1413 typedef void (*of_init_fn_1)(struct device_node *); 1414 1415 #define OF_DECLARE_1(table, name, compat, fn) \ 1416 _OF_DECLARE(table, name, compat, fn, of_init_fn_1) 1417 #define OF_DECLARE_1_RET(table, name, compat, fn) \ 1418 _OF_DECLARE(table, name, compat, fn, of_init_fn_1_ret) 1419 #define OF_DECLARE_2(table, name, compat, fn) \ 1420 _OF_DECLARE(table, name, compat, fn, of_init_fn_2) 1421 1422 /** 1423 * struct of_changeset_entry - Holds a changeset entry 1424 * 1425 * @node: list_head for the log list 1426 * @action: notifier action 1427 * @np: pointer to the device node affected 1428 * @prop: pointer to the property affected 1429 * @old_prop: hold a pointer to the original property 1430 * 1431 * Every modification of the device tree during a changeset 1432 * is held in a list of of_changeset_entry structures. 1433 * That way we can recover from a partial application, or we can 1434 * revert the changeset 1435 */ 1436 struct of_changeset_entry { 1437 struct list_head node; 1438 unsigned long action; 1439 struct device_node *np; 1440 struct property *prop; 1441 struct property *old_prop; 1442 }; 1443 1444 /** 1445 * struct of_changeset - changeset tracker structure 1446 * 1447 * @entries: list_head for the changeset entries 1448 * 1449 * changesets are a convenient way to apply bulk changes to the 1450 * live tree. In case of an error, changes are rolled-back. 1451 * changesets live on after initial application, and if not 1452 * destroyed after use, they can be reverted in one single call. 1453 */ 1454 struct of_changeset { 1455 struct list_head entries; 1456 }; 1457 1458 enum of_reconfig_change { 1459 OF_RECONFIG_NO_CHANGE = 0, 1460 OF_RECONFIG_CHANGE_ADD, 1461 OF_RECONFIG_CHANGE_REMOVE, 1462 }; 1463 1464 #ifdef CONFIG_OF_DYNAMIC 1465 extern int of_reconfig_notifier_register(struct notifier_block *); 1466 extern int of_reconfig_notifier_unregister(struct notifier_block *); 1467 extern int of_reconfig_notify(unsigned long, struct of_reconfig_data *rd); 1468 extern int of_reconfig_get_state_change(unsigned long action, 1469 struct of_reconfig_data *arg); 1470 1471 extern void of_changeset_init(struct of_changeset *ocs); 1472 extern void of_changeset_destroy(struct of_changeset *ocs); 1473 extern int of_changeset_apply(struct of_changeset *ocs); 1474 extern int of_changeset_revert(struct of_changeset *ocs); 1475 extern int of_changeset_action(struct of_changeset *ocs, 1476 unsigned long action, struct device_node *np, 1477 struct property *prop); 1478 1479 static inline int of_changeset_attach_node(struct of_changeset *ocs, 1480 struct device_node *np) 1481 { 1482 return of_changeset_action(ocs, OF_RECONFIG_ATTACH_NODE, np, NULL); 1483 } 1484 1485 static inline int of_changeset_detach_node(struct of_changeset *ocs, 1486 struct device_node *np) 1487 { 1488 return of_changeset_action(ocs, OF_RECONFIG_DETACH_NODE, np, NULL); 1489 } 1490 1491 static inline int of_changeset_add_property(struct of_changeset *ocs, 1492 struct device_node *np, struct property *prop) 1493 { 1494 return of_changeset_action(ocs, OF_RECONFIG_ADD_PROPERTY, np, prop); 1495 } 1496 1497 static inline int of_changeset_remove_property(struct of_changeset *ocs, 1498 struct device_node *np, struct property *prop) 1499 { 1500 return of_changeset_action(ocs, OF_RECONFIG_REMOVE_PROPERTY, np, prop); 1501 } 1502 1503 static inline int of_changeset_update_property(struct of_changeset *ocs, 1504 struct device_node *np, struct property *prop) 1505 { 1506 return of_changeset_action(ocs, OF_RECONFIG_UPDATE_PROPERTY, np, prop); 1507 } 1508 #else /* CONFIG_OF_DYNAMIC */ 1509 static inline int of_reconfig_notifier_register(struct notifier_block *nb) 1510 { 1511 return -EINVAL; 1512 } 1513 static inline int of_reconfig_notifier_unregister(struct notifier_block *nb) 1514 { 1515 return -EINVAL; 1516 } 1517 static inline int of_reconfig_notify(unsigned long action, 1518 struct of_reconfig_data *arg) 1519 { 1520 return -EINVAL; 1521 } 1522 static inline int of_reconfig_get_state_change(unsigned long action, 1523 struct of_reconfig_data *arg) 1524 { 1525 return -EINVAL; 1526 } 1527 #endif /* CONFIG_OF_DYNAMIC */ 1528 1529 /** 1530 * of_device_is_system_power_controller - Tells if system-power-controller is found for device_node 1531 * @np: Pointer to the given device_node 1532 * 1533 * Return: true if present false otherwise 1534 */ 1535 static inline bool of_device_is_system_power_controller(const struct device_node *np) 1536 { 1537 return of_property_read_bool(np, "system-power-controller"); 1538 } 1539 1540 /* 1541 * Overlay support 1542 */ 1543 1544 enum of_overlay_notify_action { 1545 OF_OVERLAY_INIT = 0, /* kzalloc() of ovcs sets this value */ 1546 OF_OVERLAY_PRE_APPLY, 1547 OF_OVERLAY_POST_APPLY, 1548 OF_OVERLAY_PRE_REMOVE, 1549 OF_OVERLAY_POST_REMOVE, 1550 }; 1551 1552 static inline char *of_overlay_action_name(enum of_overlay_notify_action action) 1553 { 1554 static char *of_overlay_action_name[] = { 1555 "init", 1556 "pre-apply", 1557 "post-apply", 1558 "pre-remove", 1559 "post-remove", 1560 }; 1561 1562 return of_overlay_action_name[action]; 1563 } 1564 1565 struct of_overlay_notify_data { 1566 struct device_node *overlay; 1567 struct device_node *target; 1568 }; 1569 1570 #ifdef CONFIG_OF_OVERLAY 1571 1572 int of_overlay_fdt_apply(const void *overlay_fdt, u32 overlay_fdt_size, 1573 int *ovcs_id); 1574 int of_overlay_remove(int *ovcs_id); 1575 int of_overlay_remove_all(void); 1576 1577 int of_overlay_notifier_register(struct notifier_block *nb); 1578 int of_overlay_notifier_unregister(struct notifier_block *nb); 1579 1580 #else 1581 1582 static inline int of_overlay_fdt_apply(void *overlay_fdt, u32 overlay_fdt_size, 1583 int *ovcs_id) 1584 { 1585 return -ENOTSUPP; 1586 } 1587 1588 static inline int of_overlay_remove(int *ovcs_id) 1589 { 1590 return -ENOTSUPP; 1591 } 1592 1593 static inline int of_overlay_remove_all(void) 1594 { 1595 return -ENOTSUPP; 1596 } 1597 1598 static inline int of_overlay_notifier_register(struct notifier_block *nb) 1599 { 1600 return 0; 1601 } 1602 1603 static inline int of_overlay_notifier_unregister(struct notifier_block *nb) 1604 { 1605 return 0; 1606 } 1607 1608 #endif 1609 1610 #endif /* _LINUX_OF_H */ 1611