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