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