eda50b4be9349d26c5600a19426cdc1d7f7fe92b
[muen/linux.git] / drivers / of / property.c
1 /*
2  * drivers/of/property.c - Procedures for accessing and interpreting
3  *                         Devicetree properties and graphs.
4  *
5  * Initially created by copying procedures from drivers/of/base.c. This
6  * file contains the OF property as well as the OF graph interface
7  * functions.
8  *
9  * Paul Mackerras       August 1996.
10  * Copyright (C) 1996-2005 Paul Mackerras.
11  *
12  *  Adapted for 64bit PowerPC by Dave Engebretsen and Peter Bergner.
13  *    {engebret|bergner}@us.ibm.com
14  *
15  *  Adapted for sparc and sparc64 by David S. Miller davem@davemloft.net
16  *
17  *  Reconsolidated from arch/x/kernel/prom.c by Stephen Rothwell and
18  *  Grant Likely.
19  *
20  *      This program is free software; you can redistribute it and/or
21  *      modify it under the terms of the GNU General Public License
22  *      as published by the Free Software Foundation; either version
23  *      2 of the License, or (at your option) any later version.
24  */
25
26 #define pr_fmt(fmt)     "OF: " fmt
27
28 #include <linux/of.h>
29 #include <linux/of_device.h>
30 #include <linux/of_graph.h>
31 #include <linux/string.h>
32
33 #include "of_private.h"
34
35 /**
36  * of_property_count_elems_of_size - Count the number of elements in a property
37  *
38  * @np:         device node from which the property value is to be read.
39  * @propname:   name of the property to be searched.
40  * @elem_size:  size of the individual element
41  *
42  * Search for a property in a device node and count the number of elements of
43  * size elem_size in it. Returns number of elements on sucess, -EINVAL if the
44  * property does not exist or its length does not match a multiple of elem_size
45  * and -ENODATA if the property does not have a value.
46  */
47 int of_property_count_elems_of_size(const struct device_node *np,
48                                 const char *propname, int elem_size)
49 {
50         struct property *prop = of_find_property(np, propname, NULL);
51
52         if (!prop)
53                 return -EINVAL;
54         if (!prop->value)
55                 return -ENODATA;
56
57         if (prop->length % elem_size != 0) {
58                 pr_err("size of %s in node %s is not a multiple of %d\n",
59                        propname, np->full_name, elem_size);
60                 return -EINVAL;
61         }
62
63         return prop->length / elem_size;
64 }
65 EXPORT_SYMBOL_GPL(of_property_count_elems_of_size);
66
67 /**
68  * of_find_property_value_of_size
69  *
70  * @np:         device node from which the property value is to be read.
71  * @propname:   name of the property to be searched.
72  * @min:        minimum allowed length of property value
73  * @max:        maximum allowed length of property value (0 means unlimited)
74  * @len:        if !=NULL, actual length is written to here
75  *
76  * Search for a property in a device node and valid the requested size.
77  * Returns the property value on success, -EINVAL if the property does not
78  *  exist, -ENODATA if property does not have a value, and -EOVERFLOW if the
79  * property data is too small or too large.
80  *
81  */
82 static void *of_find_property_value_of_size(const struct device_node *np,
83                         const char *propname, u32 min, u32 max, size_t *len)
84 {
85         struct property *prop = of_find_property(np, propname, NULL);
86
87         if (!prop)
88                 return ERR_PTR(-EINVAL);
89         if (!prop->value)
90                 return ERR_PTR(-ENODATA);
91         if (prop->length < min)
92                 return ERR_PTR(-EOVERFLOW);
93         if (max && prop->length > max)
94                 return ERR_PTR(-EOVERFLOW);
95
96         if (len)
97                 *len = prop->length;
98
99         return prop->value;
100 }
101
102 /**
103  * of_property_read_u32_index - Find and read a u32 from a multi-value property.
104  *
105  * @np:         device node from which the property value is to be read.
106  * @propname:   name of the property to be searched.
107  * @index:      index of the u32 in the list of values
108  * @out_value:  pointer to return value, modified only if no error.
109  *
110  * Search for a property in a device node and read nth 32-bit value from
111  * it. Returns 0 on success, -EINVAL if the property does not exist,
112  * -ENODATA if property does not have a value, and -EOVERFLOW if the
113  * property data isn't large enough.
114  *
115  * The out_value is modified only if a valid u32 value can be decoded.
116  */
117 int of_property_read_u32_index(const struct device_node *np,
118                                        const char *propname,
119                                        u32 index, u32 *out_value)
120 {
121         const u32 *val = of_find_property_value_of_size(np, propname,
122                                         ((index + 1) * sizeof(*out_value)),
123                                         0,
124                                         NULL);
125
126         if (IS_ERR(val))
127                 return PTR_ERR(val);
128
129         *out_value = be32_to_cpup(((__be32 *)val) + index);
130         return 0;
131 }
132 EXPORT_SYMBOL_GPL(of_property_read_u32_index);
133
134 /**
135  * of_property_read_u64_index - Find and read a u64 from a multi-value property.
136  *
137  * @np:         device node from which the property value is to be read.
138  * @propname:   name of the property to be searched.
139  * @index:      index of the u64 in the list of values
140  * @out_value:  pointer to return value, modified only if no error.
141  *
142  * Search for a property in a device node and read nth 64-bit value from
143  * it. Returns 0 on success, -EINVAL if the property does not exist,
144  * -ENODATA if property does not have a value, and -EOVERFLOW if the
145  * property data isn't large enough.
146  *
147  * The out_value is modified only if a valid u64 value can be decoded.
148  */
149 int of_property_read_u64_index(const struct device_node *np,
150                                        const char *propname,
151                                        u32 index, u64 *out_value)
152 {
153         const u64 *val = of_find_property_value_of_size(np, propname,
154                                         ((index + 1) * sizeof(*out_value)),
155                                         0, NULL);
156
157         if (IS_ERR(val))
158                 return PTR_ERR(val);
159
160         *out_value = be64_to_cpup(((__be64 *)val) + index);
161         return 0;
162 }
163 EXPORT_SYMBOL_GPL(of_property_read_u64_index);
164
165 /**
166  * of_property_read_variable_u8_array - Find and read an array of u8 from a
167  * property, with bounds on the minimum and maximum array size.
168  *
169  * @np:         device node from which the property value is to be read.
170  * @propname:   name of the property to be searched.
171  * @out_values: pointer to return value, modified only if return value is 0.
172  * @sz_min:     minimum number of array elements to read
173  * @sz_max:     maximum number of array elements to read, if zero there is no
174  *              upper limit on the number of elements in the dts entry but only
175  *              sz_min will be read.
176  *
177  * Search for a property in a device node and read 8-bit value(s) from
178  * it. Returns number of elements read on success, -EINVAL if the property
179  * does not exist, -ENODATA if property does not have a value, and -EOVERFLOW
180  * if the property data is smaller than sz_min or longer than sz_max.
181  *
182  * dts entry of array should be like:
183  *      property = /bits/ 8 <0x50 0x60 0x70>;
184  *
185  * The out_values is modified only if a valid u8 value can be decoded.
186  */
187 int of_property_read_variable_u8_array(const struct device_node *np,
188                                         const char *propname, u8 *out_values,
189                                         size_t sz_min, size_t sz_max)
190 {
191         size_t sz, count;
192         const u8 *val = of_find_property_value_of_size(np, propname,
193                                                 (sz_min * sizeof(*out_values)),
194                                                 (sz_max * sizeof(*out_values)),
195                                                 &sz);
196
197         if (IS_ERR(val))
198                 return PTR_ERR(val);
199
200         if (!sz_max)
201                 sz = sz_min;
202         else
203                 sz /= sizeof(*out_values);
204
205         count = sz;
206         while (count--)
207                 *out_values++ = *val++;
208
209         return sz;
210 }
211 EXPORT_SYMBOL_GPL(of_property_read_variable_u8_array);
212
213 /**
214  * of_property_read_variable_u16_array - Find and read an array of u16 from a
215  * property, with bounds on the minimum and maximum array size.
216  *
217  * @np:         device node from which the property value is to be read.
218  * @propname:   name of the property to be searched.
219  * @out_values: pointer to return value, modified only if return value is 0.
220  * @sz_min:     minimum number of array elements to read
221  * @sz_max:     maximum number of array elements to read, if zero there is no
222  *              upper limit on the number of elements in the dts entry but only
223  *              sz_min will be read.
224  *
225  * Search for a property in a device node and read 16-bit value(s) from
226  * it. Returns number of elements read on success, -EINVAL if the property
227  * does not exist, -ENODATA if property does not have a value, and -EOVERFLOW
228  * if the property data is smaller than sz_min or longer than sz_max.
229  *
230  * dts entry of array should be like:
231  *      property = /bits/ 16 <0x5000 0x6000 0x7000>;
232  *
233  * The out_values is modified only if a valid u16 value can be decoded.
234  */
235 int of_property_read_variable_u16_array(const struct device_node *np,
236                                         const char *propname, u16 *out_values,
237                                         size_t sz_min, size_t sz_max)
238 {
239         size_t sz, count;
240         const __be16 *val = of_find_property_value_of_size(np, propname,
241                                                 (sz_min * sizeof(*out_values)),
242                                                 (sz_max * sizeof(*out_values)),
243                                                 &sz);
244
245         if (IS_ERR(val))
246                 return PTR_ERR(val);
247
248         if (!sz_max)
249                 sz = sz_min;
250         else
251                 sz /= sizeof(*out_values);
252
253         count = sz;
254         while (count--)
255                 *out_values++ = be16_to_cpup(val++);
256
257         return sz;
258 }
259 EXPORT_SYMBOL_GPL(of_property_read_variable_u16_array);
260
261 /**
262  * of_property_read_variable_u32_array - Find and read an array of 32 bit
263  * integers from a property, with bounds on the minimum and maximum array size.
264  *
265  * @np:         device node from which the property value is to be read.
266  * @propname:   name of the property to be searched.
267  * @out_values: pointer to return value, modified only if return value is 0.
268  * @sz_min:     minimum number of array elements to read
269  * @sz_max:     maximum number of array elements to read, if zero there is no
270  *              upper limit on the number of elements in the dts entry but only
271  *              sz_min will be read.
272  *
273  * Search for a property in a device node and read 32-bit value(s) from
274  * it. Returns number of elements read on success, -EINVAL if the property
275  * does not exist, -ENODATA if property does not have a value, and -EOVERFLOW
276  * if the property data is smaller than sz_min or longer than sz_max.
277  *
278  * The out_values is modified only if a valid u32 value can be decoded.
279  */
280 int of_property_read_variable_u32_array(const struct device_node *np,
281                                const char *propname, u32 *out_values,
282                                size_t sz_min, size_t sz_max)
283 {
284         size_t sz, count;
285         const __be32 *val = of_find_property_value_of_size(np, propname,
286                                                 (sz_min * sizeof(*out_values)),
287                                                 (sz_max * sizeof(*out_values)),
288                                                 &sz);
289
290         if (IS_ERR(val))
291                 return PTR_ERR(val);
292
293         if (!sz_max)
294                 sz = sz_min;
295         else
296                 sz /= sizeof(*out_values);
297
298         count = sz;
299         while (count--)
300                 *out_values++ = be32_to_cpup(val++);
301
302         return sz;
303 }
304 EXPORT_SYMBOL_GPL(of_property_read_variable_u32_array);
305
306 /**
307  * of_property_read_u64 - Find and read a 64 bit integer from a property
308  * @np:         device node from which the property value is to be read.
309  * @propname:   name of the property to be searched.
310  * @out_value:  pointer to return value, modified only if return value is 0.
311  *
312  * Search for a property in a device node and read a 64-bit value from
313  * it. Returns 0 on success, -EINVAL if the property does not exist,
314  * -ENODATA if property does not have a value, and -EOVERFLOW if the
315  * property data isn't large enough.
316  *
317  * The out_value is modified only if a valid u64 value can be decoded.
318  */
319 int of_property_read_u64(const struct device_node *np, const char *propname,
320                          u64 *out_value)
321 {
322         const __be32 *val = of_find_property_value_of_size(np, propname,
323                                                 sizeof(*out_value),
324                                                 0,
325                                                 NULL);
326
327         if (IS_ERR(val))
328                 return PTR_ERR(val);
329
330         *out_value = of_read_number(val, 2);
331         return 0;
332 }
333 EXPORT_SYMBOL_GPL(of_property_read_u64);
334
335 /**
336  * of_property_read_variable_u64_array - Find and read an array of 64 bit
337  * integers from a property, with bounds on the minimum and maximum array size.
338  *
339  * @np:         device node from which the property value is to be read.
340  * @propname:   name of the property to be searched.
341  * @out_values: pointer to return value, modified only if return value is 0.
342  * @sz_min:     minimum number of array elements to read
343  * @sz_max:     maximum number of array elements to read, if zero there is no
344  *              upper limit on the number of elements in the dts entry but only
345  *              sz_min will be read.
346  *
347  * Search for a property in a device node and read 64-bit value(s) from
348  * it. Returns number of elements read on success, -EINVAL if the property
349  * does not exist, -ENODATA if property does not have a value, and -EOVERFLOW
350  * if the property data is smaller than sz_min or longer than sz_max.
351  *
352  * The out_values is modified only if a valid u64 value can be decoded.
353  */
354 int of_property_read_variable_u64_array(const struct device_node *np,
355                                const char *propname, u64 *out_values,
356                                size_t sz_min, size_t sz_max)
357 {
358         size_t sz, count;
359         const __be32 *val = of_find_property_value_of_size(np, propname,
360                                                 (sz_min * sizeof(*out_values)),
361                                                 (sz_max * sizeof(*out_values)),
362                                                 &sz);
363
364         if (IS_ERR(val))
365                 return PTR_ERR(val);
366
367         if (!sz_max)
368                 sz = sz_min;
369         else
370                 sz /= sizeof(*out_values);
371
372         count = sz;
373         while (count--) {
374                 *out_values++ = of_read_number(val, 2);
375                 val += 2;
376         }
377
378         return sz;
379 }
380 EXPORT_SYMBOL_GPL(of_property_read_variable_u64_array);
381
382 /**
383  * of_property_read_string - Find and read a string from a property
384  * @np:         device node from which the property value is to be read.
385  * @propname:   name of the property to be searched.
386  * @out_string: pointer to null terminated return string, modified only if
387  *              return value is 0.
388  *
389  * Search for a property in a device tree node and retrieve a null
390  * terminated string value (pointer to data, not a copy). Returns 0 on
391  * success, -EINVAL if the property does not exist, -ENODATA if property
392  * does not have a value, and -EILSEQ if the string is not null-terminated
393  * within the length of the property data.
394  *
395  * The out_string pointer is modified only if a valid string can be decoded.
396  */
397 int of_property_read_string(const struct device_node *np, const char *propname,
398                                 const char **out_string)
399 {
400         const struct property *prop = of_find_property(np, propname, NULL);
401         if (!prop)
402                 return -EINVAL;
403         if (!prop->value)
404                 return -ENODATA;
405         if (strnlen(prop->value, prop->length) >= prop->length)
406                 return -EILSEQ;
407         *out_string = prop->value;
408         return 0;
409 }
410 EXPORT_SYMBOL_GPL(of_property_read_string);
411
412 /**
413  * of_property_match_string() - Find string in a list and return index
414  * @np: pointer to node containing string list property
415  * @propname: string list property name
416  * @string: pointer to string to search for in string list
417  *
418  * This function searches a string list property and returns the index
419  * of a specific string value.
420  */
421 int of_property_match_string(const struct device_node *np, const char *propname,
422                              const char *string)
423 {
424         const struct property *prop = of_find_property(np, propname, NULL);
425         size_t l;
426         int i;
427         const char *p, *end;
428
429         if (!prop)
430                 return -EINVAL;
431         if (!prop->value)
432                 return -ENODATA;
433
434         p = prop->value;
435         end = p + prop->length;
436
437         for (i = 0; p < end; i++, p += l) {
438                 l = strnlen(p, end - p) + 1;
439                 if (p + l > end)
440                         return -EILSEQ;
441                 pr_debug("comparing %s with %s\n", string, p);
442                 if (strcmp(string, p) == 0)
443                         return i; /* Found it; return index */
444         }
445         return -ENODATA;
446 }
447 EXPORT_SYMBOL_GPL(of_property_match_string);
448
449 /**
450  * of_property_read_string_helper() - Utility helper for parsing string properties
451  * @np:         device node from which the property value is to be read.
452  * @propname:   name of the property to be searched.
453  * @out_strs:   output array of string pointers.
454  * @sz:         number of array elements to read.
455  * @skip:       Number of strings to skip over at beginning of list.
456  *
457  * Don't call this function directly. It is a utility helper for the
458  * of_property_read_string*() family of functions.
459  */
460 int of_property_read_string_helper(const struct device_node *np,
461                                    const char *propname, const char **out_strs,
462                                    size_t sz, int skip)
463 {
464         const struct property *prop = of_find_property(np, propname, NULL);
465         int l = 0, i = 0;
466         const char *p, *end;
467
468         if (!prop)
469                 return -EINVAL;
470         if (!prop->value)
471                 return -ENODATA;
472         p = prop->value;
473         end = p + prop->length;
474
475         for (i = 0; p < end && (!out_strs || i < skip + sz); i++, p += l) {
476                 l = strnlen(p, end - p) + 1;
477                 if (p + l > end)
478                         return -EILSEQ;
479                 if (out_strs && i >= skip)
480                         *out_strs++ = p;
481         }
482         i -= skip;
483         return i <= 0 ? -ENODATA : i;
484 }
485 EXPORT_SYMBOL_GPL(of_property_read_string_helper);
486
487 const __be32 *of_prop_next_u32(struct property *prop, const __be32 *cur,
488                                u32 *pu)
489 {
490         const void *curv = cur;
491
492         if (!prop)
493                 return NULL;
494
495         if (!cur) {
496                 curv = prop->value;
497                 goto out_val;
498         }
499
500         curv += sizeof(*cur);
501         if (curv >= prop->value + prop->length)
502                 return NULL;
503
504 out_val:
505         *pu = be32_to_cpup(curv);
506         return curv;
507 }
508 EXPORT_SYMBOL_GPL(of_prop_next_u32);
509
510 const char *of_prop_next_string(struct property *prop, const char *cur)
511 {
512         const void *curv = cur;
513
514         if (!prop)
515                 return NULL;
516
517         if (!cur)
518                 return prop->value;
519
520         curv += strlen(cur) + 1;
521         if (curv >= prop->value + prop->length)
522                 return NULL;
523
524         return curv;
525 }
526 EXPORT_SYMBOL_GPL(of_prop_next_string);
527
528 /**
529  * of_graph_parse_endpoint() - parse common endpoint node properties
530  * @node: pointer to endpoint device_node
531  * @endpoint: pointer to the OF endpoint data structure
532  *
533  * The caller should hold a reference to @node.
534  */
535 int of_graph_parse_endpoint(const struct device_node *node,
536                             struct of_endpoint *endpoint)
537 {
538         struct device_node *port_node = of_get_parent(node);
539
540         WARN_ONCE(!port_node, "%s(): endpoint %s has no parent node\n",
541                   __func__, node->full_name);
542
543         memset(endpoint, 0, sizeof(*endpoint));
544
545         endpoint->local_node = node;
546         /*
547          * It doesn't matter whether the two calls below succeed.
548          * If they don't then the default value 0 is used.
549          */
550         of_property_read_u32(port_node, "reg", &endpoint->port);
551         of_property_read_u32(node, "reg", &endpoint->id);
552
553         of_node_put(port_node);
554
555         return 0;
556 }
557 EXPORT_SYMBOL(of_graph_parse_endpoint);
558
559 /**
560  * of_graph_get_port_by_id() - get the port matching a given id
561  * @parent: pointer to the parent device node
562  * @id: id of the port
563  *
564  * Return: A 'port' node pointer with refcount incremented. The caller
565  * has to use of_node_put() on it when done.
566  */
567 struct device_node *of_graph_get_port_by_id(struct device_node *parent, u32 id)
568 {
569         struct device_node *node, *port;
570
571         node = of_get_child_by_name(parent, "ports");
572         if (node)
573                 parent = node;
574
575         for_each_child_of_node(parent, port) {
576                 u32 port_id = 0;
577
578                 if (of_node_cmp(port->name, "port") != 0)
579                         continue;
580                 of_property_read_u32(port, "reg", &port_id);
581                 if (id == port_id)
582                         break;
583         }
584
585         of_node_put(node);
586
587         return port;
588 }
589 EXPORT_SYMBOL(of_graph_get_port_by_id);
590
591 /**
592  * of_graph_get_next_endpoint() - get next endpoint node
593  * @parent: pointer to the parent device node
594  * @prev: previous endpoint node, or NULL to get first
595  *
596  * Return: An 'endpoint' node pointer with refcount incremented. Refcount
597  * of the passed @prev node is decremented.
598  */
599 struct device_node *of_graph_get_next_endpoint(const struct device_node *parent,
600                                         struct device_node *prev)
601 {
602         struct device_node *endpoint;
603         struct device_node *port;
604
605         if (!parent)
606                 return NULL;
607
608         /*
609          * Start by locating the port node. If no previous endpoint is specified
610          * search for the first port node, otherwise get the previous endpoint
611          * parent port node.
612          */
613         if (!prev) {
614                 struct device_node *node;
615
616                 node = of_get_child_by_name(parent, "ports");
617                 if (node)
618                         parent = node;
619
620                 port = of_get_child_by_name(parent, "port");
621                 of_node_put(node);
622
623                 if (!port) {
624                         pr_err("graph: no port node found in %s\n",
625                                parent->full_name);
626                         return NULL;
627                 }
628         } else {
629                 port = of_get_parent(prev);
630                 if (WARN_ONCE(!port, "%s(): endpoint %s has no parent node\n",
631                               __func__, prev->full_name))
632                         return NULL;
633         }
634
635         while (1) {
636                 /*
637                  * Now that we have a port node, get the next endpoint by
638                  * getting the next child. If the previous endpoint is NULL this
639                  * will return the first child.
640                  */
641                 endpoint = of_get_next_child(port, prev);
642                 if (endpoint) {
643                         of_node_put(port);
644                         return endpoint;
645                 }
646
647                 /* No more endpoints under this port, try the next one. */
648                 prev = NULL;
649
650                 do {
651                         port = of_get_next_child(parent, port);
652                         if (!port)
653                                 return NULL;
654                 } while (of_node_cmp(port->name, "port"));
655         }
656 }
657 EXPORT_SYMBOL(of_graph_get_next_endpoint);
658
659 /**
660  * of_graph_get_endpoint_by_regs() - get endpoint node of specific identifiers
661  * @parent: pointer to the parent device node
662  * @port_reg: identifier (value of reg property) of the parent port node
663  * @reg: identifier (value of reg property) of the endpoint node
664  *
665  * Return: An 'endpoint' node pointer which is identified by reg and at the same
666  * is the child of a port node identified by port_reg. reg and port_reg are
667  * ignored when they are -1.
668  */
669 struct device_node *of_graph_get_endpoint_by_regs(
670         const struct device_node *parent, int port_reg, int reg)
671 {
672         struct of_endpoint endpoint;
673         struct device_node *node = NULL;
674
675         for_each_endpoint_of_node(parent, node) {
676                 of_graph_parse_endpoint(node, &endpoint);
677                 if (((port_reg == -1) || (endpoint.port == port_reg)) &&
678                         ((reg == -1) || (endpoint.id == reg)))
679                         return node;
680         }
681
682         return NULL;
683 }
684 EXPORT_SYMBOL(of_graph_get_endpoint_by_regs);
685
686 /**
687  * of_graph_get_remote_endpoint() - get remote endpoint node
688  * @node: pointer to a local endpoint device_node
689  *
690  * Return: Remote endpoint node associated with remote endpoint node linked
691  *         to @node. Use of_node_put() on it when done.
692  */
693 struct device_node *of_graph_get_remote_endpoint(const struct device_node *node)
694 {
695         /* Get remote endpoint node. */
696         return of_parse_phandle(node, "remote-endpoint", 0);
697 }
698 EXPORT_SYMBOL(of_graph_get_remote_endpoint);
699
700 /**
701  * of_graph_get_port_parent() - get port's parent node
702  * @node: pointer to a local endpoint device_node
703  *
704  * Return: device node associated with endpoint node linked
705  *         to @node. Use of_node_put() on it when done.
706  */
707 struct device_node *of_graph_get_port_parent(struct device_node *node)
708 {
709         unsigned int depth;
710
711         /* Walk 3 levels up only if there is 'ports' node. */
712         for (depth = 3; depth && node; depth--) {
713                 node = of_get_next_parent(node);
714                 if (depth == 2 && of_node_cmp(node->name, "ports"))
715                         break;
716         }
717         return node;
718 }
719 EXPORT_SYMBOL(of_graph_get_port_parent);
720
721 /**
722  * of_graph_get_remote_port_parent() - get remote port's parent node
723  * @node: pointer to a local endpoint device_node
724  *
725  * Return: Remote device node associated with remote endpoint node linked
726  *         to @node. Use of_node_put() on it when done.
727  */
728 struct device_node *of_graph_get_remote_port_parent(
729                                const struct device_node *node)
730 {
731         struct device_node *np;
732
733         /* Get remote endpoint node. */
734         np = of_graph_get_remote_endpoint(node);
735
736         return of_graph_get_port_parent(np);
737 }
738 EXPORT_SYMBOL(of_graph_get_remote_port_parent);
739
740 /**
741  * of_graph_get_remote_port() - get remote port node
742  * @node: pointer to a local endpoint device_node
743  *
744  * Return: Remote port node associated with remote endpoint node linked
745  *         to @node. Use of_node_put() on it when done.
746  */
747 struct device_node *of_graph_get_remote_port(const struct device_node *node)
748 {
749         struct device_node *np;
750
751         /* Get remote endpoint node. */
752         np = of_graph_get_remote_endpoint(node);
753         if (!np)
754                 return NULL;
755         return of_get_next_parent(np);
756 }
757 EXPORT_SYMBOL(of_graph_get_remote_port);
758
759 int of_graph_get_endpoint_count(const struct device_node *np)
760 {
761         struct device_node *endpoint;
762         int num = 0;
763
764         for_each_endpoint_of_node(np, endpoint)
765                 num++;
766
767         return num;
768 }
769 EXPORT_SYMBOL(of_graph_get_endpoint_count);
770
771 /**
772  * of_graph_get_remote_node() - get remote parent device_node for given port/endpoint
773  * @node: pointer to parent device_node containing graph port/endpoint
774  * @port: identifier (value of reg property) of the parent port node
775  * @endpoint: identifier (value of reg property) of the endpoint node
776  *
777  * Return: Remote device node associated with remote endpoint node linked
778  *         to @node. Use of_node_put() on it when done.
779  */
780 struct device_node *of_graph_get_remote_node(const struct device_node *node,
781                                              u32 port, u32 endpoint)
782 {
783         struct device_node *endpoint_node, *remote;
784
785         endpoint_node = of_graph_get_endpoint_by_regs(node, port, endpoint);
786         if (!endpoint_node) {
787                 pr_debug("no valid endpoint (%d, %d) for node %s\n",
788                          port, endpoint, node->full_name);
789                 return NULL;
790         }
791
792         remote = of_graph_get_remote_port_parent(endpoint_node);
793         of_node_put(endpoint_node);
794         if (!remote) {
795                 pr_debug("no valid remote node\n");
796                 return NULL;
797         }
798
799         if (!of_device_is_available(remote)) {
800                 pr_debug("not available for remote node\n");
801                 return NULL;
802         }
803
804         return remote;
805 }
806 EXPORT_SYMBOL(of_graph_get_remote_node);
807
808 static void of_fwnode_get(struct fwnode_handle *fwnode)
809 {
810         of_node_get(to_of_node(fwnode));
811 }
812
813 static void of_fwnode_put(struct fwnode_handle *fwnode)
814 {
815         of_node_put(to_of_node(fwnode));
816 }
817
818 static bool of_fwnode_device_is_available(struct fwnode_handle *fwnode)
819 {
820         return of_device_is_available(to_of_node(fwnode));
821 }
822
823 static bool of_fwnode_property_present(struct fwnode_handle *fwnode,
824                                        const char *propname)
825 {
826         return of_property_read_bool(to_of_node(fwnode), propname);
827 }
828
829 static int of_fwnode_property_read_int_array(struct fwnode_handle *fwnode,
830                                              const char *propname,
831                                              unsigned int elem_size, void *val,
832                                              size_t nval)
833 {
834         struct device_node *node = to_of_node(fwnode);
835
836         if (!val)
837                 return of_property_count_elems_of_size(node, propname,
838                                                        elem_size);
839
840         switch (elem_size) {
841         case sizeof(u8):
842                 return of_property_read_u8_array(node, propname, val, nval);
843         case sizeof(u16):
844                 return of_property_read_u16_array(node, propname, val, nval);
845         case sizeof(u32):
846                 return of_property_read_u32_array(node, propname, val, nval);
847         case sizeof(u64):
848                 return of_property_read_u64_array(node, propname, val, nval);
849         }
850
851         return -ENXIO;
852 }
853
854 static int of_fwnode_property_read_string_array(struct fwnode_handle *fwnode,
855                                                 const char *propname,
856                                                 const char **val, size_t nval)
857 {
858         struct device_node *node = to_of_node(fwnode);
859
860         return val ?
861                 of_property_read_string_array(node, propname, val, nval) :
862                 of_property_count_strings(node, propname);
863 }
864
865 static struct fwnode_handle *of_fwnode_get_parent(struct fwnode_handle *fwnode)
866 {
867         return of_fwnode_handle(of_get_parent(to_of_node(fwnode)));
868 }
869
870 static struct fwnode_handle *
871 of_fwnode_get_next_child_node(struct fwnode_handle *fwnode,
872                               struct fwnode_handle *child)
873 {
874         return of_fwnode_handle(of_get_next_available_child(to_of_node(fwnode),
875                                                             to_of_node(child)));
876 }
877
878 static struct fwnode_handle *
879 of_fwnode_get_named_child_node(struct fwnode_handle *fwnode,
880                                const char *childname)
881 {
882         struct device_node *node = to_of_node(fwnode);
883         struct device_node *child;
884
885         for_each_available_child_of_node(node, child)
886                 if (!of_node_cmp(child->name, childname))
887                         return of_fwnode_handle(child);
888
889         return NULL;
890 }
891
892 static struct fwnode_handle *
893 of_fwnode_graph_get_next_endpoint(struct fwnode_handle *fwnode,
894                                   struct fwnode_handle *prev)
895 {
896         return of_fwnode_handle(of_graph_get_next_endpoint(to_of_node(fwnode),
897                                                            to_of_node(prev)));
898 }
899
900 static struct fwnode_handle *
901 of_fwnode_graph_get_remote_endpoint(struct fwnode_handle *fwnode)
902 {
903         return of_fwnode_handle(of_parse_phandle(to_of_node(fwnode),
904                                                  "remote-endpoint", 0));
905 }
906
907 static struct fwnode_handle *
908 of_fwnode_graph_get_port_parent(struct fwnode_handle *fwnode)
909 {
910         struct device_node *np;
911
912         /* Get the parent of the port */
913         np = of_get_next_parent(to_of_node(fwnode));
914         if (!np)
915                 return NULL;
916
917         /* Is this the "ports" node? If not, it's the port parent. */
918         if (of_node_cmp(np->name, "ports"))
919                 return of_fwnode_handle(np);
920
921         return of_fwnode_handle(of_get_next_parent(np));
922 }
923
924 static int of_fwnode_graph_parse_endpoint(struct fwnode_handle *fwnode,
925                                           struct fwnode_endpoint *endpoint)
926 {
927         struct device_node *node = to_of_node(fwnode);
928         struct device_node *port_node = of_get_parent(node);
929
930         endpoint->local_fwnode = fwnode;
931
932         of_property_read_u32(port_node, "reg", &endpoint->port);
933         of_property_read_u32(node, "reg", &endpoint->id);
934
935         of_node_put(port_node);
936
937         return 0;
938 }
939
940 const struct fwnode_operations of_fwnode_ops = {
941         .get = of_fwnode_get,
942         .put = of_fwnode_put,
943         .device_is_available = of_fwnode_device_is_available,
944         .property_present = of_fwnode_property_present,
945         .property_read_int_array = of_fwnode_property_read_int_array,
946         .property_read_string_array = of_fwnode_property_read_string_array,
947         .get_parent = of_fwnode_get_parent,
948         .get_next_child_node = of_fwnode_get_next_child_node,
949         .get_named_child_node = of_fwnode_get_named_child_node,
950         .graph_get_next_endpoint = of_fwnode_graph_get_next_endpoint,
951         .graph_get_remote_endpoint = of_fwnode_graph_get_remote_endpoint,
952         .graph_get_port_parent = of_fwnode_graph_get_port_parent,
953         .graph_parse_endpoint = of_fwnode_graph_parse_endpoint,
954 };