Merge tag 'iommu-fixes-v6.1-rc7' of git://git.kernel.org/pub/scm/linux/kernel/git...
[platform/kernel/linux-starfive.git] / drivers / of / property.c
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * drivers/of/property.c - Procedures for accessing and interpreting
4  *                         Devicetree properties and graphs.
5  *
6  * Initially created by copying procedures from drivers/of/base.c. This
7  * file contains the OF property as well as the OF graph interface
8  * functions.
9  *
10  * Paul Mackerras       August 1996.
11  * Copyright (C) 1996-2005 Paul Mackerras.
12  *
13  *  Adapted for 64bit PowerPC by Dave Engebretsen and Peter Bergner.
14  *    {engebret|bergner}@us.ibm.com
15  *
16  *  Adapted for sparc and sparc64 by David S. Miller davem@davemloft.net
17  *
18  *  Reconsolidated from arch/x/kernel/prom.c by Stephen Rothwell and
19  *  Grant Likely.
20  */
21
22 #define pr_fmt(fmt)     "OF: " fmt
23
24 #include <linux/of.h>
25 #include <linux/of_address.h>
26 #include <linux/of_device.h>
27 #include <linux/of_graph.h>
28 #include <linux/of_irq.h>
29 #include <linux/string.h>
30 #include <linux/moduleparam.h>
31
32 #include "of_private.h"
33
34 /**
35  * of_graph_is_present() - check graph's presence
36  * @node: pointer to device_node containing graph port
37  *
38  * Return: True if @node has a port or ports (with a port) sub-node,
39  * false otherwise.
40  */
41 bool of_graph_is_present(const struct device_node *node)
42 {
43         struct device_node *ports, *port;
44
45         ports = of_get_child_by_name(node, "ports");
46         if (ports)
47                 node = ports;
48
49         port = of_get_child_by_name(node, "port");
50         of_node_put(ports);
51         of_node_put(port);
52
53         return !!port;
54 }
55 EXPORT_SYMBOL(of_graph_is_present);
56
57 /**
58  * of_property_count_elems_of_size - Count the number of elements in a property
59  *
60  * @np:         device node from which the property value is to be read.
61  * @propname:   name of the property to be searched.
62  * @elem_size:  size of the individual element
63  *
64  * Search for a property in a device node and count the number of elements of
65  * size elem_size in it.
66  *
67  * Return: The number of elements on sucess, -EINVAL if the property does not
68  * exist or its length does not match a multiple of elem_size and -ENODATA if
69  * the property does not have a value.
70  */
71 int of_property_count_elems_of_size(const struct device_node *np,
72                                 const char *propname, int elem_size)
73 {
74         struct property *prop = of_find_property(np, propname, NULL);
75
76         if (!prop)
77                 return -EINVAL;
78         if (!prop->value)
79                 return -ENODATA;
80
81         if (prop->length % elem_size != 0) {
82                 pr_err("size of %s in node %pOF is not a multiple of %d\n",
83                        propname, np, elem_size);
84                 return -EINVAL;
85         }
86
87         return prop->length / elem_size;
88 }
89 EXPORT_SYMBOL_GPL(of_property_count_elems_of_size);
90
91 /**
92  * of_find_property_value_of_size
93  *
94  * @np:         device node from which the property value is to be read.
95  * @propname:   name of the property to be searched.
96  * @min:        minimum allowed length of property value
97  * @max:        maximum allowed length of property value (0 means unlimited)
98  * @len:        if !=NULL, actual length is written to here
99  *
100  * Search for a property in a device node and valid the requested size.
101  *
102  * Return: The property value on success, -EINVAL if the property does not
103  * exist, -ENODATA if property does not have a value, and -EOVERFLOW if the
104  * property data is too small or too large.
105  *
106  */
107 static void *of_find_property_value_of_size(const struct device_node *np,
108                         const char *propname, u32 min, u32 max, size_t *len)
109 {
110         struct property *prop = of_find_property(np, propname, NULL);
111
112         if (!prop)
113                 return ERR_PTR(-EINVAL);
114         if (!prop->value)
115                 return ERR_PTR(-ENODATA);
116         if (prop->length < min)
117                 return ERR_PTR(-EOVERFLOW);
118         if (max && prop->length > max)
119                 return ERR_PTR(-EOVERFLOW);
120
121         if (len)
122                 *len = prop->length;
123
124         return prop->value;
125 }
126
127 /**
128  * of_property_read_u32_index - Find and read a u32 from a multi-value property.
129  *
130  * @np:         device node from which the property value is to be read.
131  * @propname:   name of the property to be searched.
132  * @index:      index of the u32 in the list of values
133  * @out_value:  pointer to return value, modified only if no error.
134  *
135  * Search for a property in a device node and read nth 32-bit value from
136  * it.
137  *
138  * Return: 0 on success, -EINVAL if the property does not exist,
139  * -ENODATA if property does not have a value, and -EOVERFLOW if the
140  * property data isn't large enough.
141  *
142  * The out_value is modified only if a valid u32 value can be decoded.
143  */
144 int of_property_read_u32_index(const struct device_node *np,
145                                        const char *propname,
146                                        u32 index, u32 *out_value)
147 {
148         const u32 *val = of_find_property_value_of_size(np, propname,
149                                         ((index + 1) * sizeof(*out_value)),
150                                         0,
151                                         NULL);
152
153         if (IS_ERR(val))
154                 return PTR_ERR(val);
155
156         *out_value = be32_to_cpup(((__be32 *)val) + index);
157         return 0;
158 }
159 EXPORT_SYMBOL_GPL(of_property_read_u32_index);
160
161 /**
162  * of_property_read_u64_index - Find and read a u64 from a multi-value property.
163  *
164  * @np:         device node from which the property value is to be read.
165  * @propname:   name of the property to be searched.
166  * @index:      index of the u64 in the list of values
167  * @out_value:  pointer to return value, modified only if no error.
168  *
169  * Search for a property in a device node and read nth 64-bit value from
170  * it.
171  *
172  * Return: 0 on success, -EINVAL if the property does not exist,
173  * -ENODATA if property does not have a value, and -EOVERFLOW if the
174  * property data isn't large enough.
175  *
176  * The out_value is modified only if a valid u64 value can be decoded.
177  */
178 int of_property_read_u64_index(const struct device_node *np,
179                                        const char *propname,
180                                        u32 index, u64 *out_value)
181 {
182         const u64 *val = of_find_property_value_of_size(np, propname,
183                                         ((index + 1) * sizeof(*out_value)),
184                                         0, NULL);
185
186         if (IS_ERR(val))
187                 return PTR_ERR(val);
188
189         *out_value = be64_to_cpup(((__be64 *)val) + index);
190         return 0;
191 }
192 EXPORT_SYMBOL_GPL(of_property_read_u64_index);
193
194 /**
195  * of_property_read_variable_u8_array - Find and read an array of u8 from a
196  * property, with bounds on the minimum and maximum array size.
197  *
198  * @np:         device node from which the property value is to be read.
199  * @propname:   name of the property to be searched.
200  * @out_values: pointer to found values.
201  * @sz_min:     minimum number of array elements to read
202  * @sz_max:     maximum number of array elements to read, if zero there is no
203  *              upper limit on the number of elements in the dts entry but only
204  *              sz_min will be read.
205  *
206  * Search for a property in a device node and read 8-bit value(s) from
207  * it.
208  *
209  * dts entry of array should be like:
210  *  ``property = /bits/ 8 <0x50 0x60 0x70>;``
211  *
212  * Return: The number of elements read on success, -EINVAL if the property
213  * does not exist, -ENODATA if property does not have a value, and -EOVERFLOW
214  * if the property data is smaller than sz_min or longer than sz_max.
215  *
216  * The out_values is modified only if a valid u8 value can be decoded.
217  */
218 int of_property_read_variable_u8_array(const struct device_node *np,
219                                         const char *propname, u8 *out_values,
220                                         size_t sz_min, size_t sz_max)
221 {
222         size_t sz, count;
223         const u8 *val = of_find_property_value_of_size(np, propname,
224                                                 (sz_min * sizeof(*out_values)),
225                                                 (sz_max * sizeof(*out_values)),
226                                                 &sz);
227
228         if (IS_ERR(val))
229                 return PTR_ERR(val);
230
231         if (!sz_max)
232                 sz = sz_min;
233         else
234                 sz /= sizeof(*out_values);
235
236         count = sz;
237         while (count--)
238                 *out_values++ = *val++;
239
240         return sz;
241 }
242 EXPORT_SYMBOL_GPL(of_property_read_variable_u8_array);
243
244 /**
245  * of_property_read_variable_u16_array - Find and read an array of u16 from a
246  * property, with bounds on the minimum and maximum array size.
247  *
248  * @np:         device node from which the property value is to be read.
249  * @propname:   name of the property to be searched.
250  * @out_values: pointer to found values.
251  * @sz_min:     minimum number of array elements to read
252  * @sz_max:     maximum number of array elements to read, if zero there is no
253  *              upper limit on the number of elements in the dts entry but only
254  *              sz_min will be read.
255  *
256  * Search for a property in a device node and read 16-bit value(s) from
257  * it.
258  *
259  * dts entry of array should be like:
260  *  ``property = /bits/ 16 <0x5000 0x6000 0x7000>;``
261  *
262  * Return: The number of elements read on success, -EINVAL if the property
263  * does not exist, -ENODATA if property does not have a value, and -EOVERFLOW
264  * if the property data is smaller than sz_min or longer than sz_max.
265  *
266  * The out_values is modified only if a valid u16 value can be decoded.
267  */
268 int of_property_read_variable_u16_array(const struct device_node *np,
269                                         const char *propname, u16 *out_values,
270                                         size_t sz_min, size_t sz_max)
271 {
272         size_t sz, count;
273         const __be16 *val = of_find_property_value_of_size(np, propname,
274                                                 (sz_min * sizeof(*out_values)),
275                                                 (sz_max * sizeof(*out_values)),
276                                                 &sz);
277
278         if (IS_ERR(val))
279                 return PTR_ERR(val);
280
281         if (!sz_max)
282                 sz = sz_min;
283         else
284                 sz /= sizeof(*out_values);
285
286         count = sz;
287         while (count--)
288                 *out_values++ = be16_to_cpup(val++);
289
290         return sz;
291 }
292 EXPORT_SYMBOL_GPL(of_property_read_variable_u16_array);
293
294 /**
295  * of_property_read_variable_u32_array - Find and read an array of 32 bit
296  * integers from a property, with bounds on the minimum and maximum array size.
297  *
298  * @np:         device node from which the property value is to be read.
299  * @propname:   name of the property to be searched.
300  * @out_values: pointer to return found values.
301  * @sz_min:     minimum number of array elements to read
302  * @sz_max:     maximum number of array elements to read, if zero there is no
303  *              upper limit on the number of elements in the dts entry but only
304  *              sz_min will be read.
305  *
306  * Search for a property in a device node and read 32-bit value(s) from
307  * it.
308  *
309  * Return: The number of elements read on success, -EINVAL if the property
310  * does not exist, -ENODATA if property does not have a value, and -EOVERFLOW
311  * if the property data is smaller than sz_min or longer than sz_max.
312  *
313  * The out_values is modified only if a valid u32 value can be decoded.
314  */
315 int of_property_read_variable_u32_array(const struct device_node *np,
316                                const char *propname, u32 *out_values,
317                                size_t sz_min, size_t sz_max)
318 {
319         size_t sz, count;
320         const __be32 *val = of_find_property_value_of_size(np, propname,
321                                                 (sz_min * sizeof(*out_values)),
322                                                 (sz_max * sizeof(*out_values)),
323                                                 &sz);
324
325         if (IS_ERR(val))
326                 return PTR_ERR(val);
327
328         if (!sz_max)
329                 sz = sz_min;
330         else
331                 sz /= sizeof(*out_values);
332
333         count = sz;
334         while (count--)
335                 *out_values++ = be32_to_cpup(val++);
336
337         return sz;
338 }
339 EXPORT_SYMBOL_GPL(of_property_read_variable_u32_array);
340
341 /**
342  * of_property_read_u64 - Find and read a 64 bit integer from a property
343  * @np:         device node from which the property value is to be read.
344  * @propname:   name of the property to be searched.
345  * @out_value:  pointer to return value, modified only if return value is 0.
346  *
347  * Search for a property in a device node and read a 64-bit value from
348  * it.
349  *
350  * Return: 0 on success, -EINVAL if the property does not exist,
351  * -ENODATA if property does not have a value, and -EOVERFLOW if the
352  * property data isn't large enough.
353  *
354  * The out_value is modified only if a valid u64 value can be decoded.
355  */
356 int of_property_read_u64(const struct device_node *np, const char *propname,
357                          u64 *out_value)
358 {
359         const __be32 *val = of_find_property_value_of_size(np, propname,
360                                                 sizeof(*out_value),
361                                                 0,
362                                                 NULL);
363
364         if (IS_ERR(val))
365                 return PTR_ERR(val);
366
367         *out_value = of_read_number(val, 2);
368         return 0;
369 }
370 EXPORT_SYMBOL_GPL(of_property_read_u64);
371
372 /**
373  * of_property_read_variable_u64_array - Find and read an array of 64 bit
374  * integers from a property, with bounds on the minimum and maximum array size.
375  *
376  * @np:         device node from which the property value is to be read.
377  * @propname:   name of the property to be searched.
378  * @out_values: pointer to found values.
379  * @sz_min:     minimum number of array elements to read
380  * @sz_max:     maximum number of array elements to read, if zero there is no
381  *              upper limit on the number of elements in the dts entry but only
382  *              sz_min will be read.
383  *
384  * Search for a property in a device node and read 64-bit value(s) from
385  * it.
386  *
387  * Return: The number of elements read on success, -EINVAL if the property
388  * does not exist, -ENODATA if property does not have a value, and -EOVERFLOW
389  * if the property data is smaller than sz_min or longer than sz_max.
390  *
391  * The out_values is modified only if a valid u64 value can be decoded.
392  */
393 int of_property_read_variable_u64_array(const struct device_node *np,
394                                const char *propname, u64 *out_values,
395                                size_t sz_min, size_t sz_max)
396 {
397         size_t sz, count;
398         const __be32 *val = of_find_property_value_of_size(np, propname,
399                                                 (sz_min * sizeof(*out_values)),
400                                                 (sz_max * sizeof(*out_values)),
401                                                 &sz);
402
403         if (IS_ERR(val))
404                 return PTR_ERR(val);
405
406         if (!sz_max)
407                 sz = sz_min;
408         else
409                 sz /= sizeof(*out_values);
410
411         count = sz;
412         while (count--) {
413                 *out_values++ = of_read_number(val, 2);
414                 val += 2;
415         }
416
417         return sz;
418 }
419 EXPORT_SYMBOL_GPL(of_property_read_variable_u64_array);
420
421 /**
422  * of_property_read_string - Find and read a string from a property
423  * @np:         device node from which the property value is to be read.
424  * @propname:   name of the property to be searched.
425  * @out_string: pointer to null terminated return string, modified only if
426  *              return value is 0.
427  *
428  * Search for a property in a device tree node and retrieve a null
429  * terminated string value (pointer to data, not a copy).
430  *
431  * Return: 0 on success, -EINVAL if the property does not exist, -ENODATA if
432  * property does not have a value, and -EILSEQ if the string is not
433  * null-terminated within the length of the property data.
434  *
435  * Note that the empty string "" has length of 1, thus -ENODATA cannot
436  * be interpreted as an empty string.
437  *
438  * The out_string pointer is modified only if a valid string can be decoded.
439  */
440 int of_property_read_string(const struct device_node *np, const char *propname,
441                                 const char **out_string)
442 {
443         const struct property *prop = of_find_property(np, propname, NULL);
444         if (!prop)
445                 return -EINVAL;
446         if (!prop->length)
447                 return -ENODATA;
448         if (strnlen(prop->value, prop->length) >= prop->length)
449                 return -EILSEQ;
450         *out_string = prop->value;
451         return 0;
452 }
453 EXPORT_SYMBOL_GPL(of_property_read_string);
454
455 /**
456  * of_property_match_string() - Find string in a list and return index
457  * @np: pointer to node containing string list property
458  * @propname: string list property name
459  * @string: pointer to string to search for in string list
460  *
461  * This function searches a string list property and returns the index
462  * of a specific string value.
463  */
464 int of_property_match_string(const struct device_node *np, const char *propname,
465                              const char *string)
466 {
467         const struct property *prop = of_find_property(np, propname, NULL);
468         size_t l;
469         int i;
470         const char *p, *end;
471
472         if (!prop)
473                 return -EINVAL;
474         if (!prop->value)
475                 return -ENODATA;
476
477         p = prop->value;
478         end = p + prop->length;
479
480         for (i = 0; p < end; i++, p += l) {
481                 l = strnlen(p, end - p) + 1;
482                 if (p + l > end)
483                         return -EILSEQ;
484                 pr_debug("comparing %s with %s\n", string, p);
485                 if (strcmp(string, p) == 0)
486                         return i; /* Found it; return index */
487         }
488         return -ENODATA;
489 }
490 EXPORT_SYMBOL_GPL(of_property_match_string);
491
492 /**
493  * of_property_read_string_helper() - Utility helper for parsing string properties
494  * @np:         device node from which the property value is to be read.
495  * @propname:   name of the property to be searched.
496  * @out_strs:   output array of string pointers.
497  * @sz:         number of array elements to read.
498  * @skip:       Number of strings to skip over at beginning of list.
499  *
500  * Don't call this function directly. It is a utility helper for the
501  * of_property_read_string*() family of functions.
502  */
503 int of_property_read_string_helper(const struct device_node *np,
504                                    const char *propname, const char **out_strs,
505                                    size_t sz, int skip)
506 {
507         const struct property *prop = of_find_property(np, propname, NULL);
508         int l = 0, i = 0;
509         const char *p, *end;
510
511         if (!prop)
512                 return -EINVAL;
513         if (!prop->value)
514                 return -ENODATA;
515         p = prop->value;
516         end = p + prop->length;
517
518         for (i = 0; p < end && (!out_strs || i < skip + sz); i++, p += l) {
519                 l = strnlen(p, end - p) + 1;
520                 if (p + l > end)
521                         return -EILSEQ;
522                 if (out_strs && i >= skip)
523                         *out_strs++ = p;
524         }
525         i -= skip;
526         return i <= 0 ? -ENODATA : i;
527 }
528 EXPORT_SYMBOL_GPL(of_property_read_string_helper);
529
530 const __be32 *of_prop_next_u32(struct property *prop, const __be32 *cur,
531                                u32 *pu)
532 {
533         const void *curv = cur;
534
535         if (!prop)
536                 return NULL;
537
538         if (!cur) {
539                 curv = prop->value;
540                 goto out_val;
541         }
542
543         curv += sizeof(*cur);
544         if (curv >= prop->value + prop->length)
545                 return NULL;
546
547 out_val:
548         *pu = be32_to_cpup(curv);
549         return curv;
550 }
551 EXPORT_SYMBOL_GPL(of_prop_next_u32);
552
553 const char *of_prop_next_string(struct property *prop, const char *cur)
554 {
555         const void *curv = cur;
556
557         if (!prop)
558                 return NULL;
559
560         if (!cur)
561                 return prop->value;
562
563         curv += strlen(cur) + 1;
564         if (curv >= prop->value + prop->length)
565                 return NULL;
566
567         return curv;
568 }
569 EXPORT_SYMBOL_GPL(of_prop_next_string);
570
571 /**
572  * of_graph_parse_endpoint() - parse common endpoint node properties
573  * @node: pointer to endpoint device_node
574  * @endpoint: pointer to the OF endpoint data structure
575  *
576  * The caller should hold a reference to @node.
577  */
578 int of_graph_parse_endpoint(const struct device_node *node,
579                             struct of_endpoint *endpoint)
580 {
581         struct device_node *port_node = of_get_parent(node);
582
583         WARN_ONCE(!port_node, "%s(): endpoint %pOF has no parent node\n",
584                   __func__, node);
585
586         memset(endpoint, 0, sizeof(*endpoint));
587
588         endpoint->local_node = node;
589         /*
590          * It doesn't matter whether the two calls below succeed.
591          * If they don't then the default value 0 is used.
592          */
593         of_property_read_u32(port_node, "reg", &endpoint->port);
594         of_property_read_u32(node, "reg", &endpoint->id);
595
596         of_node_put(port_node);
597
598         return 0;
599 }
600 EXPORT_SYMBOL(of_graph_parse_endpoint);
601
602 /**
603  * of_graph_get_port_by_id() - get the port matching a given id
604  * @parent: pointer to the parent device node
605  * @id: id of the port
606  *
607  * Return: A 'port' node pointer with refcount incremented. The caller
608  * has to use of_node_put() on it when done.
609  */
610 struct device_node *of_graph_get_port_by_id(struct device_node *parent, u32 id)
611 {
612         struct device_node *node, *port;
613
614         node = of_get_child_by_name(parent, "ports");
615         if (node)
616                 parent = node;
617
618         for_each_child_of_node(parent, port) {
619                 u32 port_id = 0;
620
621                 if (!of_node_name_eq(port, "port"))
622                         continue;
623                 of_property_read_u32(port, "reg", &port_id);
624                 if (id == port_id)
625                         break;
626         }
627
628         of_node_put(node);
629
630         return port;
631 }
632 EXPORT_SYMBOL(of_graph_get_port_by_id);
633
634 /**
635  * of_graph_get_next_endpoint() - get next endpoint node
636  * @parent: pointer to the parent device node
637  * @prev: previous endpoint node, or NULL to get first
638  *
639  * Return: An 'endpoint' node pointer with refcount incremented. Refcount
640  * of the passed @prev node is decremented.
641  */
642 struct device_node *of_graph_get_next_endpoint(const struct device_node *parent,
643                                         struct device_node *prev)
644 {
645         struct device_node *endpoint;
646         struct device_node *port;
647
648         if (!parent)
649                 return NULL;
650
651         /*
652          * Start by locating the port node. If no previous endpoint is specified
653          * search for the first port node, otherwise get the previous endpoint
654          * parent port node.
655          */
656         if (!prev) {
657                 struct device_node *node;
658
659                 node = of_get_child_by_name(parent, "ports");
660                 if (node)
661                         parent = node;
662
663                 port = of_get_child_by_name(parent, "port");
664                 of_node_put(node);
665
666                 if (!port) {
667                         pr_err("graph: no port node found in %pOF\n", parent);
668                         return NULL;
669                 }
670         } else {
671                 port = of_get_parent(prev);
672                 if (WARN_ONCE(!port, "%s(): endpoint %pOF has no parent node\n",
673                               __func__, prev))
674                         return NULL;
675         }
676
677         while (1) {
678                 /*
679                  * Now that we have a port node, get the next endpoint by
680                  * getting the next child. If the previous endpoint is NULL this
681                  * will return the first child.
682                  */
683                 endpoint = of_get_next_child(port, prev);
684                 if (endpoint) {
685                         of_node_put(port);
686                         return endpoint;
687                 }
688
689                 /* No more endpoints under this port, try the next one. */
690                 prev = NULL;
691
692                 do {
693                         port = of_get_next_child(parent, port);
694                         if (!port)
695                                 return NULL;
696                 } while (!of_node_name_eq(port, "port"));
697         }
698 }
699 EXPORT_SYMBOL(of_graph_get_next_endpoint);
700
701 /**
702  * of_graph_get_endpoint_by_regs() - get endpoint node of specific identifiers
703  * @parent: pointer to the parent device node
704  * @port_reg: identifier (value of reg property) of the parent port node
705  * @reg: identifier (value of reg property) of the endpoint node
706  *
707  * Return: An 'endpoint' node pointer which is identified by reg and at the same
708  * is the child of a port node identified by port_reg. reg and port_reg are
709  * ignored when they are -1. Use of_node_put() on the pointer when done.
710  */
711 struct device_node *of_graph_get_endpoint_by_regs(
712         const struct device_node *parent, int port_reg, int reg)
713 {
714         struct of_endpoint endpoint;
715         struct device_node *node = NULL;
716
717         for_each_endpoint_of_node(parent, node) {
718                 of_graph_parse_endpoint(node, &endpoint);
719                 if (((port_reg == -1) || (endpoint.port == port_reg)) &&
720                         ((reg == -1) || (endpoint.id == reg)))
721                         return node;
722         }
723
724         return NULL;
725 }
726 EXPORT_SYMBOL(of_graph_get_endpoint_by_regs);
727
728 /**
729  * of_graph_get_remote_endpoint() - get remote endpoint node
730  * @node: pointer to a local endpoint device_node
731  *
732  * Return: Remote endpoint node associated with remote endpoint node linked
733  *         to @node. Use of_node_put() on it when done.
734  */
735 struct device_node *of_graph_get_remote_endpoint(const struct device_node *node)
736 {
737         /* Get remote endpoint node. */
738         return of_parse_phandle(node, "remote-endpoint", 0);
739 }
740 EXPORT_SYMBOL(of_graph_get_remote_endpoint);
741
742 /**
743  * of_graph_get_port_parent() - get port's parent node
744  * @node: pointer to a local endpoint device_node
745  *
746  * Return: device node associated with endpoint node linked
747  *         to @node. Use of_node_put() on it when done.
748  */
749 struct device_node *of_graph_get_port_parent(struct device_node *node)
750 {
751         unsigned int depth;
752
753         if (!node)
754                 return NULL;
755
756         /*
757          * Preserve usecount for passed in node as of_get_next_parent()
758          * will do of_node_put() on it.
759          */
760         of_node_get(node);
761
762         /* Walk 3 levels up only if there is 'ports' node. */
763         for (depth = 3; depth && node; depth--) {
764                 node = of_get_next_parent(node);
765                 if (depth == 2 && !of_node_name_eq(node, "ports"))
766                         break;
767         }
768         return node;
769 }
770 EXPORT_SYMBOL(of_graph_get_port_parent);
771
772 /**
773  * of_graph_get_remote_port_parent() - get remote port's parent node
774  * @node: pointer to a local endpoint device_node
775  *
776  * Return: Remote device node associated with remote endpoint node linked
777  *         to @node. Use of_node_put() on it when done.
778  */
779 struct device_node *of_graph_get_remote_port_parent(
780                                const struct device_node *node)
781 {
782         struct device_node *np, *pp;
783
784         /* Get remote endpoint node. */
785         np = of_graph_get_remote_endpoint(node);
786
787         pp = of_graph_get_port_parent(np);
788
789         of_node_put(np);
790
791         return pp;
792 }
793 EXPORT_SYMBOL(of_graph_get_remote_port_parent);
794
795 /**
796  * of_graph_get_remote_port() - get remote port node
797  * @node: pointer to a local endpoint device_node
798  *
799  * Return: Remote port node associated with remote endpoint node linked
800  * to @node. Use of_node_put() on it when done.
801  */
802 struct device_node *of_graph_get_remote_port(const struct device_node *node)
803 {
804         struct device_node *np;
805
806         /* Get remote endpoint node. */
807         np = of_graph_get_remote_endpoint(node);
808         if (!np)
809                 return NULL;
810         return of_get_next_parent(np);
811 }
812 EXPORT_SYMBOL(of_graph_get_remote_port);
813
814 int of_graph_get_endpoint_count(const struct device_node *np)
815 {
816         struct device_node *endpoint;
817         int num = 0;
818
819         for_each_endpoint_of_node(np, endpoint)
820                 num++;
821
822         return num;
823 }
824 EXPORT_SYMBOL(of_graph_get_endpoint_count);
825
826 /**
827  * of_graph_get_remote_node() - get remote parent device_node for given port/endpoint
828  * @node: pointer to parent device_node containing graph port/endpoint
829  * @port: identifier (value of reg property) of the parent port node
830  * @endpoint: identifier (value of reg property) of the endpoint node
831  *
832  * Return: Remote device node associated with remote endpoint node linked
833  * to @node. Use of_node_put() on it when done.
834  */
835 struct device_node *of_graph_get_remote_node(const struct device_node *node,
836                                              u32 port, u32 endpoint)
837 {
838         struct device_node *endpoint_node, *remote;
839
840         endpoint_node = of_graph_get_endpoint_by_regs(node, port, endpoint);
841         if (!endpoint_node) {
842                 pr_debug("no valid endpoint (%d, %d) for node %pOF\n",
843                          port, endpoint, node);
844                 return NULL;
845         }
846
847         remote = of_graph_get_remote_port_parent(endpoint_node);
848         of_node_put(endpoint_node);
849         if (!remote) {
850                 pr_debug("no valid remote node\n");
851                 return NULL;
852         }
853
854         if (!of_device_is_available(remote)) {
855                 pr_debug("not available for remote node\n");
856                 of_node_put(remote);
857                 return NULL;
858         }
859
860         return remote;
861 }
862 EXPORT_SYMBOL(of_graph_get_remote_node);
863
864 static struct fwnode_handle *of_fwnode_get(struct fwnode_handle *fwnode)
865 {
866         return of_fwnode_handle(of_node_get(to_of_node(fwnode)));
867 }
868
869 static void of_fwnode_put(struct fwnode_handle *fwnode)
870 {
871         of_node_put(to_of_node(fwnode));
872 }
873
874 static bool of_fwnode_device_is_available(const struct fwnode_handle *fwnode)
875 {
876         return of_device_is_available(to_of_node(fwnode));
877 }
878
879 static bool of_fwnode_device_dma_supported(const struct fwnode_handle *fwnode)
880 {
881         return true;
882 }
883
884 static enum dev_dma_attr
885 of_fwnode_device_get_dma_attr(const struct fwnode_handle *fwnode)
886 {
887         if (of_dma_is_coherent(to_of_node(fwnode)))
888                 return DEV_DMA_COHERENT;
889         else
890                 return DEV_DMA_NON_COHERENT;
891 }
892
893 static bool of_fwnode_property_present(const struct fwnode_handle *fwnode,
894                                        const char *propname)
895 {
896         return of_property_read_bool(to_of_node(fwnode), propname);
897 }
898
899 static int of_fwnode_property_read_int_array(const struct fwnode_handle *fwnode,
900                                              const char *propname,
901                                              unsigned int elem_size, void *val,
902                                              size_t nval)
903 {
904         const struct device_node *node = to_of_node(fwnode);
905
906         if (!val)
907                 return of_property_count_elems_of_size(node, propname,
908                                                        elem_size);
909
910         switch (elem_size) {
911         case sizeof(u8):
912                 return of_property_read_u8_array(node, propname, val, nval);
913         case sizeof(u16):
914                 return of_property_read_u16_array(node, propname, val, nval);
915         case sizeof(u32):
916                 return of_property_read_u32_array(node, propname, val, nval);
917         case sizeof(u64):
918                 return of_property_read_u64_array(node, propname, val, nval);
919         }
920
921         return -ENXIO;
922 }
923
924 static int
925 of_fwnode_property_read_string_array(const struct fwnode_handle *fwnode,
926                                      const char *propname, const char **val,
927                                      size_t nval)
928 {
929         const struct device_node *node = to_of_node(fwnode);
930
931         return val ?
932                 of_property_read_string_array(node, propname, val, nval) :
933                 of_property_count_strings(node, propname);
934 }
935
936 static const char *of_fwnode_get_name(const struct fwnode_handle *fwnode)
937 {
938         return kbasename(to_of_node(fwnode)->full_name);
939 }
940
941 static const char *of_fwnode_get_name_prefix(const struct fwnode_handle *fwnode)
942 {
943         /* Root needs no prefix here (its name is "/"). */
944         if (!to_of_node(fwnode)->parent)
945                 return "";
946
947         return "/";
948 }
949
950 static struct fwnode_handle *
951 of_fwnode_get_parent(const struct fwnode_handle *fwnode)
952 {
953         return of_fwnode_handle(of_get_parent(to_of_node(fwnode)));
954 }
955
956 static struct fwnode_handle *
957 of_fwnode_get_next_child_node(const struct fwnode_handle *fwnode,
958                               struct fwnode_handle *child)
959 {
960         return of_fwnode_handle(of_get_next_available_child(to_of_node(fwnode),
961                                                             to_of_node(child)));
962 }
963
964 static struct fwnode_handle *
965 of_fwnode_get_named_child_node(const struct fwnode_handle *fwnode,
966                                const char *childname)
967 {
968         const struct device_node *node = to_of_node(fwnode);
969         struct device_node *child;
970
971         for_each_available_child_of_node(node, child)
972                 if (of_node_name_eq(child, childname))
973                         return of_fwnode_handle(child);
974
975         return NULL;
976 }
977
978 static int
979 of_fwnode_get_reference_args(const struct fwnode_handle *fwnode,
980                              const char *prop, const char *nargs_prop,
981                              unsigned int nargs, unsigned int index,
982                              struct fwnode_reference_args *args)
983 {
984         struct of_phandle_args of_args;
985         unsigned int i;
986         int ret;
987
988         if (nargs_prop)
989                 ret = of_parse_phandle_with_args(to_of_node(fwnode), prop,
990                                                  nargs_prop, index, &of_args);
991         else
992                 ret = of_parse_phandle_with_fixed_args(to_of_node(fwnode), prop,
993                                                        nargs, index, &of_args);
994         if (ret < 0)
995                 return ret;
996         if (!args) {
997                 of_node_put(of_args.np);
998                 return 0;
999         }
1000
1001         args->nargs = of_args.args_count;
1002         args->fwnode = of_fwnode_handle(of_args.np);
1003
1004         for (i = 0; i < NR_FWNODE_REFERENCE_ARGS; i++)
1005                 args->args[i] = i < of_args.args_count ? of_args.args[i] : 0;
1006
1007         return 0;
1008 }
1009
1010 static struct fwnode_handle *
1011 of_fwnode_graph_get_next_endpoint(const struct fwnode_handle *fwnode,
1012                                   struct fwnode_handle *prev)
1013 {
1014         return of_fwnode_handle(of_graph_get_next_endpoint(to_of_node(fwnode),
1015                                                            to_of_node(prev)));
1016 }
1017
1018 static struct fwnode_handle *
1019 of_fwnode_graph_get_remote_endpoint(const struct fwnode_handle *fwnode)
1020 {
1021         return of_fwnode_handle(
1022                 of_graph_get_remote_endpoint(to_of_node(fwnode)));
1023 }
1024
1025 static struct fwnode_handle *
1026 of_fwnode_graph_get_port_parent(struct fwnode_handle *fwnode)
1027 {
1028         struct device_node *np;
1029
1030         /* Get the parent of the port */
1031         np = of_get_parent(to_of_node(fwnode));
1032         if (!np)
1033                 return NULL;
1034
1035         /* Is this the "ports" node? If not, it's the port parent. */
1036         if (!of_node_name_eq(np, "ports"))
1037                 return of_fwnode_handle(np);
1038
1039         return of_fwnode_handle(of_get_next_parent(np));
1040 }
1041
1042 static int of_fwnode_graph_parse_endpoint(const struct fwnode_handle *fwnode,
1043                                           struct fwnode_endpoint *endpoint)
1044 {
1045         const struct device_node *node = to_of_node(fwnode);
1046         struct device_node *port_node = of_get_parent(node);
1047
1048         endpoint->local_fwnode = fwnode;
1049
1050         of_property_read_u32(port_node, "reg", &endpoint->port);
1051         of_property_read_u32(node, "reg", &endpoint->id);
1052
1053         of_node_put(port_node);
1054
1055         return 0;
1056 }
1057
1058 static const void *
1059 of_fwnode_device_get_match_data(const struct fwnode_handle *fwnode,
1060                                 const struct device *dev)
1061 {
1062         return of_device_get_match_data(dev);
1063 }
1064
1065 static bool of_is_ancestor_of(struct device_node *test_ancestor,
1066                               struct device_node *child)
1067 {
1068         of_node_get(child);
1069         while (child) {
1070                 if (child == test_ancestor) {
1071                         of_node_put(child);
1072                         return true;
1073                 }
1074                 child = of_get_next_parent(child);
1075         }
1076         return false;
1077 }
1078
1079 static struct device_node *of_get_compat_node(struct device_node *np)
1080 {
1081         of_node_get(np);
1082
1083         while (np) {
1084                 if (!of_device_is_available(np)) {
1085                         of_node_put(np);
1086                         np = NULL;
1087                 }
1088
1089                 if (of_find_property(np, "compatible", NULL))
1090                         break;
1091
1092                 np = of_get_next_parent(np);
1093         }
1094
1095         return np;
1096 }
1097
1098 static struct device_node *of_get_compat_node_parent(struct device_node *np)
1099 {
1100         struct device_node *parent, *node;
1101
1102         parent = of_get_parent(np);
1103         node = of_get_compat_node(parent);
1104         of_node_put(parent);
1105
1106         return node;
1107 }
1108
1109 /**
1110  * of_link_to_phandle - Add fwnode link to supplier from supplier phandle
1111  * @con_np: consumer device tree node
1112  * @sup_np: supplier device tree node
1113  *
1114  * Given a phandle to a supplier device tree node (@sup_np), this function
1115  * finds the device that owns the supplier device tree node and creates a
1116  * device link from @dev consumer device to the supplier device. This function
1117  * doesn't create device links for invalid scenarios such as trying to create a
1118  * link with a parent device as the consumer of its child device. In such
1119  * cases, it returns an error.
1120  *
1121  * Returns:
1122  * - 0 if fwnode link successfully created to supplier
1123  * - -EINVAL if the supplier link is invalid and should not be created
1124  * - -ENODEV if struct device will never be create for supplier
1125  */
1126 static int of_link_to_phandle(struct device_node *con_np,
1127                               struct device_node *sup_np)
1128 {
1129         struct device *sup_dev;
1130         struct device_node *tmp_np = sup_np;
1131
1132         /*
1133          * Find the device node that contains the supplier phandle.  It may be
1134          * @sup_np or it may be an ancestor of @sup_np.
1135          */
1136         sup_np = of_get_compat_node(sup_np);
1137         if (!sup_np) {
1138                 pr_debug("Not linking %pOFP to %pOFP - No device\n",
1139                          con_np, tmp_np);
1140                 return -ENODEV;
1141         }
1142
1143         /*
1144          * Don't allow linking a device node as a consumer of one of its
1145          * descendant nodes. By definition, a child node can't be a functional
1146          * dependency for the parent node.
1147          */
1148         if (of_is_ancestor_of(con_np, sup_np)) {
1149                 pr_debug("Not linking %pOFP to %pOFP - is descendant\n",
1150                          con_np, sup_np);
1151                 of_node_put(sup_np);
1152                 return -EINVAL;
1153         }
1154
1155         /*
1156          * Don't create links to "early devices" that won't have struct devices
1157          * created for them.
1158          */
1159         sup_dev = get_dev_from_fwnode(&sup_np->fwnode);
1160         if (!sup_dev &&
1161             (of_node_check_flag(sup_np, OF_POPULATED) ||
1162              sup_np->fwnode.flags & FWNODE_FLAG_NOT_DEVICE)) {
1163                 pr_debug("Not linking %pOFP to %pOFP - No struct device\n",
1164                          con_np, sup_np);
1165                 of_node_put(sup_np);
1166                 return -ENODEV;
1167         }
1168         put_device(sup_dev);
1169
1170         fwnode_link_add(of_fwnode_handle(con_np), of_fwnode_handle(sup_np));
1171         of_node_put(sup_np);
1172
1173         return 0;
1174 }
1175
1176 /**
1177  * parse_prop_cells - Property parsing function for suppliers
1178  *
1179  * @np:         Pointer to device tree node containing a list
1180  * @prop_name:  Name of property to be parsed. Expected to hold phandle values
1181  * @index:      For properties holding a list of phandles, this is the index
1182  *              into the list.
1183  * @list_name:  Property name that is known to contain list of phandle(s) to
1184  *              supplier(s)
1185  * @cells_name: property name that specifies phandles' arguments count
1186  *
1187  * This is a helper function to parse properties that have a known fixed name
1188  * and are a list of phandles and phandle arguments.
1189  *
1190  * Returns:
1191  * - phandle node pointer with refcount incremented. Caller must of_node_put()
1192  *   on it when done.
1193  * - NULL if no phandle found at index
1194  */
1195 static struct device_node *parse_prop_cells(struct device_node *np,
1196                                             const char *prop_name, int index,
1197                                             const char *list_name,
1198                                             const char *cells_name)
1199 {
1200         struct of_phandle_args sup_args;
1201
1202         if (strcmp(prop_name, list_name))
1203                 return NULL;
1204
1205         if (of_parse_phandle_with_args(np, list_name, cells_name, index,
1206                                        &sup_args))
1207                 return NULL;
1208
1209         return sup_args.np;
1210 }
1211
1212 #define DEFINE_SIMPLE_PROP(fname, name, cells)                            \
1213 static struct device_node *parse_##fname(struct device_node *np,          \
1214                                         const char *prop_name, int index) \
1215 {                                                                         \
1216         return parse_prop_cells(np, prop_name, index, name, cells);       \
1217 }
1218
1219 static int strcmp_suffix(const char *str, const char *suffix)
1220 {
1221         unsigned int len, suffix_len;
1222
1223         len = strlen(str);
1224         suffix_len = strlen(suffix);
1225         if (len <= suffix_len)
1226                 return -1;
1227         return strcmp(str + len - suffix_len, suffix);
1228 }
1229
1230 /**
1231  * parse_suffix_prop_cells - Suffix property parsing function for suppliers
1232  *
1233  * @np:         Pointer to device tree node containing a list
1234  * @prop_name:  Name of property to be parsed. Expected to hold phandle values
1235  * @index:      For properties holding a list of phandles, this is the index
1236  *              into the list.
1237  * @suffix:     Property suffix that is known to contain list of phandle(s) to
1238  *              supplier(s)
1239  * @cells_name: property name that specifies phandles' arguments count
1240  *
1241  * This is a helper function to parse properties that have a known fixed suffix
1242  * and are a list of phandles and phandle arguments.
1243  *
1244  * Returns:
1245  * - phandle node pointer with refcount incremented. Caller must of_node_put()
1246  *   on it when done.
1247  * - NULL if no phandle found at index
1248  */
1249 static struct device_node *parse_suffix_prop_cells(struct device_node *np,
1250                                             const char *prop_name, int index,
1251                                             const char *suffix,
1252                                             const char *cells_name)
1253 {
1254         struct of_phandle_args sup_args;
1255
1256         if (strcmp_suffix(prop_name, suffix))
1257                 return NULL;
1258
1259         if (of_parse_phandle_with_args(np, prop_name, cells_name, index,
1260                                        &sup_args))
1261                 return NULL;
1262
1263         return sup_args.np;
1264 }
1265
1266 #define DEFINE_SUFFIX_PROP(fname, suffix, cells)                             \
1267 static struct device_node *parse_##fname(struct device_node *np,             \
1268                                         const char *prop_name, int index)    \
1269 {                                                                            \
1270         return parse_suffix_prop_cells(np, prop_name, index, suffix, cells); \
1271 }
1272
1273 /**
1274  * struct supplier_bindings - Property parsing functions for suppliers
1275  *
1276  * @parse_prop: function name
1277  *      parse_prop() finds the node corresponding to a supplier phandle
1278  * @parse_prop.np: Pointer to device node holding supplier phandle property
1279  * @parse_prop.prop_name: Name of property holding a phandle value
1280  * @parse_prop.index: For properties holding a list of phandles, this is the
1281  *                    index into the list
1282  * @optional: Describes whether a supplier is mandatory or not
1283  * @node_not_dev: The consumer node containing the property is never converted
1284  *                to a struct device. Instead, parse ancestor nodes for the
1285  *                compatible property to find a node corresponding to a device.
1286  *
1287  * Returns:
1288  * parse_prop() return values are
1289  * - phandle node pointer with refcount incremented. Caller must of_node_put()
1290  *   on it when done.
1291  * - NULL if no phandle found at index
1292  */
1293 struct supplier_bindings {
1294         struct device_node *(*parse_prop)(struct device_node *np,
1295                                           const char *prop_name, int index);
1296         bool optional;
1297         bool node_not_dev;
1298 };
1299
1300 DEFINE_SIMPLE_PROP(clocks, "clocks", "#clock-cells")
1301 DEFINE_SIMPLE_PROP(interconnects, "interconnects", "#interconnect-cells")
1302 DEFINE_SIMPLE_PROP(iommus, "iommus", "#iommu-cells")
1303 DEFINE_SIMPLE_PROP(mboxes, "mboxes", "#mbox-cells")
1304 DEFINE_SIMPLE_PROP(io_channels, "io-channel", "#io-channel-cells")
1305 DEFINE_SIMPLE_PROP(interrupt_parent, "interrupt-parent", NULL)
1306 DEFINE_SIMPLE_PROP(dmas, "dmas", "#dma-cells")
1307 DEFINE_SIMPLE_PROP(power_domains, "power-domains", "#power-domain-cells")
1308 DEFINE_SIMPLE_PROP(hwlocks, "hwlocks", "#hwlock-cells")
1309 DEFINE_SIMPLE_PROP(extcon, "extcon", NULL)
1310 DEFINE_SIMPLE_PROP(nvmem_cells, "nvmem-cells", NULL)
1311 DEFINE_SIMPLE_PROP(phys, "phys", "#phy-cells")
1312 DEFINE_SIMPLE_PROP(wakeup_parent, "wakeup-parent", NULL)
1313 DEFINE_SIMPLE_PROP(pinctrl0, "pinctrl-0", NULL)
1314 DEFINE_SIMPLE_PROP(pinctrl1, "pinctrl-1", NULL)
1315 DEFINE_SIMPLE_PROP(pinctrl2, "pinctrl-2", NULL)
1316 DEFINE_SIMPLE_PROP(pinctrl3, "pinctrl-3", NULL)
1317 DEFINE_SIMPLE_PROP(pinctrl4, "pinctrl-4", NULL)
1318 DEFINE_SIMPLE_PROP(pinctrl5, "pinctrl-5", NULL)
1319 DEFINE_SIMPLE_PROP(pinctrl6, "pinctrl-6", NULL)
1320 DEFINE_SIMPLE_PROP(pinctrl7, "pinctrl-7", NULL)
1321 DEFINE_SIMPLE_PROP(pinctrl8, "pinctrl-8", NULL)
1322 DEFINE_SIMPLE_PROP(remote_endpoint, "remote-endpoint", NULL)
1323 DEFINE_SIMPLE_PROP(pwms, "pwms", "#pwm-cells")
1324 DEFINE_SIMPLE_PROP(resets, "resets", "#reset-cells")
1325 DEFINE_SIMPLE_PROP(leds, "leds", NULL)
1326 DEFINE_SIMPLE_PROP(backlight, "backlight", NULL)
1327 DEFINE_SUFFIX_PROP(regulators, "-supply", NULL)
1328 DEFINE_SUFFIX_PROP(gpio, "-gpio", "#gpio-cells")
1329
1330 static struct device_node *parse_gpios(struct device_node *np,
1331                                        const char *prop_name, int index)
1332 {
1333         if (!strcmp_suffix(prop_name, ",nr-gpios"))
1334                 return NULL;
1335
1336         return parse_suffix_prop_cells(np, prop_name, index, "-gpios",
1337                                        "#gpio-cells");
1338 }
1339
1340 static struct device_node *parse_iommu_maps(struct device_node *np,
1341                                             const char *prop_name, int index)
1342 {
1343         if (strcmp(prop_name, "iommu-map"))
1344                 return NULL;
1345
1346         return of_parse_phandle(np, prop_name, (index * 4) + 1);
1347 }
1348
1349 static struct device_node *parse_gpio_compat(struct device_node *np,
1350                                              const char *prop_name, int index)
1351 {
1352         struct of_phandle_args sup_args;
1353
1354         if (strcmp(prop_name, "gpio") && strcmp(prop_name, "gpios"))
1355                 return NULL;
1356
1357         /*
1358          * Ignore node with gpio-hog property since its gpios are all provided
1359          * by its parent.
1360          */
1361         if (of_find_property(np, "gpio-hog", NULL))
1362                 return NULL;
1363
1364         if (of_parse_phandle_with_args(np, prop_name, "#gpio-cells", index,
1365                                        &sup_args))
1366                 return NULL;
1367
1368         return sup_args.np;
1369 }
1370
1371 static struct device_node *parse_interrupts(struct device_node *np,
1372                                             const char *prop_name, int index)
1373 {
1374         struct of_phandle_args sup_args;
1375
1376         if (!IS_ENABLED(CONFIG_OF_IRQ) || IS_ENABLED(CONFIG_PPC))
1377                 return NULL;
1378
1379         if (strcmp(prop_name, "interrupts") &&
1380             strcmp(prop_name, "interrupts-extended"))
1381                 return NULL;
1382
1383         return of_irq_parse_one(np, index, &sup_args) ? NULL : sup_args.np;
1384 }
1385
1386 static const struct supplier_bindings of_supplier_bindings[] = {
1387         { .parse_prop = parse_clocks, },
1388         { .parse_prop = parse_interconnects, },
1389         { .parse_prop = parse_iommus, .optional = true, },
1390         { .parse_prop = parse_iommu_maps, .optional = true, },
1391         { .parse_prop = parse_mboxes, },
1392         { .parse_prop = parse_io_channels, },
1393         { .parse_prop = parse_interrupt_parent, },
1394         { .parse_prop = parse_dmas, .optional = true, },
1395         { .parse_prop = parse_power_domains, },
1396         { .parse_prop = parse_hwlocks, },
1397         { .parse_prop = parse_extcon, },
1398         { .parse_prop = parse_nvmem_cells, },
1399         { .parse_prop = parse_phys, },
1400         { .parse_prop = parse_wakeup_parent, },
1401         { .parse_prop = parse_pinctrl0, },
1402         { .parse_prop = parse_pinctrl1, },
1403         { .parse_prop = parse_pinctrl2, },
1404         { .parse_prop = parse_pinctrl3, },
1405         { .parse_prop = parse_pinctrl4, },
1406         { .parse_prop = parse_pinctrl5, },
1407         { .parse_prop = parse_pinctrl6, },
1408         { .parse_prop = parse_pinctrl7, },
1409         { .parse_prop = parse_pinctrl8, },
1410         { .parse_prop = parse_remote_endpoint, .node_not_dev = true, },
1411         { .parse_prop = parse_pwms, },
1412         { .parse_prop = parse_resets, },
1413         { .parse_prop = parse_leds, },
1414         { .parse_prop = parse_backlight, },
1415         { .parse_prop = parse_gpio_compat, },
1416         { .parse_prop = parse_interrupts, },
1417         { .parse_prop = parse_regulators, },
1418         { .parse_prop = parse_gpio, },
1419         { .parse_prop = parse_gpios, },
1420         {}
1421 };
1422
1423 /**
1424  * of_link_property - Create device links to suppliers listed in a property
1425  * @con_np: The consumer device tree node which contains the property
1426  * @prop_name: Name of property to be parsed
1427  *
1428  * This function checks if the property @prop_name that is present in the
1429  * @con_np device tree node is one of the known common device tree bindings
1430  * that list phandles to suppliers. If @prop_name isn't one, this function
1431  * doesn't do anything.
1432  *
1433  * If @prop_name is one, this function attempts to create fwnode links from the
1434  * consumer device tree node @con_np to all the suppliers device tree nodes
1435  * listed in @prop_name.
1436  *
1437  * Any failed attempt to create a fwnode link will NOT result in an immediate
1438  * return.  of_link_property() must create links to all the available supplier
1439  * device tree nodes even when attempts to create a link to one or more
1440  * suppliers fail.
1441  */
1442 static int of_link_property(struct device_node *con_np, const char *prop_name)
1443 {
1444         struct device_node *phandle;
1445         const struct supplier_bindings *s = of_supplier_bindings;
1446         unsigned int i = 0;
1447         bool matched = false;
1448
1449         /* Do not stop at first failed link, link all available suppliers. */
1450         while (!matched && s->parse_prop) {
1451                 if (s->optional && !fw_devlink_is_strict()) {
1452                         s++;
1453                         continue;
1454                 }
1455
1456                 while ((phandle = s->parse_prop(con_np, prop_name, i))) {
1457                         struct device_node *con_dev_np;
1458
1459                         con_dev_np = s->node_not_dev
1460                                         ? of_get_compat_node_parent(con_np)
1461                                         : of_node_get(con_np);
1462                         matched = true;
1463                         i++;
1464                         of_link_to_phandle(con_dev_np, phandle);
1465                         of_node_put(phandle);
1466                         of_node_put(con_dev_np);
1467                 }
1468                 s++;
1469         }
1470         return 0;
1471 }
1472
1473 static void __iomem *of_fwnode_iomap(struct fwnode_handle *fwnode, int index)
1474 {
1475 #ifdef CONFIG_OF_ADDRESS
1476         return of_iomap(to_of_node(fwnode), index);
1477 #else
1478         return NULL;
1479 #endif
1480 }
1481
1482 static int of_fwnode_irq_get(const struct fwnode_handle *fwnode,
1483                              unsigned int index)
1484 {
1485         return of_irq_get(to_of_node(fwnode), index);
1486 }
1487
1488 static int of_fwnode_add_links(struct fwnode_handle *fwnode)
1489 {
1490         struct property *p;
1491         struct device_node *con_np = to_of_node(fwnode);
1492
1493         if (IS_ENABLED(CONFIG_X86))
1494                 return 0;
1495
1496         if (!con_np)
1497                 return -EINVAL;
1498
1499         for_each_property_of_node(con_np, p)
1500                 of_link_property(con_np, p->name);
1501
1502         return 0;
1503 }
1504
1505 const struct fwnode_operations of_fwnode_ops = {
1506         .get = of_fwnode_get,
1507         .put = of_fwnode_put,
1508         .device_is_available = of_fwnode_device_is_available,
1509         .device_get_match_data = of_fwnode_device_get_match_data,
1510         .device_dma_supported = of_fwnode_device_dma_supported,
1511         .device_get_dma_attr = of_fwnode_device_get_dma_attr,
1512         .property_present = of_fwnode_property_present,
1513         .property_read_int_array = of_fwnode_property_read_int_array,
1514         .property_read_string_array = of_fwnode_property_read_string_array,
1515         .get_name = of_fwnode_get_name,
1516         .get_name_prefix = of_fwnode_get_name_prefix,
1517         .get_parent = of_fwnode_get_parent,
1518         .get_next_child_node = of_fwnode_get_next_child_node,
1519         .get_named_child_node = of_fwnode_get_named_child_node,
1520         .get_reference_args = of_fwnode_get_reference_args,
1521         .graph_get_next_endpoint = of_fwnode_graph_get_next_endpoint,
1522         .graph_get_remote_endpoint = of_fwnode_graph_get_remote_endpoint,
1523         .graph_get_port_parent = of_fwnode_graph_get_port_parent,
1524         .graph_parse_endpoint = of_fwnode_graph_parse_endpoint,
1525         .iomap = of_fwnode_iomap,
1526         .irq_get = of_fwnode_irq_get,
1527         .add_links = of_fwnode_add_links,
1528 };
1529 EXPORT_SYMBOL_GPL(of_fwnode_ops);