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