]>
Commit | Line | Data |
---|---|---|
f11c7ab9 SG |
1 | /* |
2 | * Function to read values from the device tree node attached to a udevice. | |
3 | * | |
4 | * Copyright (c) 2017 Google, Inc | |
5 | * Written by Simon Glass <sjg@chromium.org> | |
6 | * | |
7 | * SPDX-License-Identifier: GPL-2.0+ | |
8 | */ | |
9 | ||
10 | #ifndef _DM_READ_H | |
11 | #define _DM_READ_H | |
12 | ||
13 | #include <dm/fdtaddr.h> | |
14 | #include <dm/ofnode.h> | |
15 | #include <dm/uclass.h> | |
16 | ||
a4481012 SG |
17 | struct resource; |
18 | ||
f11c7ab9 SG |
19 | #if CONFIG_IS_ENABLED(OF_LIVE) |
20 | static inline const struct device_node *dev_np(struct udevice *dev) | |
21 | { | |
22 | return ofnode_to_np(dev->node); | |
23 | } | |
24 | #else | |
25 | static inline const struct device_node *dev_np(struct udevice *dev) | |
26 | { | |
27 | return NULL; | |
28 | } | |
29 | #endif | |
30 | ||
31 | /** | |
32 | * dev_ofnode() - get the DT node reference associated with a udevice | |
33 | * | |
34 | * @dev: device to check | |
35 | * @return reference of the the device's DT node | |
36 | */ | |
37 | static inline ofnode dev_ofnode(struct udevice *dev) | |
38 | { | |
39 | return dev->node; | |
40 | } | |
41 | ||
42 | static inline bool dev_of_valid(struct udevice *dev) | |
43 | { | |
44 | return ofnode_valid(dev_ofnode(dev)); | |
45 | } | |
46 | ||
a4481012 SG |
47 | /** |
48 | * dev_read_resource() - obtain an indexed resource from a device. | |
49 | * | |
50 | * @dev: devuce to examine | |
51 | * @index index of the resource to retrieve (0 = first) | |
52 | * @res returns the resource | |
53 | * @return 0 if ok, negative on error | |
54 | */ | |
55 | int dev_read_resource(struct udevice *dev, uint index, struct resource *res); | |
56 | ||
47a0fd3b SG |
57 | #ifndef CONFIG_DM_DEV_READ_INLINE |
58 | /** | |
59 | * dev_read_u32_default() - read a 32-bit integer from a device's DT property | |
60 | * | |
61 | * @dev: device to read DT property from | |
62 | * @propname: name of the property to read from | |
63 | * @def: default value to return if the property has no value | |
64 | * @return property value, or @def if not found | |
65 | */ | |
66 | int dev_read_u32_default(struct udevice *dev, const char *propname, int def); | |
f11c7ab9 SG |
67 | |
68 | /** | |
69 | * dev_read_string() - Read a string from a device's DT property | |
70 | * | |
71 | * @dev: device to read DT property from | |
72 | * @propname: name of the property to read | |
73 | * @return string from property value, or NULL if there is no such property | |
74 | */ | |
47a0fd3b | 75 | const char *dev_read_string(struct udevice *dev, const char *propname); |
f11c7ab9 SG |
76 | |
77 | /** | |
78 | * dev_read_bool() - read a boolean value from a device's DT property | |
79 | * | |
80 | * @dev: device to read DT property from | |
81 | * @propname: name of property to read | |
82 | * @return true if property is present (meaning true), false if not present | |
83 | */ | |
47a0fd3b | 84 | bool dev_read_bool(struct udevice *dev, const char *propname); |
f11c7ab9 SG |
85 | |
86 | /** | |
87 | * dev_read_subnode() - find a named subnode of a device | |
88 | * | |
89 | * @dev: device whose DT node contains the subnode | |
90 | * @subnode_name: name of subnode to find | |
91 | * @return reference to subnode (which can be invalid if there is no such | |
92 | * subnode) | |
93 | */ | |
47a0fd3b | 94 | ofnode dev_read_subnode(struct udevice *dev, const char *subbnode_name); |
f11c7ab9 SG |
95 | |
96 | /** | |
97 | * dev_read_size() - read the size of a property | |
98 | * | |
99 | * @dev: device to check | |
100 | * @propname: property to check | |
101 | * @return size of property if present, or -EINVAL if not | |
102 | */ | |
47a0fd3b | 103 | int dev_read_size(struct udevice *dev, const char *propname); |
f11c7ab9 SG |
104 | |
105 | /** | |
106 | * dev_read_addr_index() - Get the indexed reg property of a device | |
107 | * | |
108 | * @dev: Device to read from | |
109 | * @index: the 'reg' property can hold a list of <addr, size> pairs | |
110 | * and @index is used to select which one is required | |
111 | * | |
112 | * @return address or FDT_ADDR_T_NONE if not found | |
113 | */ | |
47a0fd3b | 114 | fdt_addr_t dev_read_addr_index(struct udevice *dev, int index); |
f11c7ab9 SG |
115 | |
116 | /** | |
117 | * dev_read_addr() - Get the reg property of a device | |
118 | * | |
119 | * @dev: Device to read from | |
120 | * | |
121 | * @return address or FDT_ADDR_T_NONE if not found | |
122 | */ | |
47a0fd3b | 123 | fdt_addr_t dev_read_addr(struct udevice *dev); |
f11c7ab9 SG |
124 | |
125 | /** | |
126 | * dev_read_addr_size() - get address and size from a device property | |
127 | * | |
128 | * This does no address translation. It simply reads an property that contains | |
129 | * an address and a size value, one after the other. | |
130 | * | |
131 | * @dev: Device to read from | |
132 | * @propname: property to read | |
133 | * @sizep: place to put size value (on success) | |
134 | * @return address value, or FDT_ADDR_T_NONE on error | |
135 | */ | |
47a0fd3b SG |
136 | fdt_addr_t dev_read_addr_size(struct udevice *dev, const char *propname, |
137 | fdt_size_t *sizep); | |
f11c7ab9 SG |
138 | |
139 | /** | |
140 | * dev_read_name() - get the name of a device's node | |
141 | * | |
142 | * @node: valid node to look up | |
143 | * @return name of node | |
144 | */ | |
47a0fd3b | 145 | const char *dev_read_name(struct udevice *dev); |
f11c7ab9 SG |
146 | |
147 | /** | |
148 | * dev_read_stringlist_search() - find string in a string list and return index | |
149 | * | |
150 | * Note that it is possible for this function to succeed on property values | |
151 | * that are not NUL-terminated. That's because the function will stop after | |
152 | * finding the first occurrence of @string. This can for example happen with | |
153 | * small-valued cell properties, such as #address-cells, when searching for | |
154 | * the empty string. | |
155 | * | |
156 | * @dev: device to check | |
157 | * @propname: name of the property containing the string list | |
158 | * @string: string to look up in the string list | |
159 | * | |
160 | * @return: | |
161 | * the index of the string in the list of strings | |
162 | * -ENODATA if the property is not found | |
163 | * -EINVAL on some other error | |
164 | */ | |
47a0fd3b SG |
165 | int dev_read_stringlist_search(struct udevice *dev, const char *property, |
166 | const char *string); | |
f11c7ab9 SG |
167 | |
168 | /** | |
169 | * dev_read_phandle_with_args() - Find a node pointed by phandle in a list | |
170 | * | |
171 | * This function is useful to parse lists of phandles and their arguments. | |
172 | * Returns 0 on success and fills out_args, on error returns appropriate | |
173 | * errno value. | |
174 | * | |
175 | * Caller is responsible to call of_node_put() on the returned out_args->np | |
176 | * pointer. | |
177 | * | |
178 | * Example: | |
179 | * | |
180 | * phandle1: node1 { | |
181 | * #list-cells = <2>; | |
182 | * } | |
183 | * | |
184 | * phandle2: node2 { | |
185 | * #list-cells = <1>; | |
186 | * } | |
187 | * | |
188 | * node3 { | |
189 | * list = <&phandle1 1 2 &phandle2 3>; | |
190 | * } | |
191 | * | |
192 | * To get a device_node of the `node2' node you may call this: | |
193 | * dev_read_phandle_with_args(dev, "list", "#list-cells", 0, 1, &args); | |
194 | * | |
195 | * @dev: device whose node containing a list | |
196 | * @list_name: property name that contains a list | |
197 | * @cells_name: property name that specifies phandles' arguments count | |
198 | * @cells_count: Cell count to use if @cells_name is NULL | |
199 | * @index: index of a phandle to parse out | |
200 | * @out_args: optional pointer to output arguments structure (will be filled) | |
201 | * @return 0 on success (with @out_args filled out if not NULL), -ENOENT if | |
202 | * @list_name does not exist, -EINVAL if a phandle was not found, | |
203 | * @cells_name could not be found, the arguments were truncated or there | |
204 | * were too many arguments. | |
205 | */ | |
47a0fd3b SG |
206 | int dev_read_phandle_with_args(struct udevice *dev, const char *list_name, |
207 | const char *cells_name, int cell_count, | |
208 | int index, | |
209 | struct ofnode_phandle_args *out_args); | |
f11c7ab9 SG |
210 | |
211 | /** | |
212 | * dev_read_addr_cells() - Get the number of address cells for a device's node | |
213 | * | |
214 | * This walks back up the tree to find the closest #address-cells property | |
215 | * which controls the given node. | |
216 | * | |
217 | * @dev: devioe to check | |
218 | * @return number of address cells this node uses | |
219 | */ | |
47a0fd3b | 220 | int dev_read_addr_cells(struct udevice *dev); |
f11c7ab9 SG |
221 | |
222 | /** | |
223 | * dev_read_size_cells() - Get the number of size cells for a device's node | |
224 | * | |
225 | * This walks back up the tree to find the closest #size-cells property | |
226 | * which controls the given node. | |
227 | * | |
228 | * @dev: devioe to check | |
229 | * @return number of size cells this node uses | |
230 | */ | |
47a0fd3b | 231 | int dev_read_size_cells(struct udevice *dev); |
f11c7ab9 SG |
232 | |
233 | /** | |
234 | * dev_read_phandle() - Get the phandle from a device | |
235 | * | |
236 | * @dev: device to check | |
237 | * @return phandle (1 or greater), or 0 if no phandle or other error | |
238 | */ | |
47a0fd3b | 239 | int dev_read_phandle(struct udevice *dev); |
f11c7ab9 SG |
240 | |
241 | /** | |
242 | * dev_read_prop()- - read a property from a device's node | |
243 | * | |
244 | * @dev: device to check | |
245 | * @propname: property to read | |
246 | * @lenp: place to put length on success | |
247 | * @return pointer to property, or NULL if not found | |
248 | */ | |
47a0fd3b | 249 | const u32 *dev_read_prop(struct udevice *dev, const char *propname, int *lenp); |
f11c7ab9 SG |
250 | |
251 | /** | |
252 | * dev_read_alias_seq() - Get the alias sequence number of a node | |
253 | * | |
254 | * This works out whether a node is pointed to by an alias, and if so, the | |
255 | * sequence number of that alias. Aliases are of the form <base><num> where | |
256 | * <num> is the sequence number. For example spi2 would be sequence number 2. | |
257 | * | |
258 | * @dev: device to look up | |
259 | * @devnump: set to the sequence number if one is found | |
260 | * @return 0 if a sequence was found, -ve if not | |
261 | */ | |
47a0fd3b | 262 | int dev_read_alias_seq(struct udevice *dev, int *devnump); |
f11c7ab9 SG |
263 | |
264 | /** | |
265 | * dev_read_u32_array() - Find and read an array of 32 bit integers | |
266 | * | |
267 | * Search for a property in a device node and read 32-bit value(s) from | |
268 | * it. | |
269 | * | |
270 | * The out_values is modified only if a valid u32 value can be decoded. | |
271 | * | |
272 | * @dev: device to look up | |
273 | * @propname: name of the property to read | |
274 | * @out_values: pointer to return value, modified only if return value is 0 | |
275 | * @sz: number of array elements to read | |
276 | * @return 0 on success, -EINVAL if the property does not exist, -ENODATA if | |
277 | * property does not have a value, and -EOVERFLOW if the property data isn't | |
278 | * large enough. | |
279 | */ | |
47a0fd3b SG |
280 | int dev_read_u32_array(struct udevice *dev, const char *propname, |
281 | u32 *out_values, size_t sz); | |
f11c7ab9 SG |
282 | |
283 | /** | |
284 | * dev_read_first_subnode() - find the first subnode of a device's node | |
285 | * | |
286 | * @dev: device to look up | |
287 | * @return reference to the first subnode (which can be invalid if the device's | |
288 | * node has no subnodes) | |
289 | */ | |
47a0fd3b | 290 | ofnode dev_read_first_subnode(struct udevice *dev); |
f11c7ab9 SG |
291 | |
292 | /** | |
293 | * ofnode_next_subnode() - find the next sibling of a subnode | |
294 | * | |
295 | * @node: valid reference to previous node (sibling) | |
296 | * @return reference to the next subnode (which can be invalid if the node | |
297 | * has no more siblings) | |
298 | */ | |
47a0fd3b | 299 | ofnode dev_read_next_subnode(ofnode node); |
f11c7ab9 SG |
300 | |
301 | /** | |
302 | * dev_read_u8_array_ptr() - find an 8-bit array | |
303 | * | |
304 | * Look up a device's node property and return a pointer to its contents as a | |
305 | * byte array of given length. The property must have at least enough data | |
306 | * for the array (count bytes). It may have more, but this will be ignored. | |
307 | * The data is not copied. | |
308 | * | |
309 | * @dev: device to look up | |
310 | * @propname: name of property to find | |
311 | * @sz: number of array elements | |
312 | * @return pointer to byte array if found, or NULL if the property is not | |
313 | * found or there is not enough data | |
314 | */ | |
47a0fd3b SG |
315 | const uint8_t *dev_read_u8_array_ptr(struct udevice *dev, const char *propname, |
316 | size_t sz); | |
317 | ||
f7d6fcf7 SG |
318 | /** |
319 | * dev_read_enabled() - check whether a node is enabled | |
320 | * | |
321 | * This looks for a 'status' property. If this exists, then returns 1 if | |
322 | * the status is 'ok' and 0 otherwise. If there is no status property, | |
323 | * it returns 1 on the assumption that anything mentioned should be enabled | |
324 | * by default. | |
325 | * | |
326 | * @dev: device to examine | |
327 | * @return integer value 0 (not enabled) or 1 (enabled) | |
328 | */ | |
329 | int dev_read_enabled(struct udevice *dev); | |
330 | ||
47a0fd3b SG |
331 | #else /* CONFIG_DM_DEV_READ_INLINE is enabled */ |
332 | ||
333 | static inline int dev_read_u32_default(struct udevice *dev, | |
334 | const char *propname, int def) | |
335 | { | |
336 | return ofnode_read_u32_default(dev_ofnode(dev), propname, def); | |
337 | } | |
338 | ||
339 | static inline const char *dev_read_string(struct udevice *dev, | |
340 | const char *propname) | |
341 | { | |
342 | return ofnode_read_string(dev_ofnode(dev), propname); | |
343 | } | |
344 | ||
345 | static inline bool dev_read_bool(struct udevice *dev, const char *propname) | |
346 | { | |
347 | return ofnode_read_bool(dev_ofnode(dev), propname); | |
348 | } | |
349 | ||
350 | static inline ofnode dev_read_subnode(struct udevice *dev, | |
351 | const char *subbnode_name) | |
352 | { | |
353 | return ofnode_find_subnode(dev_ofnode(dev), subbnode_name); | |
354 | } | |
355 | ||
356 | static inline int dev_read_size(struct udevice *dev, const char *propname) | |
357 | { | |
358 | return ofnode_read_size(dev_ofnode(dev), propname); | |
359 | } | |
360 | ||
361 | static inline fdt_addr_t dev_read_addr_index(struct udevice *dev, int index) | |
362 | { | |
363 | return devfdt_get_addr_index(dev, index); | |
364 | } | |
365 | ||
366 | static inline fdt_addr_t dev_read_addr(struct udevice *dev) | |
367 | { | |
368 | return devfdt_get_addr(dev); | |
369 | } | |
370 | ||
371 | static inline fdt_addr_t dev_read_addr_size(struct udevice *dev, | |
372 | const char *propname, | |
373 | fdt_size_t *sizep) | |
374 | { | |
375 | return ofnode_get_addr_size(dev_ofnode(dev), propname, sizep); | |
376 | } | |
377 | ||
378 | static inline const char *dev_read_name(struct udevice *dev) | |
379 | { | |
380 | return ofnode_get_name(dev_ofnode(dev)); | |
381 | } | |
382 | ||
383 | static inline int dev_read_stringlist_search(struct udevice *dev, | |
384 | const char *propname, | |
385 | const char *string) | |
386 | { | |
387 | return ofnode_stringlist_search(dev_ofnode(dev), propname, string); | |
388 | } | |
389 | ||
390 | static inline int dev_read_phandle_with_args(struct udevice *dev, | |
391 | const char *list_name, const char *cells_name, int cell_count, | |
392 | int index, struct ofnode_phandle_args *out_args) | |
393 | { | |
394 | return ofnode_parse_phandle_with_args(dev_ofnode(dev), list_name, | |
395 | cells_name, cell_count, index, | |
396 | out_args); | |
397 | } | |
398 | ||
399 | static inline int dev_read_addr_cells(struct udevice *dev) | |
400 | { | |
401 | return fdt_address_cells(gd->fdt_blob, dev_of_offset(dev)); | |
402 | } | |
403 | ||
404 | static inline int dev_read_size_cells(struct udevice *dev) | |
405 | { | |
406 | return fdt_size_cells(gd->fdt_blob, dev_of_offset(dev)); | |
407 | } | |
408 | ||
409 | static inline int dev_read_phandle(struct udevice *dev) | |
410 | { | |
411 | return fdt_get_phandle(gd->fdt_blob, dev_of_offset(dev)); | |
412 | } | |
413 | ||
414 | static inline const u32 *dev_read_prop(struct udevice *dev, | |
415 | const char *propname, int *lenp) | |
416 | { | |
417 | return ofnode_read_prop(dev_ofnode(dev), propname, lenp); | |
418 | } | |
419 | ||
420 | static inline int dev_read_alias_seq(struct udevice *dev, int *devnump) | |
421 | { | |
422 | return fdtdec_get_alias_seq(gd->fdt_blob, dev->uclass->uc_drv->name, | |
423 | dev_of_offset(dev), devnump); | |
424 | } | |
425 | ||
426 | static inline int dev_read_u32_array(struct udevice *dev, const char *propname, | |
427 | u32 *out_values, size_t sz) | |
428 | { | |
429 | return ofnode_read_u32_array(dev_ofnode(dev), propname, out_values, sz); | |
430 | } | |
431 | ||
432 | static inline ofnode dev_read_first_subnode(struct udevice *dev) | |
433 | { | |
434 | return ofnode_first_subnode(dev_ofnode(dev)); | |
435 | } | |
436 | ||
437 | static inline ofnode dev_read_next_subnode(ofnode node) | |
438 | { | |
439 | return ofnode_next_subnode(node); | |
440 | } | |
441 | ||
f11c7ab9 SG |
442 | static inline const uint8_t *dev_read_u8_array_ptr(struct udevice *dev, |
443 | const char *propname, size_t sz) | |
444 | { | |
445 | return ofnode_read_u8_array_ptr(dev_ofnode(dev), propname, sz); | |
446 | } | |
447 | ||
f7d6fcf7 SG |
448 | static inline int dev_read_enabled(struct udevice *dev) |
449 | { | |
450 | return fdtdec_get_is_enabled(gd->fdt_blob, dev_of_offset(dev)); | |
451 | } | |
452 | ||
f11c7ab9 SG |
453 | #endif /* CONFIG_DM_DEV_READ_INLINE */ |
454 | ||
455 | /** | |
456 | * dev_for_each_subnode() - Helper function to iterate through subnodes | |
457 | * | |
458 | * This creates a for() loop which works through the subnodes in a device's | |
459 | * device-tree node. | |
460 | * | |
461 | * @subnode: ofnode holding the current subnode | |
462 | * @dev: device to use for interation (struct udevice *) | |
463 | */ | |
464 | #define dev_for_each_subnode(subnode, dev) \ | |
465 | for (subnode = dev_read_first_subnode(dev); \ | |
466 | ofnode_valid(subnode); \ | |
467 | subnode = ofnode_next_subnode(subnode)) | |
468 | ||
469 | #endif |