of.h 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467
  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/kref.h>
  22. #include <linux/mod_devicetable.h>
  23. #include <linux/spinlock.h>
  24. #include <linux/topology.h>
  25. #include <asm/byteorder.h>
  26. #include <asm/errno.h>
  27. typedef u32 phandle;
  28. typedef u32 ihandle;
  29. struct property {
  30. char *name;
  31. int length;
  32. void *value;
  33. struct property *next;
  34. unsigned long _flags;
  35. unsigned int unique_id;
  36. };
  37. #if defined(CONFIG_SPARC)
  38. struct of_irq_controller;
  39. #endif
  40. struct device_node {
  41. const char *name;
  42. const char *type;
  43. phandle phandle;
  44. char *full_name;
  45. struct property *properties;
  46. struct property *deadprops; /* removed properties */
  47. struct device_node *parent;
  48. struct device_node *child;
  49. struct device_node *sibling;
  50. struct device_node *next; /* next device of same type */
  51. struct device_node *allnext; /* next in list of all nodes */
  52. struct proc_dir_entry *pde; /* this node's proc directory */
  53. struct kref kref;
  54. unsigned long _flags;
  55. void *data;
  56. #if defined(CONFIG_SPARC)
  57. char *path_component_name;
  58. unsigned int unique_id;
  59. struct of_irq_controller *irq_trans;
  60. #endif
  61. };
  62. #define MAX_PHANDLE_ARGS 8
  63. struct of_phandle_args {
  64. struct device_node *np;
  65. int args_count;
  66. uint32_t args[MAX_PHANDLE_ARGS];
  67. };
  68. #ifdef CONFIG_OF_DYNAMIC
  69. extern struct device_node *of_node_get(struct device_node *node);
  70. extern void of_node_put(struct device_node *node);
  71. #else /* CONFIG_OF_DYNAMIC */
  72. /* Dummy ref counting routines - to be implemented later */
  73. static inline struct device_node *of_node_get(struct device_node *node)
  74. {
  75. return node;
  76. }
  77. static inline void of_node_put(struct device_node *node) { }
  78. #endif /* !CONFIG_OF_DYNAMIC */
  79. #ifdef CONFIG_OF
  80. /* Pointer for first entry in chain of all nodes. */
  81. extern struct device_node *allnodes;
  82. extern struct device_node *of_chosen;
  83. extern struct device_node *of_aliases;
  84. extern rwlock_t devtree_lock;
  85. static inline bool of_have_populated_dt(void)
  86. {
  87. return allnodes != NULL;
  88. }
  89. static inline bool of_node_is_root(const struct device_node *node)
  90. {
  91. return node && (node->parent == NULL);
  92. }
  93. static inline int of_node_check_flag(struct device_node *n, unsigned long flag)
  94. {
  95. return test_bit(flag, &n->_flags);
  96. }
  97. static inline void of_node_set_flag(struct device_node *n, unsigned long flag)
  98. {
  99. set_bit(flag, &n->_flags);
  100. }
  101. extern struct device_node *of_find_all_nodes(struct device_node *prev);
  102. /*
  103. * OF address retrieval & translation
  104. */
  105. /* Helper to read a big number; size is in cells (not bytes) */
  106. static inline u64 of_read_number(const __be32 *cell, int size)
  107. {
  108. u64 r = 0;
  109. while (size--)
  110. r = (r << 32) | be32_to_cpu(*(cell++));
  111. return r;
  112. }
  113. /* Like of_read_number, but we want an unsigned long result */
  114. static inline unsigned long of_read_ulong(const __be32 *cell, int size)
  115. {
  116. /* toss away upper bits if unsigned long is smaller than u64 */
  117. return of_read_number(cell, size);
  118. }
  119. #include <asm/prom.h>
  120. /* Default #address and #size cells. Allow arch asm/prom.h to override */
  121. #if !defined(OF_ROOT_NODE_ADDR_CELLS_DEFAULT)
  122. #define OF_ROOT_NODE_ADDR_CELLS_DEFAULT 1
  123. #define OF_ROOT_NODE_SIZE_CELLS_DEFAULT 1
  124. #endif
  125. /* Default string compare functions, Allow arch asm/prom.h to override */
  126. #if !defined(of_compat_cmp)
  127. #define of_compat_cmp(s1, s2, l) strcasecmp((s1), (s2))
  128. #define of_prop_cmp(s1, s2) strcmp((s1), (s2))
  129. #define of_node_cmp(s1, s2) strcasecmp((s1), (s2))
  130. #endif
  131. /* flag descriptions */
  132. #define OF_DYNAMIC 1 /* node and properties were allocated via kmalloc */
  133. #define OF_DETACHED 2 /* node has been detached from the device tree */
  134. #define OF_IS_DYNAMIC(x) test_bit(OF_DYNAMIC, &x->_flags)
  135. #define OF_MARK_DYNAMIC(x) set_bit(OF_DYNAMIC, &x->_flags)
  136. #define OF_BAD_ADDR ((u64)-1)
  137. static inline const char* of_node_full_name(struct device_node *np)
  138. {
  139. return np ? np->full_name : "<no-node>";
  140. }
  141. extern struct device_node *of_find_node_by_name(struct device_node *from,
  142. const char *name);
  143. #define for_each_node_by_name(dn, name) \
  144. for (dn = of_find_node_by_name(NULL, name); dn; \
  145. dn = of_find_node_by_name(dn, name))
  146. extern struct device_node *of_find_node_by_type(struct device_node *from,
  147. const char *type);
  148. #define for_each_node_by_type(dn, type) \
  149. for (dn = of_find_node_by_type(NULL, type); dn; \
  150. dn = of_find_node_by_type(dn, type))
  151. extern struct device_node *of_find_compatible_node(struct device_node *from,
  152. const char *type, const char *compat);
  153. #define for_each_compatible_node(dn, type, compatible) \
  154. for (dn = of_find_compatible_node(NULL, type, compatible); dn; \
  155. dn = of_find_compatible_node(dn, type, compatible))
  156. extern struct device_node *of_find_matching_node(struct device_node *from,
  157. const struct of_device_id *matches);
  158. #define for_each_matching_node(dn, matches) \
  159. for (dn = of_find_matching_node(NULL, matches); dn; \
  160. dn = of_find_matching_node(dn, matches))
  161. extern struct device_node *of_find_node_by_path(const char *path);
  162. extern struct device_node *of_find_node_by_phandle(phandle handle);
  163. extern struct device_node *of_get_parent(const struct device_node *node);
  164. extern struct device_node *of_get_next_parent(struct device_node *node);
  165. extern struct device_node *of_get_next_child(const struct device_node *node,
  166. struct device_node *prev);
  167. extern struct device_node *of_get_next_available_child(
  168. const struct device_node *node, struct device_node *prev);
  169. extern struct device_node *of_get_child_by_name(const struct device_node *node,
  170. const char *name);
  171. #define for_each_child_of_node(parent, child) \
  172. for (child = of_get_next_child(parent, NULL); child != NULL; \
  173. child = of_get_next_child(parent, child))
  174. #define for_each_available_child_of_node(parent, child) \
  175. for (child = of_get_next_available_child(parent, NULL); child != NULL; \
  176. child = of_get_next_available_child(parent, child))
  177. static inline int of_get_child_count(const struct device_node *np)
  178. {
  179. struct device_node *child;
  180. int num = 0;
  181. for_each_child_of_node(np, child)
  182. num++;
  183. return num;
  184. }
  185. extern struct device_node *of_find_node_with_property(
  186. struct device_node *from, const char *prop_name);
  187. #define for_each_node_with_property(dn, prop_name) \
  188. for (dn = of_find_node_with_property(NULL, prop_name); dn; \
  189. dn = of_find_node_with_property(dn, prop_name))
  190. extern struct property *of_find_property(const struct device_node *np,
  191. const char *name,
  192. int *lenp);
  193. extern int of_property_read_u32_array(const struct device_node *np,
  194. const char *propname,
  195. u32 *out_values,
  196. size_t sz);
  197. extern int of_property_read_u64(const struct device_node *np,
  198. const char *propname, u64 *out_value);
  199. extern int of_property_read_string(struct device_node *np,
  200. const char *propname,
  201. const char **out_string);
  202. extern int of_property_read_string_index(struct device_node *np,
  203. const char *propname,
  204. int index, const char **output);
  205. extern int of_property_match_string(struct device_node *np,
  206. const char *propname,
  207. const char *string);
  208. extern int of_property_count_strings(struct device_node *np,
  209. const char *propname);
  210. extern int of_device_is_compatible(const struct device_node *device,
  211. const char *);
  212. extern int of_device_is_available(const struct device_node *device);
  213. extern const void *of_get_property(const struct device_node *node,
  214. const char *name,
  215. int *lenp);
  216. #define for_each_property_of_node(dn, pp) \
  217. for (pp = dn->properties; pp != NULL; pp = pp->next)
  218. extern int of_n_addr_cells(struct device_node *np);
  219. extern int of_n_size_cells(struct device_node *np);
  220. extern const struct of_device_id *of_match_node(
  221. const struct of_device_id *matches, const struct device_node *node);
  222. extern int of_modalias_node(struct device_node *node, char *modalias, int len);
  223. extern struct device_node *of_parse_phandle(struct device_node *np,
  224. const char *phandle_name,
  225. int index);
  226. extern int of_parse_phandle_with_args(struct device_node *np,
  227. const char *list_name, const char *cells_name, int index,
  228. struct of_phandle_args *out_args);
  229. extern void of_alias_scan(void * (*dt_alloc)(u64 size, u64 align));
  230. extern int of_alias_get_id(struct device_node *np, const char *stem);
  231. extern int of_machine_is_compatible(const char *compat);
  232. extern int prom_add_property(struct device_node* np, struct property* prop);
  233. extern int prom_remove_property(struct device_node *np, struct property *prop);
  234. extern int prom_update_property(struct device_node *np,
  235. struct property *newprop);
  236. #if defined(CONFIG_OF_DYNAMIC)
  237. /* For updating the device tree at runtime */
  238. extern void of_attach_node(struct device_node *);
  239. extern void of_detach_node(struct device_node *);
  240. #endif
  241. #define of_match_ptr(_ptr) (_ptr)
  242. /*
  243. * struct property *prop;
  244. * const __be32 *p;
  245. * u32 u;
  246. *
  247. * of_property_for_each_u32(np, "propname", prop, p, u)
  248. * printk("U32 value: %x\n", u);
  249. */
  250. const __be32 *of_prop_next_u32(struct property *prop, const __be32 *cur,
  251. u32 *pu);
  252. #define of_property_for_each_u32(np, propname, prop, p, u) \
  253. for (prop = of_find_property(np, propname, NULL), \
  254. p = of_prop_next_u32(prop, NULL, &u); \
  255. p; \
  256. p = of_prop_next_u32(prop, p, &u))
  257. /*
  258. * struct property *prop;
  259. * const char *s;
  260. *
  261. * of_property_for_each_string(np, "propname", prop, s)
  262. * printk("String value: %s\n", s);
  263. */
  264. const char *of_prop_next_string(struct property *prop, const char *cur);
  265. #define of_property_for_each_string(np, propname, prop, s) \
  266. for (prop = of_find_property(np, propname, NULL), \
  267. s = of_prop_next_string(prop, NULL); \
  268. s; \
  269. s = of_prop_next_string(prop, s))
  270. #else /* CONFIG_OF */
  271. static inline const char* of_node_full_name(struct device_node *np)
  272. {
  273. return "<no-node>";
  274. }
  275. static inline bool of_have_populated_dt(void)
  276. {
  277. return false;
  278. }
  279. #define for_each_child_of_node(parent, child) \
  280. while (0)
  281. static inline int of_get_child_count(const struct device_node *np)
  282. {
  283. return 0;
  284. }
  285. static inline int of_device_is_compatible(const struct device_node *device,
  286. const char *name)
  287. {
  288. return 0;
  289. }
  290. static inline struct property *of_find_property(const struct device_node *np,
  291. const char *name,
  292. int *lenp)
  293. {
  294. return NULL;
  295. }
  296. static inline struct device_node *of_find_compatible_node(
  297. struct device_node *from,
  298. const char *type,
  299. const char *compat)
  300. {
  301. return NULL;
  302. }
  303. static inline int of_property_read_u32_array(const struct device_node *np,
  304. const char *propname,
  305. u32 *out_values, size_t sz)
  306. {
  307. return -ENOSYS;
  308. }
  309. static inline int of_property_read_string(struct device_node *np,
  310. const char *propname,
  311. const char **out_string)
  312. {
  313. return -ENOSYS;
  314. }
  315. static inline int of_property_read_string_index(struct device_node *np,
  316. const char *propname, int index,
  317. const char **out_string)
  318. {
  319. return -ENOSYS;
  320. }
  321. static inline int of_property_count_strings(struct device_node *np,
  322. const char *propname)
  323. {
  324. return -ENOSYS;
  325. }
  326. static inline const void *of_get_property(const struct device_node *node,
  327. const char *name,
  328. int *lenp)
  329. {
  330. return NULL;
  331. }
  332. static inline int of_property_read_u64(const struct device_node *np,
  333. const char *propname, u64 *out_value)
  334. {
  335. return -ENOSYS;
  336. }
  337. static inline int of_property_match_string(struct device_node *np,
  338. const char *propname,
  339. const char *string)
  340. {
  341. return -ENOSYS;
  342. }
  343. static inline struct device_node *of_parse_phandle(struct device_node *np,
  344. const char *phandle_name,
  345. int index)
  346. {
  347. return NULL;
  348. }
  349. static inline int of_parse_phandle_with_args(struct device_node *np,
  350. const char *list_name,
  351. const char *cells_name,
  352. int index,
  353. struct of_phandle_args *out_args)
  354. {
  355. return -ENOSYS;
  356. }
  357. static inline int of_alias_get_id(struct device_node *np, const char *stem)
  358. {
  359. return -ENOSYS;
  360. }
  361. static inline int of_machine_is_compatible(const char *compat)
  362. {
  363. return 0;
  364. }
  365. #define of_match_ptr(_ptr) NULL
  366. #define of_match_node(_matches, _node) NULL
  367. #define of_property_for_each_u32(np, propname, prop, p, u) \
  368. while (0)
  369. #define of_property_for_each_string(np, propname, prop, s) \
  370. while (0)
  371. #endif /* CONFIG_OF */
  372. #ifndef of_node_to_nid
  373. static inline int of_node_to_nid(struct device_node *np)
  374. {
  375. return numa_node_id();
  376. }
  377. #define of_node_to_nid of_node_to_nid
  378. #endif
  379. /**
  380. * of_property_read_bool - Findfrom a property
  381. * @np: device node from which the property value is to be read.
  382. * @propname: name of the property to be searched.
  383. *
  384. * Search for a property in a device node.
  385. * Returns true if the property exist false otherwise.
  386. */
  387. static inline bool of_property_read_bool(const struct device_node *np,
  388. const char *propname)
  389. {
  390. struct property *prop = of_find_property(np, propname, NULL);
  391. return prop ? true : false;
  392. }
  393. static inline int of_property_read_u32(const struct device_node *np,
  394. const char *propname,
  395. u32 *out_value)
  396. {
  397. return of_property_read_u32_array(np, propname, out_value, 1);
  398. }
  399. #endif /* _LINUX_OF_H */