blob: b952551d5552dc04e097c230f5a42cb8a723e932 [file] [log] [blame]
Tom Rini83d290c2018-05-06 17:58:06 -04001/* SPDX-License-Identifier: GPL-2.0+ */
Simon Glassf11c7ab2017-05-18 20:09:03 -06002/*
3 * Function to read values from the device tree node attached to a udevice.
4 *
5 * Copyright (c) 2017 Google, Inc
6 * Written by Simon Glass <sjg@chromium.org>
Simon Glassf11c7ab2017-05-18 20:09:03 -06007 */
8
9#ifndef _DM_READ_H
10#define _DM_READ_H
11
12#include <dm/fdtaddr.h>
13#include <dm/ofnode.h>
14#include <dm/uclass.h>
15
Simon Glassa4481012017-06-12 06:21:29 -060016struct resource;
17
Simon Glassf11c7ab2017-05-18 20:09:03 -060018#if CONFIG_IS_ENABLED(OF_LIVE)
Simon Glass88b3a372020-01-27 08:49:40 -070019static inline const struct device_node *dev_np(const struct udevice *dev)
Simon Glassf11c7ab2017-05-18 20:09:03 -060020{
21 return ofnode_to_np(dev->node);
22}
23#else
Simon Glass88b3a372020-01-27 08:49:40 -070024static inline const struct device_node *dev_np(const struct udevice *dev)
Simon Glassf11c7ab2017-05-18 20:09:03 -060025{
26 return NULL;
27}
28#endif
29
30/**
31 * dev_ofnode() - get the DT node reference associated with a udevice
32 *
33 * @dev: device to check
34 * @return reference of the the device's DT node
35 */
Simon Glassfc347fb2020-01-27 08:49:36 -070036static inline ofnode dev_ofnode(const struct udevice *dev)
Simon Glassf11c7ab2017-05-18 20:09:03 -060037{
38 return dev->node;
39}
40
Simon Glassfc347fb2020-01-27 08:49:36 -070041static inline bool dev_of_valid(const struct udevice *dev)
Simon Glassf11c7ab2017-05-18 20:09:03 -060042{
43 return ofnode_valid(dev_ofnode(dev));
44}
45
Simon Glass47a0fd32017-05-18 20:09:04 -060046#ifndef CONFIG_DM_DEV_READ_INLINE
T Karthik Reddy3f3d7712019-09-02 16:34:30 +020047
Simon Glass47a0fd32017-05-18 20:09:04 -060048/**
Masahiro Yamada3ab48f62017-12-30 02:00:05 +090049 * dev_read_u32() - read a 32-bit integer from a device's DT property
50 *
51 * @dev: device to read DT property from
52 * @propname: name of the property to read from
53 * @outp: place to put value (if found)
54 * @return 0 if OK, -ve on error
55 */
Simon Glass88b3a372020-01-27 08:49:40 -070056int dev_read_u32(const struct udevice *dev, const char *propname, u32 *outp);
Masahiro Yamada3ab48f62017-12-30 02:00:05 +090057
58/**
Simon Glass47a0fd32017-05-18 20:09:04 -060059 * 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 */
Simon Glass88b3a372020-01-27 08:49:40 -070066int dev_read_u32_default(const struct udevice *dev, const char *propname,
67 int def);
Simon Glassf11c7ab2017-05-18 20:09:03 -060068
69/**
Dario Binacchi4bb70752020-03-29 18:04:41 +020070 * dev_read_u32_index() - read an indexed 32-bit integer from a device's DT
71 * property
72 *
73 * @dev: device to read DT property from
74 * @propname: name of the property to read from
75 * @index: index of the integer to return
76 * @outp: place to put value (if found)
77 * @return 0 if OK, -ve on error
78 */
79int dev_read_u32_index(struct udevice *dev, const char *propname, int index,
80 u32 *outp);
81
82/**
83 * dev_read_u32_index_default() - read an indexed 32-bit integer from a device's
84 * DT property
85 *
86 * @dev: device to read DT property from
87 * @propname: name of the property to read from
88 * @index: index of the integer to return
89 * @def: default value to return if the property has no value
90 * @return property value, or @def if not found
91 */
92u32 dev_read_u32_index_default(struct udevice *dev, const char *propname,
93 int index, u32 def);
94
95/**
Simon Glassa1b17e42018-12-10 10:37:37 -070096 * dev_read_s32() - read a signed 32-bit integer from a device's DT property
97 *
98 * @dev: device to read DT property from
99 * @propname: name of the property to read from
100 * @outp: place to put value (if found)
101 * @return 0 if OK, -ve on error
102 */
Simon Glass88b3a372020-01-27 08:49:40 -0700103int dev_read_s32(const struct udevice *dev, const char *propname, s32 *outp);
Simon Glassa1b17e42018-12-10 10:37:37 -0700104
105/**
106 * dev_read_s32_default() - read a signed 32-bit int from a device's DT property
107 *
108 * @dev: device to read DT property from
109 * @propname: name of the property to read from
110 * @def: default value to return if the property has no value
111 * @return property value, or @def if not found
112 */
Simon Glass88b3a372020-01-27 08:49:40 -0700113int dev_read_s32_default(const struct udevice *dev, const char *propname,
114 int def);
Simon Glassa1b17e42018-12-10 10:37:37 -0700115
116/**
117 * dev_read_u32u() - read a 32-bit integer from a device's DT property
118 *
119 * This version uses a standard uint type.
120 *
121 * @dev: device to read DT property from
122 * @propname: name of the property to read from
123 * @outp: place to put value (if found)
124 * @return 0 if OK, -ve on error
125 */
Simon Glass88b3a372020-01-27 08:49:40 -0700126int dev_read_u32u(const struct udevice *dev, const char *propname, uint *outp);
Simon Glassa1b17e42018-12-10 10:37:37 -0700127
128/**
T Karthik Reddy3f3d7712019-09-02 16:34:30 +0200129 * dev_read_u64() - read a 64-bit integer from a device's DT property
130 *
131 * @dev: device to read DT property from
132 * @propname: name of the property to read from
133 * @outp: place to put value (if found)
134 * @return 0 if OK, -ve on error
135 */
Simon Glass88b3a372020-01-27 08:49:40 -0700136int dev_read_u64(const struct udevice *dev, const char *propname, u64 *outp);
T Karthik Reddy3f3d7712019-09-02 16:34:30 +0200137
138/**
139 * dev_read_u64_default() - read a 64-bit integer from a device's DT property
140 *
141 * @dev: device to read DT property from
142 * @propname: name of the property to read from
143 * @def: default value to return if the property has no value
144 * @return property value, or @def if not found
145 */
Simon Glass88b3a372020-01-27 08:49:40 -0700146u64 dev_read_u64_default(const struct udevice *dev, const char *propname,
147 u64 def);
T Karthik Reddy3f3d7712019-09-02 16:34:30 +0200148
149/**
Simon Glassf11c7ab2017-05-18 20:09:03 -0600150 * dev_read_string() - Read a string from a device's DT property
151 *
152 * @dev: device to read DT property from
153 * @propname: name of the property to read
154 * @return string from property value, or NULL if there is no such property
155 */
Simon Glass88b3a372020-01-27 08:49:40 -0700156const char *dev_read_string(const struct udevice *dev, const char *propname);
Simon Glassf11c7ab2017-05-18 20:09:03 -0600157
158/**
159 * dev_read_bool() - read a boolean value from a device's DT property
160 *
161 * @dev: device to read DT property from
162 * @propname: name of property to read
163 * @return true if property is present (meaning true), false if not present
164 */
Simon Glass88b3a372020-01-27 08:49:40 -0700165bool dev_read_bool(const struct udevice *dev, const char *propname);
Simon Glassf11c7ab2017-05-18 20:09:03 -0600166
167/**
168 * dev_read_subnode() - find a named subnode of a device
169 *
170 * @dev: device whose DT node contains the subnode
171 * @subnode_name: name of subnode to find
172 * @return reference to subnode (which can be invalid if there is no such
173 * subnode)
174 */
Simon Glass88b3a372020-01-27 08:49:40 -0700175ofnode dev_read_subnode(const struct udevice *dev, const char *subbnode_name);
Simon Glassf11c7ab2017-05-18 20:09:03 -0600176
177/**
178 * dev_read_size() - read the size of a property
179 *
180 * @dev: device to check
181 * @propname: property to check
182 * @return size of property if present, or -EINVAL if not
183 */
Simon Glass88b3a372020-01-27 08:49:40 -0700184int dev_read_size(const struct udevice *dev, const char *propname);
Simon Glassf11c7ab2017-05-18 20:09:03 -0600185
186/**
187 * dev_read_addr_index() - Get the indexed reg property of a device
188 *
189 * @dev: Device to read from
190 * @index: the 'reg' property can hold a list of <addr, size> pairs
191 * and @index is used to select which one is required
192 *
193 * @return address or FDT_ADDR_T_NONE if not found
194 */
Simon Glass88b3a372020-01-27 08:49:40 -0700195fdt_addr_t dev_read_addr_index(const struct udevice *dev, int index);
Simon Glassf11c7ab2017-05-18 20:09:03 -0600196
197/**
Sekhar Norif5b90472019-08-01 19:12:56 +0530198 * dev_read_addr_size_index() - Get the indexed reg property of a device
199 *
200 * @dev: Device to read from
201 * @index: the 'reg' property can hold a list of <addr, size> pairs
202 * and @index is used to select which one is required
203 * @size: place to put size value (on success)
204 *
205 * @return address or FDT_ADDR_T_NONE if not found
206 */
Simon Glass88b3a372020-01-27 08:49:40 -0700207fdt_addr_t dev_read_addr_size_index(const struct udevice *dev, int index,
Sekhar Norif5b90472019-08-01 19:12:56 +0530208 fdt_size_t *size);
209
210/**
Álvaro Fernández Rojas30a90f52018-04-29 21:56:54 +0200211 * dev_remap_addr_index() - Get the indexed reg property of a device
212 * as a memory-mapped I/O pointer
213 *
214 * @dev: Device to read from
215 * @index: the 'reg' property can hold a list of <addr, size> pairs
216 * and @index is used to select which one is required
217 *
218 * @return pointer or NULL if not found
219 */
Simon Glass88b3a372020-01-27 08:49:40 -0700220void *dev_remap_addr_index(const struct udevice *dev, int index);
Álvaro Fernández Rojas30a90f52018-04-29 21:56:54 +0200221
222/**
Álvaro Fernández Rojas79598822018-12-03 19:37:09 +0100223 * dev_read_addr_name() - Get the reg property of a device, indexed by name
224 *
225 * @dev: Device to read from
226 * @name: the 'reg' property can hold a list of <addr, size> pairs, with the
227 * 'reg-names' property providing named-based identification. @index
228 * indicates the value to search for in 'reg-names'.
229 *
230 * @return address or FDT_ADDR_T_NONE if not found
231 */
Simon Glass88b3a372020-01-27 08:49:40 -0700232fdt_addr_t dev_read_addr_name(const struct udevice *dev, const char *name);
Álvaro Fernández Rojas79598822018-12-03 19:37:09 +0100233
234/**
Sekhar Norif5b90472019-08-01 19:12:56 +0530235 * dev_read_addr_size_name() - Get the reg property of a device, indexed by name
236 *
237 * @dev: Device to read from
238 * @name: the 'reg' property can hold a list of <addr, size> pairs, with the
239 * 'reg-names' property providing named-based identification. @index
240 * indicates the value to search for in 'reg-names'.
241 * @size: place to put size value (on success)
242 *
243 * @return address or FDT_ADDR_T_NONE if not found
244 */
Simon Glass88b3a372020-01-27 08:49:40 -0700245fdt_addr_t dev_read_addr_size_name(const struct udevice *dev, const char *name,
Sekhar Norif5b90472019-08-01 19:12:56 +0530246 fdt_size_t *size);
247
248/**
Álvaro Fernández Rojas79598822018-12-03 19:37:09 +0100249 * dev_remap_addr_name() - Get the reg property of a device, indexed by name,
250 * as a memory-mapped I/O pointer
251 *
252 * @dev: Device to read from
253 * @name: the 'reg' property can hold a list of <addr, size> pairs, with the
254 * 'reg-names' property providing named-based identification. @index
255 * indicates the value to search for in 'reg-names'.
256 *
257 * @return pointer or NULL if not found
258 */
Simon Glass88b3a372020-01-27 08:49:40 -0700259void *dev_remap_addr_name(const struct udevice *dev, const char *name);
Álvaro Fernández Rojas79598822018-12-03 19:37:09 +0100260
261/**
Simon Glassf11c7ab2017-05-18 20:09:03 -0600262 * dev_read_addr() - Get the reg property of a device
263 *
264 * @dev: Device to read from
265 *
266 * @return address or FDT_ADDR_T_NONE if not found
267 */
Simon Glass88b3a372020-01-27 08:49:40 -0700268fdt_addr_t dev_read_addr(const struct udevice *dev);
Simon Glassf11c7ab2017-05-18 20:09:03 -0600269
270/**
Philipp Tomsichc131c8b2017-09-11 22:04:12 +0200271 * dev_read_addr_ptr() - Get the reg property of a device
272 * as a pointer
273 *
274 * @dev: Device to read from
275 *
276 * @return pointer or NULL if not found
277 */
Simon Glass88b3a372020-01-27 08:49:40 -0700278void *dev_read_addr_ptr(const struct udevice *dev);
Philipp Tomsichc131c8b2017-09-11 22:04:12 +0200279
280/**
Simon Glass33c215a2019-09-15 12:08:58 -0600281 * dev_read_addr_pci() - Read an address and handle PCI address translation
282 *
283 * At present U-Boot does not have address translation logic for PCI in the
284 * livetree implementation (of_addr.c). This special function supports this for
285 * the flat tree implementation.
286 *
287 * This function should be removed (and code should use dev_read() instead)
288 * once:
289 *
290 * 1. PCI address translation is added; and either
291 * 2. everything uses livetree where PCI translation is used (which is feasible
292 * in SPL and U-Boot proper) or PCI address translation is added to
293 * fdtdec_get_addr() and friends.
294 *
295 * @dev: Device to read from
296 * @return address or FDT_ADDR_T_NONE if not found
297 */
Simon Glass88b3a372020-01-27 08:49:40 -0700298fdt_addr_t dev_read_addr_pci(const struct udevice *dev);
Simon Glass33c215a2019-09-15 12:08:58 -0600299
300/**
Álvaro Fernández Rojas30a90f52018-04-29 21:56:54 +0200301 * dev_remap_addr() - Get the reg property of a device as a
302 * memory-mapped I/O pointer
303 *
304 * @dev: Device to read from
305 *
306 * @return pointer or NULL if not found
307 */
Simon Glass88b3a372020-01-27 08:49:40 -0700308void *dev_remap_addr(const struct udevice *dev);
Álvaro Fernández Rojas30a90f52018-04-29 21:56:54 +0200309
310/**
Simon Glassf11c7ab2017-05-18 20:09:03 -0600311 * dev_read_addr_size() - get address and size from a device property
312 *
313 * This does no address translation. It simply reads an property that contains
314 * an address and a size value, one after the other.
315 *
316 * @dev: Device to read from
317 * @propname: property to read
318 * @sizep: place to put size value (on success)
319 * @return address value, or FDT_ADDR_T_NONE on error
320 */
Simon Glass88b3a372020-01-27 08:49:40 -0700321fdt_addr_t dev_read_addr_size(const struct udevice *dev, const char *propname,
322 fdt_size_t *sizep);
Simon Glassf11c7ab2017-05-18 20:09:03 -0600323
324/**
325 * dev_read_name() - get the name of a device's node
326 *
Bin Meng15d61d02019-07-05 09:23:18 -0700327 * @dev: Device to read from
Simon Glassf11c7ab2017-05-18 20:09:03 -0600328 * @return name of node
329 */
Simon Glass88b3a372020-01-27 08:49:40 -0700330const char *dev_read_name(const struct udevice *dev);
Simon Glassf11c7ab2017-05-18 20:09:03 -0600331
332/**
333 * dev_read_stringlist_search() - find string in a string list and return index
334 *
335 * Note that it is possible for this function to succeed on property values
336 * that are not NUL-terminated. That's because the function will stop after
337 * finding the first occurrence of @string. This can for example happen with
338 * small-valued cell properties, such as #address-cells, when searching for
339 * the empty string.
340 *
341 * @dev: device to check
342 * @propname: name of the property containing the string list
343 * @string: string to look up in the string list
344 *
345 * @return:
346 * the index of the string in the list of strings
347 * -ENODATA if the property is not found
348 * -EINVAL on some other error
349 */
Simon Glass88b3a372020-01-27 08:49:40 -0700350int dev_read_stringlist_search(const struct udevice *dev, const char *property,
351 const char *string);
Simon Glassf11c7ab2017-05-18 20:09:03 -0600352
353/**
Jean-Jacques Hiblotb5a144a2017-09-21 17:03:09 +0200354 * dev_read_string_index() - obtain an indexed string from a string list
355 *
356 * @dev: device to examine
357 * @propname: name of the property containing the string list
358 * @index: index of the string to return
359 * @out: return location for the string
360 *
361 * @return:
362 * length of string, if found or -ve error value if not found
363 */
Simon Glass88b3a372020-01-27 08:49:40 -0700364int dev_read_string_index(const struct udevice *dev, const char *propname,
365 int index, const char **outp);
Jean-Jacques Hiblotb5a144a2017-09-21 17:03:09 +0200366
367/**
368 * dev_read_string_count() - find the number of strings in a string list
369 *
370 * @dev: device to examine
371 * @propname: name of the property containing the string list
372 * @return:
373 * number of strings in the list, or -ve error value if not found
374 */
Simon Glass88b3a372020-01-27 08:49:40 -0700375int dev_read_string_count(const struct udevice *dev, const char *propname);
Jean-Jacques Hiblotb5a144a2017-09-21 17:03:09 +0200376/**
Simon Glassf11c7ab2017-05-18 20:09:03 -0600377 * dev_read_phandle_with_args() - Find a node pointed by phandle in a list
378 *
379 * This function is useful to parse lists of phandles and their arguments.
380 * Returns 0 on success and fills out_args, on error returns appropriate
381 * errno value.
382 *
383 * Caller is responsible to call of_node_put() on the returned out_args->np
384 * pointer.
385 *
386 * Example:
387 *
388 * phandle1: node1 {
389 * #list-cells = <2>;
390 * }
391 *
392 * phandle2: node2 {
393 * #list-cells = <1>;
394 * }
395 *
396 * node3 {
397 * list = <&phandle1 1 2 &phandle2 3>;
398 * }
399 *
400 * To get a device_node of the `node2' node you may call this:
401 * dev_read_phandle_with_args(dev, "list", "#list-cells", 0, 1, &args);
402 *
403 * @dev: device whose node containing a list
404 * @list_name: property name that contains a list
405 * @cells_name: property name that specifies phandles' arguments count
406 * @cells_count: Cell count to use if @cells_name is NULL
407 * @index: index of a phandle to parse out
408 * @out_args: optional pointer to output arguments structure (will be filled)
409 * @return 0 on success (with @out_args filled out if not NULL), -ENOENT if
410 * @list_name does not exist, -EINVAL if a phandle was not found,
411 * @cells_name could not be found, the arguments were truncated or there
412 * were too many arguments.
413 */
Simon Glass88b3a372020-01-27 08:49:40 -0700414int dev_read_phandle_with_args(const struct udevice *dev, const char *list_name,
415 const char *cells_name, int cell_count,
416 int index, struct ofnode_phandle_args *out_args);
Simon Glassf11c7ab2017-05-18 20:09:03 -0600417
418/**
Patrice Chotard642346a2017-07-18 11:57:08 +0200419 * dev_count_phandle_with_args() - Return phandle number in a list
420 *
421 * This function is usefull to get phandle number contained in a property list.
422 * For example, this allows to allocate the right amount of memory to keep
423 * clock's reference contained into the "clocks" property.
424 *
425 *
426 * @dev: device whose node containing a list
427 * @list_name: property name that contains a list
428 * @cells_name: property name that specifies phandles' arguments count
429 * @Returns number of phandle found on success, on error returns appropriate
430 * errno value.
431 */
432
Simon Glass88b3a372020-01-27 08:49:40 -0700433int dev_count_phandle_with_args(const struct udevice *dev,
434 const char *list_name, const char *cells_name);
Patrice Chotard642346a2017-07-18 11:57:08 +0200435
436/**
Simon Glassf11c7ab2017-05-18 20:09:03 -0600437 * dev_read_addr_cells() - Get the number of address cells for a device's node
438 *
439 * This walks back up the tree to find the closest #address-cells property
440 * which controls the given node.
441 *
Mario Six7ba50412018-01-15 11:09:36 +0100442 * @dev: device to check
Simon Glassf11c7ab2017-05-18 20:09:03 -0600443 * @return number of address cells this node uses
444 */
Simon Glass88b3a372020-01-27 08:49:40 -0700445int dev_read_addr_cells(const struct udevice *dev);
Simon Glassf11c7ab2017-05-18 20:09:03 -0600446
447/**
448 * dev_read_size_cells() - Get the number of size cells for a device's node
449 *
450 * This walks back up the tree to find the closest #size-cells property
451 * which controls the given node.
452 *
Mario Six7ba50412018-01-15 11:09:36 +0100453 * @dev: device to check
Simon Glassf11c7ab2017-05-18 20:09:03 -0600454 * @return number of size cells this node uses
455 */
Simon Glass88b3a372020-01-27 08:49:40 -0700456int dev_read_size_cells(const struct udevice *dev);
Simon Glassf11c7ab2017-05-18 20:09:03 -0600457
458/**
Simon Glass878d68c2017-06-12 06:21:31 -0600459 * dev_read_addr_cells() - Get the address cells property in a node
460 *
461 * This function matches fdt_address_cells().
462 *
Mario Six7ba50412018-01-15 11:09:36 +0100463 * @dev: device to check
Simon Glass878d68c2017-06-12 06:21:31 -0600464 * @return number of address cells this node uses
465 */
Simon Glass88b3a372020-01-27 08:49:40 -0700466int dev_read_simple_addr_cells(const struct udevice *dev);
Simon Glass878d68c2017-06-12 06:21:31 -0600467
468/**
469 * dev_read_size_cells() - Get the size cells property in a node
470 *
471 * This function matches fdt_size_cells().
472 *
Mario Six7ba50412018-01-15 11:09:36 +0100473 * @dev: device to check
Simon Glass878d68c2017-06-12 06:21:31 -0600474 * @return number of size cells this node uses
475 */
Simon Glass88b3a372020-01-27 08:49:40 -0700476int dev_read_simple_size_cells(const struct udevice *dev);
Simon Glass878d68c2017-06-12 06:21:31 -0600477
478/**
Simon Glassf11c7ab2017-05-18 20:09:03 -0600479 * dev_read_phandle() - Get the phandle from a device
480 *
481 * @dev: device to check
482 * @return phandle (1 or greater), or 0 if no phandle or other error
483 */
Simon Glass88b3a372020-01-27 08:49:40 -0700484int dev_read_phandle(const struct udevice *dev);
Simon Glassf11c7ab2017-05-18 20:09:03 -0600485
486/**
487 * dev_read_prop()- - read a property from a device's node
488 *
489 * @dev: device to check
490 * @propname: property to read
491 * @lenp: place to put length on success
492 * @return pointer to property, or NULL if not found
493 */
Simon Glass88b3a372020-01-27 08:49:40 -0700494const void *dev_read_prop(const struct udevice *dev, const char *propname,
495 int *lenp);
Simon Glassf11c7ab2017-05-18 20:09:03 -0600496
497/**
Patrick Delaunayce891fca2020-01-13 11:34:56 +0100498 * dev_read_first_prop()- get the reference of the first property
499 *
500 * Get reference to the first property of the node, it is used to iterate
501 * and read all the property with dev_read_prop_by_prop().
502 *
503 * @dev: device to check
504 * @prop: place to put argument reference
505 * @return 0 if OK, -ve on error. -FDT_ERR_NOTFOUND if not found
506 */
507int dev_read_first_prop(const struct udevice *dev, struct ofprop *prop);
508
509/**
510 * ofnode_get_next_property() - get the reference of the next property
511 *
512 * Get reference to the next property of the node, it is used to iterate
513 * and read all the property with dev_read_prop_by_prop().
514 *
515 * @prop: reference of current argument and place to put reference of next one
516 * @return 0 if OK, -ve on error. -FDT_ERR_NOTFOUND if not found
517 */
518int dev_read_next_prop(struct ofprop *prop);
519
520/**
521 * dev_read_prop_by_prop() - get a pointer to the value of a property
522 *
523 * Get value for the property identified by the provided reference.
524 *
525 * @prop: reference on property
526 * @propname: If non-NULL, place to property name on success,
527 * @lenp: If non-NULL, place to put length on success
528 * @return 0 if OK, -ve on error. -FDT_ERR_NOTFOUND if not found
529 */
530const void *dev_read_prop_by_prop(struct ofprop *prop,
531 const char **propname, int *lenp);
532
533/**
Simon Glassf11c7ab2017-05-18 20:09:03 -0600534 * dev_read_alias_seq() - Get the alias sequence number of a node
535 *
536 * This works out whether a node is pointed to by an alias, and if so, the
537 * sequence number of that alias. Aliases are of the form <base><num> where
538 * <num> is the sequence number. For example spi2 would be sequence number 2.
539 *
540 * @dev: device to look up
541 * @devnump: set to the sequence number if one is found
542 * @return 0 if a sequence was found, -ve if not
543 */
Simon Glass88b3a372020-01-27 08:49:40 -0700544int dev_read_alias_seq(const struct udevice *dev, int *devnump);
Simon Glassf11c7ab2017-05-18 20:09:03 -0600545
546/**
547 * dev_read_u32_array() - Find and read an array of 32 bit integers
548 *
549 * Search for a property in a device node and read 32-bit value(s) from
550 * it.
551 *
552 * The out_values is modified only if a valid u32 value can be decoded.
553 *
554 * @dev: device to look up
555 * @propname: name of the property to read
556 * @out_values: pointer to return value, modified only if return value is 0
557 * @sz: number of array elements to read
558 * @return 0 on success, -EINVAL if the property does not exist, -ENODATA if
559 * property does not have a value, and -EOVERFLOW if the property data isn't
560 * large enough.
561 */
Simon Glass88b3a372020-01-27 08:49:40 -0700562int dev_read_u32_array(const struct udevice *dev, const char *propname,
Simon Glass47a0fd32017-05-18 20:09:04 -0600563 u32 *out_values, size_t sz);
Simon Glassf11c7ab2017-05-18 20:09:03 -0600564
565/**
566 * dev_read_first_subnode() - find the first subnode of a device's node
567 *
568 * @dev: device to look up
569 * @return reference to the first subnode (which can be invalid if the device's
570 * node has no subnodes)
571 */
Simon Glass88b3a372020-01-27 08:49:40 -0700572ofnode dev_read_first_subnode(const struct udevice *dev);
Simon Glassf11c7ab2017-05-18 20:09:03 -0600573
574/**
575 * ofnode_next_subnode() - find the next sibling of a subnode
576 *
577 * @node: valid reference to previous node (sibling)
578 * @return reference to the next subnode (which can be invalid if the node
579 * has no more siblings)
580 */
Simon Glass47a0fd32017-05-18 20:09:04 -0600581ofnode dev_read_next_subnode(ofnode node);
Simon Glassf11c7ab2017-05-18 20:09:03 -0600582
583/**
584 * dev_read_u8_array_ptr() - find an 8-bit array
585 *
586 * Look up a device's node property and return a pointer to its contents as a
587 * byte array of given length. The property must have at least enough data
588 * for the array (count bytes). It may have more, but this will be ignored.
589 * The data is not copied.
590 *
591 * @dev: device to look up
592 * @propname: name of property to find
593 * @sz: number of array elements
594 * @return pointer to byte array if found, or NULL if the property is not
595 * found or there is not enough data
596 */
Simon Glass88b3a372020-01-27 08:49:40 -0700597const uint8_t *dev_read_u8_array_ptr(const struct udevice *dev,
598 const char *propname, size_t sz);
Simon Glass47a0fd32017-05-18 20:09:04 -0600599
Simon Glassf7d6fcf2017-06-12 06:21:30 -0600600/**
601 * dev_read_enabled() - check whether a node is enabled
602 *
603 * This looks for a 'status' property. If this exists, then returns 1 if
604 * the status is 'ok' and 0 otherwise. If there is no status property,
605 * it returns 1 on the assumption that anything mentioned should be enabled
606 * by default.
607 *
608 * @dev: device to examine
609 * @return integer value 0 (not enabled) or 1 (enabled)
610 */
Simon Glass88b3a372020-01-27 08:49:40 -0700611int dev_read_enabled(const struct udevice *dev);
Simon Glassf7d6fcf2017-06-12 06:21:30 -0600612
Simon Glassdcf98852017-07-25 08:29:55 -0600613/**
614 * dev_read_resource() - obtain an indexed resource from a device.
615 *
Masahiro Yamada7b8b47b2017-08-26 01:12:30 +0900616 * @dev: device to examine
Simon Glassdcf98852017-07-25 08:29:55 -0600617 * @index index of the resource to retrieve (0 = first)
618 * @res returns the resource
619 * @return 0 if ok, negative on error
620 */
Simon Glass88b3a372020-01-27 08:49:40 -0700621int dev_read_resource(const struct udevice *dev, uint index,
622 struct resource *res);
Simon Glassdcf98852017-07-25 08:29:55 -0600623
Masahiro Yamada7b8b47b2017-08-26 01:12:30 +0900624/**
625 * dev_read_resource_byname() - obtain a named resource from a device.
626 *
627 * @dev: device to examine
628 * @name: name of the resource to retrieve
629 * @res: returns the resource
630 * @return 0 if ok, negative on error
631 */
Simon Glass88b3a372020-01-27 08:49:40 -0700632int dev_read_resource_byname(const struct udevice *dev, const char *name,
Masahiro Yamada7b8b47b2017-08-26 01:12:30 +0900633 struct resource *res);
634
Mario Six147c6072018-01-15 11:07:19 +0100635/**
Fabien Dessenne641067f2019-05-31 15:11:30 +0200636 * dev_translate_address() - Translate a device-tree address
Mario Six147c6072018-01-15 11:07:19 +0100637 *
638 * Translate an address from the device-tree into a CPU physical address. This
639 * function walks up the tree and applies the various bus mappings along the
640 * way.
641 *
642 * @dev: device giving the context in which to translate the address
643 * @in_addr: pointer to the address to translate
644 * @return the translated address; OF_BAD_ADDR on error
645 */
Simon Glass88b3a372020-01-27 08:49:40 -0700646u64 dev_translate_address(const struct udevice *dev, const fdt32_t *in_addr);
Michal Simek83e4c7e2019-01-31 16:30:59 +0100647
648/**
Fabien Dessenne641067f2019-05-31 15:11:30 +0200649 * dev_translate_dma_address() - Translate a device-tree DMA address
650 *
651 * Translate a DMA address from the device-tree into a CPU physical address.
652 * This function walks up the tree and applies the various bus mappings along
653 * the way.
654 *
655 * @dev: device giving the context in which to translate the DMA address
656 * @in_addr: pointer to the DMA address to translate
657 * @return the translated DMA address; OF_BAD_ADDR on error
658 */
Simon Glass88b3a372020-01-27 08:49:40 -0700659u64 dev_translate_dma_address(const struct udevice *dev,
660 const fdt32_t *in_addr);
Fabien Dessenne641067f2019-05-31 15:11:30 +0200661
662/**
Michal Simek83e4c7e2019-01-31 16:30:59 +0100663 * dev_read_alias_highest_id - Get highest alias id for the given stem
664 * @stem: Alias stem to be examined
665 *
666 * The function travels the lookup table to get the highest alias id for the
667 * given alias stem.
668 * @return alias ID, if found, else -1
669 */
670int dev_read_alias_highest_id(const char *stem);
671
Chunfeng Yun89b84b82020-05-02 11:35:09 +0200672/**
673 * dev_get_child_count() - get the child count of a device
674 *
675 * @dev: device to use for interation (struct udevice *)
676 * @return the count of child subnode
677 */
678int dev_get_child_count(const struct udevice *dev);
679
Simon Glass47a0fd32017-05-18 20:09:04 -0600680#else /* CONFIG_DM_DEV_READ_INLINE is enabled */
681
Simon Glass88b3a372020-01-27 08:49:40 -0700682static inline int dev_read_u32(const struct udevice *dev,
Masahiro Yamada3ab48f62017-12-30 02:00:05 +0900683 const char *propname, u32 *outp)
684{
685 return ofnode_read_u32(dev_ofnode(dev), propname, outp);
686}
687
Simon Glass88b3a372020-01-27 08:49:40 -0700688static inline int dev_read_u32_default(const struct udevice *dev,
Simon Glass47a0fd32017-05-18 20:09:04 -0600689 const char *propname, int def)
690{
691 return ofnode_read_u32_default(dev_ofnode(dev), propname, def);
692}
693
Dario Binacchi4bb70752020-03-29 18:04:41 +0200694static inline int dev_read_u32_index(struct udevice *dev,
695 const char *propname, int index, u32 *outp)
696{
697 return ofnode_read_u32_index(dev_ofnode(dev), propname, index, outp);
698}
699
700static inline u32 dev_read_u32_index_default(struct udevice *dev,
701 const char *propname, int index,
702 u32 def)
703{
704 return ofnode_read_u32_index_default(dev_ofnode(dev), propname, index,
705 def);
706}
707
Simon Glass88b3a372020-01-27 08:49:40 -0700708static inline int dev_read_s32(const struct udevice *dev,
Simon Glassa1b17e42018-12-10 10:37:37 -0700709 const char *propname, s32 *outp)
710{
711 return ofnode_read_s32(dev_ofnode(dev), propname, outp);
712}
713
Simon Glass88b3a372020-01-27 08:49:40 -0700714static inline int dev_read_s32_default(const struct udevice *dev,
Simon Glassa1b17e42018-12-10 10:37:37 -0700715 const char *propname, int def)
716{
717 return ofnode_read_s32_default(dev_ofnode(dev), propname, def);
718}
719
Simon Glass88b3a372020-01-27 08:49:40 -0700720static inline int dev_read_u32u(const struct udevice *dev,
Simon Glassa1b17e42018-12-10 10:37:37 -0700721 const char *propname, uint *outp)
722{
723 u32 val;
724 int ret;
725
726 ret = ofnode_read_u32(dev_ofnode(dev), propname, &val);
727 if (ret)
728 return ret;
729 *outp = val;
730
731 return 0;
732}
733
Simon Glass88b3a372020-01-27 08:49:40 -0700734static inline int dev_read_u64(const struct udevice *dev,
T Karthik Reddy3f3d7712019-09-02 16:34:30 +0200735 const char *propname, u64 *outp)
736{
737 return ofnode_read_u64(dev_ofnode(dev), propname, outp);
738}
739
Simon Glass88b3a372020-01-27 08:49:40 -0700740static inline u64 dev_read_u64_default(const struct udevice *dev,
T Karthik Reddy3f3d7712019-09-02 16:34:30 +0200741 const char *propname, u64 def)
742{
743 return ofnode_read_u64_default(dev_ofnode(dev), propname, def);
744}
745
Simon Glass88b3a372020-01-27 08:49:40 -0700746static inline const char *dev_read_string(const struct udevice *dev,
Simon Glass47a0fd32017-05-18 20:09:04 -0600747 const char *propname)
748{
749 return ofnode_read_string(dev_ofnode(dev), propname);
750}
751
Simon Glass88b3a372020-01-27 08:49:40 -0700752static inline bool dev_read_bool(const struct udevice *dev,
753 const char *propname)
Simon Glass47a0fd32017-05-18 20:09:04 -0600754{
755 return ofnode_read_bool(dev_ofnode(dev), propname);
756}
757
Simon Glass88b3a372020-01-27 08:49:40 -0700758static inline ofnode dev_read_subnode(const struct udevice *dev,
Simon Glass47a0fd32017-05-18 20:09:04 -0600759 const char *subbnode_name)
760{
761 return ofnode_find_subnode(dev_ofnode(dev), subbnode_name);
762}
763
Simon Glass88b3a372020-01-27 08:49:40 -0700764static inline int dev_read_size(const struct udevice *dev, const char *propname)
Simon Glass47a0fd32017-05-18 20:09:04 -0600765{
766 return ofnode_read_size(dev_ofnode(dev), propname);
767}
768
Simon Glass88b3a372020-01-27 08:49:40 -0700769static inline fdt_addr_t dev_read_addr_index(const struct udevice *dev,
770 int index)
Simon Glass47a0fd32017-05-18 20:09:04 -0600771{
772 return devfdt_get_addr_index(dev, index);
773}
774
Simon Glass88b3a372020-01-27 08:49:40 -0700775static inline fdt_addr_t dev_read_addr_size_index(const struct udevice *dev,
Sekhar Norif5b90472019-08-01 19:12:56 +0530776 int index,
777 fdt_size_t *size)
778{
779 return devfdt_get_addr_size_index(dev, index, size);
780}
781
Simon Glass88b3a372020-01-27 08:49:40 -0700782static inline fdt_addr_t dev_read_addr_name(const struct udevice *dev,
Álvaro Fernández Rojas79598822018-12-03 19:37:09 +0100783 const char *name)
784{
785 return devfdt_get_addr_name(dev, name);
786}
787
Simon Glass88b3a372020-01-27 08:49:40 -0700788static inline fdt_addr_t dev_read_addr_size_name(const struct udevice *dev,
Sekhar Norif5b90472019-08-01 19:12:56 +0530789 const char *name,
790 fdt_size_t *size)
791{
792 return devfdt_get_addr_size_name(dev, name, size);
793}
794
Simon Glass88b3a372020-01-27 08:49:40 -0700795static inline fdt_addr_t dev_read_addr(const struct udevice *dev)
Simon Glass47a0fd32017-05-18 20:09:04 -0600796{
797 return devfdt_get_addr(dev);
798}
799
Simon Glass88b3a372020-01-27 08:49:40 -0700800static inline void *dev_read_addr_ptr(const struct udevice *dev)
Philipp Tomsichc131c8b2017-09-11 22:04:12 +0200801{
802 return devfdt_get_addr_ptr(dev);
803}
804
Simon Glass88b3a372020-01-27 08:49:40 -0700805static inline fdt_addr_t dev_read_addr_pci(const struct udevice *dev)
Simon Glass33c215a2019-09-15 12:08:58 -0600806{
807 return devfdt_get_addr_pci(dev);
808}
809
Simon Glass88b3a372020-01-27 08:49:40 -0700810static inline void *dev_remap_addr(const struct udevice *dev)
Álvaro Fernández Rojas30a90f52018-04-29 21:56:54 +0200811{
812 return devfdt_remap_addr(dev);
813}
814
Simon Glass88b3a372020-01-27 08:49:40 -0700815static inline void *dev_remap_addr_index(const struct udevice *dev, int index)
Álvaro Fernández Rojas30a90f52018-04-29 21:56:54 +0200816{
817 return devfdt_remap_addr_index(dev, index);
818}
819
Simon Glass88b3a372020-01-27 08:49:40 -0700820static inline void *dev_remap_addr_name(const struct udevice *dev,
821 const char *name)
Álvaro Fernández Rojas79598822018-12-03 19:37:09 +0100822{
823 return devfdt_remap_addr_name(dev, name);
824}
825
Simon Glass88b3a372020-01-27 08:49:40 -0700826static inline fdt_addr_t dev_read_addr_size(const struct udevice *dev,
Simon Glass47a0fd32017-05-18 20:09:04 -0600827 const char *propname,
828 fdt_size_t *sizep)
829{
830 return ofnode_get_addr_size(dev_ofnode(dev), propname, sizep);
831}
832
Simon Glass88b3a372020-01-27 08:49:40 -0700833static inline const char *dev_read_name(const struct udevice *dev)
Simon Glass47a0fd32017-05-18 20:09:04 -0600834{
835 return ofnode_get_name(dev_ofnode(dev));
836}
837
Simon Glass88b3a372020-01-27 08:49:40 -0700838static inline int dev_read_stringlist_search(const struct udevice *dev,
Simon Glass47a0fd32017-05-18 20:09:04 -0600839 const char *propname,
840 const char *string)
841{
842 return ofnode_stringlist_search(dev_ofnode(dev), propname, string);
843}
844
Simon Glass88b3a372020-01-27 08:49:40 -0700845static inline int dev_read_string_index(const struct udevice *dev,
Jean-Jacques Hiblotb5a144a2017-09-21 17:03:09 +0200846 const char *propname, int index,
847 const char **outp)
848{
849 return ofnode_read_string_index(dev_ofnode(dev), propname, index, outp);
850}
851
Simon Glass88b3a372020-01-27 08:49:40 -0700852static inline int dev_read_string_count(const struct udevice *dev,
Jean-Jacques Hiblotb5a144a2017-09-21 17:03:09 +0200853 const char *propname)
854{
855 return ofnode_read_string_count(dev_ofnode(dev), propname);
856}
857
Simon Glass88b3a372020-01-27 08:49:40 -0700858static inline int dev_read_phandle_with_args(const struct udevice *dev,
Simon Glass47a0fd32017-05-18 20:09:04 -0600859 const char *list_name, const char *cells_name, int cell_count,
860 int index, struct ofnode_phandle_args *out_args)
861{
862 return ofnode_parse_phandle_with_args(dev_ofnode(dev), list_name,
863 cells_name, cell_count, index,
864 out_args);
865}
866
Simon Glass88b3a372020-01-27 08:49:40 -0700867static inline int dev_count_phandle_with_args(const struct udevice *dev,
Patrice Chotard642346a2017-07-18 11:57:08 +0200868 const char *list_name, const char *cells_name)
869{
870 return ofnode_count_phandle_with_args(dev_ofnode(dev), list_name,
871 cells_name);
872}
873
Simon Glass88b3a372020-01-27 08:49:40 -0700874static inline int dev_read_addr_cells(const struct udevice *dev)
Simon Glass47a0fd32017-05-18 20:09:04 -0600875{
Simon Glass878d68c2017-06-12 06:21:31 -0600876 /* NOTE: this call should walk up the parent stack */
Simon Glass47a0fd32017-05-18 20:09:04 -0600877 return fdt_address_cells(gd->fdt_blob, dev_of_offset(dev));
878}
879
Simon Glass88b3a372020-01-27 08:49:40 -0700880static inline int dev_read_size_cells(const struct udevice *dev)
Simon Glass47a0fd32017-05-18 20:09:04 -0600881{
Simon Glass878d68c2017-06-12 06:21:31 -0600882 /* NOTE: this call should walk up the parent stack */
883 return fdt_size_cells(gd->fdt_blob, dev_of_offset(dev));
884}
885
Simon Glass88b3a372020-01-27 08:49:40 -0700886static inline int dev_read_simple_addr_cells(const struct udevice *dev)
Simon Glass878d68c2017-06-12 06:21:31 -0600887{
888 return fdt_address_cells(gd->fdt_blob, dev_of_offset(dev));
889}
890
Simon Glass88b3a372020-01-27 08:49:40 -0700891static inline int dev_read_simple_size_cells(const struct udevice *dev)
Simon Glass878d68c2017-06-12 06:21:31 -0600892{
Simon Glass47a0fd32017-05-18 20:09:04 -0600893 return fdt_size_cells(gd->fdt_blob, dev_of_offset(dev));
894}
895
Simon Glass88b3a372020-01-27 08:49:40 -0700896static inline int dev_read_phandle(const struct udevice *dev)
Simon Glass47a0fd32017-05-18 20:09:04 -0600897{
898 return fdt_get_phandle(gd->fdt_blob, dev_of_offset(dev));
899}
900
Simon Glass88b3a372020-01-27 08:49:40 -0700901static inline const void *dev_read_prop(const struct udevice *dev,
Masahiro Yamadafd736212017-07-17 12:18:39 +0900902 const char *propname, int *lenp)
Simon Glass47a0fd32017-05-18 20:09:04 -0600903{
Masahiro Yamada61e51ba2017-06-22 16:54:05 +0900904 return ofnode_get_property(dev_ofnode(dev), propname, lenp);
Simon Glass47a0fd32017-05-18 20:09:04 -0600905}
906
Patrick Delaunayce891fca2020-01-13 11:34:56 +0100907static inline int dev_read_first_prop(const struct udevice *dev, struct ofprop *prop)
908{
909 return ofnode_get_first_property(dev_ofnode(dev), prop);
910}
911
912static inline int dev_read_next_prop(struct ofprop *prop)
913{
914 return ofnode_get_next_property(prop);
915}
916
917static inline const void *dev_read_prop_by_prop(struct ofprop *prop,
918 const char **propname,
919 int *lenp)
920{
921 return ofnode_get_property_by_prop(prop, propname, lenp);
922}
923
Simon Glass88b3a372020-01-27 08:49:40 -0700924static inline int dev_read_alias_seq(const struct udevice *dev, int *devnump)
Simon Glass47a0fd32017-05-18 20:09:04 -0600925{
926 return fdtdec_get_alias_seq(gd->fdt_blob, dev->uclass->uc_drv->name,
927 dev_of_offset(dev), devnump);
928}
929
Simon Glass88b3a372020-01-27 08:49:40 -0700930static inline int dev_read_u32_array(const struct udevice *dev,
931 const char *propname, u32 *out_values,
932 size_t sz)
Simon Glass47a0fd32017-05-18 20:09:04 -0600933{
934 return ofnode_read_u32_array(dev_ofnode(dev), propname, out_values, sz);
935}
936
Simon Glass88b3a372020-01-27 08:49:40 -0700937static inline ofnode dev_read_first_subnode(const struct udevice *dev)
Simon Glass47a0fd32017-05-18 20:09:04 -0600938{
939 return ofnode_first_subnode(dev_ofnode(dev));
940}
941
942static inline ofnode dev_read_next_subnode(ofnode node)
943{
944 return ofnode_next_subnode(node);
945}
946
Simon Glass88b3a372020-01-27 08:49:40 -0700947static inline const uint8_t *dev_read_u8_array_ptr(const struct udevice *dev,
Simon Glassf262d4c2020-01-27 08:49:47 -0700948 const char *propname,
949 size_t sz)
Simon Glassf11c7ab2017-05-18 20:09:03 -0600950{
951 return ofnode_read_u8_array_ptr(dev_ofnode(dev), propname, sz);
952}
953
Simon Glass88b3a372020-01-27 08:49:40 -0700954static inline int dev_read_enabled(const struct udevice *dev)
Simon Glassf7d6fcf2017-06-12 06:21:30 -0600955{
956 return fdtdec_get_is_enabled(gd->fdt_blob, dev_of_offset(dev));
957}
958
Simon Glass88b3a372020-01-27 08:49:40 -0700959static inline int dev_read_resource(const struct udevice *dev, uint index,
Simon Glassdcf98852017-07-25 08:29:55 -0600960 struct resource *res)
961{
962 return ofnode_read_resource(dev_ofnode(dev), index, res);
963}
964
Simon Glass88b3a372020-01-27 08:49:40 -0700965static inline int dev_read_resource_byname(const struct udevice *dev,
Masahiro Yamada7b8b47b2017-08-26 01:12:30 +0900966 const char *name,
967 struct resource *res)
968{
969 return ofnode_read_resource_byname(dev_ofnode(dev), name, res);
970}
971
Simon Glass88b3a372020-01-27 08:49:40 -0700972static inline u64 dev_translate_address(const struct udevice *dev,
973 const fdt32_t *in_addr)
Mario Six147c6072018-01-15 11:07:19 +0100974{
975 return ofnode_translate_address(dev_ofnode(dev), in_addr);
976}
977
Simon Glass88b3a372020-01-27 08:49:40 -0700978static inline u64 dev_translate_dma_address(const struct udevice *dev,
979 const fdt32_t *in_addr)
Fabien Dessenne641067f2019-05-31 15:11:30 +0200980{
981 return ofnode_translate_dma_address(dev_ofnode(dev), in_addr);
982}
983
Michal Simek83e4c7e2019-01-31 16:30:59 +0100984static inline int dev_read_alias_highest_id(const char *stem)
985{
986 return fdtdec_get_alias_highest_id(gd->fdt_blob, stem);
987}
988
Chunfeng Yun89b84b82020-05-02 11:35:09 +0200989static inline int dev_get_child_count(const struct udevice *dev)
990{
991 return ofnode_get_child_count(dev_ofnode(dev));
992}
993
Simon Glassf11c7ab2017-05-18 20:09:03 -0600994#endif /* CONFIG_DM_DEV_READ_INLINE */
995
996/**
997 * dev_for_each_subnode() - Helper function to iterate through subnodes
998 *
999 * This creates a for() loop which works through the subnodes in a device's
1000 * device-tree node.
1001 *
1002 * @subnode: ofnode holding the current subnode
1003 * @dev: device to use for interation (struct udevice *)
1004 */
1005#define dev_for_each_subnode(subnode, dev) \
1006 for (subnode = dev_read_first_subnode(dev); \
1007 ofnode_valid(subnode); \
1008 subnode = ofnode_next_subnode(subnode))
1009
Patrick Delaunayce891fca2020-01-13 11:34:56 +01001010/**
1011 * dev_for_each_property() - Helper function to iterate through property
1012 *
1013 * This creates a for() loop which works through the property in a device's
1014 * device-tree node.
1015 *
1016 * @prop: struct ofprop holding the current property
1017 * @dev: device to use for interation (struct udevice *)
1018 */
1019#define dev_for_each_property(prop, dev) \
1020 for (int ret_prop = dev_read_first_prop(dev, &prop); \
1021 !ret_prop; \
1022 ret_prop = dev_read_next_prop(&prop))
1023
Simon Glassf11c7ab2017-05-18 20:09:03 -06001024#endif