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(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(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 int ima_get_kexec_buffer(void **addr, size_t *size); 445 int ima_free_kexec_buffer(void); 446 #else /* CONFIG_OF */ 447 448 static inline void of_core_init(void) 449 { 450 } 451 452 static inline bool is_of_node(const struct fwnode_handle *fwnode) 453 { 454 return false; 455 } 456 457 static inline struct device_node *to_of_node(const struct fwnode_handle *fwnode) 458 { 459 return NULL; 460 } 461 462 static inline bool of_node_name_eq(const struct device_node *np, const char *name) 463 { 464 return false; 465 } 466 467 static inline bool of_node_name_prefix(const struct device_node *np, const char *prefix) 468 { 469 return false; 470 } 471 472 static inline const char* of_node_full_name(const struct device_node *np) 473 { 474 return "<no-node>"; 475 } 476 477 static inline struct device_node *of_find_node_by_name(struct device_node *from, 478 const char *name) 479 { 480 return NULL; 481 } 482 483 static inline struct device_node *of_find_node_by_type(struct device_node *from, 484 const char *type) 485 { 486 return NULL; 487 } 488 489 static inline struct device_node *of_find_matching_node_and_match( 490 struct device_node *from, 491 const struct of_device_id *matches, 492 const struct of_device_id **match) 493 { 494 return NULL; 495 } 496 497 static inline struct device_node *of_find_node_by_path(const char *path) 498 { 499 return NULL; 500 } 501 502 static inline struct device_node *of_find_node_opts_by_path(const char *path, 503 const char **opts) 504 { 505 return NULL; 506 } 507 508 static inline struct device_node *of_find_node_by_phandle(phandle handle) 509 { 510 return NULL; 511 } 512 513 static inline struct device_node *of_get_parent(const struct device_node *node) 514 { 515 return NULL; 516 } 517 518 static inline struct device_node *of_get_next_parent(struct device_node *node) 519 { 520 return NULL; 521 } 522 523 static inline struct device_node *of_get_next_child( 524 const struct device_node *node, struct device_node *prev) 525 { 526 return NULL; 527 } 528 529 static inline struct device_node *of_get_next_available_child( 530 const struct device_node *node, struct device_node *prev) 531 { 532 return NULL; 533 } 534 535 static inline struct device_node *of_find_node_with_property( 536 struct device_node *from, const char *prop_name) 537 { 538 return NULL; 539 } 540 541 #define of_fwnode_handle(node) NULL 542 543 static inline bool of_have_populated_dt(void) 544 { 545 return false; 546 } 547 548 static inline struct device_node *of_get_compatible_child(const struct device_node *parent, 549 const char *compatible) 550 { 551 return NULL; 552 } 553 554 static inline struct device_node *of_get_child_by_name( 555 const struct device_node *node, 556 const char *name) 557 { 558 return NULL; 559 } 560 561 static inline int of_device_is_compatible(const struct device_node *device, 562 const char *name) 563 { 564 return 0; 565 } 566 567 static inline int of_device_compatible_match(struct device_node *device, 568 const char *const *compat) 569 { 570 return 0; 571 } 572 573 static inline bool of_device_is_available(const struct device_node *device) 574 { 575 return false; 576 } 577 578 static inline bool of_device_is_big_endian(const struct device_node *device) 579 { 580 return false; 581 } 582 583 static inline struct property *of_find_property(const struct device_node *np, 584 const char *name, 585 int *lenp) 586 { 587 return NULL; 588 } 589 590 static inline struct device_node *of_find_compatible_node( 591 struct device_node *from, 592 const char *type, 593 const char *compat) 594 { 595 return NULL; 596 } 597 598 static inline int of_property_count_elems_of_size(const struct device_node *np, 599 const char *propname, int elem_size) 600 { 601 return -ENOSYS; 602 } 603 604 static inline int of_property_read_u32_index(const struct device_node *np, 605 const char *propname, u32 index, u32 *out_value) 606 { 607 return -ENOSYS; 608 } 609 610 static inline int of_property_read_u64_index(const struct device_node *np, 611 const char *propname, u32 index, u64 *out_value) 612 { 613 return -ENOSYS; 614 } 615 616 static inline const void *of_get_property(const struct device_node *node, 617 const char *name, 618 int *lenp) 619 { 620 return NULL; 621 } 622 623 static inline struct device_node *of_get_cpu_node(int cpu, 624 unsigned int *thread) 625 { 626 return NULL; 627 } 628 629 static inline struct device_node *of_get_next_cpu_node(struct device_node *prev) 630 { 631 return NULL; 632 } 633 634 static inline struct device_node *of_get_cpu_state_node(struct device_node *cpu_node, 635 int index) 636 { 637 return NULL; 638 } 639 640 static inline int of_n_addr_cells(struct device_node *np) 641 { 642 return 0; 643 644 } 645 static inline int of_n_size_cells(struct device_node *np) 646 { 647 return 0; 648 } 649 650 static inline int of_property_read_variable_u8_array(const struct device_node *np, 651 const char *propname, u8 *out_values, 652 size_t sz_min, size_t sz_max) 653 { 654 return -ENOSYS; 655 } 656 657 static inline int of_property_read_variable_u16_array(const struct device_node *np, 658 const char *propname, u16 *out_values, 659 size_t sz_min, size_t sz_max) 660 { 661 return -ENOSYS; 662 } 663 664 static inline int of_property_read_variable_u32_array(const struct device_node *np, 665 const char *propname, 666 u32 *out_values, 667 size_t sz_min, 668 size_t sz_max) 669 { 670 return -ENOSYS; 671 } 672 673 static inline int of_property_read_u64(const struct device_node *np, 674 const char *propname, u64 *out_value) 675 { 676 return -ENOSYS; 677 } 678 679 static inline int of_property_read_variable_u64_array(const struct device_node *np, 680 const char *propname, 681 u64 *out_values, 682 size_t sz_min, 683 size_t sz_max) 684 { 685 return -ENOSYS; 686 } 687 688 static inline int of_property_read_string(const struct device_node *np, 689 const char *propname, 690 const char **out_string) 691 { 692 return -ENOSYS; 693 } 694 695 static inline int of_property_match_string(const struct device_node *np, 696 const char *propname, 697 const char *string) 698 { 699 return -ENOSYS; 700 } 701 702 static inline int of_property_read_string_helper(const struct device_node *np, 703 const char *propname, 704 const char **out_strs, size_t sz, int index) 705 { 706 return -ENOSYS; 707 } 708 709 static inline int __of_parse_phandle_with_args(const struct device_node *np, 710 const char *list_name, 711 const char *cells_name, 712 int cell_count, 713 int index, 714 struct of_phandle_args *out_args) 715 { 716 return -ENOSYS; 717 } 718 719 static inline int of_parse_phandle_with_args_map(const struct device_node *np, 720 const char *list_name, 721 const char *stem_name, 722 int index, 723 struct of_phandle_args *out_args) 724 { 725 return -ENOSYS; 726 } 727 728 static inline int of_count_phandle_with_args(const struct device_node *np, 729 const char *list_name, 730 const char *cells_name) 731 { 732 return -ENOSYS; 733 } 734 735 static inline int of_phandle_iterator_init(struct of_phandle_iterator *it, 736 const struct device_node *np, 737 const char *list_name, 738 const char *cells_name, 739 int cell_count) 740 { 741 return -ENOSYS; 742 } 743 744 static inline int of_phandle_iterator_next(struct of_phandle_iterator *it) 745 { 746 return -ENOSYS; 747 } 748 749 static inline int of_phandle_iterator_args(struct of_phandle_iterator *it, 750 uint32_t *args, 751 int size) 752 { 753 return 0; 754 } 755 756 static inline int of_alias_get_id(struct device_node *np, const char *stem) 757 { 758 return -ENOSYS; 759 } 760 761 static inline int of_alias_get_highest_id(const char *stem) 762 { 763 return -ENOSYS; 764 } 765 766 static inline int of_machine_is_compatible(const char *compat) 767 { 768 return 0; 769 } 770 771 static inline int of_add_property(struct device_node *np, struct property *prop) 772 { 773 return 0; 774 } 775 776 static inline int of_remove_property(struct device_node *np, struct property *prop) 777 { 778 return 0; 779 } 780 781 static inline bool of_console_check(const struct device_node *dn, const char *name, int index) 782 { 783 return false; 784 } 785 786 static inline const __be32 *of_prop_next_u32(struct property *prop, 787 const __be32 *cur, u32 *pu) 788 { 789 return NULL; 790 } 791 792 static inline const char *of_prop_next_string(struct property *prop, 793 const char *cur) 794 { 795 return NULL; 796 } 797 798 static inline int of_node_check_flag(struct device_node *n, unsigned long flag) 799 { 800 return 0; 801 } 802 803 static inline int of_node_test_and_set_flag(struct device_node *n, 804 unsigned long flag) 805 { 806 return 0; 807 } 808 809 static inline void of_node_set_flag(struct device_node *n, unsigned long flag) 810 { 811 } 812 813 static inline void of_node_clear_flag(struct device_node *n, unsigned long flag) 814 { 815 } 816 817 static inline int of_property_check_flag(struct property *p, unsigned long flag) 818 { 819 return 0; 820 } 821 822 static inline void of_property_set_flag(struct property *p, unsigned long flag) 823 { 824 } 825 826 static inline void of_property_clear_flag(struct property *p, unsigned long flag) 827 { 828 } 829 830 static inline int of_cpu_node_to_id(struct device_node *np) 831 { 832 return -ENODEV; 833 } 834 835 static inline int of_map_id(struct device_node *np, u32 id, 836 const char *map_name, const char *map_mask_name, 837 struct device_node **target, u32 *id_out) 838 { 839 return -EINVAL; 840 } 841 842 static inline phys_addr_t of_dma_get_max_cpu_address(struct device_node *np) 843 { 844 return PHYS_ADDR_MAX; 845 } 846 847 #define of_match_ptr(_ptr) NULL 848 #define of_match_node(_matches, _node) NULL 849 #endif /* CONFIG_OF */ 850 851 /* Default string compare functions, Allow arch asm/prom.h to override */ 852 #if !defined(of_compat_cmp) 853 #define of_compat_cmp(s1, s2, l) strcasecmp((s1), (s2)) 854 #define of_prop_cmp(s1, s2) strcmp((s1), (s2)) 855 #define of_node_cmp(s1, s2) strcasecmp((s1), (s2)) 856 #endif 857 858 static inline int of_prop_val_eq(struct property *p1, struct property *p2) 859 { 860 return p1->length == p2->length && 861 !memcmp(p1->value, p2->value, (size_t)p1->length); 862 } 863 864 #if defined(CONFIG_OF) && defined(CONFIG_NUMA) 865 extern int of_node_to_nid(struct device_node *np); 866 #else 867 static inline int of_node_to_nid(struct device_node *device) 868 { 869 return NUMA_NO_NODE; 870 } 871 #endif 872 873 #ifdef CONFIG_OF_NUMA 874 extern int of_numa_init(void); 875 #else 876 static inline int of_numa_init(void) 877 { 878 return -ENOSYS; 879 } 880 #endif 881 882 static inline struct device_node *of_find_matching_node( 883 struct device_node *from, 884 const struct of_device_id *matches) 885 { 886 return of_find_matching_node_and_match(from, matches, NULL); 887 } 888 889 static inline const char *of_node_get_device_type(const struct device_node *np) 890 { 891 return of_get_property(np, "device_type", NULL); 892 } 893 894 static inline bool of_node_is_type(const struct device_node *np, const char *type) 895 { 896 const char *match = of_node_get_device_type(np); 897 898 return np && match && type && !strcmp(match, type); 899 } 900 901 /** 902 * of_parse_phandle - Resolve a phandle property to a device_node pointer 903 * @np: Pointer to device node holding phandle property 904 * @phandle_name: Name of property holding a phandle value 905 * @index: For properties holding a table of phandles, this is the index into 906 * the table 907 * 908 * Return: The device_node pointer with refcount incremented. Use 909 * of_node_put() on it when done. 910 */ 911 static inline struct device_node *of_parse_phandle(const struct device_node *np, 912 const char *phandle_name, 913 int index) 914 { 915 struct of_phandle_args args; 916 917 if (__of_parse_phandle_with_args(np, phandle_name, NULL, 0, 918 index, &args)) 919 return NULL; 920 921 return args.np; 922 } 923 924 /** 925 * of_parse_phandle_with_args() - Find a node pointed by phandle in a list 926 * @np: pointer to a device tree node containing a list 927 * @list_name: property name that contains a list 928 * @cells_name: property name that specifies phandles' arguments count 929 * @index: index of a phandle to parse out 930 * @out_args: optional pointer to output arguments structure (will be filled) 931 * 932 * This function is useful to parse lists of phandles and their arguments. 933 * Returns 0 on success and fills out_args, on error returns appropriate 934 * errno value. 935 * 936 * Caller is responsible to call of_node_put() on the returned out_args->np 937 * pointer. 938 * 939 * Example:: 940 * 941 * phandle1: node1 { 942 * #list-cells = <2>; 943 * }; 944 * 945 * phandle2: node2 { 946 * #list-cells = <1>; 947 * }; 948 * 949 * node3 { 950 * list = <&phandle1 1 2 &phandle2 3>; 951 * }; 952 * 953 * To get a device_node of the ``node2`` node you may call this: 954 * of_parse_phandle_with_args(node3, "list", "#list-cells", 1, &args); 955 */ 956 static inline int of_parse_phandle_with_args(const struct device_node *np, 957 const char *list_name, 958 const char *cells_name, 959 int index, 960 struct of_phandle_args *out_args) 961 { 962 int cell_count = -1; 963 964 /* If cells_name is NULL we assume a cell count of 0 */ 965 if (!cells_name) 966 cell_count = 0; 967 968 return __of_parse_phandle_with_args(np, list_name, cells_name, 969 cell_count, index, out_args); 970 } 971 972 /** 973 * of_parse_phandle_with_fixed_args() - Find a node pointed by phandle in a list 974 * @np: pointer to a device tree node containing a list 975 * @list_name: property name that contains a list 976 * @cell_count: number of argument cells following the phandle 977 * @index: index of a phandle to parse out 978 * @out_args: optional pointer to output arguments structure (will be filled) 979 * 980 * This function is useful to parse lists of phandles and their arguments. 981 * Returns 0 on success and fills out_args, on error returns appropriate 982 * errno value. 983 * 984 * Caller is responsible to call of_node_put() on the returned out_args->np 985 * pointer. 986 * 987 * Example:: 988 * 989 * phandle1: node1 { 990 * }; 991 * 992 * phandle2: node2 { 993 * }; 994 * 995 * node3 { 996 * list = <&phandle1 0 2 &phandle2 2 3>; 997 * }; 998 * 999 * To get a device_node of the ``node2`` node you may call this: 1000 * of_parse_phandle_with_fixed_args(node3, "list", 2, 1, &args); 1001 */ 1002 static inline int of_parse_phandle_with_fixed_args(const struct device_node *np, 1003 const char *list_name, 1004 int cell_count, 1005 int index, 1006 struct of_phandle_args *out_args) 1007 { 1008 return __of_parse_phandle_with_args(np, list_name, NULL, cell_count, 1009 index, out_args); 1010 } 1011 1012 /** 1013 * of_property_count_u8_elems - Count the number of u8 elements in a property 1014 * 1015 * @np: device node from which the property value is to be read. 1016 * @propname: name of the property to be searched. 1017 * 1018 * Search for a property in a device node and count the number of u8 elements 1019 * in it. 1020 * 1021 * Return: The number of elements on sucess, -EINVAL if the property does 1022 * not exist or its length does not match a multiple of u8 and -ENODATA if the 1023 * property does not have a value. 1024 */ 1025 static inline int of_property_count_u8_elems(const struct device_node *np, 1026 const char *propname) 1027 { 1028 return of_property_count_elems_of_size(np, propname, sizeof(u8)); 1029 } 1030 1031 /** 1032 * of_property_count_u16_elems - Count the number of u16 elements in a property 1033 * 1034 * @np: device node from which the property value is to be read. 1035 * @propname: name of the property to be searched. 1036 * 1037 * Search for a property in a device node and count the number of u16 elements 1038 * in it. 1039 * 1040 * Return: The number of elements on sucess, -EINVAL if the property does 1041 * not exist or its length does not match a multiple of u16 and -ENODATA if the 1042 * property does not have a value. 1043 */ 1044 static inline int of_property_count_u16_elems(const struct device_node *np, 1045 const char *propname) 1046 { 1047 return of_property_count_elems_of_size(np, propname, sizeof(u16)); 1048 } 1049 1050 /** 1051 * of_property_count_u32_elems - Count the number of u32 elements in a property 1052 * 1053 * @np: device node from which the property value is to be read. 1054 * @propname: name of the property to be searched. 1055 * 1056 * Search for a property in a device node and count the number of u32 elements 1057 * in it. 1058 * 1059 * Return: The number of elements on sucess, -EINVAL if the property does 1060 * not exist or its length does not match a multiple of u32 and -ENODATA if the 1061 * property does not have a value. 1062 */ 1063 static inline int of_property_count_u32_elems(const struct device_node *np, 1064 const char *propname) 1065 { 1066 return of_property_count_elems_of_size(np, propname, sizeof(u32)); 1067 } 1068 1069 /** 1070 * of_property_count_u64_elems - Count the number of u64 elements in a property 1071 * 1072 * @np: device node from which the property value is to be read. 1073 * @propname: name of the property to be searched. 1074 * 1075 * Search for a property in a device node and count the number of u64 elements 1076 * in it. 1077 * 1078 * Return: The number of elements on sucess, -EINVAL if the property does 1079 * not exist or its length does not match a multiple of u64 and -ENODATA if the 1080 * property does not have a value. 1081 */ 1082 static inline int of_property_count_u64_elems(const struct device_node *np, 1083 const char *propname) 1084 { 1085 return of_property_count_elems_of_size(np, propname, sizeof(u64)); 1086 } 1087 1088 /** 1089 * of_property_read_string_array() - Read an array of strings from a multiple 1090 * strings property. 1091 * @np: device node from which the property value is to be read. 1092 * @propname: name of the property to be searched. 1093 * @out_strs: output array of string pointers. 1094 * @sz: number of array elements to read. 1095 * 1096 * Search for a property in a device tree node and retrieve a list of 1097 * terminated string values (pointer to data, not a copy) in that property. 1098 * 1099 * Return: If @out_strs is NULL, the number of strings in the property is returned. 1100 */ 1101 static inline int of_property_read_string_array(const struct device_node *np, 1102 const char *propname, const char **out_strs, 1103 size_t sz) 1104 { 1105 return of_property_read_string_helper(np, propname, out_strs, sz, 0); 1106 } 1107 1108 /** 1109 * of_property_count_strings() - Find and return the number of strings from a 1110 * multiple strings property. 1111 * @np: device node from which the property value is to be read. 1112 * @propname: name of the property to be searched. 1113 * 1114 * Search for a property in a device tree node and retrieve the number of null 1115 * terminated string contain in it. 1116 * 1117 * Return: The number of strings on success, -EINVAL if the property does not 1118 * exist, -ENODATA if property does not have a value, and -EILSEQ if the string 1119 * is not null-terminated within the length of the property data. 1120 */ 1121 static inline int of_property_count_strings(const struct device_node *np, 1122 const char *propname) 1123 { 1124 return of_property_read_string_helper(np, propname, NULL, 0, 0); 1125 } 1126 1127 /** 1128 * of_property_read_string_index() - Find and read a string from a multiple 1129 * strings property. 1130 * @np: device node from which the property value is to be read. 1131 * @propname: name of the property to be searched. 1132 * @index: index of the string in the list of strings 1133 * @output: pointer to null terminated return string, modified only if 1134 * return value is 0. 1135 * 1136 * Search for a property in a device tree node and retrieve a null 1137 * terminated string value (pointer to data, not a copy) in the list of strings 1138 * contained in that property. 1139 * 1140 * Return: 0 on success, -EINVAL if the property does not exist, -ENODATA if 1141 * property does not have a value, and -EILSEQ if the string is not 1142 * null-terminated within the length of the property data. 1143 * 1144 * The out_string pointer is modified only if a valid string can be decoded. 1145 */ 1146 static inline int of_property_read_string_index(const struct device_node *np, 1147 const char *propname, 1148 int index, const char **output) 1149 { 1150 int rc = of_property_read_string_helper(np, propname, output, 1, index); 1151 return rc < 0 ? rc : 0; 1152 } 1153 1154 /** 1155 * of_property_read_bool - Find a property 1156 * @np: device node from which the property value is to be read. 1157 * @propname: name of the property to be searched. 1158 * 1159 * Search for a property in a device node. 1160 * 1161 * Return: true if the property exists false otherwise. 1162 */ 1163 static inline bool of_property_read_bool(const struct device_node *np, 1164 const char *propname) 1165 { 1166 struct property *prop = of_find_property(np, propname, NULL); 1167 1168 return prop ? true : false; 1169 } 1170 1171 /** 1172 * of_property_read_u8_array - Find and read an array of u8 from a property. 1173 * 1174 * @np: device node from which the property value is to be read. 1175 * @propname: name of the property to be searched. 1176 * @out_values: pointer to return value, modified only if return value is 0. 1177 * @sz: number of array elements to read 1178 * 1179 * Search for a property in a device node and read 8-bit value(s) from 1180 * it. 1181 * 1182 * dts entry of array should be like: 1183 * ``property = /bits/ 8 <0x50 0x60 0x70>;`` 1184 * 1185 * Return: 0 on success, -EINVAL if the property does not exist, 1186 * -ENODATA if property does not have a value, and -EOVERFLOW if the 1187 * property data isn't large enough. 1188 * 1189 * The out_values is modified only if a valid u8 value can be decoded. 1190 */ 1191 static inline int of_property_read_u8_array(const struct device_node *np, 1192 const char *propname, 1193 u8 *out_values, size_t sz) 1194 { 1195 int ret = of_property_read_variable_u8_array(np, propname, out_values, 1196 sz, 0); 1197 if (ret >= 0) 1198 return 0; 1199 else 1200 return ret; 1201 } 1202 1203 /** 1204 * of_property_read_u16_array - Find and read an array of u16 from a property. 1205 * 1206 * @np: device node from which the property value is to be read. 1207 * @propname: name of the property to be searched. 1208 * @out_values: pointer to return value, modified only if return value is 0. 1209 * @sz: number of array elements to read 1210 * 1211 * Search for a property in a device node and read 16-bit value(s) from 1212 * it. 1213 * 1214 * dts entry of array should be like: 1215 * ``property = /bits/ 16 <0x5000 0x6000 0x7000>;`` 1216 * 1217 * Return: 0 on success, -EINVAL if the property does not exist, 1218 * -ENODATA if property does not have a value, and -EOVERFLOW if the 1219 * property data isn't large enough. 1220 * 1221 * The out_values is modified only if a valid u16 value can be decoded. 1222 */ 1223 static inline int of_property_read_u16_array(const struct device_node *np, 1224 const char *propname, 1225 u16 *out_values, size_t sz) 1226 { 1227 int ret = of_property_read_variable_u16_array(np, propname, out_values, 1228 sz, 0); 1229 if (ret >= 0) 1230 return 0; 1231 else 1232 return ret; 1233 } 1234 1235 /** 1236 * of_property_read_u32_array - Find and read an array of 32 bit integers 1237 * from a property. 1238 * 1239 * @np: device node from which the property value is to be read. 1240 * @propname: name of the property to be searched. 1241 * @out_values: pointer to return value, modified only if return value is 0. 1242 * @sz: number of array elements to read 1243 * 1244 * Search for a property in a device node and read 32-bit value(s) from 1245 * it. 1246 * 1247 * Return: 0 on success, -EINVAL if the property does not exist, 1248 * -ENODATA if property does not have a value, and -EOVERFLOW if the 1249 * property data isn't large enough. 1250 * 1251 * The out_values is modified only if a valid u32 value can be decoded. 1252 */ 1253 static inline int of_property_read_u32_array(const struct device_node *np, 1254 const char *propname, 1255 u32 *out_values, size_t sz) 1256 { 1257 int ret = of_property_read_variable_u32_array(np, propname, out_values, 1258 sz, 0); 1259 if (ret >= 0) 1260 return 0; 1261 else 1262 return ret; 1263 } 1264 1265 /** 1266 * of_property_read_u64_array - Find and read an array of 64 bit integers 1267 * from a property. 1268 * 1269 * @np: device node from which the property value is to be read. 1270 * @propname: name of the property to be searched. 1271 * @out_values: pointer to return value, modified only if return value is 0. 1272 * @sz: number of array elements to read 1273 * 1274 * Search for a property in a device node and read 64-bit value(s) from 1275 * it. 1276 * 1277 * Return: 0 on success, -EINVAL if the property does not exist, 1278 * -ENODATA if property does not have a value, and -EOVERFLOW if the 1279 * property data isn't large enough. 1280 * 1281 * The out_values is modified only if a valid u64 value can be decoded. 1282 */ 1283 static inline int of_property_read_u64_array(const struct device_node *np, 1284 const char *propname, 1285 u64 *out_values, size_t sz) 1286 { 1287 int ret = of_property_read_variable_u64_array(np, propname, out_values, 1288 sz, 0); 1289 if (ret >= 0) 1290 return 0; 1291 else 1292 return ret; 1293 } 1294 1295 static inline int of_property_read_u8(const struct device_node *np, 1296 const char *propname, 1297 u8 *out_value) 1298 { 1299 return of_property_read_u8_array(np, propname, out_value, 1); 1300 } 1301 1302 static inline int of_property_read_u16(const struct device_node *np, 1303 const char *propname, 1304 u16 *out_value) 1305 { 1306 return of_property_read_u16_array(np, propname, out_value, 1); 1307 } 1308 1309 static inline int of_property_read_u32(const struct device_node *np, 1310 const char *propname, 1311 u32 *out_value) 1312 { 1313 return of_property_read_u32_array(np, propname, out_value, 1); 1314 } 1315 1316 static inline int of_property_read_s32(const struct device_node *np, 1317 const char *propname, 1318 s32 *out_value) 1319 { 1320 return of_property_read_u32(np, propname, (u32*) out_value); 1321 } 1322 1323 #define of_for_each_phandle(it, err, np, ln, cn, cc) \ 1324 for (of_phandle_iterator_init((it), (np), (ln), (cn), (cc)), \ 1325 err = of_phandle_iterator_next(it); \ 1326 err == 0; \ 1327 err = of_phandle_iterator_next(it)) 1328 1329 #define of_property_for_each_u32(np, propname, prop, p, u) \ 1330 for (prop = of_find_property(np, propname, NULL), \ 1331 p = of_prop_next_u32(prop, NULL, &u); \ 1332 p; \ 1333 p = of_prop_next_u32(prop, p, &u)) 1334 1335 #define of_property_for_each_string(np, propname, prop, s) \ 1336 for (prop = of_find_property(np, propname, NULL), \ 1337 s = of_prop_next_string(prop, NULL); \ 1338 s; \ 1339 s = of_prop_next_string(prop, s)) 1340 1341 #define for_each_node_by_name(dn, name) \ 1342 for (dn = of_find_node_by_name(NULL, name); dn; \ 1343 dn = of_find_node_by_name(dn, name)) 1344 #define for_each_node_by_type(dn, type) \ 1345 for (dn = of_find_node_by_type(NULL, type); dn; \ 1346 dn = of_find_node_by_type(dn, type)) 1347 #define for_each_compatible_node(dn, type, compatible) \ 1348 for (dn = of_find_compatible_node(NULL, type, compatible); dn; \ 1349 dn = of_find_compatible_node(dn, type, compatible)) 1350 #define for_each_matching_node(dn, matches) \ 1351 for (dn = of_find_matching_node(NULL, matches); dn; \ 1352 dn = of_find_matching_node(dn, matches)) 1353 #define for_each_matching_node_and_match(dn, matches, match) \ 1354 for (dn = of_find_matching_node_and_match(NULL, matches, match); \ 1355 dn; dn = of_find_matching_node_and_match(dn, matches, match)) 1356 1357 #define for_each_child_of_node(parent, child) \ 1358 for (child = of_get_next_child(parent, NULL); child != NULL; \ 1359 child = of_get_next_child(parent, child)) 1360 #define for_each_available_child_of_node(parent, child) \ 1361 for (child = of_get_next_available_child(parent, NULL); child != NULL; \ 1362 child = of_get_next_available_child(parent, child)) 1363 1364 #define for_each_of_cpu_node(cpu) \ 1365 for (cpu = of_get_next_cpu_node(NULL); cpu != NULL; \ 1366 cpu = of_get_next_cpu_node(cpu)) 1367 1368 #define for_each_node_with_property(dn, prop_name) \ 1369 for (dn = of_find_node_with_property(NULL, prop_name); dn; \ 1370 dn = of_find_node_with_property(dn, prop_name)) 1371 1372 static inline int of_get_child_count(const struct device_node *np) 1373 { 1374 struct device_node *child; 1375 int num = 0; 1376 1377 for_each_child_of_node(np, child) 1378 num++; 1379 1380 return num; 1381 } 1382 1383 static inline int of_get_available_child_count(const struct device_node *np) 1384 { 1385 struct device_node *child; 1386 int num = 0; 1387 1388 for_each_available_child_of_node(np, child) 1389 num++; 1390 1391 return num; 1392 } 1393 1394 #define _OF_DECLARE_STUB(table, name, compat, fn, fn_type) \ 1395 static const struct of_device_id __of_table_##name \ 1396 __attribute__((unused)) \ 1397 = { .compatible = compat, \ 1398 .data = (fn == (fn_type)NULL) ? fn : fn } 1399 1400 #if defined(CONFIG_OF) && !defined(MODULE) 1401 #define _OF_DECLARE(table, name, compat, fn, fn_type) \ 1402 static const struct of_device_id __of_table_##name \ 1403 __used __section("__" #table "_of_table") \ 1404 __aligned(__alignof__(struct of_device_id)) \ 1405 = { .compatible = compat, \ 1406 .data = (fn == (fn_type)NULL) ? fn : fn } 1407 #else 1408 #define _OF_DECLARE(table, name, compat, fn, fn_type) \ 1409 _OF_DECLARE_STUB(table, name, compat, fn, fn_type) 1410 #endif 1411 1412 typedef int (*of_init_fn_2)(struct device_node *, struct device_node *); 1413 typedef int (*of_init_fn_1_ret)(struct device_node *); 1414 typedef void (*of_init_fn_1)(struct device_node *); 1415 1416 #define OF_DECLARE_1(table, name, compat, fn) \ 1417 _OF_DECLARE(table, name, compat, fn, of_init_fn_1) 1418 #define OF_DECLARE_1_RET(table, name, compat, fn) \ 1419 _OF_DECLARE(table, name, compat, fn, of_init_fn_1_ret) 1420 #define OF_DECLARE_2(table, name, compat, fn) \ 1421 _OF_DECLARE(table, name, compat, fn, of_init_fn_2) 1422 1423 /** 1424 * struct of_changeset_entry - Holds a changeset entry 1425 * 1426 * @node: list_head for the log list 1427 * @action: notifier action 1428 * @np: pointer to the device node affected 1429 * @prop: pointer to the property affected 1430 * @old_prop: hold a pointer to the original property 1431 * 1432 * Every modification of the device tree during a changeset 1433 * is held in a list of of_changeset_entry structures. 1434 * That way we can recover from a partial application, or we can 1435 * revert the changeset 1436 */ 1437 struct of_changeset_entry { 1438 struct list_head node; 1439 unsigned long action; 1440 struct device_node *np; 1441 struct property *prop; 1442 struct property *old_prop; 1443 }; 1444 1445 /** 1446 * struct of_changeset - changeset tracker structure 1447 * 1448 * @entries: list_head for the changeset entries 1449 * 1450 * changesets are a convenient way to apply bulk changes to the 1451 * live tree. In case of an error, changes are rolled-back. 1452 * changesets live on after initial application, and if not 1453 * destroyed after use, they can be reverted in one single call. 1454 */ 1455 struct of_changeset { 1456 struct list_head entries; 1457 }; 1458 1459 enum of_reconfig_change { 1460 OF_RECONFIG_NO_CHANGE = 0, 1461 OF_RECONFIG_CHANGE_ADD, 1462 OF_RECONFIG_CHANGE_REMOVE, 1463 }; 1464 1465 #ifdef CONFIG_OF_DYNAMIC 1466 extern int of_reconfig_notifier_register(struct notifier_block *); 1467 extern int of_reconfig_notifier_unregister(struct notifier_block *); 1468 extern int of_reconfig_notify(unsigned long, struct of_reconfig_data *rd); 1469 extern int of_reconfig_get_state_change(unsigned long action, 1470 struct of_reconfig_data *arg); 1471 1472 extern void of_changeset_init(struct of_changeset *ocs); 1473 extern void of_changeset_destroy(struct of_changeset *ocs); 1474 extern int of_changeset_apply(struct of_changeset *ocs); 1475 extern int of_changeset_revert(struct of_changeset *ocs); 1476 extern int of_changeset_action(struct of_changeset *ocs, 1477 unsigned long action, struct device_node *np, 1478 struct property *prop); 1479 1480 static inline int of_changeset_attach_node(struct of_changeset *ocs, 1481 struct device_node *np) 1482 { 1483 return of_changeset_action(ocs, OF_RECONFIG_ATTACH_NODE, np, NULL); 1484 } 1485 1486 static inline int of_changeset_detach_node(struct of_changeset *ocs, 1487 struct device_node *np) 1488 { 1489 return of_changeset_action(ocs, OF_RECONFIG_DETACH_NODE, np, NULL); 1490 } 1491 1492 static inline int of_changeset_add_property(struct of_changeset *ocs, 1493 struct device_node *np, struct property *prop) 1494 { 1495 return of_changeset_action(ocs, OF_RECONFIG_ADD_PROPERTY, np, prop); 1496 } 1497 1498 static inline int of_changeset_remove_property(struct of_changeset *ocs, 1499 struct device_node *np, struct property *prop) 1500 { 1501 return of_changeset_action(ocs, OF_RECONFIG_REMOVE_PROPERTY, np, prop); 1502 } 1503 1504 static inline int of_changeset_update_property(struct of_changeset *ocs, 1505 struct device_node *np, struct property *prop) 1506 { 1507 return of_changeset_action(ocs, OF_RECONFIG_UPDATE_PROPERTY, np, prop); 1508 } 1509 #else /* CONFIG_OF_DYNAMIC */ 1510 static inline int of_reconfig_notifier_register(struct notifier_block *nb) 1511 { 1512 return -EINVAL; 1513 } 1514 static inline int of_reconfig_notifier_unregister(struct notifier_block *nb) 1515 { 1516 return -EINVAL; 1517 } 1518 static inline int of_reconfig_notify(unsigned long action, 1519 struct of_reconfig_data *arg) 1520 { 1521 return -EINVAL; 1522 } 1523 static inline int of_reconfig_get_state_change(unsigned long action, 1524 struct of_reconfig_data *arg) 1525 { 1526 return -EINVAL; 1527 } 1528 #endif /* CONFIG_OF_DYNAMIC */ 1529 1530 /** 1531 * of_device_is_system_power_controller - Tells if system-power-controller is found for device_node 1532 * @np: Pointer to the given device_node 1533 * 1534 * Return: true if present false otherwise 1535 */ 1536 static inline bool of_device_is_system_power_controller(const struct device_node *np) 1537 { 1538 return of_property_read_bool(np, "system-power-controller"); 1539 } 1540 1541 /* 1542 * Overlay support 1543 */ 1544 1545 enum of_overlay_notify_action { 1546 OF_OVERLAY_INIT = 0, /* kzalloc() of ovcs sets this value */ 1547 OF_OVERLAY_PRE_APPLY, 1548 OF_OVERLAY_POST_APPLY, 1549 OF_OVERLAY_PRE_REMOVE, 1550 OF_OVERLAY_POST_REMOVE, 1551 }; 1552 1553 static inline char *of_overlay_action_name(enum of_overlay_notify_action action) 1554 { 1555 static char *of_overlay_action_name[] = { 1556 "init", 1557 "pre-apply", 1558 "post-apply", 1559 "pre-remove", 1560 "post-remove", 1561 }; 1562 1563 return of_overlay_action_name[action]; 1564 } 1565 1566 struct of_overlay_notify_data { 1567 struct device_node *overlay; 1568 struct device_node *target; 1569 }; 1570 1571 #ifdef CONFIG_OF_OVERLAY 1572 1573 int of_overlay_fdt_apply(const void *overlay_fdt, u32 overlay_fdt_size, 1574 int *ovcs_id); 1575 int of_overlay_remove(int *ovcs_id); 1576 int of_overlay_remove_all(void); 1577 1578 int of_overlay_notifier_register(struct notifier_block *nb); 1579 int of_overlay_notifier_unregister(struct notifier_block *nb); 1580 1581 #else 1582 1583 static inline int of_overlay_fdt_apply(void *overlay_fdt, u32 overlay_fdt_size, 1584 int *ovcs_id) 1585 { 1586 return -ENOTSUPP; 1587 } 1588 1589 static inline int of_overlay_remove(int *ovcs_id) 1590 { 1591 return -ENOTSUPP; 1592 } 1593 1594 static inline int of_overlay_remove_all(void) 1595 { 1596 return -ENOTSUPP; 1597 } 1598 1599 static inline int of_overlay_notifier_register(struct notifier_block *nb) 1600 { 1601 return 0; 1602 } 1603 1604 static inline int of_overlay_notifier_unregister(struct notifier_block *nb) 1605 { 1606 return 0; 1607 } 1608 1609 #endif 1610 1611 #endif /* _LINUX_OF_H */ 1612