of: Fix overflow bug in string property parsing functions
[sfrench/cifs-2.6.git] / drivers / of / base.c
1 /*
2  * Procedures for creating, accessing and interpreting the device tree.
3  *
4  * Paul Mackerras       August 1996.
5  * Copyright (C) 1996-2005 Paul Mackerras.
6  *
7  *  Adapted for 64bit PowerPC by Dave Engebretsen and Peter Bergner.
8  *    {engebret|bergner}@us.ibm.com
9  *
10  *  Adapted for sparc and sparc64 by David S. Miller davem@davemloft.net
11  *
12  *  Reconsolidated from arch/x/kernel/prom.c by Stephen Rothwell and
13  *  Grant Likely.
14  *
15  *      This program is free software; you can redistribute it and/or
16  *      modify it under the terms of the GNU General Public License
17  *      as published by the Free Software Foundation; either version
18  *      2 of the License, or (at your option) any later version.
19  */
20 #include <linux/console.h>
21 #include <linux/ctype.h>
22 #include <linux/cpu.h>
23 #include <linux/module.h>
24 #include <linux/of.h>
25 #include <linux/of_graph.h>
26 #include <linux/spinlock.h>
27 #include <linux/slab.h>
28 #include <linux/string.h>
29 #include <linux/proc_fs.h>
30
31 #include "of_private.h"
32
33 LIST_HEAD(aliases_lookup);
34
35 struct device_node *of_allnodes;
36 EXPORT_SYMBOL(of_allnodes);
37 struct device_node *of_chosen;
38 struct device_node *of_aliases;
39 struct device_node *of_stdout;
40
41 struct kset *of_kset;
42
43 /*
44  * Used to protect the of_aliases, to hold off addition of nodes to sysfs.
45  * This mutex must be held whenever modifications are being made to the
46  * device tree. The of_{attach,detach}_node() and
47  * of_{add,remove,update}_property() helpers make sure this happens.
48  */
49 DEFINE_MUTEX(of_mutex);
50
51 /* use when traversing tree through the allnext, child, sibling,
52  * or parent members of struct device_node.
53  */
54 DEFINE_RAW_SPINLOCK(devtree_lock);
55
56 int of_n_addr_cells(struct device_node *np)
57 {
58         const __be32 *ip;
59
60         do {
61                 if (np->parent)
62                         np = np->parent;
63                 ip = of_get_property(np, "#address-cells", NULL);
64                 if (ip)
65                         return be32_to_cpup(ip);
66         } while (np->parent);
67         /* No #address-cells property for the root node */
68         return OF_ROOT_NODE_ADDR_CELLS_DEFAULT;
69 }
70 EXPORT_SYMBOL(of_n_addr_cells);
71
72 int of_n_size_cells(struct device_node *np)
73 {
74         const __be32 *ip;
75
76         do {
77                 if (np->parent)
78                         np = np->parent;
79                 ip = of_get_property(np, "#size-cells", NULL);
80                 if (ip)
81                         return be32_to_cpup(ip);
82         } while (np->parent);
83         /* No #size-cells property for the root node */
84         return OF_ROOT_NODE_SIZE_CELLS_DEFAULT;
85 }
86 EXPORT_SYMBOL(of_n_size_cells);
87
88 #ifdef CONFIG_NUMA
89 int __weak of_node_to_nid(struct device_node *np)
90 {
91         return numa_node_id();
92 }
93 #endif
94
95 #ifndef CONFIG_OF_DYNAMIC
96 static void of_node_release(struct kobject *kobj)
97 {
98         /* Without CONFIG_OF_DYNAMIC, no nodes gets freed */
99 }
100 #endif /* CONFIG_OF_DYNAMIC */
101
102 struct kobj_type of_node_ktype = {
103         .release = of_node_release,
104 };
105
106 static ssize_t of_node_property_read(struct file *filp, struct kobject *kobj,
107                                 struct bin_attribute *bin_attr, char *buf,
108                                 loff_t offset, size_t count)
109 {
110         struct property *pp = container_of(bin_attr, struct property, attr);
111         return memory_read_from_buffer(buf, count, &offset, pp->value, pp->length);
112 }
113
114 static const char *safe_name(struct kobject *kobj, const char *orig_name)
115 {
116         const char *name = orig_name;
117         struct kernfs_node *kn;
118         int i = 0;
119
120         /* don't be a hero. After 16 tries give up */
121         while (i < 16 && (kn = sysfs_get_dirent(kobj->sd, name))) {
122                 sysfs_put(kn);
123                 if (name != orig_name)
124                         kfree(name);
125                 name = kasprintf(GFP_KERNEL, "%s#%i", orig_name, ++i);
126         }
127
128         if (name != orig_name)
129                 pr_warn("device-tree: Duplicate name in %s, renamed to \"%s\"\n",
130                         kobject_name(kobj), name);
131         return name;
132 }
133
134 int __of_add_property_sysfs(struct device_node *np, struct property *pp)
135 {
136         int rc;
137
138         /* Important: Don't leak passwords */
139         bool secure = strncmp(pp->name, "security-", 9) == 0;
140
141         if (!IS_ENABLED(CONFIG_SYSFS))
142                 return 0;
143
144         if (!of_kset || !of_node_is_attached(np))
145                 return 0;
146
147         sysfs_bin_attr_init(&pp->attr);
148         pp->attr.attr.name = safe_name(&np->kobj, pp->name);
149         pp->attr.attr.mode = secure ? S_IRUSR : S_IRUGO;
150         pp->attr.size = secure ? 0 : pp->length;
151         pp->attr.read = of_node_property_read;
152
153         rc = sysfs_create_bin_file(&np->kobj, &pp->attr);
154         WARN(rc, "error adding attribute %s to node %s\n", pp->name, np->full_name);
155         return rc;
156 }
157
158 int __of_attach_node_sysfs(struct device_node *np)
159 {
160         const char *name;
161         struct property *pp;
162         int rc;
163
164         if (!IS_ENABLED(CONFIG_SYSFS))
165                 return 0;
166
167         if (!of_kset)
168                 return 0;
169
170         np->kobj.kset = of_kset;
171         if (!np->parent) {
172                 /* Nodes without parents are new top level trees */
173                 rc = kobject_add(&np->kobj, NULL, "%s",
174                                  safe_name(&of_kset->kobj, "base"));
175         } else {
176                 name = safe_name(&np->parent->kobj, kbasename(np->full_name));
177                 if (!name || !name[0])
178                         return -EINVAL;
179
180                 rc = kobject_add(&np->kobj, &np->parent->kobj, "%s", name);
181         }
182         if (rc)
183                 return rc;
184
185         for_each_property_of_node(np, pp)
186                 __of_add_property_sysfs(np, pp);
187
188         return 0;
189 }
190
191 static int __init of_init(void)
192 {
193         struct device_node *np;
194
195         /* Create the kset, and register existing nodes */
196         mutex_lock(&of_mutex);
197         of_kset = kset_create_and_add("devicetree", NULL, firmware_kobj);
198         if (!of_kset) {
199                 mutex_unlock(&of_mutex);
200                 return -ENOMEM;
201         }
202         for_each_of_allnodes(np)
203                 __of_attach_node_sysfs(np);
204         mutex_unlock(&of_mutex);
205
206         /* Symlink in /proc as required by userspace ABI */
207         if (of_allnodes)
208                 proc_symlink("device-tree", NULL, "/sys/firmware/devicetree/base");
209
210         return 0;
211 }
212 core_initcall(of_init);
213
214 static struct property *__of_find_property(const struct device_node *np,
215                                            const char *name, int *lenp)
216 {
217         struct property *pp;
218
219         if (!np)
220                 return NULL;
221
222         for (pp = np->properties; pp; pp = pp->next) {
223                 if (of_prop_cmp(pp->name, name) == 0) {
224                         if (lenp)
225                                 *lenp = pp->length;
226                         break;
227                 }
228         }
229
230         return pp;
231 }
232
233 struct property *of_find_property(const struct device_node *np,
234                                   const char *name,
235                                   int *lenp)
236 {
237         struct property *pp;
238         unsigned long flags;
239
240         raw_spin_lock_irqsave(&devtree_lock, flags);
241         pp = __of_find_property(np, name, lenp);
242         raw_spin_unlock_irqrestore(&devtree_lock, flags);
243
244         return pp;
245 }
246 EXPORT_SYMBOL(of_find_property);
247
248 /**
249  * of_find_all_nodes - Get next node in global list
250  * @prev:       Previous node or NULL to start iteration
251  *              of_node_put() will be called on it
252  *
253  * Returns a node pointer with refcount incremented, use
254  * of_node_put() on it when done.
255  */
256 struct device_node *of_find_all_nodes(struct device_node *prev)
257 {
258         struct device_node *np;
259         unsigned long flags;
260
261         raw_spin_lock_irqsave(&devtree_lock, flags);
262         np = prev ? prev->allnext : of_allnodes;
263         for (; np != NULL; np = np->allnext)
264                 if (of_node_get(np))
265                         break;
266         of_node_put(prev);
267         raw_spin_unlock_irqrestore(&devtree_lock, flags);
268         return np;
269 }
270 EXPORT_SYMBOL(of_find_all_nodes);
271
272 /*
273  * Find a property with a given name for a given node
274  * and return the value.
275  */
276 const void *__of_get_property(const struct device_node *np,
277                               const char *name, int *lenp)
278 {
279         struct property *pp = __of_find_property(np, name, lenp);
280
281         return pp ? pp->value : NULL;
282 }
283
284 /*
285  * Find a property with a given name for a given node
286  * and return the value.
287  */
288 const void *of_get_property(const struct device_node *np, const char *name,
289                             int *lenp)
290 {
291         struct property *pp = of_find_property(np, name, lenp);
292
293         return pp ? pp->value : NULL;
294 }
295 EXPORT_SYMBOL(of_get_property);
296
297 /*
298  * arch_match_cpu_phys_id - Match the given logical CPU and physical id
299  *
300  * @cpu: logical cpu index of a core/thread
301  * @phys_id: physical identifier of a core/thread
302  *
303  * CPU logical to physical index mapping is architecture specific.
304  * However this __weak function provides a default match of physical
305  * id to logical cpu index. phys_id provided here is usually values read
306  * from the device tree which must match the hardware internal registers.
307  *
308  * Returns true if the physical identifier and the logical cpu index
309  * correspond to the same core/thread, false otherwise.
310  */
311 bool __weak arch_match_cpu_phys_id(int cpu, u64 phys_id)
312 {
313         return (u32)phys_id == cpu;
314 }
315
316 /**
317  * Checks if the given "prop_name" property holds the physical id of the
318  * core/thread corresponding to the logical cpu 'cpu'. If 'thread' is not
319  * NULL, local thread number within the core is returned in it.
320  */
321 static bool __of_find_n_match_cpu_property(struct device_node *cpun,
322                         const char *prop_name, int cpu, unsigned int *thread)
323 {
324         const __be32 *cell;
325         int ac, prop_len, tid;
326         u64 hwid;
327
328         ac = of_n_addr_cells(cpun);
329         cell = of_get_property(cpun, prop_name, &prop_len);
330         if (!cell || !ac)
331                 return false;
332         prop_len /= sizeof(*cell) * ac;
333         for (tid = 0; tid < prop_len; tid++) {
334                 hwid = of_read_number(cell, ac);
335                 if (arch_match_cpu_phys_id(cpu, hwid)) {
336                         if (thread)
337                                 *thread = tid;
338                         return true;
339                 }
340                 cell += ac;
341         }
342         return false;
343 }
344
345 /*
346  * arch_find_n_match_cpu_physical_id - See if the given device node is
347  * for the cpu corresponding to logical cpu 'cpu'.  Return true if so,
348  * else false.  If 'thread' is non-NULL, the local thread number within the
349  * core is returned in it.
350  */
351 bool __weak arch_find_n_match_cpu_physical_id(struct device_node *cpun,
352                                               int cpu, unsigned int *thread)
353 {
354         /* Check for non-standard "ibm,ppc-interrupt-server#s" property
355          * for thread ids on PowerPC. If it doesn't exist fallback to
356          * standard "reg" property.
357          */
358         if (IS_ENABLED(CONFIG_PPC) &&
359             __of_find_n_match_cpu_property(cpun,
360                                            "ibm,ppc-interrupt-server#s",
361                                            cpu, thread))
362                 return true;
363
364         if (__of_find_n_match_cpu_property(cpun, "reg", cpu, thread))
365                 return true;
366
367         return false;
368 }
369
370 /**
371  * of_get_cpu_node - Get device node associated with the given logical CPU
372  *
373  * @cpu: CPU number(logical index) for which device node is required
374  * @thread: if not NULL, local thread number within the physical core is
375  *          returned
376  *
377  * The main purpose of this function is to retrieve the device node for the
378  * given logical CPU index. It should be used to initialize the of_node in
379  * cpu device. Once of_node in cpu device is populated, all the further
380  * references can use that instead.
381  *
382  * CPU logical to physical index mapping is architecture specific and is built
383  * before booting secondary cores. This function uses arch_match_cpu_phys_id
384  * which can be overridden by architecture specific implementation.
385  *
386  * Returns a node pointer for the logical cpu if found, else NULL.
387  */
388 struct device_node *of_get_cpu_node(int cpu, unsigned int *thread)
389 {
390         struct device_node *cpun;
391
392         for_each_node_by_type(cpun, "cpu") {
393                 if (arch_find_n_match_cpu_physical_id(cpun, cpu, thread))
394                         return cpun;
395         }
396         return NULL;
397 }
398 EXPORT_SYMBOL(of_get_cpu_node);
399
400 /**
401  * __of_device_is_compatible() - Check if the node matches given constraints
402  * @device: pointer to node
403  * @compat: required compatible string, NULL or "" for any match
404  * @type: required device_type value, NULL or "" for any match
405  * @name: required node name, NULL or "" for any match
406  *
407  * Checks if the given @compat, @type and @name strings match the
408  * properties of the given @device. A constraints can be skipped by
409  * passing NULL or an empty string as the constraint.
410  *
411  * Returns 0 for no match, and a positive integer on match. The return
412  * value is a relative score with larger values indicating better
413  * matches. The score is weighted for the most specific compatible value
414  * to get the highest score. Matching type is next, followed by matching
415  * name. Practically speaking, this results in the following priority
416  * order for matches:
417  *
418  * 1. specific compatible && type && name
419  * 2. specific compatible && type
420  * 3. specific compatible && name
421  * 4. specific compatible
422  * 5. general compatible && type && name
423  * 6. general compatible && type
424  * 7. general compatible && name
425  * 8. general compatible
426  * 9. type && name
427  * 10. type
428  * 11. name
429  */
430 static int __of_device_is_compatible(const struct device_node *device,
431                                      const char *compat, const char *type, const char *name)
432 {
433         struct property *prop;
434         const char *cp;
435         int index = 0, score = 0;
436
437         /* Compatible match has highest priority */
438         if (compat && compat[0]) {
439                 prop = __of_find_property(device, "compatible", NULL);
440                 for (cp = of_prop_next_string(prop, NULL); cp;
441                      cp = of_prop_next_string(prop, cp), index++) {
442                         if (of_compat_cmp(cp, compat, strlen(compat)) == 0) {
443                                 score = INT_MAX/2 - (index << 2);
444                                 break;
445                         }
446                 }
447                 if (!score)
448                         return 0;
449         }
450
451         /* Matching type is better than matching name */
452         if (type && type[0]) {
453                 if (!device->type || of_node_cmp(type, device->type))
454                         return 0;
455                 score += 2;
456         }
457
458         /* Matching name is a bit better than not */
459         if (name && name[0]) {
460                 if (!device->name || of_node_cmp(name, device->name))
461                         return 0;
462                 score++;
463         }
464
465         return score;
466 }
467
468 /** Checks if the given "compat" string matches one of the strings in
469  * the device's "compatible" property
470  */
471 int of_device_is_compatible(const struct device_node *device,
472                 const char *compat)
473 {
474         unsigned long flags;
475         int res;
476
477         raw_spin_lock_irqsave(&devtree_lock, flags);
478         res = __of_device_is_compatible(device, compat, NULL, NULL);
479         raw_spin_unlock_irqrestore(&devtree_lock, flags);
480         return res;
481 }
482 EXPORT_SYMBOL(of_device_is_compatible);
483
484 /**
485  * of_machine_is_compatible - Test root of device tree for a given compatible value
486  * @compat: compatible string to look for in root node's compatible property.
487  *
488  * Returns true if the root node has the given value in its
489  * compatible property.
490  */
491 int of_machine_is_compatible(const char *compat)
492 {
493         struct device_node *root;
494         int rc = 0;
495
496         root = of_find_node_by_path("/");
497         if (root) {
498                 rc = of_device_is_compatible(root, compat);
499                 of_node_put(root);
500         }
501         return rc;
502 }
503 EXPORT_SYMBOL(of_machine_is_compatible);
504
505 /**
506  *  __of_device_is_available - check if a device is available for use
507  *
508  *  @device: Node to check for availability, with locks already held
509  *
510  *  Returns 1 if the status property is absent or set to "okay" or "ok",
511  *  0 otherwise
512  */
513 static int __of_device_is_available(const struct device_node *device)
514 {
515         const char *status;
516         int statlen;
517
518         if (!device)
519                 return 0;
520
521         status = __of_get_property(device, "status", &statlen);
522         if (status == NULL)
523                 return 1;
524
525         if (statlen > 0) {
526                 if (!strcmp(status, "okay") || !strcmp(status, "ok"))
527                         return 1;
528         }
529
530         return 0;
531 }
532
533 /**
534  *  of_device_is_available - check if a device is available for use
535  *
536  *  @device: Node to check for availability
537  *
538  *  Returns 1 if the status property is absent or set to "okay" or "ok",
539  *  0 otherwise
540  */
541 int of_device_is_available(const struct device_node *device)
542 {
543         unsigned long flags;
544         int res;
545
546         raw_spin_lock_irqsave(&devtree_lock, flags);
547         res = __of_device_is_available(device);
548         raw_spin_unlock_irqrestore(&devtree_lock, flags);
549         return res;
550
551 }
552 EXPORT_SYMBOL(of_device_is_available);
553
554 /**
555  *      of_get_parent - Get a node's parent if any
556  *      @node:  Node to get parent
557  *
558  *      Returns a node pointer with refcount incremented, use
559  *      of_node_put() on it when done.
560  */
561 struct device_node *of_get_parent(const struct device_node *node)
562 {
563         struct device_node *np;
564         unsigned long flags;
565
566         if (!node)
567                 return NULL;
568
569         raw_spin_lock_irqsave(&devtree_lock, flags);
570         np = of_node_get(node->parent);
571         raw_spin_unlock_irqrestore(&devtree_lock, flags);
572         return np;
573 }
574 EXPORT_SYMBOL(of_get_parent);
575
576 /**
577  *      of_get_next_parent - Iterate to a node's parent
578  *      @node:  Node to get parent of
579  *
580  *      This is like of_get_parent() except that it drops the
581  *      refcount on the passed node, making it suitable for iterating
582  *      through a node's parents.
583  *
584  *      Returns a node pointer with refcount incremented, use
585  *      of_node_put() on it when done.
586  */
587 struct device_node *of_get_next_parent(struct device_node *node)
588 {
589         struct device_node *parent;
590         unsigned long flags;
591
592         if (!node)
593                 return NULL;
594
595         raw_spin_lock_irqsave(&devtree_lock, flags);
596         parent = of_node_get(node->parent);
597         of_node_put(node);
598         raw_spin_unlock_irqrestore(&devtree_lock, flags);
599         return parent;
600 }
601 EXPORT_SYMBOL(of_get_next_parent);
602
603 static struct device_node *__of_get_next_child(const struct device_node *node,
604                                                 struct device_node *prev)
605 {
606         struct device_node *next;
607
608         if (!node)
609                 return NULL;
610
611         next = prev ? prev->sibling : node->child;
612         for (; next; next = next->sibling)
613                 if (of_node_get(next))
614                         break;
615         of_node_put(prev);
616         return next;
617 }
618 #define __for_each_child_of_node(parent, child) \
619         for (child = __of_get_next_child(parent, NULL); child != NULL; \
620              child = __of_get_next_child(parent, child))
621
622 /**
623  *      of_get_next_child - Iterate a node childs
624  *      @node:  parent node
625  *      @prev:  previous child of the parent node, or NULL to get first
626  *
627  *      Returns a node pointer with refcount incremented, use
628  *      of_node_put() on it when done.
629  */
630 struct device_node *of_get_next_child(const struct device_node *node,
631         struct device_node *prev)
632 {
633         struct device_node *next;
634         unsigned long flags;
635
636         raw_spin_lock_irqsave(&devtree_lock, flags);
637         next = __of_get_next_child(node, prev);
638         raw_spin_unlock_irqrestore(&devtree_lock, flags);
639         return next;
640 }
641 EXPORT_SYMBOL(of_get_next_child);
642
643 /**
644  *      of_get_next_available_child - Find the next available child node
645  *      @node:  parent node
646  *      @prev:  previous child of the parent node, or NULL to get first
647  *
648  *      This function is like of_get_next_child(), except that it
649  *      automatically skips any disabled nodes (i.e. status = "disabled").
650  */
651 struct device_node *of_get_next_available_child(const struct device_node *node,
652         struct device_node *prev)
653 {
654         struct device_node *next;
655         unsigned long flags;
656
657         if (!node)
658                 return NULL;
659
660         raw_spin_lock_irqsave(&devtree_lock, flags);
661         next = prev ? prev->sibling : node->child;
662         for (; next; next = next->sibling) {
663                 if (!__of_device_is_available(next))
664                         continue;
665                 if (of_node_get(next))
666                         break;
667         }
668         of_node_put(prev);
669         raw_spin_unlock_irqrestore(&devtree_lock, flags);
670         return next;
671 }
672 EXPORT_SYMBOL(of_get_next_available_child);
673
674 /**
675  *      of_get_child_by_name - Find the child node by name for a given parent
676  *      @node:  parent node
677  *      @name:  child name to look for.
678  *
679  *      This function looks for child node for given matching name
680  *
681  *      Returns a node pointer if found, with refcount incremented, use
682  *      of_node_put() on it when done.
683  *      Returns NULL if node is not found.
684  */
685 struct device_node *of_get_child_by_name(const struct device_node *node,
686                                 const char *name)
687 {
688         struct device_node *child;
689
690         for_each_child_of_node(node, child)
691                 if (child->name && (of_node_cmp(child->name, name) == 0))
692                         break;
693         return child;
694 }
695 EXPORT_SYMBOL(of_get_child_by_name);
696
697 static struct device_node *__of_find_node_by_path(struct device_node *parent,
698                                                 const char *path)
699 {
700         struct device_node *child;
701         int len = strchrnul(path, '/') - path;
702
703         if (!len)
704                 return NULL;
705
706         __for_each_child_of_node(parent, child) {
707                 const char *name = strrchr(child->full_name, '/');
708                 if (WARN(!name, "malformed device_node %s\n", child->full_name))
709                         continue;
710                 name++;
711                 if (strncmp(path, name, len) == 0 && (strlen(name) == len))
712                         return child;
713         }
714         return NULL;
715 }
716
717 /**
718  *      of_find_node_by_path - Find a node matching a full OF path
719  *      @path: Either the full path to match, or if the path does not
720  *             start with '/', the name of a property of the /aliases
721  *             node (an alias).  In the case of an alias, the node
722  *             matching the alias' value will be returned.
723  *
724  *      Valid paths:
725  *              /foo/bar        Full path
726  *              foo             Valid alias
727  *              foo/bar         Valid alias + relative path
728  *
729  *      Returns a node pointer with refcount incremented, use
730  *      of_node_put() on it when done.
731  */
732 struct device_node *of_find_node_by_path(const char *path)
733 {
734         struct device_node *np = NULL;
735         struct property *pp;
736         unsigned long flags;
737
738         if (strcmp(path, "/") == 0)
739                 return of_node_get(of_allnodes);
740
741         /* The path could begin with an alias */
742         if (*path != '/') {
743                 char *p = strchrnul(path, '/');
744                 int len = p - path;
745
746                 /* of_aliases must not be NULL */
747                 if (!of_aliases)
748                         return NULL;
749
750                 for_each_property_of_node(of_aliases, pp) {
751                         if (strlen(pp->name) == len && !strncmp(pp->name, path, len)) {
752                                 np = of_find_node_by_path(pp->value);
753                                 break;
754                         }
755                 }
756                 if (!np)
757                         return NULL;
758                 path = p;
759         }
760
761         /* Step down the tree matching path components */
762         raw_spin_lock_irqsave(&devtree_lock, flags);
763         if (!np)
764                 np = of_node_get(of_allnodes);
765         while (np && *path == '/') {
766                 path++; /* Increment past '/' delimiter */
767                 np = __of_find_node_by_path(np, path);
768                 path = strchrnul(path, '/');
769         }
770         raw_spin_unlock_irqrestore(&devtree_lock, flags);
771         return np;
772 }
773 EXPORT_SYMBOL(of_find_node_by_path);
774
775 /**
776  *      of_find_node_by_name - Find a node by its "name" property
777  *      @from:  The node to start searching from or NULL, the node
778  *              you pass will not be searched, only the next one
779  *              will; typically, you pass what the previous call
780  *              returned. of_node_put() will be called on it
781  *      @name:  The name string to match against
782  *
783  *      Returns a node pointer with refcount incremented, use
784  *      of_node_put() on it when done.
785  */
786 struct device_node *of_find_node_by_name(struct device_node *from,
787         const char *name)
788 {
789         struct device_node *np;
790         unsigned long flags;
791
792         raw_spin_lock_irqsave(&devtree_lock, flags);
793         np = from ? from->allnext : of_allnodes;
794         for (; np; np = np->allnext)
795                 if (np->name && (of_node_cmp(np->name, name) == 0)
796                     && of_node_get(np))
797                         break;
798         of_node_put(from);
799         raw_spin_unlock_irqrestore(&devtree_lock, flags);
800         return np;
801 }
802 EXPORT_SYMBOL(of_find_node_by_name);
803
804 /**
805  *      of_find_node_by_type - Find a node by its "device_type" property
806  *      @from:  The node to start searching from, or NULL to start searching
807  *              the entire device tree. The node you pass will not be
808  *              searched, only the next one will; typically, you pass
809  *              what the previous call returned. of_node_put() will be
810  *              called on from for you.
811  *      @type:  The type string to match against
812  *
813  *      Returns a node pointer with refcount incremented, use
814  *      of_node_put() on it when done.
815  */
816 struct device_node *of_find_node_by_type(struct device_node *from,
817         const char *type)
818 {
819         struct device_node *np;
820         unsigned long flags;
821
822         raw_spin_lock_irqsave(&devtree_lock, flags);
823         np = from ? from->allnext : of_allnodes;
824         for (; np; np = np->allnext)
825                 if (np->type && (of_node_cmp(np->type, type) == 0)
826                     && of_node_get(np))
827                         break;
828         of_node_put(from);
829         raw_spin_unlock_irqrestore(&devtree_lock, flags);
830         return np;
831 }
832 EXPORT_SYMBOL(of_find_node_by_type);
833
834 /**
835  *      of_find_compatible_node - Find a node based on type and one of the
836  *                                tokens in its "compatible" property
837  *      @from:          The node to start searching from or NULL, the node
838  *                      you pass will not be searched, only the next one
839  *                      will; typically, you pass what the previous call
840  *                      returned. of_node_put() will be called on it
841  *      @type:          The type string to match "device_type" or NULL to ignore
842  *      @compatible:    The string to match to one of the tokens in the device
843  *                      "compatible" list.
844  *
845  *      Returns a node pointer with refcount incremented, use
846  *      of_node_put() on it when done.
847  */
848 struct device_node *of_find_compatible_node(struct device_node *from,
849         const char *type, const char *compatible)
850 {
851         struct device_node *np;
852         unsigned long flags;
853
854         raw_spin_lock_irqsave(&devtree_lock, flags);
855         np = from ? from->allnext : of_allnodes;
856         for (; np; np = np->allnext) {
857                 if (__of_device_is_compatible(np, compatible, type, NULL) &&
858                     of_node_get(np))
859                         break;
860         }
861         of_node_put(from);
862         raw_spin_unlock_irqrestore(&devtree_lock, flags);
863         return np;
864 }
865 EXPORT_SYMBOL(of_find_compatible_node);
866
867 /**
868  *      of_find_node_with_property - Find a node which has a property with
869  *                                   the given name.
870  *      @from:          The node to start searching from or NULL, the node
871  *                      you pass will not be searched, only the next one
872  *                      will; typically, you pass what the previous call
873  *                      returned. of_node_put() will be called on it
874  *      @prop_name:     The name of the property to look for.
875  *
876  *      Returns a node pointer with refcount incremented, use
877  *      of_node_put() on it when done.
878  */
879 struct device_node *of_find_node_with_property(struct device_node *from,
880         const char *prop_name)
881 {
882         struct device_node *np;
883         struct property *pp;
884         unsigned long flags;
885
886         raw_spin_lock_irqsave(&devtree_lock, flags);
887         np = from ? from->allnext : of_allnodes;
888         for (; np; np = np->allnext) {
889                 for (pp = np->properties; pp; pp = pp->next) {
890                         if (of_prop_cmp(pp->name, prop_name) == 0) {
891                                 of_node_get(np);
892                                 goto out;
893                         }
894                 }
895         }
896 out:
897         of_node_put(from);
898         raw_spin_unlock_irqrestore(&devtree_lock, flags);
899         return np;
900 }
901 EXPORT_SYMBOL(of_find_node_with_property);
902
903 static
904 const struct of_device_id *__of_match_node(const struct of_device_id *matches,
905                                            const struct device_node *node)
906 {
907         const struct of_device_id *best_match = NULL;
908         int score, best_score = 0;
909
910         if (!matches)
911                 return NULL;
912
913         for (; matches->name[0] || matches->type[0] || matches->compatible[0]; matches++) {
914                 score = __of_device_is_compatible(node, matches->compatible,
915                                                   matches->type, matches->name);
916                 if (score > best_score) {
917                         best_match = matches;
918                         best_score = score;
919                 }
920         }
921
922         return best_match;
923 }
924
925 /**
926  * of_match_node - Tell if an device_node has a matching of_match structure
927  *      @matches:       array of of device match structures to search in
928  *      @node:          the of device structure to match against
929  *
930  *      Low level utility function used by device matching.
931  */
932 const struct of_device_id *of_match_node(const struct of_device_id *matches,
933                                          const struct device_node *node)
934 {
935         const struct of_device_id *match;
936         unsigned long flags;
937
938         raw_spin_lock_irqsave(&devtree_lock, flags);
939         match = __of_match_node(matches, node);
940         raw_spin_unlock_irqrestore(&devtree_lock, flags);
941         return match;
942 }
943 EXPORT_SYMBOL(of_match_node);
944
945 /**
946  *      of_find_matching_node_and_match - Find a node based on an of_device_id
947  *                                        match table.
948  *      @from:          The node to start searching from or NULL, the node
949  *                      you pass will not be searched, only the next one
950  *                      will; typically, you pass what the previous call
951  *                      returned. of_node_put() will be called on it
952  *      @matches:       array of of device match structures to search in
953  *      @match          Updated to point at the matches entry which matched
954  *
955  *      Returns a node pointer with refcount incremented, use
956  *      of_node_put() on it when done.
957  */
958 struct device_node *of_find_matching_node_and_match(struct device_node *from,
959                                         const struct of_device_id *matches,
960                                         const struct of_device_id **match)
961 {
962         struct device_node *np;
963         const struct of_device_id *m;
964         unsigned long flags;
965
966         if (match)
967                 *match = NULL;
968
969         raw_spin_lock_irqsave(&devtree_lock, flags);
970         np = from ? from->allnext : of_allnodes;
971         for (; np; np = np->allnext) {
972                 m = __of_match_node(matches, np);
973                 if (m && of_node_get(np)) {
974                         if (match)
975                                 *match = m;
976                         break;
977                 }
978         }
979         of_node_put(from);
980         raw_spin_unlock_irqrestore(&devtree_lock, flags);
981         return np;
982 }
983 EXPORT_SYMBOL(of_find_matching_node_and_match);
984
985 /**
986  * of_modalias_node - Lookup appropriate modalias for a device node
987  * @node:       pointer to a device tree node
988  * @modalias:   Pointer to buffer that modalias value will be copied into
989  * @len:        Length of modalias value
990  *
991  * Based on the value of the compatible property, this routine will attempt
992  * to choose an appropriate modalias value for a particular device tree node.
993  * It does this by stripping the manufacturer prefix (as delimited by a ',')
994  * from the first entry in the compatible list property.
995  *
996  * This routine returns 0 on success, <0 on failure.
997  */
998 int of_modalias_node(struct device_node *node, char *modalias, int len)
999 {
1000         const char *compatible, *p;
1001         int cplen;
1002
1003         compatible = of_get_property(node, "compatible", &cplen);
1004         if (!compatible || strlen(compatible) > cplen)
1005                 return -ENODEV;
1006         p = strchr(compatible, ',');
1007         strlcpy(modalias, p ? p + 1 : compatible, len);
1008         return 0;
1009 }
1010 EXPORT_SYMBOL_GPL(of_modalias_node);
1011
1012 /**
1013  * of_find_node_by_phandle - Find a node given a phandle
1014  * @handle:     phandle of the node to find
1015  *
1016  * Returns a node pointer with refcount incremented, use
1017  * of_node_put() on it when done.
1018  */
1019 struct device_node *of_find_node_by_phandle(phandle handle)
1020 {
1021         struct device_node *np;
1022         unsigned long flags;
1023
1024         if (!handle)
1025                 return NULL;
1026
1027         raw_spin_lock_irqsave(&devtree_lock, flags);
1028         for (np = of_allnodes; np; np = np->allnext)
1029                 if (np->phandle == handle)
1030                         break;
1031         of_node_get(np);
1032         raw_spin_unlock_irqrestore(&devtree_lock, flags);
1033         return np;
1034 }
1035 EXPORT_SYMBOL(of_find_node_by_phandle);
1036
1037 /**
1038  * of_property_count_elems_of_size - Count the number of elements in a property
1039  *
1040  * @np:         device node from which the property value is to be read.
1041  * @propname:   name of the property to be searched.
1042  * @elem_size:  size of the individual element
1043  *
1044  * Search for a property in a device node and count the number of elements of
1045  * size elem_size in it. Returns number of elements on sucess, -EINVAL if the
1046  * property does not exist or its length does not match a multiple of elem_size
1047  * and -ENODATA if the property does not have a value.
1048  */
1049 int of_property_count_elems_of_size(const struct device_node *np,
1050                                 const char *propname, int elem_size)
1051 {
1052         struct property *prop = of_find_property(np, propname, NULL);
1053
1054         if (!prop)
1055                 return -EINVAL;
1056         if (!prop->value)
1057                 return -ENODATA;
1058
1059         if (prop->length % elem_size != 0) {
1060                 pr_err("size of %s in node %s is not a multiple of %d\n",
1061                        propname, np->full_name, elem_size);
1062                 return -EINVAL;
1063         }
1064
1065         return prop->length / elem_size;
1066 }
1067 EXPORT_SYMBOL_GPL(of_property_count_elems_of_size);
1068
1069 /**
1070  * of_find_property_value_of_size
1071  *
1072  * @np:         device node from which the property value is to be read.
1073  * @propname:   name of the property to be searched.
1074  * @len:        requested length of property value
1075  *
1076  * Search for a property in a device node and valid the requested size.
1077  * Returns the property value on success, -EINVAL if the property does not
1078  *  exist, -ENODATA if property does not have a value, and -EOVERFLOW if the
1079  * property data isn't large enough.
1080  *
1081  */
1082 static void *of_find_property_value_of_size(const struct device_node *np,
1083                         const char *propname, u32 len)
1084 {
1085         struct property *prop = of_find_property(np, propname, NULL);
1086
1087         if (!prop)
1088                 return ERR_PTR(-EINVAL);
1089         if (!prop->value)
1090                 return ERR_PTR(-ENODATA);
1091         if (len > prop->length)
1092                 return ERR_PTR(-EOVERFLOW);
1093
1094         return prop->value;
1095 }
1096
1097 /**
1098  * of_property_read_u32_index - Find and read a u32 from a multi-value property.
1099  *
1100  * @np:         device node from which the property value is to be read.
1101  * @propname:   name of the property to be searched.
1102  * @index:      index of the u32 in the list of values
1103  * @out_value:  pointer to return value, modified only if no error.
1104  *
1105  * Search for a property in a device node and read nth 32-bit value from
1106  * it. Returns 0 on success, -EINVAL if the property does not exist,
1107  * -ENODATA if property does not have a value, and -EOVERFLOW if the
1108  * property data isn't large enough.
1109  *
1110  * The out_value is modified only if a valid u32 value can be decoded.
1111  */
1112 int of_property_read_u32_index(const struct device_node *np,
1113                                        const char *propname,
1114                                        u32 index, u32 *out_value)
1115 {
1116         const u32 *val = of_find_property_value_of_size(np, propname,
1117                                         ((index + 1) * sizeof(*out_value)));
1118
1119         if (IS_ERR(val))
1120                 return PTR_ERR(val);
1121
1122         *out_value = be32_to_cpup(((__be32 *)val) + index);
1123         return 0;
1124 }
1125 EXPORT_SYMBOL_GPL(of_property_read_u32_index);
1126
1127 /**
1128  * of_property_read_u8_array - Find and read an array of u8 from a property.
1129  *
1130  * @np:         device node from which the property value is to be read.
1131  * @propname:   name of the property to be searched.
1132  * @out_values: pointer to return value, modified only if return value is 0.
1133  * @sz:         number of array elements to read
1134  *
1135  * Search for a property in a device node and read 8-bit value(s) from
1136  * it. Returns 0 on success, -EINVAL if the property does not exist,
1137  * -ENODATA if property does not have a value, and -EOVERFLOW if the
1138  * property data isn't large enough.
1139  *
1140  * dts entry of array should be like:
1141  *      property = /bits/ 8 <0x50 0x60 0x70>;
1142  *
1143  * The out_values is modified only if a valid u8 value can be decoded.
1144  */
1145 int of_property_read_u8_array(const struct device_node *np,
1146                         const char *propname, u8 *out_values, size_t sz)
1147 {
1148         const u8 *val = of_find_property_value_of_size(np, propname,
1149                                                 (sz * sizeof(*out_values)));
1150
1151         if (IS_ERR(val))
1152                 return PTR_ERR(val);
1153
1154         while (sz--)
1155                 *out_values++ = *val++;
1156         return 0;
1157 }
1158 EXPORT_SYMBOL_GPL(of_property_read_u8_array);
1159
1160 /**
1161  * of_property_read_u16_array - Find and read an array of u16 from a property.
1162  *
1163  * @np:         device node from which the property value is to be read.
1164  * @propname:   name of the property to be searched.
1165  * @out_values: pointer to return value, modified only if return value is 0.
1166  * @sz:         number of array elements to read
1167  *
1168  * Search for a property in a device node and read 16-bit value(s) from
1169  * it. Returns 0 on success, -EINVAL if the property does not exist,
1170  * -ENODATA if property does not have a value, and -EOVERFLOW if the
1171  * property data isn't large enough.
1172  *
1173  * dts entry of array should be like:
1174  *      property = /bits/ 16 <0x5000 0x6000 0x7000>;
1175  *
1176  * The out_values is modified only if a valid u16 value can be decoded.
1177  */
1178 int of_property_read_u16_array(const struct device_node *np,
1179                         const char *propname, u16 *out_values, size_t sz)
1180 {
1181         const __be16 *val = of_find_property_value_of_size(np, propname,
1182                                                 (sz * sizeof(*out_values)));
1183
1184         if (IS_ERR(val))
1185                 return PTR_ERR(val);
1186
1187         while (sz--)
1188                 *out_values++ = be16_to_cpup(val++);
1189         return 0;
1190 }
1191 EXPORT_SYMBOL_GPL(of_property_read_u16_array);
1192
1193 /**
1194  * of_property_read_u32_array - Find and read an array of 32 bit integers
1195  * from a property.
1196  *
1197  * @np:         device node from which the property value is to be read.
1198  * @propname:   name of the property to be searched.
1199  * @out_values: pointer to return value, modified only if return value is 0.
1200  * @sz:         number of array elements to read
1201  *
1202  * Search for a property in a device node and read 32-bit value(s) from
1203  * it. Returns 0 on success, -EINVAL if the property does not exist,
1204  * -ENODATA if property does not have a value, and -EOVERFLOW if the
1205  * property data isn't large enough.
1206  *
1207  * The out_values is modified only if a valid u32 value can be decoded.
1208  */
1209 int of_property_read_u32_array(const struct device_node *np,
1210                                const char *propname, u32 *out_values,
1211                                size_t sz)
1212 {
1213         const __be32 *val = of_find_property_value_of_size(np, propname,
1214                                                 (sz * sizeof(*out_values)));
1215
1216         if (IS_ERR(val))
1217                 return PTR_ERR(val);
1218
1219         while (sz--)
1220                 *out_values++ = be32_to_cpup(val++);
1221         return 0;
1222 }
1223 EXPORT_SYMBOL_GPL(of_property_read_u32_array);
1224
1225 /**
1226  * of_property_read_u64 - Find and read a 64 bit integer from a property
1227  * @np:         device node from which the property value is to be read.
1228  * @propname:   name of the property to be searched.
1229  * @out_value:  pointer to return value, modified only if return value is 0.
1230  *
1231  * Search for a property in a device node and read a 64-bit value from
1232  * it. Returns 0 on success, -EINVAL if the property does not exist,
1233  * -ENODATA if property does not have a value, and -EOVERFLOW if the
1234  * property data isn't large enough.
1235  *
1236  * The out_value is modified only if a valid u64 value can be decoded.
1237  */
1238 int of_property_read_u64(const struct device_node *np, const char *propname,
1239                          u64 *out_value)
1240 {
1241         const __be32 *val = of_find_property_value_of_size(np, propname,
1242                                                 sizeof(*out_value));
1243
1244         if (IS_ERR(val))
1245                 return PTR_ERR(val);
1246
1247         *out_value = of_read_number(val, 2);
1248         return 0;
1249 }
1250 EXPORT_SYMBOL_GPL(of_property_read_u64);
1251
1252 /**
1253  * of_property_read_string - Find and read a string from a property
1254  * @np:         device node from which the property value is to be read.
1255  * @propname:   name of the property to be searched.
1256  * @out_string: pointer to null terminated return string, modified only if
1257  *              return value is 0.
1258  *
1259  * Search for a property in a device tree node and retrieve a null
1260  * terminated string value (pointer to data, not a copy). Returns 0 on
1261  * success, -EINVAL if the property does not exist, -ENODATA if property
1262  * does not have a value, and -EILSEQ if the string is not null-terminated
1263  * within the length of the property data.
1264  *
1265  * The out_string pointer is modified only if a valid string can be decoded.
1266  */
1267 int of_property_read_string(struct device_node *np, const char *propname,
1268                                 const char **out_string)
1269 {
1270         struct property *prop = of_find_property(np, propname, NULL);
1271         if (!prop)
1272                 return -EINVAL;
1273         if (!prop->value)
1274                 return -ENODATA;
1275         if (strnlen(prop->value, prop->length) >= prop->length)
1276                 return -EILSEQ;
1277         *out_string = prop->value;
1278         return 0;
1279 }
1280 EXPORT_SYMBOL_GPL(of_property_read_string);
1281
1282 /**
1283  * of_property_match_string() - Find string in a list and return index
1284  * @np: pointer to node containing string list property
1285  * @propname: string list property name
1286  * @string: pointer to string to search for in string list
1287  *
1288  * This function searches a string list property and returns the index
1289  * of a specific string value.
1290  */
1291 int of_property_match_string(struct device_node *np, const char *propname,
1292                              const char *string)
1293 {
1294         struct property *prop = of_find_property(np, propname, NULL);
1295         size_t l;
1296         int i;
1297         const char *p, *end;
1298
1299         if (!prop)
1300                 return -EINVAL;
1301         if (!prop->value)
1302                 return -ENODATA;
1303
1304         p = prop->value;
1305         end = p + prop->length;
1306
1307         for (i = 0; p < end; i++, p += l) {
1308                 l = strnlen(p, end - p) + 1;
1309                 if (p + l > end)
1310                         return -EILSEQ;
1311                 pr_debug("comparing %s with %s\n", string, p);
1312                 if (strcmp(string, p) == 0)
1313                         return i; /* Found it; return index */
1314         }
1315         return -ENODATA;
1316 }
1317 EXPORT_SYMBOL_GPL(of_property_match_string);
1318
1319 /**
1320  * of_property_read_string_util() - Utility helper for parsing string properties
1321  * @np:         device node from which the property value is to be read.
1322  * @propname:   name of the property to be searched.
1323  * @out_strs:   output array of string pointers.
1324  * @sz:         number of array elements to read.
1325  * @skip:       Number of strings to skip over at beginning of list.
1326  *
1327  * Don't call this function directly. It is a utility helper for the
1328  * of_property_read_string*() family of functions.
1329  */
1330 int of_property_read_string_helper(struct device_node *np, const char *propname,
1331                                    const char **out_strs, size_t sz, int skip)
1332 {
1333         struct property *prop = of_find_property(np, propname, NULL);
1334         int l = 0, i = 0;
1335         const char *p, *end;
1336
1337         if (!prop)
1338                 return -EINVAL;
1339         if (!prop->value)
1340                 return -ENODATA;
1341         p = prop->value;
1342         end = p + prop->length;
1343
1344         for (i = 0; p < end && (!out_strs || i < skip + sz); i++, p += l) {
1345                 l = strnlen(p, end - p) + 1;
1346                 if (p + l > end)
1347                         return -EILSEQ;
1348                 if (out_strs && i >= skip)
1349                         *out_strs++ = p;
1350         }
1351         i -= skip;
1352         return i <= 0 ? -ENODATA : i;
1353 }
1354 EXPORT_SYMBOL_GPL(of_property_read_string_helper);
1355
1356 void of_print_phandle_args(const char *msg, const struct of_phandle_args *args)
1357 {
1358         int i;
1359         printk("%s %s", msg, of_node_full_name(args->np));
1360         for (i = 0; i < args->args_count; i++)
1361                 printk(i ? ",%08x" : ":%08x", args->args[i]);
1362         printk("\n");
1363 }
1364
1365 static int __of_parse_phandle_with_args(const struct device_node *np,
1366                                         const char *list_name,
1367                                         const char *cells_name,
1368                                         int cell_count, int index,
1369                                         struct of_phandle_args *out_args)
1370 {
1371         const __be32 *list, *list_end;
1372         int rc = 0, size, cur_index = 0;
1373         uint32_t count = 0;
1374         struct device_node *node = NULL;
1375         phandle phandle;
1376
1377         /* Retrieve the phandle list property */
1378         list = of_get_property(np, list_name, &size);
1379         if (!list)
1380                 return -ENOENT;
1381         list_end = list + size / sizeof(*list);
1382
1383         /* Loop over the phandles until all the requested entry is found */
1384         while (list < list_end) {
1385                 rc = -EINVAL;
1386                 count = 0;
1387
1388                 /*
1389                  * If phandle is 0, then it is an empty entry with no
1390                  * arguments.  Skip forward to the next entry.
1391                  */
1392                 phandle = be32_to_cpup(list++);
1393                 if (phandle) {
1394                         /*
1395                          * Find the provider node and parse the #*-cells
1396                          * property to determine the argument length.
1397                          *
1398                          * This is not needed if the cell count is hard-coded
1399                          * (i.e. cells_name not set, but cell_count is set),
1400                          * except when we're going to return the found node
1401                          * below.
1402                          */
1403                         if (cells_name || cur_index == index) {
1404                                 node = of_find_node_by_phandle(phandle);
1405                                 if (!node) {
1406                                         pr_err("%s: could not find phandle\n",
1407                                                 np->full_name);
1408                                         goto err;
1409                                 }
1410                         }
1411
1412                         if (cells_name) {
1413                                 if (of_property_read_u32(node, cells_name,
1414                                                          &count)) {
1415                                         pr_err("%s: could not get %s for %s\n",
1416                                                 np->full_name, cells_name,
1417                                                 node->full_name);
1418                                         goto err;
1419                                 }
1420                         } else {
1421                                 count = cell_count;
1422                         }
1423
1424                         /*
1425                          * Make sure that the arguments actually fit in the
1426                          * remaining property data length
1427                          */
1428                         if (list + count > list_end) {
1429                                 pr_err("%s: arguments longer than property\n",
1430                                          np->full_name);
1431                                 goto err;
1432                         }
1433                 }
1434
1435                 /*
1436                  * All of the error cases above bail out of the loop, so at
1437                  * this point, the parsing is successful. If the requested
1438                  * index matches, then fill the out_args structure and return,
1439                  * or return -ENOENT for an empty entry.
1440                  */
1441                 rc = -ENOENT;
1442                 if (cur_index == index) {
1443                         if (!phandle)
1444                                 goto err;
1445
1446                         if (out_args) {
1447                                 int i;
1448                                 if (WARN_ON(count > MAX_PHANDLE_ARGS))
1449                                         count = MAX_PHANDLE_ARGS;
1450                                 out_args->np = node;
1451                                 out_args->args_count = count;
1452                                 for (i = 0; i < count; i++)
1453                                         out_args->args[i] = be32_to_cpup(list++);
1454                         } else {
1455                                 of_node_put(node);
1456                         }
1457
1458                         /* Found it! return success */
1459                         return 0;
1460                 }
1461
1462                 of_node_put(node);
1463                 node = NULL;
1464                 list += count;
1465                 cur_index++;
1466         }
1467
1468         /*
1469          * Unlock node before returning result; will be one of:
1470          * -ENOENT : index is for empty phandle
1471          * -EINVAL : parsing error on data
1472          * [1..n]  : Number of phandle (count mode; when index = -1)
1473          */
1474         rc = index < 0 ? cur_index : -ENOENT;
1475  err:
1476         if (node)
1477                 of_node_put(node);
1478         return rc;
1479 }
1480
1481 /**
1482  * of_parse_phandle - Resolve a phandle property to a device_node pointer
1483  * @np: Pointer to device node holding phandle property
1484  * @phandle_name: Name of property holding a phandle value
1485  * @index: For properties holding a table of phandles, this is the index into
1486  *         the table
1487  *
1488  * Returns the device_node pointer with refcount incremented.  Use
1489  * of_node_put() on it when done.
1490  */
1491 struct device_node *of_parse_phandle(const struct device_node *np,
1492                                      const char *phandle_name, int index)
1493 {
1494         struct of_phandle_args args;
1495
1496         if (index < 0)
1497                 return NULL;
1498
1499         if (__of_parse_phandle_with_args(np, phandle_name, NULL, 0,
1500                                          index, &args))
1501                 return NULL;
1502
1503         return args.np;
1504 }
1505 EXPORT_SYMBOL(of_parse_phandle);
1506
1507 /**
1508  * of_parse_phandle_with_args() - Find a node pointed by phandle in a list
1509  * @np:         pointer to a device tree node containing a list
1510  * @list_name:  property name that contains a list
1511  * @cells_name: property name that specifies phandles' arguments count
1512  * @index:      index of a phandle to parse out
1513  * @out_args:   optional pointer to output arguments structure (will be filled)
1514  *
1515  * This function is useful to parse lists of phandles and their arguments.
1516  * Returns 0 on success and fills out_args, on error returns appropriate
1517  * errno value.
1518  *
1519  * Caller is responsible to call of_node_put() on the returned out_args->node
1520  * pointer.
1521  *
1522  * Example:
1523  *
1524  * phandle1: node1 {
1525  *      #list-cells = <2>;
1526  * }
1527  *
1528  * phandle2: node2 {
1529  *      #list-cells = <1>;
1530  * }
1531  *
1532  * node3 {
1533  *      list = <&phandle1 1 2 &phandle2 3>;
1534  * }
1535  *
1536  * To get a device_node of the `node2' node you may call this:
1537  * of_parse_phandle_with_args(node3, "list", "#list-cells", 1, &args);
1538  */
1539 int of_parse_phandle_with_args(const struct device_node *np, const char *list_name,
1540                                 const char *cells_name, int index,
1541                                 struct of_phandle_args *out_args)
1542 {
1543         if (index < 0)
1544                 return -EINVAL;
1545         return __of_parse_phandle_with_args(np, list_name, cells_name, 0,
1546                                             index, out_args);
1547 }
1548 EXPORT_SYMBOL(of_parse_phandle_with_args);
1549
1550 /**
1551  * of_parse_phandle_with_fixed_args() - Find a node pointed by phandle in a list
1552  * @np:         pointer to a device tree node containing a list
1553  * @list_name:  property name that contains a list
1554  * @cell_count: number of argument cells following the phandle
1555  * @index:      index of a phandle to parse out
1556  * @out_args:   optional pointer to output arguments structure (will be filled)
1557  *
1558  * This function is useful to parse lists of phandles and their arguments.
1559  * Returns 0 on success and fills out_args, on error returns appropriate
1560  * errno value.
1561  *
1562  * Caller is responsible to call of_node_put() on the returned out_args->node
1563  * pointer.
1564  *
1565  * Example:
1566  *
1567  * phandle1: node1 {
1568  * }
1569  *
1570  * phandle2: node2 {
1571  * }
1572  *
1573  * node3 {
1574  *      list = <&phandle1 0 2 &phandle2 2 3>;
1575  * }
1576  *
1577  * To get a device_node of the `node2' node you may call this:
1578  * of_parse_phandle_with_fixed_args(node3, "list", 2, 1, &args);
1579  */
1580 int of_parse_phandle_with_fixed_args(const struct device_node *np,
1581                                 const char *list_name, int cell_count,
1582                                 int index, struct of_phandle_args *out_args)
1583 {
1584         if (index < 0)
1585                 return -EINVAL;
1586         return __of_parse_phandle_with_args(np, list_name, NULL, cell_count,
1587                                            index, out_args);
1588 }
1589 EXPORT_SYMBOL(of_parse_phandle_with_fixed_args);
1590
1591 /**
1592  * of_count_phandle_with_args() - Find the number of phandles references in a property
1593  * @np:         pointer to a device tree node containing a list
1594  * @list_name:  property name that contains a list
1595  * @cells_name: property name that specifies phandles' arguments count
1596  *
1597  * Returns the number of phandle + argument tuples within a property. It
1598  * is a typical pattern to encode a list of phandle and variable
1599  * arguments into a single property. The number of arguments is encoded
1600  * by a property in the phandle-target node. For example, a gpios
1601  * property would contain a list of GPIO specifies consisting of a
1602  * phandle and 1 or more arguments. The number of arguments are
1603  * determined by the #gpio-cells property in the node pointed to by the
1604  * phandle.
1605  */
1606 int of_count_phandle_with_args(const struct device_node *np, const char *list_name,
1607                                 const char *cells_name)
1608 {
1609         return __of_parse_phandle_with_args(np, list_name, cells_name, 0, -1,
1610                                             NULL);
1611 }
1612 EXPORT_SYMBOL(of_count_phandle_with_args);
1613
1614 /**
1615  * __of_add_property - Add a property to a node without lock operations
1616  */
1617 int __of_add_property(struct device_node *np, struct property *prop)
1618 {
1619         struct property **next;
1620
1621         prop->next = NULL;
1622         next = &np->properties;
1623         while (*next) {
1624                 if (strcmp(prop->name, (*next)->name) == 0)
1625                         /* duplicate ! don't insert it */
1626                         return -EEXIST;
1627
1628                 next = &(*next)->next;
1629         }
1630         *next = prop;
1631
1632         return 0;
1633 }
1634
1635 /**
1636  * of_add_property - Add a property to a node
1637  */
1638 int of_add_property(struct device_node *np, struct property *prop)
1639 {
1640         unsigned long flags;
1641         int rc;
1642
1643         mutex_lock(&of_mutex);
1644
1645         raw_spin_lock_irqsave(&devtree_lock, flags);
1646         rc = __of_add_property(np, prop);
1647         raw_spin_unlock_irqrestore(&devtree_lock, flags);
1648
1649         if (!rc)
1650                 __of_add_property_sysfs(np, prop);
1651
1652         mutex_unlock(&of_mutex);
1653
1654         if (!rc)
1655                 of_property_notify(OF_RECONFIG_ADD_PROPERTY, np, prop, NULL);
1656
1657         return rc;
1658 }
1659
1660 int __of_remove_property(struct device_node *np, struct property *prop)
1661 {
1662         struct property **next;
1663
1664         for (next = &np->properties; *next; next = &(*next)->next) {
1665                 if (*next == prop)
1666                         break;
1667         }
1668         if (*next == NULL)
1669                 return -ENODEV;
1670
1671         /* found the node */
1672         *next = prop->next;
1673         prop->next = np->deadprops;
1674         np->deadprops = prop;
1675
1676         return 0;
1677 }
1678
1679 void __of_remove_property_sysfs(struct device_node *np, struct property *prop)
1680 {
1681         if (!IS_ENABLED(CONFIG_SYSFS))
1682                 return;
1683
1684         /* at early boot, bail here and defer setup to of_init() */
1685         if (of_kset && of_node_is_attached(np))
1686                 sysfs_remove_bin_file(&np->kobj, &prop->attr);
1687 }
1688
1689 /**
1690  * of_remove_property - Remove a property from a node.
1691  *
1692  * Note that we don't actually remove it, since we have given out
1693  * who-knows-how-many pointers to the data using get-property.
1694  * Instead we just move the property to the "dead properties"
1695  * list, so it won't be found any more.
1696  */
1697 int of_remove_property(struct device_node *np, struct property *prop)
1698 {
1699         unsigned long flags;
1700         int rc;
1701
1702         mutex_lock(&of_mutex);
1703
1704         raw_spin_lock_irqsave(&devtree_lock, flags);
1705         rc = __of_remove_property(np, prop);
1706         raw_spin_unlock_irqrestore(&devtree_lock, flags);
1707
1708         if (!rc)
1709                 __of_remove_property_sysfs(np, prop);
1710
1711         mutex_unlock(&of_mutex);
1712
1713         if (!rc)
1714                 of_property_notify(OF_RECONFIG_REMOVE_PROPERTY, np, prop, NULL);
1715
1716         return rc;
1717 }
1718
1719 int __of_update_property(struct device_node *np, struct property *newprop,
1720                 struct property **oldpropp)
1721 {
1722         struct property **next, *oldprop;
1723
1724         for (next = &np->properties; *next; next = &(*next)->next) {
1725                 if (of_prop_cmp((*next)->name, newprop->name) == 0)
1726                         break;
1727         }
1728         *oldpropp = oldprop = *next;
1729
1730         if (oldprop) {
1731                 /* replace the node */
1732                 newprop->next = oldprop->next;
1733                 *next = newprop;
1734                 oldprop->next = np->deadprops;
1735                 np->deadprops = oldprop;
1736         } else {
1737                 /* new node */
1738                 newprop->next = NULL;
1739                 *next = newprop;
1740         }
1741
1742         return 0;
1743 }
1744
1745 void __of_update_property_sysfs(struct device_node *np, struct property *newprop,
1746                 struct property *oldprop)
1747 {
1748         if (!IS_ENABLED(CONFIG_SYSFS))
1749                 return;
1750
1751         /* At early boot, bail out and defer setup to of_init() */
1752         if (!of_kset)
1753                 return;
1754
1755         if (oldprop)
1756                 sysfs_remove_bin_file(&np->kobj, &oldprop->attr);
1757         __of_add_property_sysfs(np, newprop);
1758 }
1759
1760 /*
1761  * of_update_property - Update a property in a node, if the property does
1762  * not exist, add it.
1763  *
1764  * Note that we don't actually remove it, since we have given out
1765  * who-knows-how-many pointers to the data using get-property.
1766  * Instead we just move the property to the "dead properties" list,
1767  * and add the new property to the property list
1768  */
1769 int of_update_property(struct device_node *np, struct property *newprop)
1770 {
1771         struct property *oldprop;
1772         unsigned long flags;
1773         int rc;
1774
1775         if (!newprop->name)
1776                 return -EINVAL;
1777
1778         mutex_lock(&of_mutex);
1779
1780         raw_spin_lock_irqsave(&devtree_lock, flags);
1781         rc = __of_update_property(np, newprop, &oldprop);
1782         raw_spin_unlock_irqrestore(&devtree_lock, flags);
1783
1784         if (!rc)
1785                 __of_update_property_sysfs(np, newprop, oldprop);
1786
1787         mutex_unlock(&of_mutex);
1788
1789         if (!rc)
1790                 of_property_notify(OF_RECONFIG_UPDATE_PROPERTY, np, newprop, oldprop);
1791
1792         return rc;
1793 }
1794
1795 static void of_alias_add(struct alias_prop *ap, struct device_node *np,
1796                          int id, const char *stem, int stem_len)
1797 {
1798         ap->np = np;
1799         ap->id = id;
1800         strncpy(ap->stem, stem, stem_len);
1801         ap->stem[stem_len] = 0;
1802         list_add_tail(&ap->link, &aliases_lookup);
1803         pr_debug("adding DT alias:%s: stem=%s id=%i node=%s\n",
1804                  ap->alias, ap->stem, ap->id, of_node_full_name(np));
1805 }
1806
1807 /**
1808  * of_alias_scan - Scan all properties of 'aliases' node
1809  *
1810  * The function scans all the properties of 'aliases' node and populate
1811  * the the global lookup table with the properties.  It returns the
1812  * number of alias_prop found, or error code in error case.
1813  *
1814  * @dt_alloc:   An allocator that provides a virtual address to memory
1815  *              for the resulting tree
1816  */
1817 void of_alias_scan(void * (*dt_alloc)(u64 size, u64 align))
1818 {
1819         struct property *pp;
1820
1821         of_aliases = of_find_node_by_path("/aliases");
1822         of_chosen = of_find_node_by_path("/chosen");
1823         if (of_chosen == NULL)
1824                 of_chosen = of_find_node_by_path("/chosen@0");
1825
1826         if (of_chosen) {
1827                 /* linux,stdout-path and /aliases/stdout are for legacy compatibility */
1828                 const char *name = of_get_property(of_chosen, "stdout-path", NULL);
1829                 if (!name)
1830                         name = of_get_property(of_chosen, "linux,stdout-path", NULL);
1831                 if (IS_ENABLED(CONFIG_PPC) && !name)
1832                         name = of_get_property(of_aliases, "stdout", NULL);
1833                 if (name)
1834                         of_stdout = of_find_node_by_path(name);
1835         }
1836
1837         if (!of_aliases)
1838                 return;
1839
1840         for_each_property_of_node(of_aliases, pp) {
1841                 const char *start = pp->name;
1842                 const char *end = start + strlen(start);
1843                 struct device_node *np;
1844                 struct alias_prop *ap;
1845                 int id, len;
1846
1847                 /* Skip those we do not want to proceed */
1848                 if (!strcmp(pp->name, "name") ||
1849                     !strcmp(pp->name, "phandle") ||
1850                     !strcmp(pp->name, "linux,phandle"))
1851                         continue;
1852
1853                 np = of_find_node_by_path(pp->value);
1854                 if (!np)
1855                         continue;
1856
1857                 /* walk the alias backwards to extract the id and work out
1858                  * the 'stem' string */
1859                 while (isdigit(*(end-1)) && end > start)
1860                         end--;
1861                 len = end - start;
1862
1863                 if (kstrtoint(end, 10, &id) < 0)
1864                         continue;
1865
1866                 /* Allocate an alias_prop with enough space for the stem */
1867                 ap = dt_alloc(sizeof(*ap) + len + 1, 4);
1868                 if (!ap)
1869                         continue;
1870                 memset(ap, 0, sizeof(*ap) + len + 1);
1871                 ap->alias = start;
1872                 of_alias_add(ap, np, id, start, len);
1873         }
1874 }
1875
1876 /**
1877  * of_alias_get_id - Get alias id for the given device_node
1878  * @np:         Pointer to the given device_node
1879  * @stem:       Alias stem of the given device_node
1880  *
1881  * The function travels the lookup table to get the alias id for the given
1882  * device_node and alias stem.  It returns the alias id if found.
1883  */
1884 int of_alias_get_id(struct device_node *np, const char *stem)
1885 {
1886         struct alias_prop *app;
1887         int id = -ENODEV;
1888
1889         mutex_lock(&of_mutex);
1890         list_for_each_entry(app, &aliases_lookup, link) {
1891                 if (strcmp(app->stem, stem) != 0)
1892                         continue;
1893
1894                 if (np == app->np) {
1895                         id = app->id;
1896                         break;
1897                 }
1898         }
1899         mutex_unlock(&of_mutex);
1900
1901         return id;
1902 }
1903 EXPORT_SYMBOL_GPL(of_alias_get_id);
1904
1905 const __be32 *of_prop_next_u32(struct property *prop, const __be32 *cur,
1906                                u32 *pu)
1907 {
1908         const void *curv = cur;
1909
1910         if (!prop)
1911                 return NULL;
1912
1913         if (!cur) {
1914                 curv = prop->value;
1915                 goto out_val;
1916         }
1917
1918         curv += sizeof(*cur);
1919         if (curv >= prop->value + prop->length)
1920                 return NULL;
1921
1922 out_val:
1923         *pu = be32_to_cpup(curv);
1924         return curv;
1925 }
1926 EXPORT_SYMBOL_GPL(of_prop_next_u32);
1927
1928 const char *of_prop_next_string(struct property *prop, const char *cur)
1929 {
1930         const void *curv = cur;
1931
1932         if (!prop)
1933                 return NULL;
1934
1935         if (!cur)
1936                 return prop->value;
1937
1938         curv += strlen(cur) + 1;
1939         if (curv >= prop->value + prop->length)
1940                 return NULL;
1941
1942         return curv;
1943 }
1944 EXPORT_SYMBOL_GPL(of_prop_next_string);
1945
1946 /**
1947  * of_console_check() - Test and setup console for DT setup
1948  * @dn - Pointer to device node
1949  * @name - Name to use for preferred console without index. ex. "ttyS"
1950  * @index - Index to use for preferred console.
1951  *
1952  * Check if the given device node matches the stdout-path property in the
1953  * /chosen node. If it does then register it as the preferred console and return
1954  * TRUE. Otherwise return FALSE.
1955  */
1956 bool of_console_check(struct device_node *dn, char *name, int index)
1957 {
1958         if (!dn || dn != of_stdout || console_set_on_cmdline)
1959                 return false;
1960         return !add_preferred_console(name, index, NULL);
1961 }
1962 EXPORT_SYMBOL_GPL(of_console_check);
1963
1964 /**
1965  *      of_find_next_cache_node - Find a node's subsidiary cache
1966  *      @np:    node of type "cpu" or "cache"
1967  *
1968  *      Returns a node pointer with refcount incremented, use
1969  *      of_node_put() on it when done.  Caller should hold a reference
1970  *      to np.
1971  */
1972 struct device_node *of_find_next_cache_node(const struct device_node *np)
1973 {
1974         struct device_node *child;
1975         const phandle *handle;
1976
1977         handle = of_get_property(np, "l2-cache", NULL);
1978         if (!handle)
1979                 handle = of_get_property(np, "next-level-cache", NULL);
1980
1981         if (handle)
1982                 return of_find_node_by_phandle(be32_to_cpup(handle));
1983
1984         /* OF on pmac has nodes instead of properties named "l2-cache"
1985          * beneath CPU nodes.
1986          */
1987         if (!strcmp(np->type, "cpu"))
1988                 for_each_child_of_node(np, child)
1989                         if (!strcmp(child->type, "cache"))
1990                                 return child;
1991
1992         return NULL;
1993 }
1994
1995 /**
1996  * of_graph_parse_endpoint() - parse common endpoint node properties
1997  * @node: pointer to endpoint device_node
1998  * @endpoint: pointer to the OF endpoint data structure
1999  *
2000  * The caller should hold a reference to @node.
2001  */
2002 int of_graph_parse_endpoint(const struct device_node *node,
2003                             struct of_endpoint *endpoint)
2004 {
2005         struct device_node *port_node = of_get_parent(node);
2006
2007         WARN_ONCE(!port_node, "%s(): endpoint %s has no parent node\n",
2008                   __func__, node->full_name);
2009
2010         memset(endpoint, 0, sizeof(*endpoint));
2011
2012         endpoint->local_node = node;
2013         /*
2014          * It doesn't matter whether the two calls below succeed.
2015          * If they don't then the default value 0 is used.
2016          */
2017         of_property_read_u32(port_node, "reg", &endpoint->port);
2018         of_property_read_u32(node, "reg", &endpoint->id);
2019
2020         of_node_put(port_node);
2021
2022         return 0;
2023 }
2024 EXPORT_SYMBOL(of_graph_parse_endpoint);
2025
2026 /**
2027  * of_graph_get_next_endpoint() - get next endpoint node
2028  * @parent: pointer to the parent device node
2029  * @prev: previous endpoint node, or NULL to get first
2030  *
2031  * Return: An 'endpoint' node pointer with refcount incremented. Refcount
2032  * of the passed @prev node is not decremented, the caller have to use
2033  * of_node_put() on it when done.
2034  */
2035 struct device_node *of_graph_get_next_endpoint(const struct device_node *parent,
2036                                         struct device_node *prev)
2037 {
2038         struct device_node *endpoint;
2039         struct device_node *port;
2040
2041         if (!parent)
2042                 return NULL;
2043
2044         /*
2045          * Start by locating the port node. If no previous endpoint is specified
2046          * search for the first port node, otherwise get the previous endpoint
2047          * parent port node.
2048          */
2049         if (!prev) {
2050                 struct device_node *node;
2051
2052                 node = of_get_child_by_name(parent, "ports");
2053                 if (node)
2054                         parent = node;
2055
2056                 port = of_get_child_by_name(parent, "port");
2057                 of_node_put(node);
2058
2059                 if (!port) {
2060                         pr_err("%s(): no port node found in %s\n",
2061                                __func__, parent->full_name);
2062                         return NULL;
2063                 }
2064         } else {
2065                 port = of_get_parent(prev);
2066                 if (WARN_ONCE(!port, "%s(): endpoint %s has no parent node\n",
2067                               __func__, prev->full_name))
2068                         return NULL;
2069
2070                 /*
2071                  * Avoid dropping prev node refcount to 0 when getting the next
2072                  * child below.
2073                  */
2074                 of_node_get(prev);
2075         }
2076
2077         while (1) {
2078                 /*
2079                  * Now that we have a port node, get the next endpoint by
2080                  * getting the next child. If the previous endpoint is NULL this
2081                  * will return the first child.
2082                  */
2083                 endpoint = of_get_next_child(port, prev);
2084                 if (endpoint) {
2085                         of_node_put(port);
2086                         return endpoint;
2087                 }
2088
2089                 /* No more endpoints under this port, try the next one. */
2090                 prev = NULL;
2091
2092                 do {
2093                         port = of_get_next_child(parent, port);
2094                         if (!port)
2095                                 return NULL;
2096                 } while (of_node_cmp(port->name, "port"));
2097         }
2098 }
2099 EXPORT_SYMBOL(of_graph_get_next_endpoint);
2100
2101 /**
2102  * of_graph_get_remote_port_parent() - get remote port's parent node
2103  * @node: pointer to a local endpoint device_node
2104  *
2105  * Return: Remote device node associated with remote endpoint node linked
2106  *         to @node. Use of_node_put() on it when done.
2107  */
2108 struct device_node *of_graph_get_remote_port_parent(
2109                                const struct device_node *node)
2110 {
2111         struct device_node *np;
2112         unsigned int depth;
2113
2114         /* Get remote endpoint node. */
2115         np = of_parse_phandle(node, "remote-endpoint", 0);
2116
2117         /* Walk 3 levels up only if there is 'ports' node. */
2118         for (depth = 3; depth && np; depth--) {
2119                 np = of_get_next_parent(np);
2120                 if (depth == 2 && of_node_cmp(np->name, "ports"))
2121                         break;
2122         }
2123         return np;
2124 }
2125 EXPORT_SYMBOL(of_graph_get_remote_port_parent);
2126
2127 /**
2128  * of_graph_get_remote_port() - get remote port node
2129  * @node: pointer to a local endpoint device_node
2130  *
2131  * Return: Remote port node associated with remote endpoint node linked
2132  *         to @node. Use of_node_put() on it when done.
2133  */
2134 struct device_node *of_graph_get_remote_port(const struct device_node *node)
2135 {
2136         struct device_node *np;
2137
2138         /* Get remote endpoint node. */
2139         np = of_parse_phandle(node, "remote-endpoint", 0);
2140         if (!np)
2141                 return NULL;
2142         return of_get_next_parent(np);
2143 }
2144 EXPORT_SYMBOL(of_graph_get_remote_port);