Merge tag 'devicetree-fixes-for-4.15' of git://git.kernel.org/pub/scm/linux/kernel...
[muen/linux.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
21 #define pr_fmt(fmt)     "OF: " fmt
22
23 #include <linux/console.h>
24 #include <linux/ctype.h>
25 #include <linux/cpu.h>
26 #include <linux/module.h>
27 #include <linux/of.h>
28 #include <linux/of_device.h>
29 #include <linux/of_graph.h>
30 #include <linux/spinlock.h>
31 #include <linux/slab.h>
32 #include <linux/string.h>
33 #include <linux/proc_fs.h>
34
35 #include "of_private.h"
36
37 LIST_HEAD(aliases_lookup);
38
39 struct device_node *of_root;
40 EXPORT_SYMBOL(of_root);
41 struct device_node *of_chosen;
42 struct device_node *of_aliases;
43 struct device_node *of_stdout;
44 static const char *of_stdout_options;
45
46 struct kset *of_kset;
47
48 /*
49  * Used to protect the of_aliases, to hold off addition of nodes to sysfs.
50  * This mutex must be held whenever modifications are being made to the
51  * device tree. The of_{attach,detach}_node() and
52  * of_{add,remove,update}_property() helpers make sure this happens.
53  */
54 DEFINE_MUTEX(of_mutex);
55
56 /* use when traversing tree through the child, sibling,
57  * or parent members of struct device_node.
58  */
59 DEFINE_RAW_SPINLOCK(devtree_lock);
60
61 int of_n_addr_cells(struct device_node *np)
62 {
63         u32 cells;
64
65         do {
66                 if (np->parent)
67                         np = np->parent;
68                 if (!of_property_read_u32(np, "#address-cells", &cells))
69                         return cells;
70         } while (np->parent);
71         /* No #address-cells property for the root node */
72         return OF_ROOT_NODE_ADDR_CELLS_DEFAULT;
73 }
74 EXPORT_SYMBOL(of_n_addr_cells);
75
76 int of_n_size_cells(struct device_node *np)
77 {
78         u32 cells;
79
80         do {
81                 if (np->parent)
82                         np = np->parent;
83                 if (!of_property_read_u32(np, "#size-cells", &cells))
84                         return cells;
85         } while (np->parent);
86         /* No #size-cells property for the root node */
87         return OF_ROOT_NODE_SIZE_CELLS_DEFAULT;
88 }
89 EXPORT_SYMBOL(of_n_size_cells);
90
91 #ifdef CONFIG_NUMA
92 int __weak of_node_to_nid(struct device_node *np)
93 {
94         return NUMA_NO_NODE;
95 }
96 #endif
97
98 void __init of_core_init(void)
99 {
100         struct device_node *np;
101
102         /* Create the kset, and register existing nodes */
103         mutex_lock(&of_mutex);
104         of_kset = kset_create_and_add("devicetree", NULL, firmware_kobj);
105         if (!of_kset) {
106                 mutex_unlock(&of_mutex);
107                 pr_err("failed to register existing nodes\n");
108                 return;
109         }
110         for_each_of_allnodes(np)
111                 __of_attach_node_sysfs(np);
112         mutex_unlock(&of_mutex);
113
114         /* Symlink in /proc as required by userspace ABI */
115         if (of_root)
116                 proc_symlink("device-tree", NULL, "/sys/firmware/devicetree/base");
117 }
118
119 static struct property *__of_find_property(const struct device_node *np,
120                                            const char *name, int *lenp)
121 {
122         struct property *pp;
123
124         if (!np)
125                 return NULL;
126
127         for (pp = np->properties; pp; pp = pp->next) {
128                 if (of_prop_cmp(pp->name, name) == 0) {
129                         if (lenp)
130                                 *lenp = pp->length;
131                         break;
132                 }
133         }
134
135         return pp;
136 }
137
138 struct property *of_find_property(const struct device_node *np,
139                                   const char *name,
140                                   int *lenp)
141 {
142         struct property *pp;
143         unsigned long flags;
144
145         raw_spin_lock_irqsave(&devtree_lock, flags);
146         pp = __of_find_property(np, name, lenp);
147         raw_spin_unlock_irqrestore(&devtree_lock, flags);
148
149         return pp;
150 }
151 EXPORT_SYMBOL(of_find_property);
152
153 struct device_node *__of_find_all_nodes(struct device_node *prev)
154 {
155         struct device_node *np;
156         if (!prev) {
157                 np = of_root;
158         } else if (prev->child) {
159                 np = prev->child;
160         } else {
161                 /* Walk back up looking for a sibling, or the end of the structure */
162                 np = prev;
163                 while (np->parent && !np->sibling)
164                         np = np->parent;
165                 np = np->sibling; /* Might be null at the end of the tree */
166         }
167         return np;
168 }
169
170 /**
171  * of_find_all_nodes - Get next node in global list
172  * @prev:       Previous node or NULL to start iteration
173  *              of_node_put() will be called on it
174  *
175  * Returns a node pointer with refcount incremented, use
176  * of_node_put() on it when done.
177  */
178 struct device_node *of_find_all_nodes(struct device_node *prev)
179 {
180         struct device_node *np;
181         unsigned long flags;
182
183         raw_spin_lock_irqsave(&devtree_lock, flags);
184         np = __of_find_all_nodes(prev);
185         of_node_get(np);
186         of_node_put(prev);
187         raw_spin_unlock_irqrestore(&devtree_lock, flags);
188         return np;
189 }
190 EXPORT_SYMBOL(of_find_all_nodes);
191
192 /*
193  * Find a property with a given name for a given node
194  * and return the value.
195  */
196 const void *__of_get_property(const struct device_node *np,
197                               const char *name, int *lenp)
198 {
199         struct property *pp = __of_find_property(np, name, lenp);
200
201         return pp ? pp->value : NULL;
202 }
203
204 /*
205  * Find a property with a given name for a given node
206  * and return the value.
207  */
208 const void *of_get_property(const struct device_node *np, const char *name,
209                             int *lenp)
210 {
211         struct property *pp = of_find_property(np, name, lenp);
212
213         return pp ? pp->value : NULL;
214 }
215 EXPORT_SYMBOL(of_get_property);
216
217 /*
218  * arch_match_cpu_phys_id - Match the given logical CPU and physical id
219  *
220  * @cpu: logical cpu index of a core/thread
221  * @phys_id: physical identifier of a core/thread
222  *
223  * CPU logical to physical index mapping is architecture specific.
224  * However this __weak function provides a default match of physical
225  * id to logical cpu index. phys_id provided here is usually values read
226  * from the device tree which must match the hardware internal registers.
227  *
228  * Returns true if the physical identifier and the logical cpu index
229  * correspond to the same core/thread, false otherwise.
230  */
231 bool __weak arch_match_cpu_phys_id(int cpu, u64 phys_id)
232 {
233         return (u32)phys_id == cpu;
234 }
235
236 /**
237  * Checks if the given "prop_name" property holds the physical id of the
238  * core/thread corresponding to the logical cpu 'cpu'. If 'thread' is not
239  * NULL, local thread number within the core is returned in it.
240  */
241 static bool __of_find_n_match_cpu_property(struct device_node *cpun,
242                         const char *prop_name, int cpu, unsigned int *thread)
243 {
244         const __be32 *cell;
245         int ac, prop_len, tid;
246         u64 hwid;
247
248         ac = of_n_addr_cells(cpun);
249         cell = of_get_property(cpun, prop_name, &prop_len);
250         if (!cell || !ac)
251                 return false;
252         prop_len /= sizeof(*cell) * ac;
253         for (tid = 0; tid < prop_len; tid++) {
254                 hwid = of_read_number(cell, ac);
255                 if (arch_match_cpu_phys_id(cpu, hwid)) {
256                         if (thread)
257                                 *thread = tid;
258                         return true;
259                 }
260                 cell += ac;
261         }
262         return false;
263 }
264
265 /*
266  * arch_find_n_match_cpu_physical_id - See if the given device node is
267  * for the cpu corresponding to logical cpu 'cpu'.  Return true if so,
268  * else false.  If 'thread' is non-NULL, the local thread number within the
269  * core is returned in it.
270  */
271 bool __weak arch_find_n_match_cpu_physical_id(struct device_node *cpun,
272                                               int cpu, unsigned int *thread)
273 {
274         /* Check for non-standard "ibm,ppc-interrupt-server#s" property
275          * for thread ids on PowerPC. If it doesn't exist fallback to
276          * standard "reg" property.
277          */
278         if (IS_ENABLED(CONFIG_PPC) &&
279             __of_find_n_match_cpu_property(cpun,
280                                            "ibm,ppc-interrupt-server#s",
281                                            cpu, thread))
282                 return true;
283
284         return __of_find_n_match_cpu_property(cpun, "reg", cpu, thread);
285 }
286
287 /**
288  * of_get_cpu_node - Get device node associated with the given logical CPU
289  *
290  * @cpu: CPU number(logical index) for which device node is required
291  * @thread: if not NULL, local thread number within the physical core is
292  *          returned
293  *
294  * The main purpose of this function is to retrieve the device node for the
295  * given logical CPU index. It should be used to initialize the of_node in
296  * cpu device. Once of_node in cpu device is populated, all the further
297  * references can use that instead.
298  *
299  * CPU logical to physical index mapping is architecture specific and is built
300  * before booting secondary cores. This function uses arch_match_cpu_phys_id
301  * which can be overridden by architecture specific implementation.
302  *
303  * Returns a node pointer for the logical cpu with refcount incremented, use
304  * of_node_put() on it when done. Returns NULL if not found.
305  */
306 struct device_node *of_get_cpu_node(int cpu, unsigned int *thread)
307 {
308         struct device_node *cpun;
309
310         for_each_node_by_type(cpun, "cpu") {
311                 if (arch_find_n_match_cpu_physical_id(cpun, cpu, thread))
312                         return cpun;
313         }
314         return NULL;
315 }
316 EXPORT_SYMBOL(of_get_cpu_node);
317
318 /**
319  * __of_device_is_compatible() - Check if the node matches given constraints
320  * @device: pointer to node
321  * @compat: required compatible string, NULL or "" for any match
322  * @type: required device_type value, NULL or "" for any match
323  * @name: required node name, NULL or "" for any match
324  *
325  * Checks if the given @compat, @type and @name strings match the
326  * properties of the given @device. A constraints can be skipped by
327  * passing NULL or an empty string as the constraint.
328  *
329  * Returns 0 for no match, and a positive integer on match. The return
330  * value is a relative score with larger values indicating better
331  * matches. The score is weighted for the most specific compatible value
332  * to get the highest score. Matching type is next, followed by matching
333  * name. Practically speaking, this results in the following priority
334  * order for matches:
335  *
336  * 1. specific compatible && type && name
337  * 2. specific compatible && type
338  * 3. specific compatible && name
339  * 4. specific compatible
340  * 5. general compatible && type && name
341  * 6. general compatible && type
342  * 7. general compatible && name
343  * 8. general compatible
344  * 9. type && name
345  * 10. type
346  * 11. name
347  */
348 static int __of_device_is_compatible(const struct device_node *device,
349                                      const char *compat, const char *type, const char *name)
350 {
351         struct property *prop;
352         const char *cp;
353         int index = 0, score = 0;
354
355         /* Compatible match has highest priority */
356         if (compat && compat[0]) {
357                 prop = __of_find_property(device, "compatible", NULL);
358                 for (cp = of_prop_next_string(prop, NULL); cp;
359                      cp = of_prop_next_string(prop, cp), index++) {
360                         if (of_compat_cmp(cp, compat, strlen(compat)) == 0) {
361                                 score = INT_MAX/2 - (index << 2);
362                                 break;
363                         }
364                 }
365                 if (!score)
366                         return 0;
367         }
368
369         /* Matching type is better than matching name */
370         if (type && type[0]) {
371                 if (!device->type || of_node_cmp(type, device->type))
372                         return 0;
373                 score += 2;
374         }
375
376         /* Matching name is a bit better than not */
377         if (name && name[0]) {
378                 if (!device->name || of_node_cmp(name, device->name))
379                         return 0;
380                 score++;
381         }
382
383         return score;
384 }
385
386 /** Checks if the given "compat" string matches one of the strings in
387  * the device's "compatible" property
388  */
389 int of_device_is_compatible(const struct device_node *device,
390                 const char *compat)
391 {
392         unsigned long flags;
393         int res;
394
395         raw_spin_lock_irqsave(&devtree_lock, flags);
396         res = __of_device_is_compatible(device, compat, NULL, NULL);
397         raw_spin_unlock_irqrestore(&devtree_lock, flags);
398         return res;
399 }
400 EXPORT_SYMBOL(of_device_is_compatible);
401
402 /** Checks if the device is compatible with any of the entries in
403  *  a NULL terminated array of strings. Returns the best match
404  *  score or 0.
405  */
406 int of_device_compatible_match(struct device_node *device,
407                                const char *const *compat)
408 {
409         unsigned int tmp, score = 0;
410
411         if (!compat)
412                 return 0;
413
414         while (*compat) {
415                 tmp = of_device_is_compatible(device, *compat);
416                 if (tmp > score)
417                         score = tmp;
418                 compat++;
419         }
420
421         return score;
422 }
423
424 /**
425  * of_machine_is_compatible - Test root of device tree for a given compatible value
426  * @compat: compatible string to look for in root node's compatible property.
427  *
428  * Returns a positive integer if the root node has the given value in its
429  * compatible property.
430  */
431 int of_machine_is_compatible(const char *compat)
432 {
433         struct device_node *root;
434         int rc = 0;
435
436         root = of_find_node_by_path("/");
437         if (root) {
438                 rc = of_device_is_compatible(root, compat);
439                 of_node_put(root);
440         }
441         return rc;
442 }
443 EXPORT_SYMBOL(of_machine_is_compatible);
444
445 /**
446  *  __of_device_is_available - check if a device is available for use
447  *
448  *  @device: Node to check for availability, with locks already held
449  *
450  *  Returns true if the status property is absent or set to "okay" or "ok",
451  *  false otherwise
452  */
453 static bool __of_device_is_available(const struct device_node *device)
454 {
455         const char *status;
456         int statlen;
457
458         if (!device)
459                 return false;
460
461         status = __of_get_property(device, "status", &statlen);
462         if (status == NULL)
463                 return true;
464
465         if (statlen > 0) {
466                 if (!strcmp(status, "okay") || !strcmp(status, "ok"))
467                         return true;
468         }
469
470         return false;
471 }
472
473 /**
474  *  of_device_is_available - check if a device is available for use
475  *
476  *  @device: Node to check for availability
477  *
478  *  Returns true if the status property is absent or set to "okay" or "ok",
479  *  false otherwise
480  */
481 bool of_device_is_available(const struct device_node *device)
482 {
483         unsigned long flags;
484         bool res;
485
486         raw_spin_lock_irqsave(&devtree_lock, flags);
487         res = __of_device_is_available(device);
488         raw_spin_unlock_irqrestore(&devtree_lock, flags);
489         return res;
490
491 }
492 EXPORT_SYMBOL(of_device_is_available);
493
494 /**
495  *  of_device_is_big_endian - check if a device has BE registers
496  *
497  *  @device: Node to check for endianness
498  *
499  *  Returns true if the device has a "big-endian" property, or if the kernel
500  *  was compiled for BE *and* the device has a "native-endian" property.
501  *  Returns false otherwise.
502  *
503  *  Callers would nominally use ioread32be/iowrite32be if
504  *  of_device_is_big_endian() == true, or readl/writel otherwise.
505  */
506 bool of_device_is_big_endian(const struct device_node *device)
507 {
508         if (of_property_read_bool(device, "big-endian"))
509                 return true;
510         if (IS_ENABLED(CONFIG_CPU_BIG_ENDIAN) &&
511             of_property_read_bool(device, "native-endian"))
512                 return true;
513         return false;
514 }
515 EXPORT_SYMBOL(of_device_is_big_endian);
516
517 /**
518  *      of_get_parent - Get a node's parent if any
519  *      @node:  Node to get parent
520  *
521  *      Returns a node pointer with refcount incremented, use
522  *      of_node_put() on it when done.
523  */
524 struct device_node *of_get_parent(const struct device_node *node)
525 {
526         struct device_node *np;
527         unsigned long flags;
528
529         if (!node)
530                 return NULL;
531
532         raw_spin_lock_irqsave(&devtree_lock, flags);
533         np = of_node_get(node->parent);
534         raw_spin_unlock_irqrestore(&devtree_lock, flags);
535         return np;
536 }
537 EXPORT_SYMBOL(of_get_parent);
538
539 /**
540  *      of_get_next_parent - Iterate to a node's parent
541  *      @node:  Node to get parent of
542  *
543  *      This is like of_get_parent() except that it drops the
544  *      refcount on the passed node, making it suitable for iterating
545  *      through a node's parents.
546  *
547  *      Returns a node pointer with refcount incremented, use
548  *      of_node_put() on it when done.
549  */
550 struct device_node *of_get_next_parent(struct device_node *node)
551 {
552         struct device_node *parent;
553         unsigned long flags;
554
555         if (!node)
556                 return NULL;
557
558         raw_spin_lock_irqsave(&devtree_lock, flags);
559         parent = of_node_get(node->parent);
560         of_node_put(node);
561         raw_spin_unlock_irqrestore(&devtree_lock, flags);
562         return parent;
563 }
564 EXPORT_SYMBOL(of_get_next_parent);
565
566 static struct device_node *__of_get_next_child(const struct device_node *node,
567                                                 struct device_node *prev)
568 {
569         struct device_node *next;
570
571         if (!node)
572                 return NULL;
573
574         next = prev ? prev->sibling : node->child;
575         for (; next; next = next->sibling)
576                 if (of_node_get(next))
577                         break;
578         of_node_put(prev);
579         return next;
580 }
581 #define __for_each_child_of_node(parent, child) \
582         for (child = __of_get_next_child(parent, NULL); child != NULL; \
583              child = __of_get_next_child(parent, child))
584
585 /**
586  *      of_get_next_child - Iterate a node childs
587  *      @node:  parent node
588  *      @prev:  previous child of the parent node, or NULL to get first
589  *
590  *      Returns a node pointer with refcount incremented, use of_node_put() on
591  *      it when done. Returns NULL when prev is the last child. Decrements the
592  *      refcount of prev.
593  */
594 struct device_node *of_get_next_child(const struct device_node *node,
595         struct device_node *prev)
596 {
597         struct device_node *next;
598         unsigned long flags;
599
600         raw_spin_lock_irqsave(&devtree_lock, flags);
601         next = __of_get_next_child(node, prev);
602         raw_spin_unlock_irqrestore(&devtree_lock, flags);
603         return next;
604 }
605 EXPORT_SYMBOL(of_get_next_child);
606
607 /**
608  *      of_get_next_available_child - Find the next available child node
609  *      @node:  parent node
610  *      @prev:  previous child of the parent node, or NULL to get first
611  *
612  *      This function is like of_get_next_child(), except that it
613  *      automatically skips any disabled nodes (i.e. status = "disabled").
614  */
615 struct device_node *of_get_next_available_child(const struct device_node *node,
616         struct device_node *prev)
617 {
618         struct device_node *next;
619         unsigned long flags;
620
621         if (!node)
622                 return NULL;
623
624         raw_spin_lock_irqsave(&devtree_lock, flags);
625         next = prev ? prev->sibling : node->child;
626         for (; next; next = next->sibling) {
627                 if (!__of_device_is_available(next))
628                         continue;
629                 if (of_node_get(next))
630                         break;
631         }
632         of_node_put(prev);
633         raw_spin_unlock_irqrestore(&devtree_lock, flags);
634         return next;
635 }
636 EXPORT_SYMBOL(of_get_next_available_child);
637
638 /**
639  *      of_get_child_by_name - Find the child node by name for a given parent
640  *      @node:  parent node
641  *      @name:  child name to look for.
642  *
643  *      This function looks for child node for given matching name
644  *
645  *      Returns a node pointer if found, with refcount incremented, use
646  *      of_node_put() on it when done.
647  *      Returns NULL if node is not found.
648  */
649 struct device_node *of_get_child_by_name(const struct device_node *node,
650                                 const char *name)
651 {
652         struct device_node *child;
653
654         for_each_child_of_node(node, child)
655                 if (child->name && (of_node_cmp(child->name, name) == 0))
656                         break;
657         return child;
658 }
659 EXPORT_SYMBOL(of_get_child_by_name);
660
661 struct device_node *__of_find_node_by_path(struct device_node *parent,
662                                                 const char *path)
663 {
664         struct device_node *child;
665         int len;
666
667         len = strcspn(path, "/:");
668         if (!len)
669                 return NULL;
670
671         __for_each_child_of_node(parent, child) {
672                 const char *name = kbasename(child->full_name);
673                 if (strncmp(path, name, len) == 0 && (strlen(name) == len))
674                         return child;
675         }
676         return NULL;
677 }
678
679 struct device_node *__of_find_node_by_full_path(struct device_node *node,
680                                                 const char *path)
681 {
682         const char *separator = strchr(path, ':');
683
684         while (node && *path == '/') {
685                 struct device_node *tmp = node;
686
687                 path++; /* Increment past '/' delimiter */
688                 node = __of_find_node_by_path(node, path);
689                 of_node_put(tmp);
690                 path = strchrnul(path, '/');
691                 if (separator && separator < path)
692                         break;
693         }
694         return node;
695 }
696
697 /**
698  *      of_find_node_opts_by_path - Find a node matching a full OF path
699  *      @path: Either the full path to match, or if the path does not
700  *             start with '/', the name of a property of the /aliases
701  *             node (an alias).  In the case of an alias, the node
702  *             matching the alias' value will be returned.
703  *      @opts: Address of a pointer into which to store the start of
704  *             an options string appended to the end of the path with
705  *             a ':' separator.
706  *
707  *      Valid paths:
708  *              /foo/bar        Full path
709  *              foo             Valid alias
710  *              foo/bar         Valid alias + relative path
711  *
712  *      Returns a node pointer with refcount incremented, use
713  *      of_node_put() on it when done.
714  */
715 struct device_node *of_find_node_opts_by_path(const char *path, const char **opts)
716 {
717         struct device_node *np = NULL;
718         struct property *pp;
719         unsigned long flags;
720         const char *separator = strchr(path, ':');
721
722         if (opts)
723                 *opts = separator ? separator + 1 : NULL;
724
725         if (strcmp(path, "/") == 0)
726                 return of_node_get(of_root);
727
728         /* The path could begin with an alias */
729         if (*path != '/') {
730                 int len;
731                 const char *p = separator;
732
733                 if (!p)
734                         p = strchrnul(path, '/');
735                 len = p - path;
736
737                 /* of_aliases must not be NULL */
738                 if (!of_aliases)
739                         return NULL;
740
741                 for_each_property_of_node(of_aliases, pp) {
742                         if (strlen(pp->name) == len && !strncmp(pp->name, path, len)) {
743                                 np = of_find_node_by_path(pp->value);
744                                 break;
745                         }
746                 }
747                 if (!np)
748                         return NULL;
749                 path = p;
750         }
751
752         /* Step down the tree matching path components */
753         raw_spin_lock_irqsave(&devtree_lock, flags);
754         if (!np)
755                 np = of_node_get(of_root);
756         np = __of_find_node_by_full_path(np, path);
757         raw_spin_unlock_irqrestore(&devtree_lock, flags);
758         return np;
759 }
760 EXPORT_SYMBOL(of_find_node_opts_by_path);
761
762 /**
763  *      of_find_node_by_name - Find a node by its "name" property
764  *      @from:  The node to start searching from or NULL; the node
765  *              you pass will not be searched, only the next one
766  *              will. Typically, you pass what the previous call
767  *              returned. of_node_put() will be called on @from.
768  *      @name:  The name string to match against
769  *
770  *      Returns a node pointer with refcount incremented, use
771  *      of_node_put() on it when done.
772  */
773 struct device_node *of_find_node_by_name(struct device_node *from,
774         const char *name)
775 {
776         struct device_node *np;
777         unsigned long flags;
778
779         raw_spin_lock_irqsave(&devtree_lock, flags);
780         for_each_of_allnodes_from(from, np)
781                 if (np->name && (of_node_cmp(np->name, name) == 0)
782                     && of_node_get(np))
783                         break;
784         of_node_put(from);
785         raw_spin_unlock_irqrestore(&devtree_lock, flags);
786         return np;
787 }
788 EXPORT_SYMBOL(of_find_node_by_name);
789
790 /**
791  *      of_find_node_by_type - Find a node by its "device_type" property
792  *      @from:  The node to start searching from, or NULL to start searching
793  *              the entire device tree. The node you pass will not be
794  *              searched, only the next one will; typically, you pass
795  *              what the previous call returned. of_node_put() will be
796  *              called on from for you.
797  *      @type:  The type string to match against
798  *
799  *      Returns a node pointer with refcount incremented, use
800  *      of_node_put() on it when done.
801  */
802 struct device_node *of_find_node_by_type(struct device_node *from,
803         const char *type)
804 {
805         struct device_node *np;
806         unsigned long flags;
807
808         raw_spin_lock_irqsave(&devtree_lock, flags);
809         for_each_of_allnodes_from(from, np)
810                 if (np->type && (of_node_cmp(np->type, type) == 0)
811                     && of_node_get(np))
812                         break;
813         of_node_put(from);
814         raw_spin_unlock_irqrestore(&devtree_lock, flags);
815         return np;
816 }
817 EXPORT_SYMBOL(of_find_node_by_type);
818
819 /**
820  *      of_find_compatible_node - Find a node based on type and one of the
821  *                                tokens in its "compatible" property
822  *      @from:          The node to start searching from or NULL, the node
823  *                      you pass will not be searched, only the next one
824  *                      will; typically, you pass what the previous call
825  *                      returned. of_node_put() will be called on it
826  *      @type:          The type string to match "device_type" or NULL to ignore
827  *      @compatible:    The string to match to one of the tokens in the device
828  *                      "compatible" list.
829  *
830  *      Returns a node pointer with refcount incremented, use
831  *      of_node_put() on it when done.
832  */
833 struct device_node *of_find_compatible_node(struct device_node *from,
834         const char *type, const char *compatible)
835 {
836         struct device_node *np;
837         unsigned long flags;
838
839         raw_spin_lock_irqsave(&devtree_lock, flags);
840         for_each_of_allnodes_from(from, np)
841                 if (__of_device_is_compatible(np, compatible, type, NULL) &&
842                     of_node_get(np))
843                         break;
844         of_node_put(from);
845         raw_spin_unlock_irqrestore(&devtree_lock, flags);
846         return np;
847 }
848 EXPORT_SYMBOL(of_find_compatible_node);
849
850 /**
851  *      of_find_node_with_property - Find a node which has a property with
852  *                                   the given name.
853  *      @from:          The node to start searching from or NULL, the node
854  *                      you pass will not be searched, only the next one
855  *                      will; typically, you pass what the previous call
856  *                      returned. of_node_put() will be called on it
857  *      @prop_name:     The name of the property to look for.
858  *
859  *      Returns a node pointer with refcount incremented, use
860  *      of_node_put() on it when done.
861  */
862 struct device_node *of_find_node_with_property(struct device_node *from,
863         const char *prop_name)
864 {
865         struct device_node *np;
866         struct property *pp;
867         unsigned long flags;
868
869         raw_spin_lock_irqsave(&devtree_lock, flags);
870         for_each_of_allnodes_from(from, np) {
871                 for (pp = np->properties; pp; pp = pp->next) {
872                         if (of_prop_cmp(pp->name, prop_name) == 0) {
873                                 of_node_get(np);
874                                 goto out;
875                         }
876                 }
877         }
878 out:
879         of_node_put(from);
880         raw_spin_unlock_irqrestore(&devtree_lock, flags);
881         return np;
882 }
883 EXPORT_SYMBOL(of_find_node_with_property);
884
885 static
886 const struct of_device_id *__of_match_node(const struct of_device_id *matches,
887                                            const struct device_node *node)
888 {
889         const struct of_device_id *best_match = NULL;
890         int score, best_score = 0;
891
892         if (!matches)
893                 return NULL;
894
895         for (; matches->name[0] || matches->type[0] || matches->compatible[0]; matches++) {
896                 score = __of_device_is_compatible(node, matches->compatible,
897                                                   matches->type, matches->name);
898                 if (score > best_score) {
899                         best_match = matches;
900                         best_score = score;
901                 }
902         }
903
904         return best_match;
905 }
906
907 /**
908  * of_match_node - Tell if a device_node has a matching of_match structure
909  *      @matches:       array of of device match structures to search in
910  *      @node:          the of device structure to match against
911  *
912  *      Low level utility function used by device matching.
913  */
914 const struct of_device_id *of_match_node(const struct of_device_id *matches,
915                                          const struct device_node *node)
916 {
917         const struct of_device_id *match;
918         unsigned long flags;
919
920         raw_spin_lock_irqsave(&devtree_lock, flags);
921         match = __of_match_node(matches, node);
922         raw_spin_unlock_irqrestore(&devtree_lock, flags);
923         return match;
924 }
925 EXPORT_SYMBOL(of_match_node);
926
927 /**
928  *      of_find_matching_node_and_match - Find a node based on an of_device_id
929  *                                        match table.
930  *      @from:          The node to start searching from or NULL, the node
931  *                      you pass will not be searched, only the next one
932  *                      will; typically, you pass what the previous call
933  *                      returned. of_node_put() will be called on it
934  *      @matches:       array of of device match structures to search in
935  *      @match          Updated to point at the matches entry which matched
936  *
937  *      Returns a node pointer with refcount incremented, use
938  *      of_node_put() on it when done.
939  */
940 struct device_node *of_find_matching_node_and_match(struct device_node *from,
941                                         const struct of_device_id *matches,
942                                         const struct of_device_id **match)
943 {
944         struct device_node *np;
945         const struct of_device_id *m;
946         unsigned long flags;
947
948         if (match)
949                 *match = NULL;
950
951         raw_spin_lock_irqsave(&devtree_lock, flags);
952         for_each_of_allnodes_from(from, np) {
953                 m = __of_match_node(matches, np);
954                 if (m && of_node_get(np)) {
955                         if (match)
956                                 *match = m;
957                         break;
958                 }
959         }
960         of_node_put(from);
961         raw_spin_unlock_irqrestore(&devtree_lock, flags);
962         return np;
963 }
964 EXPORT_SYMBOL(of_find_matching_node_and_match);
965
966 /**
967  * of_modalias_node - Lookup appropriate modalias for a device node
968  * @node:       pointer to a device tree node
969  * @modalias:   Pointer to buffer that modalias value will be copied into
970  * @len:        Length of modalias value
971  *
972  * Based on the value of the compatible property, this routine will attempt
973  * to choose an appropriate modalias value for a particular device tree node.
974  * It does this by stripping the manufacturer prefix (as delimited by a ',')
975  * from the first entry in the compatible list property.
976  *
977  * This routine returns 0 on success, <0 on failure.
978  */
979 int of_modalias_node(struct device_node *node, char *modalias, int len)
980 {
981         const char *compatible, *p;
982         int cplen;
983
984         compatible = of_get_property(node, "compatible", &cplen);
985         if (!compatible || strlen(compatible) > cplen)
986                 return -ENODEV;
987         p = strchr(compatible, ',');
988         strlcpy(modalias, p ? p + 1 : compatible, len);
989         return 0;
990 }
991 EXPORT_SYMBOL_GPL(of_modalias_node);
992
993 /**
994  * of_find_node_by_phandle - Find a node given a phandle
995  * @handle:     phandle of the node to find
996  *
997  * Returns a node pointer with refcount incremented, use
998  * of_node_put() on it when done.
999  */
1000 struct device_node *of_find_node_by_phandle(phandle handle)
1001 {
1002         struct device_node *np;
1003         unsigned long flags;
1004
1005         if (!handle)
1006                 return NULL;
1007
1008         raw_spin_lock_irqsave(&devtree_lock, flags);
1009         for_each_of_allnodes(np)
1010                 if (np->phandle == handle)
1011                         break;
1012         of_node_get(np);
1013         raw_spin_unlock_irqrestore(&devtree_lock, flags);
1014         return np;
1015 }
1016 EXPORT_SYMBOL(of_find_node_by_phandle);
1017
1018 void of_print_phandle_args(const char *msg, const struct of_phandle_args *args)
1019 {
1020         int i;
1021         printk("%s %pOF", msg, args->np);
1022         for (i = 0; i < args->args_count; i++) {
1023                 const char delim = i ? ',' : ':';
1024
1025                 pr_cont("%c%08x", delim, args->args[i]);
1026         }
1027         pr_cont("\n");
1028 }
1029
1030 int of_phandle_iterator_init(struct of_phandle_iterator *it,
1031                 const struct device_node *np,
1032                 const char *list_name,
1033                 const char *cells_name,
1034                 int cell_count)
1035 {
1036         const __be32 *list;
1037         int size;
1038
1039         memset(it, 0, sizeof(*it));
1040
1041         list = of_get_property(np, list_name, &size);
1042         if (!list)
1043                 return -ENOENT;
1044
1045         it->cells_name = cells_name;
1046         it->cell_count = cell_count;
1047         it->parent = np;
1048         it->list_end = list + size / sizeof(*list);
1049         it->phandle_end = list;
1050         it->cur = list;
1051
1052         return 0;
1053 }
1054 EXPORT_SYMBOL_GPL(of_phandle_iterator_init);
1055
1056 int of_phandle_iterator_next(struct of_phandle_iterator *it)
1057 {
1058         uint32_t count = 0;
1059
1060         if (it->node) {
1061                 of_node_put(it->node);
1062                 it->node = NULL;
1063         }
1064
1065         if (!it->cur || it->phandle_end >= it->list_end)
1066                 return -ENOENT;
1067
1068         it->cur = it->phandle_end;
1069
1070         /* If phandle is 0, then it is an empty entry with no arguments. */
1071         it->phandle = be32_to_cpup(it->cur++);
1072
1073         if (it->phandle) {
1074
1075                 /*
1076                  * Find the provider node and parse the #*-cells property to
1077                  * determine the argument length.
1078                  */
1079                 it->node = of_find_node_by_phandle(it->phandle);
1080
1081                 if (it->cells_name) {
1082                         if (!it->node) {
1083                                 pr_err("%pOF: could not find phandle\n",
1084                                        it->parent);
1085                                 goto err;
1086                         }
1087
1088                         if (of_property_read_u32(it->node, it->cells_name,
1089                                                  &count)) {
1090                                 pr_err("%pOF: could not get %s for %pOF\n",
1091                                        it->parent,
1092                                        it->cells_name,
1093                                        it->node);
1094                                 goto err;
1095                         }
1096                 } else {
1097                         count = it->cell_count;
1098                 }
1099
1100                 /*
1101                  * Make sure that the arguments actually fit in the remaining
1102                  * property data length
1103                  */
1104                 if (it->cur + count > it->list_end) {
1105                         pr_err("%pOF: arguments longer than property\n",
1106                                it->parent);
1107                         goto err;
1108                 }
1109         }
1110
1111         it->phandle_end = it->cur + count;
1112         it->cur_count = count;
1113
1114         return 0;
1115
1116 err:
1117         if (it->node) {
1118                 of_node_put(it->node);
1119                 it->node = NULL;
1120         }
1121
1122         return -EINVAL;
1123 }
1124 EXPORT_SYMBOL_GPL(of_phandle_iterator_next);
1125
1126 int of_phandle_iterator_args(struct of_phandle_iterator *it,
1127                              uint32_t *args,
1128                              int size)
1129 {
1130         int i, count;
1131
1132         count = it->cur_count;
1133
1134         if (WARN_ON(size < count))
1135                 count = size;
1136
1137         for (i = 0; i < count; i++)
1138                 args[i] = be32_to_cpup(it->cur++);
1139
1140         return count;
1141 }
1142
1143 static int __of_parse_phandle_with_args(const struct device_node *np,
1144                                         const char *list_name,
1145                                         const char *cells_name,
1146                                         int cell_count, int index,
1147                                         struct of_phandle_args *out_args)
1148 {
1149         struct of_phandle_iterator it;
1150         int rc, cur_index = 0;
1151
1152         /* Loop over the phandles until all the requested entry is found */
1153         of_for_each_phandle(&it, rc, np, list_name, cells_name, cell_count) {
1154                 /*
1155                  * All of the error cases bail out of the loop, so at
1156                  * this point, the parsing is successful. If the requested
1157                  * index matches, then fill the out_args structure and return,
1158                  * or return -ENOENT for an empty entry.
1159                  */
1160                 rc = -ENOENT;
1161                 if (cur_index == index) {
1162                         if (!it.phandle)
1163                                 goto err;
1164
1165                         if (out_args) {
1166                                 int c;
1167
1168                                 c = of_phandle_iterator_args(&it,
1169                                                              out_args->args,
1170                                                              MAX_PHANDLE_ARGS);
1171                                 out_args->np = it.node;
1172                                 out_args->args_count = c;
1173                         } else {
1174                                 of_node_put(it.node);
1175                         }
1176
1177                         /* Found it! return success */
1178                         return 0;
1179                 }
1180
1181                 cur_index++;
1182         }
1183
1184         /*
1185          * Unlock node before returning result; will be one of:
1186          * -ENOENT : index is for empty phandle
1187          * -EINVAL : parsing error on data
1188          */
1189
1190  err:
1191         of_node_put(it.node);
1192         return rc;
1193 }
1194
1195 /**
1196  * of_parse_phandle - Resolve a phandle property to a device_node pointer
1197  * @np: Pointer to device node holding phandle property
1198  * @phandle_name: Name of property holding a phandle value
1199  * @index: For properties holding a table of phandles, this is the index into
1200  *         the table
1201  *
1202  * Returns the device_node pointer with refcount incremented.  Use
1203  * of_node_put() on it when done.
1204  */
1205 struct device_node *of_parse_phandle(const struct device_node *np,
1206                                      const char *phandle_name, int index)
1207 {
1208         struct of_phandle_args args;
1209
1210         if (index < 0)
1211                 return NULL;
1212
1213         if (__of_parse_phandle_with_args(np, phandle_name, NULL, 0,
1214                                          index, &args))
1215                 return NULL;
1216
1217         return args.np;
1218 }
1219 EXPORT_SYMBOL(of_parse_phandle);
1220
1221 /**
1222  * of_parse_phandle_with_args() - Find a node pointed by phandle in a list
1223  * @np:         pointer to a device tree node containing a list
1224  * @list_name:  property name that contains a list
1225  * @cells_name: property name that specifies phandles' arguments count
1226  * @index:      index of a phandle to parse out
1227  * @out_args:   optional pointer to output arguments structure (will be filled)
1228  *
1229  * This function is useful to parse lists of phandles and their arguments.
1230  * Returns 0 on success and fills out_args, on error returns appropriate
1231  * errno value.
1232  *
1233  * Caller is responsible to call of_node_put() on the returned out_args->np
1234  * pointer.
1235  *
1236  * Example:
1237  *
1238  * phandle1: node1 {
1239  *      #list-cells = <2>;
1240  * }
1241  *
1242  * phandle2: node2 {
1243  *      #list-cells = <1>;
1244  * }
1245  *
1246  * node3 {
1247  *      list = <&phandle1 1 2 &phandle2 3>;
1248  * }
1249  *
1250  * To get a device_node of the `node2' node you may call this:
1251  * of_parse_phandle_with_args(node3, "list", "#list-cells", 1, &args);
1252  */
1253 int of_parse_phandle_with_args(const struct device_node *np, const char *list_name,
1254                                 const char *cells_name, int index,
1255                                 struct of_phandle_args *out_args)
1256 {
1257         if (index < 0)
1258                 return -EINVAL;
1259         return __of_parse_phandle_with_args(np, list_name, cells_name, 0,
1260                                             index, out_args);
1261 }
1262 EXPORT_SYMBOL(of_parse_phandle_with_args);
1263
1264 /**
1265  * of_parse_phandle_with_fixed_args() - Find a node pointed by phandle in a list
1266  * @np:         pointer to a device tree node containing a list
1267  * @list_name:  property name that contains a list
1268  * @cell_count: number of argument cells following the phandle
1269  * @index:      index of a phandle to parse out
1270  * @out_args:   optional pointer to output arguments structure (will be filled)
1271  *
1272  * This function is useful to parse lists of phandles and their arguments.
1273  * Returns 0 on success and fills out_args, on error returns appropriate
1274  * errno value.
1275  *
1276  * Caller is responsible to call of_node_put() on the returned out_args->np
1277  * pointer.
1278  *
1279  * Example:
1280  *
1281  * phandle1: node1 {
1282  * }
1283  *
1284  * phandle2: node2 {
1285  * }
1286  *
1287  * node3 {
1288  *      list = <&phandle1 0 2 &phandle2 2 3>;
1289  * }
1290  *
1291  * To get a device_node of the `node2' node you may call this:
1292  * of_parse_phandle_with_fixed_args(node3, "list", 2, 1, &args);
1293  */
1294 int of_parse_phandle_with_fixed_args(const struct device_node *np,
1295                                 const char *list_name, int cell_count,
1296                                 int index, struct of_phandle_args *out_args)
1297 {
1298         if (index < 0)
1299                 return -EINVAL;
1300         return __of_parse_phandle_with_args(np, list_name, NULL, cell_count,
1301                                            index, out_args);
1302 }
1303 EXPORT_SYMBOL(of_parse_phandle_with_fixed_args);
1304
1305 /**
1306  * of_count_phandle_with_args() - Find the number of phandles references in a property
1307  * @np:         pointer to a device tree node containing a list
1308  * @list_name:  property name that contains a list
1309  * @cells_name: property name that specifies phandles' arguments count
1310  *
1311  * Returns the number of phandle + argument tuples within a property. It
1312  * is a typical pattern to encode a list of phandle and variable
1313  * arguments into a single property. The number of arguments is encoded
1314  * by a property in the phandle-target node. For example, a gpios
1315  * property would contain a list of GPIO specifies consisting of a
1316  * phandle and 1 or more arguments. The number of arguments are
1317  * determined by the #gpio-cells property in the node pointed to by the
1318  * phandle.
1319  */
1320 int of_count_phandle_with_args(const struct device_node *np, const char *list_name,
1321                                 const char *cells_name)
1322 {
1323         struct of_phandle_iterator it;
1324         int rc, cur_index = 0;
1325
1326         rc = of_phandle_iterator_init(&it, np, list_name, cells_name, 0);
1327         if (rc)
1328                 return rc;
1329
1330         while ((rc = of_phandle_iterator_next(&it)) == 0)
1331                 cur_index += 1;
1332
1333         if (rc != -ENOENT)
1334                 return rc;
1335
1336         return cur_index;
1337 }
1338 EXPORT_SYMBOL(of_count_phandle_with_args);
1339
1340 /**
1341  * __of_add_property - Add a property to a node without lock operations
1342  */
1343 int __of_add_property(struct device_node *np, struct property *prop)
1344 {
1345         struct property **next;
1346
1347         prop->next = NULL;
1348         next = &np->properties;
1349         while (*next) {
1350                 if (strcmp(prop->name, (*next)->name) == 0)
1351                         /* duplicate ! don't insert it */
1352                         return -EEXIST;
1353
1354                 next = &(*next)->next;
1355         }
1356         *next = prop;
1357
1358         return 0;
1359 }
1360
1361 /**
1362  * of_add_property - Add a property to a node
1363  */
1364 int of_add_property(struct device_node *np, struct property *prop)
1365 {
1366         unsigned long flags;
1367         int rc;
1368
1369         mutex_lock(&of_mutex);
1370
1371         raw_spin_lock_irqsave(&devtree_lock, flags);
1372         rc = __of_add_property(np, prop);
1373         raw_spin_unlock_irqrestore(&devtree_lock, flags);
1374
1375         if (!rc)
1376                 __of_add_property_sysfs(np, prop);
1377
1378         mutex_unlock(&of_mutex);
1379
1380         if (!rc)
1381                 of_property_notify(OF_RECONFIG_ADD_PROPERTY, np, prop, NULL);
1382
1383         return rc;
1384 }
1385
1386 int __of_remove_property(struct device_node *np, struct property *prop)
1387 {
1388         struct property **next;
1389
1390         for (next = &np->properties; *next; next = &(*next)->next) {
1391                 if (*next == prop)
1392                         break;
1393         }
1394         if (*next == NULL)
1395                 return -ENODEV;
1396
1397         /* found the node */
1398         *next = prop->next;
1399         prop->next = np->deadprops;
1400         np->deadprops = prop;
1401
1402         return 0;
1403 }
1404
1405 /**
1406  * of_remove_property - Remove a property from a node.
1407  *
1408  * Note that we don't actually remove it, since we have given out
1409  * who-knows-how-many pointers to the data using get-property.
1410  * Instead we just move the property to the "dead properties"
1411  * list, so it won't be found any more.
1412  */
1413 int of_remove_property(struct device_node *np, struct property *prop)
1414 {
1415         unsigned long flags;
1416         int rc;
1417
1418         if (!prop)
1419                 return -ENODEV;
1420
1421         mutex_lock(&of_mutex);
1422
1423         raw_spin_lock_irqsave(&devtree_lock, flags);
1424         rc = __of_remove_property(np, prop);
1425         raw_spin_unlock_irqrestore(&devtree_lock, flags);
1426
1427         if (!rc)
1428                 __of_remove_property_sysfs(np, prop);
1429
1430         mutex_unlock(&of_mutex);
1431
1432         if (!rc)
1433                 of_property_notify(OF_RECONFIG_REMOVE_PROPERTY, np, prop, NULL);
1434
1435         return rc;
1436 }
1437
1438 int __of_update_property(struct device_node *np, struct property *newprop,
1439                 struct property **oldpropp)
1440 {
1441         struct property **next, *oldprop;
1442
1443         for (next = &np->properties; *next; next = &(*next)->next) {
1444                 if (of_prop_cmp((*next)->name, newprop->name) == 0)
1445                         break;
1446         }
1447         *oldpropp = oldprop = *next;
1448
1449         if (oldprop) {
1450                 /* replace the node */
1451                 newprop->next = oldprop->next;
1452                 *next = newprop;
1453                 oldprop->next = np->deadprops;
1454                 np->deadprops = oldprop;
1455         } else {
1456                 /* new node */
1457                 newprop->next = NULL;
1458                 *next = newprop;
1459         }
1460
1461         return 0;
1462 }
1463
1464 /*
1465  * of_update_property - Update a property in a node, if the property does
1466  * not exist, add it.
1467  *
1468  * Note that we don't actually remove it, since we have given out
1469  * who-knows-how-many pointers to the data using get-property.
1470  * Instead we just move the property to the "dead properties" list,
1471  * and add the new property to the property list
1472  */
1473 int of_update_property(struct device_node *np, struct property *newprop)
1474 {
1475         struct property *oldprop;
1476         unsigned long flags;
1477         int rc;
1478
1479         if (!newprop->name)
1480                 return -EINVAL;
1481
1482         mutex_lock(&of_mutex);
1483
1484         raw_spin_lock_irqsave(&devtree_lock, flags);
1485         rc = __of_update_property(np, newprop, &oldprop);
1486         raw_spin_unlock_irqrestore(&devtree_lock, flags);
1487
1488         if (!rc)
1489                 __of_update_property_sysfs(np, newprop, oldprop);
1490
1491         mutex_unlock(&of_mutex);
1492
1493         if (!rc)
1494                 of_property_notify(OF_RECONFIG_UPDATE_PROPERTY, np, newprop, oldprop);
1495
1496         return rc;
1497 }
1498
1499 static void of_alias_add(struct alias_prop *ap, struct device_node *np,
1500                          int id, const char *stem, int stem_len)
1501 {
1502         ap->np = np;
1503         ap->id = id;
1504         strncpy(ap->stem, stem, stem_len);
1505         ap->stem[stem_len] = 0;
1506         list_add_tail(&ap->link, &aliases_lookup);
1507         pr_debug("adding DT alias:%s: stem=%s id=%i node=%pOF\n",
1508                  ap->alias, ap->stem, ap->id, np);
1509 }
1510
1511 /**
1512  * of_alias_scan - Scan all properties of the 'aliases' node
1513  *
1514  * The function scans all the properties of the 'aliases' node and populates
1515  * the global lookup table with the properties.  It returns the
1516  * number of alias properties found, or an error code in case of failure.
1517  *
1518  * @dt_alloc:   An allocator that provides a virtual address to memory
1519  *              for storing the resulting tree
1520  */
1521 void of_alias_scan(void * (*dt_alloc)(u64 size, u64 align))
1522 {
1523         struct property *pp;
1524
1525         of_aliases = of_find_node_by_path("/aliases");
1526         of_chosen = of_find_node_by_path("/chosen");
1527         if (of_chosen == NULL)
1528                 of_chosen = of_find_node_by_path("/chosen@0");
1529
1530         if (of_chosen) {
1531                 /* linux,stdout-path and /aliases/stdout are for legacy compatibility */
1532                 const char *name = NULL;
1533
1534                 if (of_property_read_string(of_chosen, "stdout-path", &name))
1535                         of_property_read_string(of_chosen, "linux,stdout-path",
1536                                                 &name);
1537                 if (IS_ENABLED(CONFIG_PPC) && !name)
1538                         of_property_read_string(of_aliases, "stdout", &name);
1539                 if (name)
1540                         of_stdout = of_find_node_opts_by_path(name, &of_stdout_options);
1541         }
1542
1543         if (!of_aliases)
1544                 return;
1545
1546         for_each_property_of_node(of_aliases, pp) {
1547                 const char *start = pp->name;
1548                 const char *end = start + strlen(start);
1549                 struct device_node *np;
1550                 struct alias_prop *ap;
1551                 int id, len;
1552
1553                 /* Skip those we do not want to proceed */
1554                 if (!strcmp(pp->name, "name") ||
1555                     !strcmp(pp->name, "phandle") ||
1556                     !strcmp(pp->name, "linux,phandle"))
1557                         continue;
1558
1559                 np = of_find_node_by_path(pp->value);
1560                 if (!np)
1561                         continue;
1562
1563                 /* walk the alias backwards to extract the id and work out
1564                  * the 'stem' string */
1565                 while (isdigit(*(end-1)) && end > start)
1566                         end--;
1567                 len = end - start;
1568
1569                 if (kstrtoint(end, 10, &id) < 0)
1570                         continue;
1571
1572                 /* Allocate an alias_prop with enough space for the stem */
1573                 ap = dt_alloc(sizeof(*ap) + len + 1, __alignof__(*ap));
1574                 if (!ap)
1575                         continue;
1576                 memset(ap, 0, sizeof(*ap) + len + 1);
1577                 ap->alias = start;
1578                 of_alias_add(ap, np, id, start, len);
1579         }
1580 }
1581
1582 /**
1583  * of_alias_get_id - Get alias id for the given device_node
1584  * @np:         Pointer to the given device_node
1585  * @stem:       Alias stem of the given device_node
1586  *
1587  * The function travels the lookup table to get the alias id for the given
1588  * device_node and alias stem.  It returns the alias id if found.
1589  */
1590 int of_alias_get_id(struct device_node *np, const char *stem)
1591 {
1592         struct alias_prop *app;
1593         int id = -ENODEV;
1594
1595         mutex_lock(&of_mutex);
1596         list_for_each_entry(app, &aliases_lookup, link) {
1597                 if (strcmp(app->stem, stem) != 0)
1598                         continue;
1599
1600                 if (np == app->np) {
1601                         id = app->id;
1602                         break;
1603                 }
1604         }
1605         mutex_unlock(&of_mutex);
1606
1607         return id;
1608 }
1609 EXPORT_SYMBOL_GPL(of_alias_get_id);
1610
1611 /**
1612  * of_alias_get_highest_id - Get highest alias id for the given stem
1613  * @stem:       Alias stem to be examined
1614  *
1615  * The function travels the lookup table to get the highest alias id for the
1616  * given alias stem.  It returns the alias id if found.
1617  */
1618 int of_alias_get_highest_id(const char *stem)
1619 {
1620         struct alias_prop *app;
1621         int id = -ENODEV;
1622
1623         mutex_lock(&of_mutex);
1624         list_for_each_entry(app, &aliases_lookup, link) {
1625                 if (strcmp(app->stem, stem) != 0)
1626                         continue;
1627
1628                 if (app->id > id)
1629                         id = app->id;
1630         }
1631         mutex_unlock(&of_mutex);
1632
1633         return id;
1634 }
1635 EXPORT_SYMBOL_GPL(of_alias_get_highest_id);
1636
1637 /**
1638  * of_console_check() - Test and setup console for DT setup
1639  * @dn - Pointer to device node
1640  * @name - Name to use for preferred console without index. ex. "ttyS"
1641  * @index - Index to use for preferred console.
1642  *
1643  * Check if the given device node matches the stdout-path property in the
1644  * /chosen node. If it does then register it as the preferred console and return
1645  * TRUE. Otherwise return FALSE.
1646  */
1647 bool of_console_check(struct device_node *dn, char *name, int index)
1648 {
1649         if (!dn || dn != of_stdout || console_set_on_cmdline)
1650                 return false;
1651
1652         /*
1653          * XXX: cast `options' to char pointer to suppress complication
1654          * warnings: printk, UART and console drivers expect char pointer.
1655          */
1656         return !add_preferred_console(name, index, (char *)of_stdout_options);
1657 }
1658 EXPORT_SYMBOL_GPL(of_console_check);
1659
1660 /**
1661  *      of_find_next_cache_node - Find a node's subsidiary cache
1662  *      @np:    node of type "cpu" or "cache"
1663  *
1664  *      Returns a node pointer with refcount incremented, use
1665  *      of_node_put() on it when done.  Caller should hold a reference
1666  *      to np.
1667  */
1668 struct device_node *of_find_next_cache_node(const struct device_node *np)
1669 {
1670         struct device_node *child, *cache_node;
1671
1672         cache_node = of_parse_phandle(np, "l2-cache", 0);
1673         if (!cache_node)
1674                 cache_node = of_parse_phandle(np, "next-level-cache", 0);
1675
1676         if (cache_node)
1677                 return cache_node;
1678
1679         /* OF on pmac has nodes instead of properties named "l2-cache"
1680          * beneath CPU nodes.
1681          */
1682         if (!strcmp(np->type, "cpu"))
1683                 for_each_child_of_node(np, child)
1684                         if (!strcmp(child->type, "cache"))
1685                                 return child;
1686
1687         return NULL;
1688 }
1689
1690 /**
1691  * of_find_last_cache_level - Find the level at which the last cache is
1692  *              present for the given logical cpu
1693  *
1694  * @cpu: cpu number(logical index) for which the last cache level is needed
1695  *
1696  * Returns the the level at which the last cache is present. It is exactly
1697  * same as  the total number of cache levels for the given logical cpu.
1698  */
1699 int of_find_last_cache_level(unsigned int cpu)
1700 {
1701         u32 cache_level = 0;
1702         struct device_node *prev = NULL, *np = of_cpu_device_node_get(cpu);
1703
1704         while (np) {
1705                 prev = np;
1706                 of_node_put(np);
1707                 np = of_find_next_cache_node(np);
1708         }
1709
1710         of_property_read_u32(prev, "cache-level", &cache_level);
1711
1712         return cache_level;
1713 }