1 #ifndef _LINUX_OF_H 2 #define _LINUX_OF_H 3 /* 4 * Definitions for talking to the Open Firmware PROM on 5 * Power Macintosh and other computers. 6 * 7 * Copyright (C) 1996-2005 Paul Mackerras. 8 * 9 * Updates for PPC64 by Peter Bergner & David Engebretsen, IBM Corp. 10 * Updates for SPARC64 by David S. Miller 11 * Derived from PowerPC and Sparc prom.h files by Stephen Rothwell, IBM Corp. 12 * 13 * This program is free software; you can redistribute it and/or 14 * modify it under the terms of the GNU General Public License 15 * as published by the Free Software Foundation; either version 16 * 2 of the License, or (at your option) any later version. 17 */ 18 #include <linux/types.h> 19 #include <linux/bitops.h> 20 #include <linux/errno.h> 21 #include <linux/kobject.h> 22 #include <linux/mod_devicetable.h> 23 #include <linux/spinlock.h> 24 #include <linux/topology.h> 25 #include <linux/notifier.h> 26 27 #include <asm/byteorder.h> 28 #include <asm/errno.h> 29 30 typedef u32 phandle; 31 typedef u32 ihandle; 32 33 struct property { 34 char *name; 35 int length; 36 void *value; 37 struct property *next; 38 unsigned long _flags; 39 unsigned int unique_id; 40 struct bin_attribute attr; 41 }; 42 43 #if defined(CONFIG_SPARC) 44 struct of_irq_controller; 45 #endif 46 47 struct device_node { 48 const char *name; 49 const char *type; 50 phandle phandle; 51 const char *full_name; 52 53 struct property *properties; 54 struct property *deadprops; /* removed properties */ 55 struct device_node *parent; 56 struct device_node *child; 57 struct device_node *sibling; 58 struct device_node *next; /* next device of same type */ 59 struct device_node *allnext; /* next in list of all nodes */ 60 struct kobject kobj; 61 unsigned long _flags; 62 void *data; 63 #if defined(CONFIG_SPARC) 64 const char *path_component_name; 65 unsigned int unique_id; 66 struct of_irq_controller *irq_trans; 67 #endif 68 }; 69 70 #define MAX_PHANDLE_ARGS 16 71 struct of_phandle_args { 72 struct device_node *np; 73 int args_count; 74 uint32_t args[MAX_PHANDLE_ARGS]; 75 }; 76 77 extern int of_node_add(struct device_node *node); 78 79 /* initialize a node */ 80 extern struct kobj_type of_node_ktype; 81 static inline void of_node_init(struct device_node *node) 82 { 83 kobject_init(&node->kobj, &of_node_ktype); 84 } 85 86 /* true when node is initialized */ 87 static inline int of_node_is_initialized(struct device_node *node) 88 { 89 return node && node->kobj.state_initialized; 90 } 91 92 /* true when node is attached (i.e. present on sysfs) */ 93 static inline int of_node_is_attached(struct device_node *node) 94 { 95 return node && node->kobj.state_in_sysfs; 96 } 97 98 #ifdef CONFIG_OF_DYNAMIC 99 extern struct device_node *of_node_get(struct device_node *node); 100 extern void of_node_put(struct device_node *node); 101 #else /* CONFIG_OF_DYNAMIC */ 102 /* Dummy ref counting routines - to be implemented later */ 103 static inline struct device_node *of_node_get(struct device_node *node) 104 { 105 return node; 106 } 107 static inline void of_node_put(struct device_node *node) { } 108 #endif /* !CONFIG_OF_DYNAMIC */ 109 110 #ifdef CONFIG_OF 111 112 /* Pointer for first entry in chain of all nodes. */ 113 extern struct device_node *of_allnodes; 114 extern struct device_node *of_chosen; 115 extern struct device_node *of_aliases; 116 extern raw_spinlock_t devtree_lock; 117 118 static inline bool of_have_populated_dt(void) 119 { 120 return of_allnodes != NULL; 121 } 122 123 static inline bool of_node_is_root(const struct device_node *node) 124 { 125 return node && (node->parent == NULL); 126 } 127 128 static inline int of_node_check_flag(struct device_node *n, unsigned long flag) 129 { 130 return test_bit(flag, &n->_flags); 131 } 132 133 static inline int of_node_test_and_set_flag(struct device_node *n, 134 unsigned long flag) 135 { 136 return test_and_set_bit(flag, &n->_flags); 137 } 138 139 static inline void of_node_set_flag(struct device_node *n, unsigned long flag) 140 { 141 set_bit(flag, &n->_flags); 142 } 143 144 static inline void of_node_clear_flag(struct device_node *n, unsigned long flag) 145 { 146 clear_bit(flag, &n->_flags); 147 } 148 149 static inline int of_property_check_flag(struct property *p, unsigned long flag) 150 { 151 return test_bit(flag, &p->_flags); 152 } 153 154 static inline void of_property_set_flag(struct property *p, unsigned long flag) 155 { 156 set_bit(flag, &p->_flags); 157 } 158 159 static inline void of_property_clear_flag(struct property *p, unsigned long flag) 160 { 161 clear_bit(flag, &p->_flags); 162 } 163 164 extern struct device_node *of_find_all_nodes(struct device_node *prev); 165 166 /* 167 * OF address retrieval & translation 168 */ 169 170 /* Helper to read a big number; size is in cells (not bytes) */ 171 static inline u64 of_read_number(const __be32 *cell, int size) 172 { 173 u64 r = 0; 174 while (size--) 175 r = (r << 32) | be32_to_cpu(*(cell++)); 176 return r; 177 } 178 179 /* Like of_read_number, but we want an unsigned long result */ 180 static inline unsigned long of_read_ulong(const __be32 *cell, int size) 181 { 182 /* toss away upper bits if unsigned long is smaller than u64 */ 183 return of_read_number(cell, size); 184 } 185 186 #if defined(CONFIG_SPARC) 187 #include <asm/prom.h> 188 #endif 189 190 /* Default #address and #size cells. Allow arch asm/prom.h to override */ 191 #if !defined(OF_ROOT_NODE_ADDR_CELLS_DEFAULT) 192 #define OF_ROOT_NODE_ADDR_CELLS_DEFAULT 1 193 #define OF_ROOT_NODE_SIZE_CELLS_DEFAULT 1 194 #endif 195 196 /* Default string compare functions, Allow arch asm/prom.h to override */ 197 #if !defined(of_compat_cmp) 198 #define of_compat_cmp(s1, s2, l) strcasecmp((s1), (s2)) 199 #define of_prop_cmp(s1, s2) strcmp((s1), (s2)) 200 #define of_node_cmp(s1, s2) strcasecmp((s1), (s2)) 201 #endif 202 203 /* flag descriptions */ 204 #define OF_DYNAMIC 1 /* node and properties were allocated via kmalloc */ 205 #define OF_DETACHED 2 /* node has been detached from the device tree */ 206 #define OF_POPULATED 3 /* device already created for the node */ 207 208 #define OF_IS_DYNAMIC(x) test_bit(OF_DYNAMIC, &x->_flags) 209 #define OF_MARK_DYNAMIC(x) set_bit(OF_DYNAMIC, &x->_flags) 210 211 #define OF_BAD_ADDR ((u64)-1) 212 213 static inline const char *of_node_full_name(const struct device_node *np) 214 { 215 return np ? np->full_name : "<no-node>"; 216 } 217 218 #define for_each_of_allnodes(dn) \ 219 for (dn = of_allnodes; dn; dn = dn->allnext) 220 extern struct device_node *of_find_node_by_name(struct device_node *from, 221 const char *name); 222 extern struct device_node *of_find_node_by_type(struct device_node *from, 223 const char *type); 224 extern struct device_node *of_find_compatible_node(struct device_node *from, 225 const char *type, const char *compat); 226 extern struct device_node *of_find_matching_node_and_match( 227 struct device_node *from, 228 const struct of_device_id *matches, 229 const struct of_device_id **match); 230 231 extern struct device_node *of_find_node_by_path(const char *path); 232 extern struct device_node *of_find_node_by_phandle(phandle handle); 233 extern struct device_node *of_get_parent(const struct device_node *node); 234 extern struct device_node *of_get_next_parent(struct device_node *node); 235 extern struct device_node *of_get_next_child(const struct device_node *node, 236 struct device_node *prev); 237 extern struct device_node *of_get_next_available_child( 238 const struct device_node *node, struct device_node *prev); 239 240 extern struct device_node *of_get_child_by_name(const struct device_node *node, 241 const char *name); 242 243 /* cache lookup */ 244 extern struct device_node *of_find_next_cache_node(const struct device_node *); 245 extern struct device_node *of_find_node_with_property( 246 struct device_node *from, const char *prop_name); 247 248 extern struct property *of_find_property(const struct device_node *np, 249 const char *name, 250 int *lenp); 251 extern int of_property_count_elems_of_size(const struct device_node *np, 252 const char *propname, int elem_size); 253 extern int of_property_read_u32_index(const struct device_node *np, 254 const char *propname, 255 u32 index, u32 *out_value); 256 extern int of_property_read_u8_array(const struct device_node *np, 257 const char *propname, u8 *out_values, size_t sz); 258 extern int of_property_read_u16_array(const struct device_node *np, 259 const char *propname, u16 *out_values, size_t sz); 260 extern int of_property_read_u32_array(const struct device_node *np, 261 const char *propname, 262 u32 *out_values, 263 size_t sz); 264 extern int of_property_read_u64(const struct device_node *np, 265 const char *propname, u64 *out_value); 266 267 extern int of_property_read_string(struct device_node *np, 268 const char *propname, 269 const char **out_string); 270 extern int of_property_read_string_index(struct device_node *np, 271 const char *propname, 272 int index, const char **output); 273 extern int of_property_match_string(struct device_node *np, 274 const char *propname, 275 const char *string); 276 extern int of_property_count_strings(struct device_node *np, 277 const char *propname); 278 extern int of_device_is_compatible(const struct device_node *device, 279 const char *); 280 extern int of_device_is_available(const struct device_node *device); 281 extern const void *of_get_property(const struct device_node *node, 282 const char *name, 283 int *lenp); 284 extern struct device_node *of_get_cpu_node(int cpu, unsigned int *thread); 285 #define for_each_property_of_node(dn, pp) \ 286 for (pp = dn->properties; pp != NULL; pp = pp->next) 287 288 extern int of_n_addr_cells(struct device_node *np); 289 extern int of_n_size_cells(struct device_node *np); 290 extern const struct of_device_id *of_match_node( 291 const struct of_device_id *matches, const struct device_node *node); 292 extern int of_modalias_node(struct device_node *node, char *modalias, int len); 293 extern void of_print_phandle_args(const char *msg, const struct of_phandle_args *args); 294 extern struct device_node *of_parse_phandle(const struct device_node *np, 295 const char *phandle_name, 296 int index); 297 extern int of_parse_phandle_with_args(const struct device_node *np, 298 const char *list_name, const char *cells_name, int index, 299 struct of_phandle_args *out_args); 300 extern int of_parse_phandle_with_fixed_args(const struct device_node *np, 301 const char *list_name, int cells_count, int index, 302 struct of_phandle_args *out_args); 303 extern int of_count_phandle_with_args(const struct device_node *np, 304 const char *list_name, const char *cells_name); 305 306 extern void of_alias_scan(void * (*dt_alloc)(u64 size, u64 align)); 307 extern int of_alias_get_id(struct device_node *np, const char *stem); 308 309 extern int of_machine_is_compatible(const char *compat); 310 311 extern int of_add_property(struct device_node *np, struct property *prop); 312 extern int of_remove_property(struct device_node *np, struct property *prop); 313 extern int of_update_property(struct device_node *np, struct property *newprop); 314 315 /* For updating the device tree at runtime */ 316 #define OF_RECONFIG_ATTACH_NODE 0x0001 317 #define OF_RECONFIG_DETACH_NODE 0x0002 318 #define OF_RECONFIG_ADD_PROPERTY 0x0003 319 #define OF_RECONFIG_REMOVE_PROPERTY 0x0004 320 #define OF_RECONFIG_UPDATE_PROPERTY 0x0005 321 322 struct of_prop_reconfig { 323 struct device_node *dn; 324 struct property *prop; 325 }; 326 327 extern int of_reconfig_notifier_register(struct notifier_block *); 328 extern int of_reconfig_notifier_unregister(struct notifier_block *); 329 extern int of_reconfig_notify(unsigned long, void *); 330 331 extern int of_attach_node(struct device_node *); 332 extern int of_detach_node(struct device_node *); 333 334 #define of_match_ptr(_ptr) (_ptr) 335 336 /* 337 * struct property *prop; 338 * const __be32 *p; 339 * u32 u; 340 * 341 * of_property_for_each_u32(np, "propname", prop, p, u) 342 * printk("U32 value: %x\n", u); 343 */ 344 const __be32 *of_prop_next_u32(struct property *prop, const __be32 *cur, 345 u32 *pu); 346 /* 347 * struct property *prop; 348 * const char *s; 349 * 350 * of_property_for_each_string(np, "propname", prop, s) 351 * printk("String value: %s\n", s); 352 */ 353 const char *of_prop_next_string(struct property *prop, const char *cur); 354 355 int of_device_is_stdout_path(struct device_node *dn); 356 357 #else /* CONFIG_OF */ 358 359 static inline const char* of_node_full_name(const struct device_node *np) 360 { 361 return "<no-node>"; 362 } 363 364 static inline struct device_node *of_find_node_by_name(struct device_node *from, 365 const char *name) 366 { 367 return NULL; 368 } 369 370 static inline struct device_node *of_find_node_by_type(struct device_node *from, 371 const char *type) 372 { 373 return NULL; 374 } 375 376 static inline struct device_node *of_find_matching_node_and_match( 377 struct device_node *from, 378 const struct of_device_id *matches, 379 const struct of_device_id **match) 380 { 381 return NULL; 382 } 383 384 static inline struct device_node *of_find_node_by_path(const char *path) 385 { 386 return NULL; 387 } 388 389 static inline struct device_node *of_get_parent(const struct device_node *node) 390 { 391 return NULL; 392 } 393 394 static inline struct device_node *of_get_next_child( 395 const struct device_node *node, struct device_node *prev) 396 { 397 return NULL; 398 } 399 400 static inline struct device_node *of_get_next_available_child( 401 const struct device_node *node, struct device_node *prev) 402 { 403 return NULL; 404 } 405 406 static inline struct device_node *of_find_node_with_property( 407 struct device_node *from, const char *prop_name) 408 { 409 return NULL; 410 } 411 412 static inline bool of_have_populated_dt(void) 413 { 414 return false; 415 } 416 417 static inline struct device_node *of_get_child_by_name( 418 const struct device_node *node, 419 const char *name) 420 { 421 return NULL; 422 } 423 424 static inline int of_device_is_compatible(const struct device_node *device, 425 const char *name) 426 { 427 return 0; 428 } 429 430 static inline int of_device_is_available(const struct device_node *device) 431 { 432 return 0; 433 } 434 435 static inline struct property *of_find_property(const struct device_node *np, 436 const char *name, 437 int *lenp) 438 { 439 return NULL; 440 } 441 442 static inline struct device_node *of_find_compatible_node( 443 struct device_node *from, 444 const char *type, 445 const char *compat) 446 { 447 return NULL; 448 } 449 450 static inline int of_property_count_elems_of_size(const struct device_node *np, 451 const char *propname, int elem_size) 452 { 453 return -ENOSYS; 454 } 455 456 static inline int of_property_read_u32_index(const struct device_node *np, 457 const char *propname, u32 index, u32 *out_value) 458 { 459 return -ENOSYS; 460 } 461 462 static inline int of_property_read_u8_array(const struct device_node *np, 463 const char *propname, u8 *out_values, size_t sz) 464 { 465 return -ENOSYS; 466 } 467 468 static inline int of_property_read_u16_array(const struct device_node *np, 469 const char *propname, u16 *out_values, size_t sz) 470 { 471 return -ENOSYS; 472 } 473 474 static inline int of_property_read_u32_array(const struct device_node *np, 475 const char *propname, 476 u32 *out_values, size_t sz) 477 { 478 return -ENOSYS; 479 } 480 481 static inline int of_property_read_string(struct device_node *np, 482 const char *propname, 483 const char **out_string) 484 { 485 return -ENOSYS; 486 } 487 488 static inline int of_property_read_string_index(struct device_node *np, 489 const char *propname, int index, 490 const char **out_string) 491 { 492 return -ENOSYS; 493 } 494 495 static inline int of_property_count_strings(struct device_node *np, 496 const char *propname) 497 { 498 return -ENOSYS; 499 } 500 501 static inline const void *of_get_property(const struct device_node *node, 502 const char *name, 503 int *lenp) 504 { 505 return NULL; 506 } 507 508 static inline struct device_node *of_get_cpu_node(int cpu, 509 unsigned int *thread) 510 { 511 return NULL; 512 } 513 514 static inline int of_property_read_u64(const struct device_node *np, 515 const char *propname, u64 *out_value) 516 { 517 return -ENOSYS; 518 } 519 520 static inline int of_property_match_string(struct device_node *np, 521 const char *propname, 522 const char *string) 523 { 524 return -ENOSYS; 525 } 526 527 static inline struct device_node *of_parse_phandle(const struct device_node *np, 528 const char *phandle_name, 529 int index) 530 { 531 return NULL; 532 } 533 534 static inline int of_parse_phandle_with_args(struct device_node *np, 535 const char *list_name, 536 const char *cells_name, 537 int index, 538 struct of_phandle_args *out_args) 539 { 540 return -ENOSYS; 541 } 542 543 static inline int of_parse_phandle_with_fixed_args(const struct device_node *np, 544 const char *list_name, int cells_count, int index, 545 struct of_phandle_args *out_args) 546 { 547 return -ENOSYS; 548 } 549 550 static inline int of_count_phandle_with_args(struct device_node *np, 551 const char *list_name, 552 const char *cells_name) 553 { 554 return -ENOSYS; 555 } 556 557 static inline int of_alias_get_id(struct device_node *np, const char *stem) 558 { 559 return -ENOSYS; 560 } 561 562 static inline int of_machine_is_compatible(const char *compat) 563 { 564 return 0; 565 } 566 567 static inline int of_device_is_stdout_path(struct device_node *dn) 568 { 569 return 0; 570 } 571 572 static inline const __be32 *of_prop_next_u32(struct property *prop, 573 const __be32 *cur, u32 *pu) 574 { 575 return NULL; 576 } 577 578 static inline const char *of_prop_next_string(struct property *prop, 579 const char *cur) 580 { 581 return NULL; 582 } 583 584 #define of_match_ptr(_ptr) NULL 585 #define of_match_node(_matches, _node) NULL 586 #endif /* CONFIG_OF */ 587 588 #if defined(CONFIG_OF) && defined(CONFIG_NUMA) 589 extern int of_node_to_nid(struct device_node *np); 590 #else 591 static inline int of_node_to_nid(struct device_node *device) { return 0; } 592 #endif 593 594 static inline struct device_node *of_find_matching_node( 595 struct device_node *from, 596 const struct of_device_id *matches) 597 { 598 return of_find_matching_node_and_match(from, matches, NULL); 599 } 600 601 /** 602 * of_property_count_u8_elems - Count the number of u8 elements in a property 603 * 604 * @np: device node from which the property value is to be read. 605 * @propname: name of the property to be searched. 606 * 607 * Search for a property in a device node and count the number of u8 elements 608 * in it. Returns number of elements on sucess, -EINVAL if the property does 609 * not exist or its length does not match a multiple of u8 and -ENODATA if the 610 * property does not have a value. 611 */ 612 static inline int of_property_count_u8_elems(const struct device_node *np, 613 const char *propname) 614 { 615 return of_property_count_elems_of_size(np, propname, sizeof(u8)); 616 } 617 618 /** 619 * of_property_count_u16_elems - Count the number of u16 elements in a property 620 * 621 * @np: device node from which the property value is to be read. 622 * @propname: name of the property to be searched. 623 * 624 * Search for a property in a device node and count the number of u16 elements 625 * in it. Returns number of elements on sucess, -EINVAL if the property does 626 * not exist or its length does not match a multiple of u16 and -ENODATA if the 627 * property does not have a value. 628 */ 629 static inline int of_property_count_u16_elems(const struct device_node *np, 630 const char *propname) 631 { 632 return of_property_count_elems_of_size(np, propname, sizeof(u16)); 633 } 634 635 /** 636 * of_property_count_u32_elems - Count the number of u32 elements in a property 637 * 638 * @np: device node from which the property value is to be read. 639 * @propname: name of the property to be searched. 640 * 641 * Search for a property in a device node and count the number of u32 elements 642 * in it. Returns number of elements on sucess, -EINVAL if the property does 643 * not exist or its length does not match a multiple of u32 and -ENODATA if the 644 * property does not have a value. 645 */ 646 static inline int of_property_count_u32_elems(const struct device_node *np, 647 const char *propname) 648 { 649 return of_property_count_elems_of_size(np, propname, sizeof(u32)); 650 } 651 652 /** 653 * of_property_count_u64_elems - Count the number of u64 elements in a property 654 * 655 * @np: device node from which the property value is to be read. 656 * @propname: name of the property to be searched. 657 * 658 * Search for a property in a device node and count the number of u64 elements 659 * in it. Returns number of elements on sucess, -EINVAL if the property does 660 * not exist or its length does not match a multiple of u64 and -ENODATA if the 661 * property does not have a value. 662 */ 663 static inline int of_property_count_u64_elems(const struct device_node *np, 664 const char *propname) 665 { 666 return of_property_count_elems_of_size(np, propname, sizeof(u64)); 667 } 668 669 /** 670 * of_property_read_bool - Findfrom a property 671 * @np: device node from which the property value is to be read. 672 * @propname: name of the property to be searched. 673 * 674 * Search for a property in a device node. 675 * Returns true if the property exist false otherwise. 676 */ 677 static inline bool of_property_read_bool(const struct device_node *np, 678 const char *propname) 679 { 680 struct property *prop = of_find_property(np, propname, NULL); 681 682 return prop ? true : false; 683 } 684 685 static inline int of_property_read_u8(const struct device_node *np, 686 const char *propname, 687 u8 *out_value) 688 { 689 return of_property_read_u8_array(np, propname, out_value, 1); 690 } 691 692 static inline int of_property_read_u16(const struct device_node *np, 693 const char *propname, 694 u16 *out_value) 695 { 696 return of_property_read_u16_array(np, propname, out_value, 1); 697 } 698 699 static inline int of_property_read_u32(const struct device_node *np, 700 const char *propname, 701 u32 *out_value) 702 { 703 return of_property_read_u32_array(np, propname, out_value, 1); 704 } 705 706 #define of_property_for_each_u32(np, propname, prop, p, u) \ 707 for (prop = of_find_property(np, propname, NULL), \ 708 p = of_prop_next_u32(prop, NULL, &u); \ 709 p; \ 710 p = of_prop_next_u32(prop, p, &u)) 711 712 #define of_property_for_each_string(np, propname, prop, s) \ 713 for (prop = of_find_property(np, propname, NULL), \ 714 s = of_prop_next_string(prop, NULL); \ 715 s; \ 716 s = of_prop_next_string(prop, s)) 717 718 #define for_each_node_by_name(dn, name) \ 719 for (dn = of_find_node_by_name(NULL, name); dn; \ 720 dn = of_find_node_by_name(dn, name)) 721 #define for_each_node_by_type(dn, type) \ 722 for (dn = of_find_node_by_type(NULL, type); dn; \ 723 dn = of_find_node_by_type(dn, type)) 724 #define for_each_compatible_node(dn, type, compatible) \ 725 for (dn = of_find_compatible_node(NULL, type, compatible); dn; \ 726 dn = of_find_compatible_node(dn, type, compatible)) 727 #define for_each_matching_node(dn, matches) \ 728 for (dn = of_find_matching_node(NULL, matches); dn; \ 729 dn = of_find_matching_node(dn, matches)) 730 #define for_each_matching_node_and_match(dn, matches, match) \ 731 for (dn = of_find_matching_node_and_match(NULL, matches, match); \ 732 dn; dn = of_find_matching_node_and_match(dn, matches, match)) 733 734 #define for_each_child_of_node(parent, child) \ 735 for (child = of_get_next_child(parent, NULL); child != NULL; \ 736 child = of_get_next_child(parent, child)) 737 #define for_each_available_child_of_node(parent, child) \ 738 for (child = of_get_next_available_child(parent, NULL); child != NULL; \ 739 child = of_get_next_available_child(parent, child)) 740 741 #define for_each_node_with_property(dn, prop_name) \ 742 for (dn = of_find_node_with_property(NULL, prop_name); dn; \ 743 dn = of_find_node_with_property(dn, prop_name)) 744 745 static inline int of_get_child_count(const struct device_node *np) 746 { 747 struct device_node *child; 748 int num = 0; 749 750 for_each_child_of_node(np, child) 751 num++; 752 753 return num; 754 } 755 756 static inline int of_get_available_child_count(const struct device_node *np) 757 { 758 struct device_node *child; 759 int num = 0; 760 761 for_each_available_child_of_node(np, child) 762 num++; 763 764 return num; 765 } 766 767 #ifdef CONFIG_OF 768 #define _OF_DECLARE(table, name, compat, fn, fn_type) \ 769 static const struct of_device_id __of_table_##name \ 770 __used __section(__##table##_of_table) \ 771 = { .compatible = compat, \ 772 .data = (fn == (fn_type)NULL) ? fn : fn } 773 #else 774 #define _OF_DECLARE(table, name, compat, fn, fn_type) \ 775 static const struct of_device_id __of_table_##name \ 776 __attribute__((unused)) \ 777 = { .compatible = compat, \ 778 .data = (fn == (fn_type)NULL) ? fn : fn } 779 #endif 780 781 typedef int (*of_init_fn_2)(struct device_node *, struct device_node *); 782 typedef void (*of_init_fn_1)(struct device_node *); 783 784 #define OF_DECLARE_1(table, name, compat, fn) \ 785 _OF_DECLARE(table, name, compat, fn, of_init_fn_1) 786 #define OF_DECLARE_2(table, name, compat, fn) \ 787 _OF_DECLARE(table, name, compat, fn, of_init_fn_2) 788 789 #endif /* _LINUX_OF_H */ 790