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