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