xref: /openbmc/u-boot/include/dm/read.h (revision fabbeb33)
1 /* SPDX-License-Identifier: GPL-2.0+ */
2 /*
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>
7  */
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 
16 struct resource;
17 
18 #if CONFIG_IS_ENABLED(OF_LIVE)
19 static inline const struct device_node *dev_np(struct udevice *dev)
20 {
21 	return ofnode_to_np(dev->node);
22 }
23 #else
24 static inline const struct device_node *dev_np(struct udevice *dev)
25 {
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  */
36 static inline ofnode dev_ofnode(struct udevice *dev)
37 {
38 	return dev->node;
39 }
40 
41 static inline bool dev_of_valid(struct udevice *dev)
42 {
43 	return ofnode_valid(dev_ofnode(dev));
44 }
45 
46 #ifndef CONFIG_DM_DEV_READ_INLINE
47 /**
48  * dev_read_u32() - read a 32-bit integer from a device's DT property
49  *
50  * @dev:	device to read DT property from
51  * @propname:	name of the property to read from
52  * @outp:	place to put value (if found)
53  * @return 0 if OK, -ve on error
54  */
55 int dev_read_u32(struct udevice *dev, const char *propname, u32 *outp);
56 
57 /**
58  * dev_read_u32_default() - read a 32-bit integer from a device's DT property
59  *
60  * @dev:	device to read DT property from
61  * @propname:	name of the property to read from
62  * @def:	default value to return if the property has no value
63  * @return property value, or @def if not found
64  */
65 int dev_read_u32_default(struct udevice *dev, const char *propname, int def);
66 
67 /**
68  * dev_read_s32() - read a signed 32-bit integer from a device's DT property
69  *
70  * @dev:	device to read DT property from
71  * @propname:	name of the property to read from
72  * @outp:	place to put value (if found)
73  * @return 0 if OK, -ve on error
74  */
75 int dev_read_s32(struct udevice *dev, const char *propname, s32 *outp);
76 
77 /**
78  * dev_read_s32_default() - read a signed 32-bit int from a device's DT property
79  *
80  * @dev:	device to read DT property from
81  * @propname:	name of the property to read from
82  * @def:	default value to return if the property has no value
83  * @return property value, or @def if not found
84  */
85 int dev_read_s32_default(struct udevice *dev, const char *propname, int def);
86 
87 /**
88  * dev_read_u32u() - read a 32-bit integer from a device's DT property
89  *
90  * This version uses a standard uint type.
91  *
92  * @dev:	device to read DT property from
93  * @propname:	name of the property to read from
94  * @outp:	place to put value (if found)
95  * @return 0 if OK, -ve on error
96  */
97 int dev_read_u32u(struct udevice *dev, const char *propname, uint *outp);
98 
99 /**
100  * dev_read_string() - Read a string from a device's DT property
101  *
102  * @dev:	device to read DT property from
103  * @propname:	name of the property to read
104  * @return string from property value, or NULL if there is no such property
105  */
106 const char *dev_read_string(struct udevice *dev, const char *propname);
107 
108 /**
109  * dev_read_bool() - read a boolean value from a device's DT property
110  *
111  * @dev:	device to read DT property from
112  * @propname:	name of property to read
113  * @return true if property is present (meaning true), false if not present
114  */
115 bool dev_read_bool(struct udevice *dev, const char *propname);
116 
117 /**
118  * dev_read_subnode() - find a named subnode of a device
119  *
120  * @dev:	device whose DT node contains the subnode
121  * @subnode_name: name of subnode to find
122  * @return reference to subnode (which can be invalid if there is no such
123  * subnode)
124  */
125 ofnode dev_read_subnode(struct udevice *dev, const char *subbnode_name);
126 
127 /**
128  * dev_read_size() - read the size of a property
129  *
130  * @dev: device to check
131  * @propname: property to check
132  * @return size of property if present, or -EINVAL if not
133  */
134 int dev_read_size(struct udevice *dev, const char *propname);
135 
136 /**
137  * dev_read_addr_index() - Get the indexed reg property of a device
138  *
139  * @dev: Device to read from
140  * @index: the 'reg' property can hold a list of <addr, size> pairs
141  *	   and @index is used to select which one is required
142  *
143  * @return address or FDT_ADDR_T_NONE if not found
144  */
145 fdt_addr_t dev_read_addr_index(struct udevice *dev, int index);
146 
147 /**
148  * dev_remap_addr_index() - Get the indexed reg property of a device
149  *                               as a memory-mapped I/O pointer
150  *
151  * @dev: Device to read from
152  * @index: the 'reg' property can hold a list of <addr, size> pairs
153  *	   and @index is used to select which one is required
154  *
155  * @return pointer or NULL if not found
156  */
157 void *dev_remap_addr_index(struct udevice *dev, int index);
158 
159 /**
160  * dev_read_addr_name() - Get the reg property of a device, indexed by name
161  *
162  * @dev: Device to read from
163  * @name: the 'reg' property can hold a list of <addr, size> pairs, with the
164  *	  'reg-names' property providing named-based identification. @index
165  *	  indicates the value to search for in 'reg-names'.
166  *
167  * @return address or FDT_ADDR_T_NONE if not found
168  */
169 fdt_addr_t dev_read_addr_name(struct udevice *dev, const char* name);
170 
171 /**
172  * dev_remap_addr_name() - Get the reg property of a device, indexed by name,
173  *                         as a memory-mapped I/O pointer
174  *
175  * @dev: Device to read from
176  * @name: the 'reg' property can hold a list of <addr, size> pairs, with the
177  *	  'reg-names' property providing named-based identification. @index
178  *	  indicates the value to search for in 'reg-names'.
179  *
180  * @return pointer or NULL if not found
181  */
182 void *dev_remap_addr_name(struct udevice *dev, const char* name);
183 
184 /**
185  * dev_read_addr() - Get the reg property of a device
186  *
187  * @dev: Device to read from
188  *
189  * @return address or FDT_ADDR_T_NONE if not found
190  */
191 fdt_addr_t dev_read_addr(struct udevice *dev);
192 
193 /**
194  * dev_read_addr_ptr() - Get the reg property of a device
195  *                       as a pointer
196  *
197  * @dev: Device to read from
198  *
199  * @return pointer or NULL if not found
200  */
201 void *dev_read_addr_ptr(struct udevice *dev);
202 
203 /**
204  * dev_remap_addr() - Get the reg property of a device as a
205  *                         memory-mapped I/O pointer
206  *
207  * @dev: Device to read from
208  *
209  * @return pointer or NULL if not found
210  */
211 void *dev_remap_addr(struct udevice *dev);
212 
213 /**
214  * dev_read_addr_size() - get address and size from a device property
215  *
216  * This does no address translation. It simply reads an property that contains
217  * an address and a size value, one after the other.
218  *
219  * @dev: Device to read from
220  * @propname: property to read
221  * @sizep: place to put size value (on success)
222  * @return address value, or FDT_ADDR_T_NONE on error
223  */
224 fdt_addr_t dev_read_addr_size(struct udevice *dev, const char *propname,
225 				fdt_size_t *sizep);
226 
227 /**
228  * dev_read_name() - get the name of a device's node
229  *
230  * @node: valid node to look up
231  * @return name of node
232  */
233 const char *dev_read_name(struct udevice *dev);
234 
235 /**
236  * dev_read_stringlist_search() - find string in a string list and return index
237  *
238  * Note that it is possible for this function to succeed on property values
239  * that are not NUL-terminated. That's because the function will stop after
240  * finding the first occurrence of @string. This can for example happen with
241  * small-valued cell properties, such as #address-cells, when searching for
242  * the empty string.
243  *
244  * @dev: device to check
245  * @propname: name of the property containing the string list
246  * @string: string to look up in the string list
247  *
248  * @return:
249  *   the index of the string in the list of strings
250  *   -ENODATA if the property is not found
251  *   -EINVAL on some other error
252  */
253 int dev_read_stringlist_search(struct udevice *dev, const char *property,
254 			  const char *string);
255 
256 /**
257  * dev_read_string_index() - obtain an indexed string from a string list
258  *
259  * @dev: device to examine
260  * @propname: name of the property containing the string list
261  * @index: index of the string to return
262  * @out: return location for the string
263  *
264  * @return:
265  *   length of string, if found or -ve error value if not found
266  */
267 int dev_read_string_index(struct udevice *dev, const char *propname, int index,
268 			  const char **outp);
269 
270 /**
271  * dev_read_string_count() - find the number of strings in a string list
272  *
273  * @dev: device to examine
274  * @propname: name of the property containing the string list
275  * @return:
276  *   number of strings in the list, or -ve error value if not found
277  */
278 int dev_read_string_count(struct udevice *dev, const char *propname);
279 /**
280  * dev_read_phandle_with_args() - Find a node pointed by phandle in a list
281  *
282  * This function is useful to parse lists of phandles and their arguments.
283  * Returns 0 on success and fills out_args, on error returns appropriate
284  * errno value.
285  *
286  * Caller is responsible to call of_node_put() on the returned out_args->np
287  * pointer.
288  *
289  * Example:
290  *
291  * phandle1: node1 {
292  *	#list-cells = <2>;
293  * }
294  *
295  * phandle2: node2 {
296  *	#list-cells = <1>;
297  * }
298  *
299  * node3 {
300  *	list = <&phandle1 1 2 &phandle2 3>;
301  * }
302  *
303  * To get a device_node of the `node2' node you may call this:
304  * dev_read_phandle_with_args(dev, "list", "#list-cells", 0, 1, &args);
305  *
306  * @dev:	device whose node containing a list
307  * @list_name:	property name that contains a list
308  * @cells_name:	property name that specifies phandles' arguments count
309  * @cells_count: Cell count to use if @cells_name is NULL
310  * @index:	index of a phandle to parse out
311  * @out_args:	optional pointer to output arguments structure (will be filled)
312  * @return 0 on success (with @out_args filled out if not NULL), -ENOENT if
313  *	@list_name does not exist, -EINVAL if a phandle was not found,
314  *	@cells_name could not be found, the arguments were truncated or there
315  *	were too many arguments.
316  */
317 int dev_read_phandle_with_args(struct udevice *dev, const char *list_name,
318 				const char *cells_name, int cell_count,
319 				int index,
320 				struct ofnode_phandle_args *out_args);
321 
322 /**
323  * dev_count_phandle_with_args() - Return phandle number in a list
324  *
325  * This function is usefull to get phandle number contained in a property list.
326  * For example, this allows to allocate the right amount of memory to keep
327  * clock's reference contained into the "clocks" property.
328  *
329  *
330  * @dev:	device whose node containing a list
331  * @list_name:	property name that contains a list
332  * @cells_name:	property name that specifies phandles' arguments count
333  * @Returns number of phandle found on success, on error returns appropriate
334  * errno value.
335  */
336 
337 int dev_count_phandle_with_args(struct udevice *dev, const char *list_name,
338 				const char *cells_name);
339 
340 /**
341  * dev_read_addr_cells() - Get the number of address cells for a device's node
342  *
343  * This walks back up the tree to find the closest #address-cells property
344  * which controls the given node.
345  *
346  * @dev: device to check
347  * @return number of address cells this node uses
348  */
349 int dev_read_addr_cells(struct udevice *dev);
350 
351 /**
352  * dev_read_size_cells() - Get the number of size cells for a device's node
353  *
354  * This walks back up the tree to find the closest #size-cells property
355  * which controls the given node.
356  *
357  * @dev: device to check
358  * @return number of size cells this node uses
359  */
360 int dev_read_size_cells(struct udevice *dev);
361 
362 /**
363  * dev_read_addr_cells() - Get the address cells property in a node
364  *
365  * This function matches fdt_address_cells().
366  *
367  * @dev: device to check
368  * @return number of address cells this node uses
369  */
370 int dev_read_simple_addr_cells(struct udevice *dev);
371 
372 /**
373  * dev_read_size_cells() - Get the size cells property in a node
374  *
375  * This function matches fdt_size_cells().
376  *
377  * @dev: device to check
378  * @return number of size cells this node uses
379  */
380 int dev_read_simple_size_cells(struct udevice *dev);
381 
382 /**
383  * dev_read_phandle() - Get the phandle from a device
384  *
385  * @dev: device to check
386  * @return phandle (1 or greater), or 0 if no phandle or other error
387  */
388 int dev_read_phandle(struct udevice *dev);
389 
390 /**
391  * dev_read_prop()- - read a property from a device's node
392  *
393  * @dev: device to check
394  * @propname: property to read
395  * @lenp: place to put length on success
396  * @return pointer to property, or NULL if not found
397  */
398 const void *dev_read_prop(struct udevice *dev, const char *propname, int *lenp);
399 
400 /**
401  * dev_read_alias_seq() - Get the alias sequence number of a node
402  *
403  * This works out whether a node is pointed to by an alias, and if so, the
404  * sequence number of that alias. Aliases are of the form <base><num> where
405  * <num> is the sequence number. For example spi2 would be sequence number 2.
406  *
407  * @dev: device to look up
408  * @devnump: set to the sequence number if one is found
409  * @return 0 if a sequence was found, -ve if not
410  */
411 int dev_read_alias_seq(struct udevice *dev, int *devnump);
412 
413 /**
414  * dev_read_u32_array() - Find and read an array of 32 bit integers
415  *
416  * Search for a property in a device node and read 32-bit value(s) from
417  * it.
418  *
419  * The out_values is modified only if a valid u32 value can be decoded.
420  *
421  * @dev: device to look up
422  * @propname:	name of the property to read
423  * @out_values:	pointer to return value, modified only if return value is 0
424  * @sz:		number of array elements to read
425  * @return 0 on success, -EINVAL if the property does not exist, -ENODATA if
426  * property does not have a value, and -EOVERFLOW if the property data isn't
427  * large enough.
428  */
429 int dev_read_u32_array(struct udevice *dev, const char *propname,
430 		       u32 *out_values, size_t sz);
431 
432 /**
433  * dev_read_first_subnode() - find the first subnode of a device's node
434  *
435  * @dev: device to look up
436  * @return reference to the first subnode (which can be invalid if the device's
437  * node has no subnodes)
438  */
439 ofnode dev_read_first_subnode(struct udevice *dev);
440 
441 /**
442  * ofnode_next_subnode() - find the next sibling of a subnode
443  *
444  * @node:	valid reference to previous node (sibling)
445  * @return reference to the next subnode (which can be invalid if the node
446  * has no more siblings)
447  */
448 ofnode dev_read_next_subnode(ofnode node);
449 
450 /**
451  * dev_read_u8_array_ptr() - find an 8-bit array
452  *
453  * Look up a device's node property and return a pointer to its contents as a
454  * byte array of given length. The property must have at least enough data
455  * for the array (count bytes). It may have more, but this will be ignored.
456  * The data is not copied.
457  *
458  * @dev: device to look up
459  * @propname: name of property to find
460  * @sz: number of array elements
461  * @return pointer to byte array if found, or NULL if the property is not
462  *		found or there is not enough data
463  */
464 const uint8_t *dev_read_u8_array_ptr(struct udevice *dev, const char *propname,
465 				     size_t sz);
466 
467 /**
468  * dev_read_enabled() - check whether a node is enabled
469  *
470  * This looks for a 'status' property. If this exists, then returns 1 if
471  * the status is 'ok' and 0 otherwise. If there is no status property,
472  * it returns 1 on the assumption that anything mentioned should be enabled
473  * by default.
474  *
475  * @dev: device to examine
476  * @return integer value 0 (not enabled) or 1 (enabled)
477  */
478 int dev_read_enabled(struct udevice *dev);
479 
480 /**
481  * dev_read_resource() - obtain an indexed resource from a device.
482  *
483  * @dev: device to examine
484  * @index index of the resource to retrieve (0 = first)
485  * @res returns the resource
486  * @return 0 if ok, negative on error
487  */
488 int dev_read_resource(struct udevice *dev, uint index, struct resource *res);
489 
490 /**
491  * dev_read_resource_byname() - obtain a named resource from a device.
492  *
493  * @dev: device to examine
494  * @name: name of the resource to retrieve
495  * @res: returns the resource
496  * @return 0 if ok, negative on error
497  */
498 int dev_read_resource_byname(struct udevice *dev, const char *name,
499 			     struct resource *res);
500 
501 /**
502  * dev_translate_address() - Tranlate a device-tree address
503  *
504  * Translate an address from the device-tree into a CPU physical address.  This
505  * function walks up the tree and applies the various bus mappings along the
506  * way.
507  *
508  * @dev: device giving the context in which to translate the address
509  * @in_addr: pointer to the address to translate
510  * @return the translated address; OF_BAD_ADDR on error
511  */
512 u64 dev_translate_address(struct udevice *dev, const fdt32_t *in_addr);
513 
514 /**
515  * dev_read_alias_highest_id - Get highest alias id for the given stem
516  * @stem:	Alias stem to be examined
517  *
518  * The function travels the lookup table to get the highest alias id for the
519  * given alias stem.
520  * @return alias ID, if found, else -1
521  */
522 int dev_read_alias_highest_id(const char *stem);
523 
524 #else /* CONFIG_DM_DEV_READ_INLINE is enabled */
525 
526 static inline int dev_read_u32(struct udevice *dev,
527 			       const char *propname, u32 *outp)
528 {
529 	return ofnode_read_u32(dev_ofnode(dev), propname, outp);
530 }
531 
532 static inline int dev_read_u32_default(struct udevice *dev,
533 				       const char *propname, int def)
534 {
535 	return ofnode_read_u32_default(dev_ofnode(dev), propname, def);
536 }
537 
538 static inline int dev_read_s32(struct udevice *dev,
539 			       const char *propname, s32 *outp)
540 {
541 	return ofnode_read_s32(dev_ofnode(dev), propname, outp);
542 }
543 
544 static inline int dev_read_s32_default(struct udevice *dev,
545 				       const char *propname, int def)
546 {
547 	return ofnode_read_s32_default(dev_ofnode(dev), propname, def);
548 }
549 
550 static inline int dev_read_u32u(struct udevice *dev,
551 				const char *propname, uint *outp)
552 {
553 	u32 val;
554 	int ret;
555 
556 	ret = ofnode_read_u32(dev_ofnode(dev), propname, &val);
557 	if (ret)
558 		return ret;
559 	*outp = val;
560 
561 	return 0;
562 }
563 
564 static inline const char *dev_read_string(struct udevice *dev,
565 					  const char *propname)
566 {
567 	return ofnode_read_string(dev_ofnode(dev), propname);
568 }
569 
570 static inline bool dev_read_bool(struct udevice *dev, const char *propname)
571 {
572 	return ofnode_read_bool(dev_ofnode(dev), propname);
573 }
574 
575 static inline ofnode dev_read_subnode(struct udevice *dev,
576 				      const char *subbnode_name)
577 {
578 	return ofnode_find_subnode(dev_ofnode(dev), subbnode_name);
579 }
580 
581 static inline int dev_read_size(struct udevice *dev, const char *propname)
582 {
583 	return ofnode_read_size(dev_ofnode(dev), propname);
584 }
585 
586 static inline fdt_addr_t dev_read_addr_index(struct udevice *dev, int index)
587 {
588 	return devfdt_get_addr_index(dev, index);
589 }
590 
591 static inline fdt_addr_t dev_read_addr_name(struct udevice *dev,
592 					    const char *name)
593 {
594 	return devfdt_get_addr_name(dev, name);
595 }
596 
597 static inline fdt_addr_t dev_read_addr(struct udevice *dev)
598 {
599 	return devfdt_get_addr(dev);
600 }
601 
602 static inline void *dev_read_addr_ptr(struct udevice *dev)
603 {
604 	return devfdt_get_addr_ptr(dev);
605 }
606 
607 static inline void *dev_remap_addr(struct udevice *dev)
608 {
609 	return devfdt_remap_addr(dev);
610 }
611 
612 static inline void *dev_remap_addr_index(struct udevice *dev, int index)
613 {
614 	return devfdt_remap_addr_index(dev, index);
615 }
616 
617 static inline void *dev_remap_addr_name(struct udevice *dev, const char *name)
618 {
619 	return devfdt_remap_addr_name(dev, name);
620 }
621 
622 static inline fdt_addr_t dev_read_addr_size(struct udevice *dev,
623 					    const char *propname,
624 					    fdt_size_t *sizep)
625 {
626 	return ofnode_get_addr_size(dev_ofnode(dev), propname, sizep);
627 }
628 
629 static inline const char *dev_read_name(struct udevice *dev)
630 {
631 	return ofnode_get_name(dev_ofnode(dev));
632 }
633 
634 static inline int dev_read_stringlist_search(struct udevice *dev,
635 					     const char *propname,
636 					     const char *string)
637 {
638 	return ofnode_stringlist_search(dev_ofnode(dev), propname, string);
639 }
640 
641 static inline int dev_read_string_index(struct udevice *dev,
642 					const char *propname, int index,
643 					const char **outp)
644 {
645 	return ofnode_read_string_index(dev_ofnode(dev), propname, index, outp);
646 }
647 
648 static inline int dev_read_string_count(struct udevice *dev,
649 					const char *propname)
650 {
651 	return ofnode_read_string_count(dev_ofnode(dev), propname);
652 }
653 
654 static inline int dev_read_phandle_with_args(struct udevice *dev,
655 		const char *list_name, const char *cells_name, int cell_count,
656 		int index, struct ofnode_phandle_args *out_args)
657 {
658 	return ofnode_parse_phandle_with_args(dev_ofnode(dev), list_name,
659 					      cells_name, cell_count, index,
660 					      out_args);
661 }
662 
663 static inline int dev_count_phandle_with_args(struct udevice *dev,
664 		const char *list_name, const char *cells_name)
665 {
666 	return ofnode_count_phandle_with_args(dev_ofnode(dev), list_name,
667 					      cells_name);
668 }
669 
670 static inline int dev_read_addr_cells(struct udevice *dev)
671 {
672 	/* NOTE: this call should walk up the parent stack */
673 	return fdt_address_cells(gd->fdt_blob, dev_of_offset(dev));
674 }
675 
676 static inline int dev_read_size_cells(struct udevice *dev)
677 {
678 	/* NOTE: this call should walk up the parent stack */
679 	return fdt_size_cells(gd->fdt_blob, dev_of_offset(dev));
680 }
681 
682 static inline int dev_read_simple_addr_cells(struct udevice *dev)
683 {
684 	return fdt_address_cells(gd->fdt_blob, dev_of_offset(dev));
685 }
686 
687 static inline int dev_read_simple_size_cells(struct udevice *dev)
688 {
689 	return fdt_size_cells(gd->fdt_blob, dev_of_offset(dev));
690 }
691 
692 static inline int dev_read_phandle(struct udevice *dev)
693 {
694 	return fdt_get_phandle(gd->fdt_blob, dev_of_offset(dev));
695 }
696 
697 static inline const void *dev_read_prop(struct udevice *dev,
698 					const char *propname, int *lenp)
699 {
700 	return ofnode_get_property(dev_ofnode(dev), propname, lenp);
701 }
702 
703 static inline int dev_read_alias_seq(struct udevice *dev, int *devnump)
704 {
705 	return fdtdec_get_alias_seq(gd->fdt_blob, dev->uclass->uc_drv->name,
706 				    dev_of_offset(dev), devnump);
707 }
708 
709 static inline int dev_read_u32_array(struct udevice *dev, const char *propname,
710 				     u32 *out_values, size_t sz)
711 {
712 	return ofnode_read_u32_array(dev_ofnode(dev), propname, out_values, sz);
713 }
714 
715 static inline ofnode dev_read_first_subnode(struct udevice *dev)
716 {
717 	return ofnode_first_subnode(dev_ofnode(dev));
718 }
719 
720 static inline ofnode dev_read_next_subnode(ofnode node)
721 {
722 	return ofnode_next_subnode(node);
723 }
724 
725 static inline const uint8_t *dev_read_u8_array_ptr(struct udevice *dev,
726 					const char *propname, size_t sz)
727 {
728 	return ofnode_read_u8_array_ptr(dev_ofnode(dev), propname, sz);
729 }
730 
731 static inline int dev_read_enabled(struct udevice *dev)
732 {
733 	return fdtdec_get_is_enabled(gd->fdt_blob, dev_of_offset(dev));
734 }
735 
736 static inline int dev_read_resource(struct udevice *dev, uint index,
737 				    struct resource *res)
738 {
739 	return ofnode_read_resource(dev_ofnode(dev), index, res);
740 }
741 
742 static inline int dev_read_resource_byname(struct udevice *dev,
743 					   const char *name,
744 					   struct resource *res)
745 {
746 	return ofnode_read_resource_byname(dev_ofnode(dev), name, res);
747 }
748 
749 static inline u64 dev_translate_address(struct udevice *dev, const fdt32_t *in_addr)
750 {
751 	return ofnode_translate_address(dev_ofnode(dev), in_addr);
752 }
753 
754 static inline int dev_read_alias_highest_id(const char *stem)
755 {
756 	return fdtdec_get_alias_highest_id(gd->fdt_blob, stem);
757 }
758 
759 #endif /* CONFIG_DM_DEV_READ_INLINE */
760 
761 /**
762  * dev_for_each_subnode() - Helper function to iterate through subnodes
763  *
764  * This creates a for() loop which works through the subnodes in a device's
765  * device-tree node.
766  *
767  * @subnode: ofnode holding the current subnode
768  * @dev: device to use for interation (struct udevice *)
769  */
770 #define dev_for_each_subnode(subnode, dev) \
771 	for (subnode = dev_read_first_subnode(dev); \
772 	     ofnode_valid(subnode); \
773 	     subnode = ofnode_next_subnode(subnode))
774 
775 #endif
776