blob: b85373768ce108050c7cf2b4886eb9f9ec962458 [file] [log] [blame]
Stephen Rothwell97e873e2007-05-01 16:26:07 +10001/*
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 *
Grant Likelye91edcf2009-10-15 10:58:09 -060012 * Reconsolidated from arch/x/kernel/prom.c by Stephen Rothwell and
13 * Grant Likely.
Stephen Rothwell97e873e2007-05-01 16:26:07 +100014 *
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 */
Rob Herring606ad422016-06-15 08:32:18 -050020
21#define pr_fmt(fmt) "OF: " fmt
22
Grant Likely3482f2c2014-03-27 17:18:55 -070023#include <linux/console.h>
Shawn Guo611cad72011-08-15 15:28:14 +080024#include <linux/ctype.h>
Sudeep KarkadaNagesha183912d2013-08-15 14:01:40 +010025#include <linux/cpu.h>
Stephen Rothwell97e873e2007-05-01 16:26:07 +100026#include <linux/module.h>
27#include <linux/of.h>
Philipp Zabelfd9fdb72014-02-10 22:01:48 +010028#include <linux/of_graph.h>
Stephen Rothwell581b6052007-04-24 16:46:53 +100029#include <linux/spinlock.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090030#include <linux/slab.h>
Grant Likely75b57ec2014-02-20 18:02:11 +000031#include <linux/string.h>
Jeremy Kerra9f2f632010-02-01 21:34:14 -070032#include <linux/proc_fs.h>
Stephen Rothwell581b6052007-04-24 16:46:53 +100033
Stepan Moskovchenkoced4eec2012-12-06 14:55:41 -080034#include "of_private.h"
Shawn Guo611cad72011-08-15 15:28:14 +080035
Stepan Moskovchenkoced4eec2012-12-06 14:55:41 -080036LIST_HEAD(aliases_lookup);
Shawn Guo611cad72011-08-15 15:28:14 +080037
Grant Likely5063e252014-10-03 16:28:27 +010038struct device_node *of_root;
39EXPORT_SYMBOL(of_root);
Grant Likelyfc0bdae2010-02-14 07:13:55 -070040struct device_node *of_chosen;
Shawn Guo611cad72011-08-15 15:28:14 +080041struct device_node *of_aliases;
Grant Likelya752ee52014-03-28 08:12:18 -070042struct device_node *of_stdout;
Leif Lindholm7914a7c2014-11-27 17:56:07 +000043static const char *of_stdout_options;
Shawn Guo611cad72011-08-15 15:28:14 +080044
Grant Likely8a2b22a2014-07-23 17:05:06 -060045struct kset *of_kset;
Grant Likely75b57ec2014-02-20 18:02:11 +000046
47/*
Grant Likely8a2b22a2014-07-23 17:05:06 -060048 * 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.
Grant Likely75b57ec2014-02-20 18:02:11 +000052 */
Pantelis Antoniouc05aba22014-07-04 19:58:03 +030053DEFINE_MUTEX(of_mutex);
Stephen Rothwell1ef4d422007-04-24 17:57:33 +100054
Grant Likely5063e252014-10-03 16:28:27 +010055/* use when traversing tree through the child, sibling,
Stephen Rothwell581b6052007-04-24 16:46:53 +100056 * or parent members of struct device_node.
57 */
Thomas Gleixnerd6d3c4e2013-02-06 15:30:56 -050058DEFINE_RAW_SPINLOCK(devtree_lock);
Stephen Rothwell97e873e2007-05-01 16:26:07 +100059
60int of_n_addr_cells(struct device_node *np)
61{
Jeremy Kerra9fadee2010-10-10 21:24:10 -060062 const __be32 *ip;
Stephen Rothwell97e873e2007-05-01 16:26:07 +100063
64 do {
65 if (np->parent)
66 np = np->parent;
67 ip = of_get_property(np, "#address-cells", NULL);
68 if (ip)
Jeremy Kerr33714882010-01-30 01:45:26 -070069 return be32_to_cpup(ip);
Stephen Rothwell97e873e2007-05-01 16:26:07 +100070 } 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{
Jeremy Kerra9fadee2010-10-10 21:24:10 -060078 const __be32 *ip;
Stephen Rothwell97e873e2007-05-01 16:26:07 +100079
80 do {
81 if (np->parent)
82 np = np->parent;
83 ip = of_get_property(np, "#size-cells", NULL);
84 if (ip)
Jeremy Kerr33714882010-01-30 01:45:26 -070085 return be32_to_cpup(ip);
Stephen Rothwell97e873e2007-05-01 16:26:07 +100086 } 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
Rob Herring0c3f0612013-09-17 10:42:50 -050092#ifdef CONFIG_NUMA
93int __weak of_node_to_nid(struct device_node *np)
94{
Konstantin Khlebnikovc8fff7b2015-04-08 19:59:20 +030095 return NUMA_NO_NODE;
Rob Herring0c3f0612013-09-17 10:42:50 -050096}
97#endif
98
Grant Likely6afc0dc2014-06-26 15:40:48 +010099#ifndef CONFIG_OF_DYNAMIC
Grant Likely75b57ec2014-02-20 18:02:11 +0000100static void of_node_release(struct kobject *kobj)
101{
102 /* Without CONFIG_OF_DYNAMIC, no nodes gets freed */
103}
Grant Likely0f22dd32012-02-15 20:38:40 -0700104#endif /* CONFIG_OF_DYNAMIC */
Grant Likely923f7e32010-01-28 13:52:53 -0700105
Grant Likely75b57ec2014-02-20 18:02:11 +0000106struct 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
Frank Rowandd9fc8802016-06-16 10:51:46 -0700118/* always return newly allocated name, caller must free after use */
Grant Likely75b57ec2014-02-20 18:02:11 +0000119static 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
Frank Rowandd9fc8802016-06-16 10:51:46 -0700133 if (name == orig_name) {
134 name = kstrdup(orig_name, GFP_KERNEL);
135 } else {
Rob Herring606ad422016-06-15 08:32:18 -0500136 pr_warn("Duplicate name in %s, renamed to \"%s\"\n",
Grant Likely75b57ec2014-02-20 18:02:11 +0000137 kobject_name(kobj), name);
Frank Rowandd9fc8802016-06-16 10:51:46 -0700138 }
Grant Likely75b57ec2014-02-20 18:02:11 +0000139 return name;
140}
141
Grant Likely8a2b22a2014-07-23 17:05:06 -0600142int __of_add_property_sysfs(struct device_node *np, struct property *pp)
Grant Likely75b57ec2014-02-20 18:02:11 +0000143{
144 int rc;
145
146 /* Important: Don't leak passwords */
147 bool secure = strncmp(pp->name, "security-", 9) == 0;
148
Gaurav Minochaef69d742014-09-05 09:56:13 -0700149 if (!IS_ENABLED(CONFIG_SYSFS))
150 return 0;
151
Grant Likely8a2b22a2014-07-23 17:05:06 -0600152 if (!of_kset || !of_node_is_attached(np))
153 return 0;
154
Grant Likely75b57ec2014-02-20 18:02:11 +0000155 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
Grant Likely8a2b22a2014-07-23 17:05:06 -0600166int __of_attach_node_sysfs(struct device_node *np)
Grant Likely75b57ec2014-02-20 18:02:11 +0000167{
168 const char *name;
Frank Rowandd9fc8802016-06-16 10:51:46 -0700169 struct kobject *parent;
Grant Likely75b57ec2014-02-20 18:02:11 +0000170 struct property *pp;
171 int rc;
172
Gaurav Minochaef69d742014-09-05 09:56:13 -0700173 if (!IS_ENABLED(CONFIG_SYSFS))
174 return 0;
175
Grant Likely8a2b22a2014-07-23 17:05:06 -0600176 if (!of_kset)
177 return 0;
178
Grant Likely75b57ec2014-02-20 18:02:11 +0000179 np->kobj.kset = of_kset;
180 if (!np->parent) {
181 /* Nodes without parents are new top level trees */
Frank Rowandd9fc8802016-06-16 10:51:46 -0700182 name = safe_name(&of_kset->kobj, "base");
183 parent = NULL;
Grant Likely75b57ec2014-02-20 18:02:11 +0000184 } else {
185 name = safe_name(&np->parent->kobj, kbasename(np->full_name));
Frank Rowandd9fc8802016-06-16 10:51:46 -0700186 parent = &np->parent->kobj;
Grant Likely75b57ec2014-02-20 18:02:11 +0000187 }
Frank Rowandd9fc8802016-06-16 10:51:46 -0700188 if (!name)
189 return -ENOMEM;
190 rc = kobject_add(&np->kobj, parent, "%s", name);
191 kfree(name);
Grant Likely75b57ec2014-02-20 18:02:11 +0000192 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
Sudeep Holla194ec9362015-05-14 15:28:24 +0100201void __init of_core_init(void)
Grant Likely75b57ec2014-02-20 18:02:11 +0000202{
203 struct device_node *np;
204
205 /* Create the kset, and register existing nodes */
Pantelis Antoniouc05aba22014-07-04 19:58:03 +0300206 mutex_lock(&of_mutex);
Grant Likely75b57ec2014-02-20 18:02:11 +0000207 of_kset = kset_create_and_add("devicetree", NULL, firmware_kobj);
208 if (!of_kset) {
Pantelis Antoniouc05aba22014-07-04 19:58:03 +0300209 mutex_unlock(&of_mutex);
Rob Herring606ad422016-06-15 08:32:18 -0500210 pr_err("failed to register existing nodes\n");
Sudeep Holla194ec9362015-05-14 15:28:24 +0100211 return;
Grant Likely75b57ec2014-02-20 18:02:11 +0000212 }
213 for_each_of_allnodes(np)
Grant Likely8a2b22a2014-07-23 17:05:06 -0600214 __of_attach_node_sysfs(np);
Pantelis Antoniouc05aba22014-07-04 19:58:03 +0300215 mutex_unlock(&of_mutex);
Grant Likely75b57ec2014-02-20 18:02:11 +0000216
Grant Likely83570412012-11-06 21:03:27 +0000217 /* Symlink in /proc as required by userspace ABI */
Grant Likely5063e252014-10-03 16:28:27 +0100218 if (of_root)
Grant Likely75b57ec2014-02-20 18:02:11 +0000219 proc_symlink("device-tree", NULL, "/sys/firmware/devicetree/base");
Grant Likely75b57ec2014-02-20 18:02:11 +0000220}
Grant Likely75b57ec2014-02-20 18:02:11 +0000221
Thomas Gleixner28d0e362013-01-25 13:21:47 -0500222static struct property *__of_find_property(const struct device_node *np,
223 const char *name, int *lenp)
Stephen Rothwell581b6052007-04-24 16:46:53 +1000224{
225 struct property *pp;
226
Timur Tabi64e45662008-05-08 05:19:59 +1000227 if (!np)
228 return NULL;
229
Sachin Kamata3a7cab2012-06-27 09:44:45 +0530230 for (pp = np->properties; pp; pp = pp->next) {
Stephen Rothwell581b6052007-04-24 16:46:53 +1000231 if (of_prop_cmp(pp->name, name) == 0) {
Sachin Kamata3a7cab2012-06-27 09:44:45 +0530232 if (lenp)
Stephen Rothwell581b6052007-04-24 16:46:53 +1000233 *lenp = pp->length;
234 break;
235 }
236 }
Thomas Gleixner28d0e362013-01-25 13:21:47 -0500237
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;
Thomas Gleixnerd6d3c4e2013-02-06 15:30:56 -0500246 unsigned long flags;
Thomas Gleixner28d0e362013-01-25 13:21:47 -0500247
Thomas Gleixnerd6d3c4e2013-02-06 15:30:56 -0500248 raw_spin_lock_irqsave(&devtree_lock, flags);
Thomas Gleixner28d0e362013-01-25 13:21:47 -0500249 pp = __of_find_property(np, name, lenp);
Thomas Gleixnerd6d3c4e2013-02-06 15:30:56 -0500250 raw_spin_unlock_irqrestore(&devtree_lock, flags);
Stephen Rothwell581b6052007-04-24 16:46:53 +1000251
252 return pp;
253}
254EXPORT_SYMBOL(of_find_property);
255
Grant Likely5063e252014-10-03 16:28:27 +0100256struct 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
Grant Likelye91edcf2009-10-15 10:58:09 -0600273/**
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;
Benjamin Herrenschmidtd25d8692013-06-12 15:39:04 +1000284 unsigned long flags;
Grant Likelye91edcf2009-10-15 10:58:09 -0600285
Benjamin Herrenschmidtd25d8692013-06-12 15:39:04 +1000286 raw_spin_lock_irqsave(&devtree_lock, flags);
Grant Likely5063e252014-10-03 16:28:27 +0100287 np = __of_find_all_nodes(prev);
288 of_node_get(np);
Grant Likelye91edcf2009-10-15 10:58:09 -0600289 of_node_put(prev);
Benjamin Herrenschmidtd25d8692013-06-12 15:39:04 +1000290 raw_spin_unlock_irqrestore(&devtree_lock, flags);
Grant Likelye91edcf2009-10-15 10:58:09 -0600291 return np;
292}
293EXPORT_SYMBOL(of_find_all_nodes);
294
Stephen Rothwell97e873e2007-05-01 16:26:07 +1000295/*
296 * Find a property with a given name for a given node
297 * and return the value.
298 */
Grant Likelya25095d2014-07-15 23:25:43 -0600299const void *__of_get_property(const struct device_node *np,
300 const char *name, int *lenp)
Thomas Gleixner28d0e362013-01-25 13:21:47 -0500301{
302 struct property *pp = __of_find_property(np, name, lenp);
303
304 return pp ? pp->value : NULL;
305}
306
307/*
308 * Find a property with a given name for a given node
309 * and return the value.
310 */
Stephen Rothwell97e873e2007-05-01 16:26:07 +1000311const void *of_get_property(const struct device_node *np, const char *name,
Thomas Gleixner28d0e362013-01-25 13:21:47 -0500312 int *lenp)
Stephen Rothwell97e873e2007-05-01 16:26:07 +1000313{
314 struct property *pp = of_find_property(np, name, lenp);
315
316 return pp ? pp->value : NULL;
317}
318EXPORT_SYMBOL(of_get_property);
Stephen Rothwell0081cbc2007-05-01 16:29:19 +1000319
Sudeep KarkadaNagesha183912d2013-08-15 14:01:40 +0100320/*
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);
Grant Likelyf3cea452013-10-04 17:24:26 +0100353 if (!cell || !ac)
Sudeep KarkadaNagesha183912d2013-08-15 14:01:40 +0100354 return false;
Grant Likelyf3cea452013-10-04 17:24:26 +0100355 prop_len /= sizeof(*cell) * ac;
Sudeep KarkadaNagesha183912d2013-08-15 14:01:40 +0100356 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
David Millerd1cb9d12013-10-03 17:24:51 -0400368/*
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
Masahiro Yamada510bd062015-10-28 12:05:27 +0900387 return __of_find_n_match_cpu_property(cpun, "reg", cpu, thread);
David Millerd1cb9d12013-10-03 17:24:51 -0400388}
389
Sudeep KarkadaNagesha183912d2013-08-15 14:01:40 +0100390/**
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 *
Masahiro Yamada1c986e32016-04-20 10:18:46 +0900406 * 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.
Sudeep KarkadaNagesha183912d2013-08-15 14:01:40 +0100408 */
409struct device_node *of_get_cpu_node(int cpu, unsigned int *thread)
410{
David Millerd1cb9d12013-10-03 17:24:51 -0400411 struct device_node *cpun;
Sudeep KarkadaNagesha183912d2013-08-15 14:01:40 +0100412
David Millerd1cb9d12013-10-03 17:24:51 -0400413 for_each_node_by_type(cpun, "cpu") {
414 if (arch_find_n_match_cpu_physical_id(cpun, cpu, thread))
Sudeep KarkadaNagesha183912d2013-08-15 14:01:40 +0100415 return cpun;
416 }
417 return NULL;
418}
419EXPORT_SYMBOL(of_get_cpu_node);
420
Kevin Hao215a14c2014-02-19 16:15:45 +0800421/**
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
Stephen Rothwell0081cbc2007-05-01 16:29:19 +1000450 */
Thomas Gleixner28d0e362013-01-25 13:21:47 -0500451static int __of_device_is_compatible(const struct device_node *device,
Kevin Hao215a14c2014-02-19 16:15:45 +0800452 const char *compat, const char *type, const char *name)
Stephen Rothwell0081cbc2007-05-01 16:29:19 +1000453{
Kevin Hao215a14c2014-02-19 16:15:45 +0800454 struct property *prop;
455 const char *cp;
456 int index = 0, score = 0;
Stephen Rothwell0081cbc2007-05-01 16:29:19 +1000457
Kevin Hao215a14c2014-02-19 16:15:45 +0800458 /* 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;
Stephen Rothwell0081cbc2007-05-01 16:29:19 +1000470 }
471
Kevin Hao215a14c2014-02-19 16:15:45 +0800472 /* 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;
477 }
478
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;
Stephen Rothwell0081cbc2007-05-01 16:29:19 +1000487}
Thomas Gleixner28d0e362013-01-25 13:21:47 -0500488
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{
Thomas Gleixnerd6d3c4e2013-02-06 15:30:56 -0500495 unsigned long flags;
Thomas Gleixner28d0e362013-01-25 13:21:47 -0500496 int res;
497
Thomas Gleixnerd6d3c4e2013-02-06 15:30:56 -0500498 raw_spin_lock_irqsave(&devtree_lock, flags);
Kevin Hao215a14c2014-02-19 16:15:45 +0800499 res = __of_device_is_compatible(device, compat, NULL, NULL);
Thomas Gleixnerd6d3c4e2013-02-06 15:30:56 -0500500 raw_spin_unlock_irqrestore(&devtree_lock, flags);
Thomas Gleixner28d0e362013-01-25 13:21:47 -0500501 return res;
502}
Stephen Rothwell0081cbc2007-05-01 16:29:19 +1000503EXPORT_SYMBOL(of_device_is_compatible);
Stephen Rothwelle679c5f2007-04-24 17:16:16 +1000504
Benjamin Herrenschmidtb9c13fe2016-07-08 08:35:59 +1000505/** 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
Stephen Rothwelle679c5f2007-04-24 17:16:16 +1000527/**
Grant Likely71a157e2010-02-01 21:34:14 -0700528 * of_machine_is_compatible - Test root of device tree for a given compatible value
Grant Likely1f43cfb2010-01-28 13:47:25 -0700529 * @compat: compatible string to look for in root node's compatible property.
530 *
Kevin Cernekee25c7a1d2014-11-12 12:54:00 -0800531 * Returns a positive integer if the root node has the given value in its
Grant Likely1f43cfb2010-01-28 13:47:25 -0700532 * compatible property.
533 */
Grant Likely71a157e2010-02-01 21:34:14 -0700534int of_machine_is_compatible(const char *compat)
Grant Likely1f43cfb2010-01-28 13:47:25 -0700535{
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}
Grant Likely71a157e2010-02-01 21:34:14 -0700546EXPORT_SYMBOL(of_machine_is_compatible);
Grant Likely1f43cfb2010-01-28 13:47:25 -0700547
548/**
Stephen Warrenc31a0c02013-02-11 14:15:32 -0700549 * __of_device_is_available - check if a device is available for use
Josh Boyer834d97d2008-03-27 00:33:14 +1100550 *
Stephen Warrenc31a0c02013-02-11 14:15:32 -0700551 * @device: Node to check for availability, with locks already held
Josh Boyer834d97d2008-03-27 00:33:14 +1100552 *
Kevin Cernekee53a4ab92014-11-12 12:54:01 -0800553 * Returns true if the status property is absent or set to "okay" or "ok",
554 * false otherwise
Josh Boyer834d97d2008-03-27 00:33:14 +1100555 */
Kevin Cernekee53a4ab92014-11-12 12:54:01 -0800556static bool __of_device_is_available(const struct device_node *device)
Josh Boyer834d97d2008-03-27 00:33:14 +1100557{
558 const char *status;
559 int statlen;
560
Xiubo Li42ccd782014-01-13 11:07:28 +0800561 if (!device)
Kevin Cernekee53a4ab92014-11-12 12:54:01 -0800562 return false;
Xiubo Li42ccd782014-01-13 11:07:28 +0800563
Stephen Warrenc31a0c02013-02-11 14:15:32 -0700564 status = __of_get_property(device, "status", &statlen);
Josh Boyer834d97d2008-03-27 00:33:14 +1100565 if (status == NULL)
Kevin Cernekee53a4ab92014-11-12 12:54:01 -0800566 return true;
Josh Boyer834d97d2008-03-27 00:33:14 +1100567
568 if (statlen > 0) {
569 if (!strcmp(status, "okay") || !strcmp(status, "ok"))
Kevin Cernekee53a4ab92014-11-12 12:54:01 -0800570 return true;
Josh Boyer834d97d2008-03-27 00:33:14 +1100571 }
572
Kevin Cernekee53a4ab92014-11-12 12:54:01 -0800573 return false;
Josh Boyer834d97d2008-03-27 00:33:14 +1100574}
Stephen Warrenc31a0c02013-02-11 14:15:32 -0700575
576/**
577 * of_device_is_available - check if a device is available for use
578 *
579 * @device: Node to check for availability
580 *
Kevin Cernekee53a4ab92014-11-12 12:54:01 -0800581 * Returns true if the status property is absent or set to "okay" or "ok",
582 * false otherwise
Stephen Warrenc31a0c02013-02-11 14:15:32 -0700583 */
Kevin Cernekee53a4ab92014-11-12 12:54:01 -0800584bool of_device_is_available(const struct device_node *device)
Stephen Warrenc31a0c02013-02-11 14:15:32 -0700585{
586 unsigned long flags;
Kevin Cernekee53a4ab92014-11-12 12:54:01 -0800587 bool res;
Stephen Warrenc31a0c02013-02-11 14:15:32 -0700588
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}
Josh Boyer834d97d2008-03-27 00:33:14 +1100595EXPORT_SYMBOL(of_device_is_available);
596
597/**
Kevin Cernekee37786c72015-04-09 13:05:14 -0700598 * 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
620/**
Stephen Rothwelle679c5f2007-04-24 17:16:16 +1000621 * 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;
Thomas Gleixnerd6d3c4e2013-02-06 15:30:56 -0500630 unsigned long flags;
Stephen Rothwelle679c5f2007-04-24 17:16:16 +1000631
632 if (!node)
633 return NULL;
634
Thomas Gleixnerd6d3c4e2013-02-06 15:30:56 -0500635 raw_spin_lock_irqsave(&devtree_lock, flags);
Stephen Rothwelle679c5f2007-04-24 17:16:16 +1000636 np = of_node_get(node->parent);
Thomas Gleixnerd6d3c4e2013-02-06 15:30:56 -0500637 raw_spin_unlock_irqrestore(&devtree_lock, flags);
Stephen Rothwelle679c5f2007-04-24 17:16:16 +1000638 return np;
639}
640EXPORT_SYMBOL(of_get_parent);
Stephen Rothwelld1cd3552007-04-24 17:21:29 +1000641
642/**
Michael Ellermanf4eb0102007-10-26 16:54:31 +1000643 * of_get_next_parent - Iterate to a node's parent
644 * @node: Node to get parent of
645 *
Geert Uytterhoevenc0e848d2014-10-22 11:44:55 +0200646 * 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.
Michael Ellermanf4eb0102007-10-26 16:54:31 +1000649 *
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;
Thomas Gleixnerd6d3c4e2013-02-06 15:30:56 -0500656 unsigned long flags;
Michael Ellermanf4eb0102007-10-26 16:54:31 +1000657
658 if (!node)
659 return NULL;
660
Thomas Gleixnerd6d3c4e2013-02-06 15:30:56 -0500661 raw_spin_lock_irqsave(&devtree_lock, flags);
Michael Ellermanf4eb0102007-10-26 16:54:31 +1000662 parent = of_node_get(node->parent);
663 of_node_put(node);
Thomas Gleixnerd6d3c4e2013-02-06 15:30:56 -0500664 raw_spin_unlock_irqrestore(&devtree_lock, flags);
Michael Ellermanf4eb0102007-10-26 16:54:31 +1000665 return parent;
666}
Guennadi Liakhovetski6695be62013-04-02 12:28:11 -0300667EXPORT_SYMBOL(of_get_next_parent);
Michael Ellermanf4eb0102007-10-26 16:54:31 +1000668
Grant Likely0d0e02d2014-05-22 01:04:17 +0900669static struct device_node *__of_get_next_child(const struct device_node *node,
670 struct device_node *prev)
671{
672 struct device_node *next;
673
Florian Fainelli43cb4362014-05-28 10:39:02 -0700674 if (!node)
675 return NULL;
676
Grant Likely0d0e02d2014-05-22 01:04:17 +0900677 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
Michael Ellermanf4eb0102007-10-26 16:54:31 +1000688/**
Stephen Rothwelld1cd3552007-04-24 17:21:29 +1000689 * 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 *
Baruch Siach64808272015-03-19 14:03:41 +0200693 * 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.
Stephen Rothwelld1cd3552007-04-24 17:21:29 +1000696 */
697struct device_node *of_get_next_child(const struct device_node *node,
698 struct device_node *prev)
699{
700 struct device_node *next;
Thomas Gleixnerd6d3c4e2013-02-06 15:30:56 -0500701 unsigned long flags;
Stephen Rothwelld1cd3552007-04-24 17:21:29 +1000702
Thomas Gleixnerd6d3c4e2013-02-06 15:30:56 -0500703 raw_spin_lock_irqsave(&devtree_lock, flags);
Grant Likely0d0e02d2014-05-22 01:04:17 +0900704 next = __of_get_next_child(node, prev);
Thomas Gleixnerd6d3c4e2013-02-06 15:30:56 -0500705 raw_spin_unlock_irqrestore(&devtree_lock, flags);
Stephen Rothwelld1cd3552007-04-24 17:21:29 +1000706 return next;
707}
708EXPORT_SYMBOL(of_get_next_child);
Stephen Rothwell1ef4d422007-04-24 17:57:33 +1000709
710/**
Timur Tabi32961932012-08-14 13:20:23 +0000711 * 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;
Benjamin Herrenschmidtd25d8692013-06-12 15:39:04 +1000722 unsigned long flags;
Timur Tabi32961932012-08-14 13:20:23 +0000723
Florian Fainelli43cb4362014-05-28 10:39:02 -0700724 if (!node)
725 return NULL;
726
Benjamin Herrenschmidtd25d8692013-06-12 15:39:04 +1000727 raw_spin_lock_irqsave(&devtree_lock, flags);
Timur Tabi32961932012-08-14 13:20:23 +0000728 next = prev ? prev->sibling : node->child;
729 for (; next; next = next->sibling) {
Stephen Warrenc31a0c02013-02-11 14:15:32 -0700730 if (!__of_device_is_available(next))
Timur Tabi32961932012-08-14 13:20:23 +0000731 continue;
732 if (of_node_get(next))
733 break;
734 }
735 of_node_put(prev);
Benjamin Herrenschmidtd25d8692013-06-12 15:39:04 +1000736 raw_spin_unlock_irqrestore(&devtree_lock, flags);
Timur Tabi32961932012-08-14 13:20:23 +0000737 return next;
738}
739EXPORT_SYMBOL(of_get_next_available_child);
740
741/**
Srinivas Kandagatla9c197612012-09-18 08:10:28 +0100742 * 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
Grant Likelyc22e6502014-03-14 17:07:12 +0000764static struct device_node *__of_find_node_by_path(struct device_node *parent,
765 const char *path)
766{
767 struct device_node *child;
Leif Lindholm106937e2015-03-06 16:52:53 +0000768 int len;
Grant Likelyc22e6502014-03-14 17:07:12 +0000769
Brian Norris721a09e2015-03-17 12:30:31 -0700770 len = strcspn(path, "/:");
Grant Likelyc22e6502014-03-14 17:07:12 +0000771 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
Srinivas Kandagatla9c197612012-09-18 08:10:28 +0100785/**
Leif Lindholm75c28c02014-11-28 11:34:28 +0000786 * of_find_node_opts_by_path - Find a node matching a full OF path
Grant Likelyc22e6502014-03-14 17:07:12 +0000787 * @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.
Leif Lindholm75c28c02014-11-28 11:34:28 +0000791 * @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.
Grant Likelyc22e6502014-03-14 17:07:12 +0000794 *
795 * Valid paths:
796 * /foo/bar Full path
797 * foo Valid alias
798 * foo/bar Valid alias + relative path
Stephen Rothwell1ef4d422007-04-24 17:57:33 +1000799 *
800 * Returns a node pointer with refcount incremented, use
801 * of_node_put() on it when done.
802 */
Leif Lindholm75c28c02014-11-28 11:34:28 +0000803struct device_node *of_find_node_opts_by_path(const char *path, const char **opts)
Stephen Rothwell1ef4d422007-04-24 17:57:33 +1000804{
Grant Likelyc22e6502014-03-14 17:07:12 +0000805 struct device_node *np = NULL;
806 struct property *pp;
Thomas Gleixnerd6d3c4e2013-02-06 15:30:56 -0500807 unsigned long flags;
Leif Lindholm75c28c02014-11-28 11:34:28 +0000808 const char *separator = strchr(path, ':');
809
810 if (opts)
811 *opts = separator ? separator + 1 : NULL;
Stephen Rothwell1ef4d422007-04-24 17:57:33 +1000812
Grant Likelyc22e6502014-03-14 17:07:12 +0000813 if (strcmp(path, "/") == 0)
Grant Likely5063e252014-10-03 16:28:27 +0100814 return of_node_get(of_root);
Grant Likelyc22e6502014-03-14 17:07:12 +0000815
816 /* The path could begin with an alias */
817 if (*path != '/') {
Leif Lindholm106937e2015-03-06 16:52:53 +0000818 int len;
819 const char *p = separator;
820
821 if (!p)
822 p = strchrnul(path, '/');
823 len = p - path;
Grant Likelyc22e6502014-03-14 17:07:12 +0000824
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 */
Thomas Gleixnerd6d3c4e2013-02-06 15:30:56 -0500841 raw_spin_lock_irqsave(&devtree_lock, flags);
Grant Likelyc22e6502014-03-14 17:07:12 +0000842 if (!np)
Grant Likely5063e252014-10-03 16:28:27 +0100843 np = of_node_get(of_root);
Grant Likelyc22e6502014-03-14 17:07:12 +0000844 while (np && *path == '/') {
845 path++; /* Increment past '/' delimiter */
846 np = __of_find_node_by_path(np, path);
847 path = strchrnul(path, '/');
Leif Lindholm106937e2015-03-06 16:52:53 +0000848 if (separator && separator < path)
849 break;
Stephen Rothwell1ef4d422007-04-24 17:57:33 +1000850 }
Thomas Gleixnerd6d3c4e2013-02-06 15:30:56 -0500851 raw_spin_unlock_irqrestore(&devtree_lock, flags);
Stephen Rothwell1ef4d422007-04-24 17:57:33 +1000852 return np;
853}
Leif Lindholm75c28c02014-11-28 11:34:28 +0000854EXPORT_SYMBOL(of_find_node_opts_by_path);
Stephen Rothwell1ef4d422007-04-24 17:57:33 +1000855
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;
Thomas Gleixnerd6d3c4e2013-02-06 15:30:56 -0500871 unsigned long flags;
Stephen Rothwell1ef4d422007-04-24 17:57:33 +1000872
Thomas Gleixnerd6d3c4e2013-02-06 15:30:56 -0500873 raw_spin_lock_irqsave(&devtree_lock, flags);
Grant Likely5063e252014-10-03 16:28:27 +0100874 for_each_of_allnodes_from(from, np)
Stephen Rothwell1ef4d422007-04-24 17:57:33 +1000875 if (np->name && (of_node_cmp(np->name, name) == 0)
876 && of_node_get(np))
877 break;
878 of_node_put(from);
Thomas Gleixnerd6d3c4e2013-02-06 15:30:56 -0500879 raw_spin_unlock_irqrestore(&devtree_lock, flags);
Stephen Rothwell1ef4d422007-04-24 17:57:33 +1000880 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;
Thomas Gleixnerd6d3c4e2013-02-06 15:30:56 -0500900 unsigned long flags;
Stephen Rothwell1ef4d422007-04-24 17:57:33 +1000901
Thomas Gleixnerd6d3c4e2013-02-06 15:30:56 -0500902 raw_spin_lock_irqsave(&devtree_lock, flags);
Grant Likely5063e252014-10-03 16:28:27 +0100903 for_each_of_allnodes_from(from, np)
Stephen Rothwell1ef4d422007-04-24 17:57:33 +1000904 if (np->type && (of_node_cmp(np->type, type) == 0)
905 && of_node_get(np))
906 break;
907 of_node_put(from);
Thomas Gleixnerd6d3c4e2013-02-06 15:30:56 -0500908 raw_spin_unlock_irqrestore(&devtree_lock, flags);
Stephen Rothwell1ef4d422007-04-24 17:57:33 +1000909 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;
Thomas Gleixnerd6d3c4e2013-02-06 15:30:56 -0500931 unsigned long flags;
Stephen Rothwell1ef4d422007-04-24 17:57:33 +1000932
Thomas Gleixnerd6d3c4e2013-02-06 15:30:56 -0500933 raw_spin_lock_irqsave(&devtree_lock, flags);
Grant Likely5063e252014-10-03 16:28:27 +0100934 for_each_of_allnodes_from(from, np)
Kevin Hao215a14c2014-02-19 16:15:45 +0800935 if (__of_device_is_compatible(np, compatible, type, NULL) &&
Thomas Gleixner28d0e362013-01-25 13:21:47 -0500936 of_node_get(np))
Stephen Rothwell1ef4d422007-04-24 17:57:33 +1000937 break;
Stephen Rothwell1ef4d422007-04-24 17:57:33 +1000938 of_node_put(from);
Thomas Gleixnerd6d3c4e2013-02-06 15:30:56 -0500939 raw_spin_unlock_irqrestore(&devtree_lock, flags);
Stephen Rothwell1ef4d422007-04-24 17:57:33 +1000940 return np;
941}
942EXPORT_SYMBOL(of_find_compatible_node);
Grant Likely283029d2008-01-09 06:20:40 +1100943
944/**
Michael Ellerman1e291b12008-11-12 18:54:42 +0000945 * 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;
Thomas Gleixnerd6d3c4e2013-02-06 15:30:56 -0500961 unsigned long flags;
Michael Ellerman1e291b12008-11-12 18:54:42 +0000962
Thomas Gleixnerd6d3c4e2013-02-06 15:30:56 -0500963 raw_spin_lock_irqsave(&devtree_lock, flags);
Grant Likely5063e252014-10-03 16:28:27 +0100964 for_each_of_allnodes_from(from, np) {
Sachin Kamata3a7cab2012-06-27 09:44:45 +0530965 for (pp = np->properties; pp; pp = pp->next) {
Michael Ellerman1e291b12008-11-12 18:54:42 +0000966 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);
Thomas Gleixnerd6d3c4e2013-02-06 15:30:56 -0500974 raw_spin_unlock_irqrestore(&devtree_lock, flags);
Michael Ellerman1e291b12008-11-12 18:54:42 +0000975 return np;
976}
977EXPORT_SYMBOL(of_find_node_with_property);
978
Thomas Gleixner28d0e362013-01-25 13:21:47 -0500979static
980const struct of_device_id *__of_match_node(const struct of_device_id *matches,
981 const struct device_node *node)
Grant Likely283029d2008-01-09 06:20:40 +1100982{
Kevin Hao215a14c2014-02-19 16:15:45 +0800983 const struct of_device_id *best_match = NULL;
984 int score, best_score = 0;
985
Grant Likelya52f07e2011-03-18 10:21:29 -0600986 if (!matches)
987 return NULL;
988
Kevin Hao215a14c2014-02-19 16:15:45 +0800989 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 }
Kevin Hao4e8ca6e2014-02-14 13:22:45 +0800996 }
Kevin Hao215a14c2014-02-19 16:15:45 +0800997
998 return best_match;
Grant Likely283029d2008-01-09 06:20:40 +1100999}
Thomas Gleixner28d0e362013-01-25 13:21:47 -05001000
1001/**
Geert Uytterhoevenc50949d2014-10-22 11:44:54 +02001002 * of_match_node - Tell if a device_node has a matching of_match structure
Thomas Gleixner28d0e362013-01-25 13:21:47 -05001003 * @matches: array of of device match structures to search in
1004 * @node: the of device structure to match against
1005 *
Kevin Hao71c54982014-02-18 15:57:29 +08001006 * Low level utility function used by device matching.
Thomas Gleixner28d0e362013-01-25 13:21:47 -05001007 */
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;
Thomas Gleixnerd6d3c4e2013-02-06 15:30:56 -05001012 unsigned long flags;
Thomas Gleixner28d0e362013-01-25 13:21:47 -05001013
Thomas Gleixnerd6d3c4e2013-02-06 15:30:56 -05001014 raw_spin_lock_irqsave(&devtree_lock, flags);
Thomas Gleixner28d0e362013-01-25 13:21:47 -05001015 match = __of_match_node(matches, node);
Thomas Gleixnerd6d3c4e2013-02-06 15:30:56 -05001016 raw_spin_unlock_irqrestore(&devtree_lock, flags);
Thomas Gleixner28d0e362013-01-25 13:21:47 -05001017 return match;
1018}
Grant Likely283029d2008-01-09 06:20:40 +11001019EXPORT_SYMBOL(of_match_node);
1020
1021/**
Stephen Warren50c8af42012-11-20 16:12:20 -07001022 * of_find_matching_node_and_match - Find a node based on an of_device_id
1023 * match table.
Grant Likely283029d2008-01-09 06:20:40 +11001024 * @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
Stephen Warren50c8af42012-11-20 16:12:20 -07001029 * @match Updated to point at the matches entry which matched
Grant Likely283029d2008-01-09 06:20:40 +11001030 *
1031 * Returns a node pointer with refcount incremented, use
1032 * of_node_put() on it when done.
1033 */
Stephen Warren50c8af42012-11-20 16:12:20 -07001034struct 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)
Grant Likely283029d2008-01-09 06:20:40 +11001037{
1038 struct device_node *np;
Thomas Abrahamdc71bcf2013-01-19 10:20:42 -08001039 const struct of_device_id *m;
Thomas Gleixnerd6d3c4e2013-02-06 15:30:56 -05001040 unsigned long flags;
Grant Likely283029d2008-01-09 06:20:40 +11001041
Stephen Warren50c8af42012-11-20 16:12:20 -07001042 if (match)
1043 *match = NULL;
1044
Thomas Gleixnerd6d3c4e2013-02-06 15:30:56 -05001045 raw_spin_lock_irqsave(&devtree_lock, flags);
Grant Likely5063e252014-10-03 16:28:27 +01001046 for_each_of_allnodes_from(from, np) {
Thomas Gleixner28d0e362013-01-25 13:21:47 -05001047 m = __of_match_node(matches, np);
Thomas Abrahamdc71bcf2013-01-19 10:20:42 -08001048 if (m && of_node_get(np)) {
Stephen Warren50c8af42012-11-20 16:12:20 -07001049 if (match)
Thomas Abrahamdc71bcf2013-01-19 10:20:42 -08001050 *match = m;
Grant Likely283029d2008-01-09 06:20:40 +11001051 break;
Stephen Warren50c8af42012-11-20 16:12:20 -07001052 }
Grant Likely283029d2008-01-09 06:20:40 +11001053 }
1054 of_node_put(from);
Thomas Gleixnerd6d3c4e2013-02-06 15:30:56 -05001055 raw_spin_unlock_irqrestore(&devtree_lock, flags);
Grant Likely283029d2008-01-09 06:20:40 +11001056 return np;
1057}
Grant Likely80c20222012-12-19 10:45:36 +00001058EXPORT_SYMBOL(of_find_matching_node_and_match);
Grant Likely3f07af42008-07-25 22:25:13 -04001059
1060/**
Grant Likely3f07af42008-07-25 22:25:13 -04001061 * 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 *
Grant Likely2ffe8c52010-06-08 07:48:19 -06001066 * 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.
Grant Likely3f07af42008-07-25 22:25:13 -04001070 *
Grant Likely2ffe8c52010-06-08 07:48:19 -06001071 * This routine returns 0 on success, <0 on failure.
Grant Likely3f07af42008-07-25 22:25:13 -04001072 */
1073int of_modalias_node(struct device_node *node, char *modalias, int len)
1074{
Grant Likely2ffe8c52010-06-08 07:48:19 -06001075 const char *compatible, *p;
1076 int cplen;
Grant Likely3f07af42008-07-25 22:25:13 -04001077
1078 compatible = of_get_property(node, "compatible", &cplen);
Grant Likely2ffe8c52010-06-08 07:48:19 -06001079 if (!compatible || strlen(compatible) > cplen)
Grant Likely3f07af42008-07-25 22:25:13 -04001080 return -ENODEV;
Grant Likely3f07af42008-07-25 22:25:13 -04001081 p = strchr(compatible, ',');
Grant Likely2ffe8c52010-06-08 07:48:19 -06001082 strlcpy(modalias, p ? p + 1 : compatible, len);
Grant Likely3f07af42008-07-25 22:25:13 -04001083 return 0;
1084}
1085EXPORT_SYMBOL_GPL(of_modalias_node);
1086
Anton Vorontsov64b60e02008-10-10 04:43:17 +00001087/**
Jeremy Kerr89751a72010-02-01 21:34:11 -07001088 * 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;
Benjamin Herrenschmidtd25d8692013-06-12 15:39:04 +10001097 unsigned long flags;
Jeremy Kerr89751a72010-02-01 21:34:11 -07001098
Grant Likelyfc59b442014-10-02 13:08:02 +01001099 if (!handle)
1100 return NULL;
1101
Benjamin Herrenschmidtd25d8692013-06-12 15:39:04 +10001102 raw_spin_lock_irqsave(&devtree_lock, flags);
Grant Likely5063e252014-10-03 16:28:27 +01001103 for_each_of_allnodes(np)
Jeremy Kerr89751a72010-02-01 21:34:11 -07001104 if (np->phandle == handle)
1105 break;
1106 of_node_get(np);
Benjamin Herrenschmidtd25d8692013-06-12 15:39:04 +10001107 raw_spin_unlock_irqrestore(&devtree_lock, flags);
Jeremy Kerr89751a72010-02-01 21:34:11 -07001108 return np;
1109}
1110EXPORT_SYMBOL(of_find_node_by_phandle);
1111
1112/**
Heiko Stuebnerad54a0c2014-02-12 01:00:34 +01001113 * 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
1144/**
Tony Priskdaeec1f2013-04-03 17:57:11 +13001145 * 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.
Richard Fitzgerald79ac5d32016-09-12 14:01:28 +01001149 * @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
Tony Priskdaeec1f2013-04-03 17:57:11 +13001152 *
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
Richard Fitzgerald79ac5d32016-09-12 14:01:28 +01001156 * property data is too small or too large.
Tony Priskdaeec1f2013-04-03 17:57:11 +13001157 *
1158 */
1159static void *of_find_property_value_of_size(const struct device_node *np,
Richard Fitzgerald79ac5d32016-09-12 14:01:28 +01001160 const char *propname, u32 min, u32 max, size_t *len)
Tony Priskdaeec1f2013-04-03 17:57:11 +13001161{
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);
Richard Fitzgerald79ac5d32016-09-12 14:01:28 +01001168 if (prop->length < min)
Tony Priskdaeec1f2013-04-03 17:57:11 +13001169 return ERR_PTR(-EOVERFLOW);
Richard Fitzgerald79ac5d32016-09-12 14:01:28 +01001170 if (max && prop->length > max)
1171 return ERR_PTR(-EOVERFLOW);
1172
1173 if (len)
1174 *len = prop->length;
Tony Priskdaeec1f2013-04-03 17:57:11 +13001175
1176 return prop->value;
1177}
1178
1179/**
Tony Prisk3daf3722013-03-23 17:02:15 +13001180 * 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{
Tony Priskdaeec1f2013-04-03 17:57:11 +13001198 const u32 *val = of_find_property_value_of_size(np, propname,
Richard Fitzgerald79ac5d32016-09-12 14:01:28 +01001199 ((index + 1) * sizeof(*out_value)),
1200 0,
1201 NULL);
Tony Prisk3daf3722013-03-23 17:02:15 +13001202
Tony Priskdaeec1f2013-04-03 17:57:11 +13001203 if (IS_ERR(val))
1204 return PTR_ERR(val);
Tony Prisk3daf3722013-03-23 17:02:15 +13001205
Tony Priskdaeec1f2013-04-03 17:57:11 +13001206 *out_value = be32_to_cpup(((__be32 *)val) + index);
Tony Prisk3daf3722013-03-23 17:02:15 +13001207 return 0;
1208}
1209EXPORT_SYMBOL_GPL(of_property_read_u32_index);
1210
1211/**
Viresh Kumarbe193242012-11-20 10:15:19 +05301212 * of_property_read_u8_array - Find and read an array of u8 from a property.
1213 *
1214 * @np: device node from which the property value is to be read.
1215 * @propname: name of the property to be searched.
Lad, Prabhakar792efb82013-05-07 11:34:11 +05301216 * @out_values: pointer to return value, modified only if return value is 0.
Viresh Kumarbe193242012-11-20 10:15:19 +05301217 * @sz: number of array elements to read
1218 *
1219 * Search for a property in a device node and read 8-bit value(s) from
1220 * it. Returns 0 on success, -EINVAL if the property does not exist,
1221 * -ENODATA if property does not have a value, and -EOVERFLOW if the
1222 * property data isn't large enough.
1223 *
1224 * dts entry of array should be like:
1225 * property = /bits/ 8 <0x50 0x60 0x70>;
1226 *
Lad, Prabhakar792efb82013-05-07 11:34:11 +05301227 * The out_values is modified only if a valid u8 value can be decoded.
Viresh Kumarbe193242012-11-20 10:15:19 +05301228 */
1229int of_property_read_u8_array(const struct device_node *np,
1230 const char *propname, u8 *out_values, size_t sz)
1231{
Tony Priskdaeec1f2013-04-03 17:57:11 +13001232 const u8 *val = of_find_property_value_of_size(np, propname,
Richard Fitzgerald79ac5d32016-09-12 14:01:28 +01001233 (sz * sizeof(*out_values)),
1234 0,
1235 NULL);
Viresh Kumarbe193242012-11-20 10:15:19 +05301236
Tony Priskdaeec1f2013-04-03 17:57:11 +13001237 if (IS_ERR(val))
1238 return PTR_ERR(val);
Viresh Kumarbe193242012-11-20 10:15:19 +05301239
Viresh Kumarbe193242012-11-20 10:15:19 +05301240 while (sz--)
1241 *out_values++ = *val++;
1242 return 0;
1243}
1244EXPORT_SYMBOL_GPL(of_property_read_u8_array);
1245
1246/**
1247 * of_property_read_u16_array - Find and read an array of u16 from a property.
1248 *
1249 * @np: device node from which the property value is to be read.
1250 * @propname: name of the property to be searched.
Lad, Prabhakar792efb82013-05-07 11:34:11 +05301251 * @out_values: pointer to return value, modified only if return value is 0.
Viresh Kumarbe193242012-11-20 10:15:19 +05301252 * @sz: number of array elements to read
1253 *
1254 * Search for a property in a device node and read 16-bit value(s) from
1255 * it. Returns 0 on success, -EINVAL if the property does not exist,
1256 * -ENODATA if property does not have a value, and -EOVERFLOW if the
1257 * property data isn't large enough.
1258 *
1259 * dts entry of array should be like:
1260 * property = /bits/ 16 <0x5000 0x6000 0x7000>;
1261 *
Lad, Prabhakar792efb82013-05-07 11:34:11 +05301262 * The out_values is modified only if a valid u16 value can be decoded.
Viresh Kumarbe193242012-11-20 10:15:19 +05301263 */
1264int of_property_read_u16_array(const struct device_node *np,
1265 const char *propname, u16 *out_values, size_t sz)
1266{
Tony Priskdaeec1f2013-04-03 17:57:11 +13001267 const __be16 *val = of_find_property_value_of_size(np, propname,
Richard Fitzgerald79ac5d32016-09-12 14:01:28 +01001268 (sz * sizeof(*out_values)),
1269 0,
1270 NULL);
Viresh Kumarbe193242012-11-20 10:15:19 +05301271
Tony Priskdaeec1f2013-04-03 17:57:11 +13001272 if (IS_ERR(val))
1273 return PTR_ERR(val);
Viresh Kumarbe193242012-11-20 10:15:19 +05301274
Viresh Kumarbe193242012-11-20 10:15:19 +05301275 while (sz--)
1276 *out_values++ = be16_to_cpup(val++);
1277 return 0;
1278}
1279EXPORT_SYMBOL_GPL(of_property_read_u16_array);
1280
1281/**
Rob Herring0e373632011-07-06 15:42:58 -05001282 * of_property_read_u32_array - Find and read an array of 32 bit integers
1283 * from a property.
1284 *
Thomas Abrahama3b85362011-06-30 21:26:10 +05301285 * @np: device node from which the property value is to be read.
1286 * @propname: name of the property to be searched.
Lad, Prabhakar792efb82013-05-07 11:34:11 +05301287 * @out_values: pointer to return value, modified only if return value is 0.
Viresh Kumarbe193242012-11-20 10:15:19 +05301288 * @sz: number of array elements to read
Thomas Abrahama3b85362011-06-30 21:26:10 +05301289 *
Rob Herring0e373632011-07-06 15:42:58 -05001290 * Search for a property in a device node and read 32-bit value(s) from
Thomas Abrahama3b85362011-06-30 21:26:10 +05301291 * it. Returns 0 on success, -EINVAL if the property does not exist,
1292 * -ENODATA if property does not have a value, and -EOVERFLOW if the
1293 * property data isn't large enough.
1294 *
Lad, Prabhakar792efb82013-05-07 11:34:11 +05301295 * The out_values is modified only if a valid u32 value can be decoded.
Thomas Abrahama3b85362011-06-30 21:26:10 +05301296 */
Jamie Ilesaac285c2011-08-02 15:45:07 +01001297int of_property_read_u32_array(const struct device_node *np,
1298 const char *propname, u32 *out_values,
1299 size_t sz)
Thomas Abrahama3b85362011-06-30 21:26:10 +05301300{
Tony Priskdaeec1f2013-04-03 17:57:11 +13001301 const __be32 *val = of_find_property_value_of_size(np, propname,
Richard Fitzgerald79ac5d32016-09-12 14:01:28 +01001302 (sz * sizeof(*out_values)),
1303 0,
1304 NULL);
Thomas Abrahama3b85362011-06-30 21:26:10 +05301305
Tony Priskdaeec1f2013-04-03 17:57:11 +13001306 if (IS_ERR(val))
1307 return PTR_ERR(val);
Rob Herring0e373632011-07-06 15:42:58 -05001308
Rob Herring0e373632011-07-06 15:42:58 -05001309 while (sz--)
1310 *out_values++ = be32_to_cpup(val++);
Thomas Abrahama3b85362011-06-30 21:26:10 +05301311 return 0;
1312}
Rob Herring0e373632011-07-06 15:42:58 -05001313EXPORT_SYMBOL_GPL(of_property_read_u32_array);
Thomas Abrahama3b85362011-06-30 21:26:10 +05301314
1315/**
Jamie Iles4cd7f7a2011-09-14 20:49:59 +01001316 * of_property_read_u64 - Find and read a 64 bit integer from a property
1317 * @np: device node from which the property value is to be read.
1318 * @propname: name of the property to be searched.
1319 * @out_value: pointer to return value, modified only if return value is 0.
1320 *
1321 * Search for a property in a device node and read a 64-bit value from
1322 * it. Returns 0 on success, -EINVAL if the property does not exist,
1323 * -ENODATA if property does not have a value, and -EOVERFLOW if the
1324 * property data isn't large enough.
1325 *
1326 * The out_value is modified only if a valid u64 value can be decoded.
1327 */
1328int of_property_read_u64(const struct device_node *np, const char *propname,
1329 u64 *out_value)
1330{
Tony Priskdaeec1f2013-04-03 17:57:11 +13001331 const __be32 *val = of_find_property_value_of_size(np, propname,
Richard Fitzgerald79ac5d32016-09-12 14:01:28 +01001332 sizeof(*out_value),
1333 0,
1334 NULL);
Jamie Iles4cd7f7a2011-09-14 20:49:59 +01001335
Tony Priskdaeec1f2013-04-03 17:57:11 +13001336 if (IS_ERR(val))
1337 return PTR_ERR(val);
1338
1339 *out_value = of_read_number(val, 2);
Jamie Iles4cd7f7a2011-09-14 20:49:59 +01001340 return 0;
1341}
1342EXPORT_SYMBOL_GPL(of_property_read_u64);
1343
1344/**
Rafael J. Wysockib31384f2014-11-04 01:28:56 +01001345 * of_property_read_u64_array - Find and read an array of 64 bit integers
1346 * from a property.
1347 *
1348 * @np: device node from which the property value is to be read.
1349 * @propname: name of the property to be searched.
1350 * @out_values: pointer to return value, modified only if return value is 0.
1351 * @sz: number of array elements to read
1352 *
1353 * Search for a property in a device node and read 64-bit value(s) from
1354 * it. Returns 0 on success, -EINVAL if the property does not exist,
1355 * -ENODATA if property does not have a value, and -EOVERFLOW if the
1356 * property data isn't large enough.
1357 *
1358 * The out_values is modified only if a valid u64 value can be decoded.
1359 */
1360int of_property_read_u64_array(const struct device_node *np,
1361 const char *propname, u64 *out_values,
1362 size_t sz)
1363{
1364 const __be32 *val = of_find_property_value_of_size(np, propname,
Richard Fitzgerald79ac5d32016-09-12 14:01:28 +01001365 (sz * sizeof(*out_values)),
1366 0,
1367 NULL);
Rafael J. Wysockib31384f2014-11-04 01:28:56 +01001368
1369 if (IS_ERR(val))
1370 return PTR_ERR(val);
1371
1372 while (sz--) {
1373 *out_values++ = of_read_number(val, 2);
1374 val += 2;
1375 }
1376 return 0;
1377}
Sakari Ailus2d4c0ae2015-01-27 12:26:35 +02001378EXPORT_SYMBOL_GPL(of_property_read_u64_array);
Rafael J. Wysockib31384f2014-11-04 01:28:56 +01001379
1380/**
Thomas Abrahama3b85362011-06-30 21:26:10 +05301381 * of_property_read_string - Find and read a string from a property
1382 * @np: device node from which the property value is to be read.
1383 * @propname: name of the property to be searched.
1384 * @out_string: pointer to null terminated return string, modified only if
1385 * return value is 0.
1386 *
1387 * Search for a property in a device tree node and retrieve a null
1388 * terminated string value (pointer to data, not a copy). Returns 0 on
1389 * success, -EINVAL if the property does not exist, -ENODATA if property
1390 * does not have a value, and -EILSEQ if the string is not null-terminated
1391 * within the length of the property data.
1392 *
1393 * The out_string pointer is modified only if a valid string can be decoded.
1394 */
David Rivshinfe99c702016-03-02 16:35:51 -05001395int of_property_read_string(const struct device_node *np, const char *propname,
Shawn Guof09bc832011-07-04 09:01:18 +08001396 const char **out_string)
Thomas Abrahama3b85362011-06-30 21:26:10 +05301397{
David Rivshinfe99c702016-03-02 16:35:51 -05001398 const struct property *prop = of_find_property(np, propname, NULL);
Thomas Abrahama3b85362011-06-30 21:26:10 +05301399 if (!prop)
1400 return -EINVAL;
1401 if (!prop->value)
1402 return -ENODATA;
1403 if (strnlen(prop->value, prop->length) >= prop->length)
1404 return -EILSEQ;
1405 *out_string = prop->value;
1406 return 0;
1407}
1408EXPORT_SYMBOL_GPL(of_property_read_string);
1409
1410/**
Grant Likely7aff0fe2011-12-12 09:25:58 -07001411 * of_property_match_string() - Find string in a list and return index
1412 * @np: pointer to node containing string list property
1413 * @propname: string list property name
1414 * @string: pointer to string to search for in string list
1415 *
1416 * This function searches a string list property and returns the index
1417 * of a specific string value.
1418 */
David Rivshinfe99c702016-03-02 16:35:51 -05001419int of_property_match_string(const struct device_node *np, const char *propname,
Grant Likely7aff0fe2011-12-12 09:25:58 -07001420 const char *string)
1421{
David Rivshinfe99c702016-03-02 16:35:51 -05001422 const struct property *prop = of_find_property(np, propname, NULL);
Grant Likely7aff0fe2011-12-12 09:25:58 -07001423 size_t l;
1424 int i;
1425 const char *p, *end;
1426
1427 if (!prop)
1428 return -EINVAL;
1429 if (!prop->value)
1430 return -ENODATA;
1431
1432 p = prop->value;
1433 end = p + prop->length;
1434
1435 for (i = 0; p < end; i++, p += l) {
Grant Likelya87fa1d2014-11-03 15:15:35 +00001436 l = strnlen(p, end - p) + 1;
Grant Likely7aff0fe2011-12-12 09:25:58 -07001437 if (p + l > end)
1438 return -EILSEQ;
1439 pr_debug("comparing %s with %s\n", string, p);
1440 if (strcmp(string, p) == 0)
1441 return i; /* Found it; return index */
1442 }
1443 return -ENODATA;
1444}
1445EXPORT_SYMBOL_GPL(of_property_match_string);
Benoit Cousson4fcd15a2011-09-27 17:45:43 +02001446
1447/**
Jiri Slabye99010e2014-11-21 13:23:09 +01001448 * of_property_read_string_helper() - Utility helper for parsing string properties
Benoit Cousson4fcd15a2011-09-27 17:45:43 +02001449 * @np: device node from which the property value is to be read.
1450 * @propname: name of the property to be searched.
Grant Likelya87fa1d2014-11-03 15:15:35 +00001451 * @out_strs: output array of string pointers.
1452 * @sz: number of array elements to read.
1453 * @skip: Number of strings to skip over at beginning of list.
Benoit Cousson4fcd15a2011-09-27 17:45:43 +02001454 *
Grant Likelya87fa1d2014-11-03 15:15:35 +00001455 * Don't call this function directly. It is a utility helper for the
1456 * of_property_read_string*() family of functions.
Benoit Cousson4fcd15a2011-09-27 17:45:43 +02001457 */
David Rivshinfe99c702016-03-02 16:35:51 -05001458int of_property_read_string_helper(const struct device_node *np,
1459 const char *propname, const char **out_strs,
1460 size_t sz, int skip)
Benoit Cousson4fcd15a2011-09-27 17:45:43 +02001461{
David Rivshinfe99c702016-03-02 16:35:51 -05001462 const struct property *prop = of_find_property(np, propname, NULL);
Grant Likelya87fa1d2014-11-03 15:15:35 +00001463 int l = 0, i = 0;
1464 const char *p, *end;
Benoit Cousson4fcd15a2011-09-27 17:45:43 +02001465
1466 if (!prop)
1467 return -EINVAL;
1468 if (!prop->value)
1469 return -ENODATA;
Benoit Cousson4fcd15a2011-09-27 17:45:43 +02001470 p = prop->value;
Grant Likelya87fa1d2014-11-03 15:15:35 +00001471 end = p + prop->length;
Benoit Cousson4fcd15a2011-09-27 17:45:43 +02001472
Grant Likelya87fa1d2014-11-03 15:15:35 +00001473 for (i = 0; p < end && (!out_strs || i < skip + sz); i++, p += l) {
1474 l = strnlen(p, end - p) + 1;
1475 if (p + l > end)
1476 return -EILSEQ;
1477 if (out_strs && i >= skip)
1478 *out_strs++ = p;
1479 }
1480 i -= skip;
1481 return i <= 0 ? -ENODATA : i;
Benoit Cousson4fcd15a2011-09-27 17:45:43 +02001482}
Grant Likelya87fa1d2014-11-03 15:15:35 +00001483EXPORT_SYMBOL_GPL(of_property_read_string_helper);
Benoit Cousson4fcd15a2011-09-27 17:45:43 +02001484
Grant Likely624cfca2013-10-11 22:05:10 +01001485void of_print_phandle_args(const char *msg, const struct of_phandle_args *args)
1486{
1487 int i;
1488 printk("%s %s", msg, of_node_full_name(args->np));
1489 for (i = 0; i < args->args_count; i++)
1490 printk(i ? ",%08x" : ":%08x", args->args[i]);
1491 printk("\n");
1492}
1493
Joerg Roedel74e1fbb2016-04-04 17:49:17 +02001494int of_phandle_iterator_init(struct of_phandle_iterator *it,
1495 const struct device_node *np,
1496 const char *list_name,
1497 const char *cells_name,
1498 int cell_count)
1499{
1500 const __be32 *list;
1501 int size;
1502
1503 memset(it, 0, sizeof(*it));
1504
1505 list = of_get_property(np, list_name, &size);
1506 if (!list)
1507 return -ENOENT;
1508
1509 it->cells_name = cells_name;
1510 it->cell_count = cell_count;
1511 it->parent = np;
1512 it->list_end = list + size / sizeof(*list);
1513 it->phandle_end = list;
1514 it->cur = list;
1515
1516 return 0;
1517}
1518
Joerg Roedelcd209b42016-04-04 17:49:18 +02001519int of_phandle_iterator_next(struct of_phandle_iterator *it)
1520{
1521 uint32_t count = 0;
1522
1523 if (it->node) {
1524 of_node_put(it->node);
1525 it->node = NULL;
1526 }
1527
1528 if (!it->cur || it->phandle_end >= it->list_end)
1529 return -ENOENT;
1530
1531 it->cur = it->phandle_end;
1532
1533 /* If phandle is 0, then it is an empty entry with no arguments. */
1534 it->phandle = be32_to_cpup(it->cur++);
1535
1536 if (it->phandle) {
1537
1538 /*
1539 * Find the provider node and parse the #*-cells property to
1540 * determine the argument length.
1541 */
1542 it->node = of_find_node_by_phandle(it->phandle);
1543
1544 if (it->cells_name) {
1545 if (!it->node) {
1546 pr_err("%s: could not find phandle\n",
1547 it->parent->full_name);
1548 goto err;
1549 }
1550
1551 if (of_property_read_u32(it->node, it->cells_name,
1552 &count)) {
1553 pr_err("%s: could not get %s for %s\n",
1554 it->parent->full_name,
1555 it->cells_name,
1556 it->node->full_name);
1557 goto err;
1558 }
1559 } else {
1560 count = it->cell_count;
1561 }
1562
1563 /*
1564 * Make sure that the arguments actually fit in the remaining
1565 * property data length
1566 */
1567 if (it->cur + count > it->list_end) {
1568 pr_err("%s: arguments longer than property\n",
1569 it->parent->full_name);
1570 goto err;
1571 }
1572 }
1573
1574 it->phandle_end = it->cur + count;
1575 it->cur_count = count;
1576
1577 return 0;
1578
1579err:
1580 if (it->node) {
1581 of_node_put(it->node);
1582 it->node = NULL;
1583 }
1584
1585 return -EINVAL;
1586}
1587
Joerg Roedelabdaa772016-04-04 17:49:21 +02001588int of_phandle_iterator_args(struct of_phandle_iterator *it,
1589 uint32_t *args,
1590 int size)
1591{
1592 int i, count;
1593
1594 count = it->cur_count;
1595
1596 if (WARN_ON(size < count))
1597 count = size;
1598
1599 for (i = 0; i < count; i++)
1600 args[i] = be32_to_cpup(it->cur++);
1601
1602 return count;
1603}
1604
Grant Likelybd69f732013-02-10 22:57:21 +00001605static int __of_parse_phandle_with_args(const struct device_node *np,
1606 const char *list_name,
Stephen Warren035fd942013-08-14 15:27:10 -06001607 const char *cells_name,
1608 int cell_count, int index,
Grant Likelybd69f732013-02-10 22:57:21 +00001609 struct of_phandle_args *out_args)
Anton Vorontsov64b60e02008-10-10 04:43:17 +00001610{
Joerg Roedel74e1fbb2016-04-04 17:49:17 +02001611 struct of_phandle_iterator it;
1612 int rc, cur_index = 0;
Anton Vorontsov64b60e02008-10-10 04:43:17 +00001613
Grant Likely15c9a0a2011-12-12 09:25:57 -07001614 /* Loop over the phandles until all the requested entry is found */
Joerg Roedelf623ce92016-04-04 17:49:20 +02001615 of_for_each_phandle(&it, rc, np, list_name, cells_name, cell_count) {
Grant Likely15c9a0a2011-12-12 09:25:57 -07001616 /*
Joerg Roedelcd209b42016-04-04 17:49:18 +02001617 * All of the error cases bail out of the loop, so at
Grant Likely15c9a0a2011-12-12 09:25:57 -07001618 * this point, the parsing is successful. If the requested
1619 * index matches, then fill the out_args structure and return,
1620 * or return -ENOENT for an empty entry.
1621 */
Grant Likely23ce04c2013-02-12 21:21:49 +00001622 rc = -ENOENT;
Grant Likely15c9a0a2011-12-12 09:25:57 -07001623 if (cur_index == index) {
Joerg Roedel74e1fbb2016-04-04 17:49:17 +02001624 if (!it.phandle)
Grant Likely23ce04c2013-02-12 21:21:49 +00001625 goto err;
Anton Vorontsov64b60e02008-10-10 04:43:17 +00001626
Grant Likely15c9a0a2011-12-12 09:25:57 -07001627 if (out_args) {
Joerg Roedelabdaa772016-04-04 17:49:21 +02001628 int c;
1629
1630 c = of_phandle_iterator_args(&it,
1631 out_args->args,
1632 MAX_PHANDLE_ARGS);
Joerg Roedel74e1fbb2016-04-04 17:49:17 +02001633 out_args->np = it.node;
Joerg Roedelabdaa772016-04-04 17:49:21 +02001634 out_args->args_count = c;
Tang Yuantianb855f162013-04-10 11:36:39 +08001635 } else {
Joerg Roedel74e1fbb2016-04-04 17:49:17 +02001636 of_node_put(it.node);
Grant Likely15c9a0a2011-12-12 09:25:57 -07001637 }
Grant Likely23ce04c2013-02-12 21:21:49 +00001638
1639 /* Found it! return success */
Grant Likely15c9a0a2011-12-12 09:25:57 -07001640 return 0;
Anton Vorontsov64b60e02008-10-10 04:43:17 +00001641 }
Anton Vorontsov64b60e02008-10-10 04:43:17 +00001642
Anton Vorontsov64b60e02008-10-10 04:43:17 +00001643 cur_index++;
1644 }
1645
Grant Likely23ce04c2013-02-12 21:21:49 +00001646 /*
1647 * Unlock node before returning result; will be one of:
1648 * -ENOENT : index is for empty phandle
1649 * -EINVAL : parsing error on data
1650 */
Joerg Roedelcd209b42016-04-04 17:49:18 +02001651
Grant Likely23ce04c2013-02-12 21:21:49 +00001652 err:
Markus Elfringbeab47d2016-07-19 22:42:22 +02001653 of_node_put(it.node);
Grant Likely23ce04c2013-02-12 21:21:49 +00001654 return rc;
Anton Vorontsov64b60e02008-10-10 04:43:17 +00001655}
Grant Likelybd69f732013-02-10 22:57:21 +00001656
Stephen Warreneded9dd2013-08-14 15:27:08 -06001657/**
Stephen Warren5fba49e2013-08-14 15:27:09 -06001658 * of_parse_phandle - Resolve a phandle property to a device_node pointer
1659 * @np: Pointer to device node holding phandle property
1660 * @phandle_name: Name of property holding a phandle value
1661 * @index: For properties holding a table of phandles, this is the index into
1662 * the table
1663 *
1664 * Returns the device_node pointer with refcount incremented. Use
1665 * of_node_put() on it when done.
1666 */
1667struct device_node *of_parse_phandle(const struct device_node *np,
1668 const char *phandle_name, int index)
1669{
Stephen Warren91d99422013-08-14 15:27:11 -06001670 struct of_phandle_args args;
Stephen Warren5fba49e2013-08-14 15:27:09 -06001671
Stephen Warren91d99422013-08-14 15:27:11 -06001672 if (index < 0)
Stephen Warren5fba49e2013-08-14 15:27:09 -06001673 return NULL;
1674
Stephen Warren91d99422013-08-14 15:27:11 -06001675 if (__of_parse_phandle_with_args(np, phandle_name, NULL, 0,
1676 index, &args))
1677 return NULL;
1678
1679 return args.np;
Stephen Warren5fba49e2013-08-14 15:27:09 -06001680}
1681EXPORT_SYMBOL(of_parse_phandle);
1682
1683/**
Stephen Warreneded9dd2013-08-14 15:27:08 -06001684 * of_parse_phandle_with_args() - Find a node pointed by phandle in a list
1685 * @np: pointer to a device tree node containing a list
1686 * @list_name: property name that contains a list
1687 * @cells_name: property name that specifies phandles' arguments count
1688 * @index: index of a phandle to parse out
1689 * @out_args: optional pointer to output arguments structure (will be filled)
1690 *
1691 * This function is useful to parse lists of phandles and their arguments.
1692 * Returns 0 on success and fills out_args, on error returns appropriate
1693 * errno value.
1694 *
Geert Uytterhoevend94a75c2014-10-22 11:44:52 +02001695 * Caller is responsible to call of_node_put() on the returned out_args->np
Stephen Warreneded9dd2013-08-14 15:27:08 -06001696 * pointer.
1697 *
1698 * Example:
1699 *
1700 * phandle1: node1 {
Geert Uytterhoevenc0e848d2014-10-22 11:44:55 +02001701 * #list-cells = <2>;
Stephen Warreneded9dd2013-08-14 15:27:08 -06001702 * }
1703 *
1704 * phandle2: node2 {
Geert Uytterhoevenc0e848d2014-10-22 11:44:55 +02001705 * #list-cells = <1>;
Stephen Warreneded9dd2013-08-14 15:27:08 -06001706 * }
1707 *
1708 * node3 {
Geert Uytterhoevenc0e848d2014-10-22 11:44:55 +02001709 * list = <&phandle1 1 2 &phandle2 3>;
Stephen Warreneded9dd2013-08-14 15:27:08 -06001710 * }
1711 *
1712 * To get a device_node of the `node2' node you may call this:
1713 * of_parse_phandle_with_args(node3, "list", "#list-cells", 1, &args);
1714 */
Grant Likelybd69f732013-02-10 22:57:21 +00001715int of_parse_phandle_with_args(const struct device_node *np, const char *list_name,
1716 const char *cells_name, int index,
1717 struct of_phandle_args *out_args)
1718{
1719 if (index < 0)
1720 return -EINVAL;
Stephen Warren035fd942013-08-14 15:27:10 -06001721 return __of_parse_phandle_with_args(np, list_name, cells_name, 0,
1722 index, out_args);
Grant Likelybd69f732013-02-10 22:57:21 +00001723}
Grant Likely15c9a0a2011-12-12 09:25:57 -07001724EXPORT_SYMBOL(of_parse_phandle_with_args);
Grant Likely02af11b2009-11-23 20:16:45 -07001725
Grant Likelybd69f732013-02-10 22:57:21 +00001726/**
Stephen Warren035fd942013-08-14 15:27:10 -06001727 * of_parse_phandle_with_fixed_args() - Find a node pointed by phandle in a list
1728 * @np: pointer to a device tree node containing a list
1729 * @list_name: property name that contains a list
1730 * @cell_count: number of argument cells following the phandle
1731 * @index: index of a phandle to parse out
1732 * @out_args: optional pointer to output arguments structure (will be filled)
1733 *
1734 * This function is useful to parse lists of phandles and their arguments.
1735 * Returns 0 on success and fills out_args, on error returns appropriate
1736 * errno value.
1737 *
Geert Uytterhoevend94a75c2014-10-22 11:44:52 +02001738 * Caller is responsible to call of_node_put() on the returned out_args->np
Stephen Warren035fd942013-08-14 15:27:10 -06001739 * pointer.
1740 *
1741 * Example:
1742 *
1743 * phandle1: node1 {
1744 * }
1745 *
1746 * phandle2: node2 {
1747 * }
1748 *
1749 * node3 {
Geert Uytterhoevenc0e848d2014-10-22 11:44:55 +02001750 * list = <&phandle1 0 2 &phandle2 2 3>;
Stephen Warren035fd942013-08-14 15:27:10 -06001751 * }
1752 *
1753 * To get a device_node of the `node2' node you may call this:
1754 * of_parse_phandle_with_fixed_args(node3, "list", 2, 1, &args);
1755 */
1756int of_parse_phandle_with_fixed_args(const struct device_node *np,
1757 const char *list_name, int cell_count,
1758 int index, struct of_phandle_args *out_args)
1759{
1760 if (index < 0)
1761 return -EINVAL;
1762 return __of_parse_phandle_with_args(np, list_name, NULL, cell_count,
1763 index, out_args);
1764}
1765EXPORT_SYMBOL(of_parse_phandle_with_fixed_args);
1766
1767/**
Grant Likelybd69f732013-02-10 22:57:21 +00001768 * of_count_phandle_with_args() - Find the number of phandles references in a property
1769 * @np: pointer to a device tree node containing a list
1770 * @list_name: property name that contains a list
1771 * @cells_name: property name that specifies phandles' arguments count
1772 *
1773 * Returns the number of phandle + argument tuples within a property. It
1774 * is a typical pattern to encode a list of phandle and variable
1775 * arguments into a single property. The number of arguments is encoded
1776 * by a property in the phandle-target node. For example, a gpios
1777 * property would contain a list of GPIO specifies consisting of a
1778 * phandle and 1 or more arguments. The number of arguments are
1779 * determined by the #gpio-cells property in the node pointed to by the
1780 * phandle.
1781 */
1782int of_count_phandle_with_args(const struct device_node *np, const char *list_name,
1783 const char *cells_name)
1784{
Joerg Roedel2021bd02016-04-04 17:49:19 +02001785 struct of_phandle_iterator it;
1786 int rc, cur_index = 0;
1787
1788 rc = of_phandle_iterator_init(&it, np, list_name, cells_name, 0);
1789 if (rc)
1790 return rc;
1791
1792 while ((rc = of_phandle_iterator_next(&it)) == 0)
1793 cur_index += 1;
1794
1795 if (rc != -ENOENT)
1796 return rc;
1797
1798 return cur_index;
Grant Likelybd69f732013-02-10 22:57:21 +00001799}
1800EXPORT_SYMBOL(of_count_phandle_with_args);
1801
Grant Likely02af11b2009-11-23 20:16:45 -07001802/**
Xiubo Li62664f62014-01-22 13:57:39 +08001803 * __of_add_property - Add a property to a node without lock operations
1804 */
Pantelis Antonioud8c50082014-07-04 19:58:46 +03001805int __of_add_property(struct device_node *np, struct property *prop)
Xiubo Li62664f62014-01-22 13:57:39 +08001806{
1807 struct property **next;
1808
1809 prop->next = NULL;
1810 next = &np->properties;
1811 while (*next) {
1812 if (strcmp(prop->name, (*next)->name) == 0)
1813 /* duplicate ! don't insert it */
1814 return -EEXIST;
1815
1816 next = &(*next)->next;
1817 }
1818 *next = prop;
1819
1820 return 0;
1821}
1822
1823/**
Nathan Fontenot79d1c712012-10-02 16:58:46 +00001824 * of_add_property - Add a property to a node
Grant Likely02af11b2009-11-23 20:16:45 -07001825 */
Nathan Fontenot79d1c712012-10-02 16:58:46 +00001826int of_add_property(struct device_node *np, struct property *prop)
Grant Likely02af11b2009-11-23 20:16:45 -07001827{
Grant Likely02af11b2009-11-23 20:16:45 -07001828 unsigned long flags;
Nathan Fontenot1cf3d8b2012-10-02 16:57:57 +00001829 int rc;
1830
Grant Likely8a2b22a2014-07-23 17:05:06 -06001831 mutex_lock(&of_mutex);
Grant Likely02af11b2009-11-23 20:16:45 -07001832
Thomas Gleixnerd6d3c4e2013-02-06 15:30:56 -05001833 raw_spin_lock_irqsave(&devtree_lock, flags);
Xiubo Li62664f62014-01-22 13:57:39 +08001834 rc = __of_add_property(np, prop);
Thomas Gleixnerd6d3c4e2013-02-06 15:30:56 -05001835 raw_spin_unlock_irqrestore(&devtree_lock, flags);
Grant Likely02af11b2009-11-23 20:16:45 -07001836
Grant Likely8a2b22a2014-07-23 17:05:06 -06001837 if (!rc)
Pantelis Antoniou0829f6d2013-12-13 20:08:59 +02001838 __of_add_property_sysfs(np, prop);
Grant Likely02af11b2009-11-23 20:16:45 -07001839
Grant Likely8a2b22a2014-07-23 17:05:06 -06001840 mutex_unlock(&of_mutex);
1841
Grant Likely259092a2014-07-16 12:48:23 -06001842 if (!rc)
1843 of_property_notify(OF_RECONFIG_ADD_PROPERTY, np, prop, NULL);
1844
Xiubo Li62664f62014-01-22 13:57:39 +08001845 return rc;
Grant Likely02af11b2009-11-23 20:16:45 -07001846}
1847
Pantelis Antonioud8c50082014-07-04 19:58:46 +03001848int __of_remove_property(struct device_node *np, struct property *prop)
1849{
1850 struct property **next;
1851
1852 for (next = &np->properties; *next; next = &(*next)->next) {
1853 if (*next == prop)
1854 break;
1855 }
1856 if (*next == NULL)
1857 return -ENODEV;
1858
1859 /* found the node */
1860 *next = prop->next;
1861 prop->next = np->deadprops;
1862 np->deadprops = prop;
1863
1864 return 0;
1865}
1866
Frank Rowandd9fc8802016-06-16 10:51:46 -07001867void __of_sysfs_remove_bin_file(struct device_node *np, struct property *prop)
1868{
1869 sysfs_remove_bin_file(&np->kobj, &prop->attr);
1870 kfree(prop->attr.attr.name);
1871}
1872
Grant Likely8a2b22a2014-07-23 17:05:06 -06001873void __of_remove_property_sysfs(struct device_node *np, struct property *prop)
1874{
Gaurav Minochaef69d742014-09-05 09:56:13 -07001875 if (!IS_ENABLED(CONFIG_SYSFS))
1876 return;
1877
Grant Likely8a2b22a2014-07-23 17:05:06 -06001878 /* at early boot, bail here and defer setup to of_init() */
1879 if (of_kset && of_node_is_attached(np))
Frank Rowandd9fc8802016-06-16 10:51:46 -07001880 __of_sysfs_remove_bin_file(np, prop);
Grant Likely8a2b22a2014-07-23 17:05:06 -06001881}
1882
Grant Likely02af11b2009-11-23 20:16:45 -07001883/**
Nathan Fontenot79d1c712012-10-02 16:58:46 +00001884 * of_remove_property - Remove a property from a node.
Grant Likely02af11b2009-11-23 20:16:45 -07001885 *
1886 * Note that we don't actually remove it, since we have given out
1887 * who-knows-how-many pointers to the data using get-property.
1888 * Instead we just move the property to the "dead properties"
1889 * list, so it won't be found any more.
1890 */
Nathan Fontenot79d1c712012-10-02 16:58:46 +00001891int of_remove_property(struct device_node *np, struct property *prop)
Grant Likely02af11b2009-11-23 20:16:45 -07001892{
Grant Likely02af11b2009-11-23 20:16:45 -07001893 unsigned long flags;
Nathan Fontenot1cf3d8b2012-10-02 16:57:57 +00001894 int rc;
1895
Suraj Jitindar Singh201b3fe2016-04-28 15:34:54 +10001896 if (!prop)
1897 return -ENODEV;
1898
Grant Likely8a2b22a2014-07-23 17:05:06 -06001899 mutex_lock(&of_mutex);
Grant Likely02af11b2009-11-23 20:16:45 -07001900
Thomas Gleixnerd6d3c4e2013-02-06 15:30:56 -05001901 raw_spin_lock_irqsave(&devtree_lock, flags);
Pantelis Antonioud8c50082014-07-04 19:58:46 +03001902 rc = __of_remove_property(np, prop);
Thomas Gleixnerd6d3c4e2013-02-06 15:30:56 -05001903 raw_spin_unlock_irqrestore(&devtree_lock, flags);
Grant Likely02af11b2009-11-23 20:16:45 -07001904
Grant Likely8a2b22a2014-07-23 17:05:06 -06001905 if (!rc)
1906 __of_remove_property_sysfs(np, prop);
Grant Likely02af11b2009-11-23 20:16:45 -07001907
Grant Likely8a2b22a2014-07-23 17:05:06 -06001908 mutex_unlock(&of_mutex);
Grant Likely75b57ec2014-02-20 18:02:11 +00001909
Grant Likely259092a2014-07-16 12:48:23 -06001910 if (!rc)
1911 of_property_notify(OF_RECONFIG_REMOVE_PROPERTY, np, prop, NULL);
1912
Grant Likely8a2b22a2014-07-23 17:05:06 -06001913 return rc;
Grant Likely02af11b2009-11-23 20:16:45 -07001914}
1915
Pantelis Antonioud8c50082014-07-04 19:58:46 +03001916int __of_update_property(struct device_node *np, struct property *newprop,
1917 struct property **oldpropp)
1918{
1919 struct property **next, *oldprop;
1920
1921 for (next = &np->properties; *next; next = &(*next)->next) {
1922 if (of_prop_cmp((*next)->name, newprop->name) == 0)
1923 break;
1924 }
1925 *oldpropp = oldprop = *next;
1926
1927 if (oldprop) {
1928 /* replace the node */
1929 newprop->next = oldprop->next;
1930 *next = newprop;
1931 oldprop->next = np->deadprops;
1932 np->deadprops = oldprop;
1933 } else {
1934 /* new node */
1935 newprop->next = NULL;
1936 *next = newprop;
1937 }
Grant Likely02af11b2009-11-23 20:16:45 -07001938
1939 return 0;
1940}
1941
Grant Likely8a2b22a2014-07-23 17:05:06 -06001942void __of_update_property_sysfs(struct device_node *np, struct property *newprop,
1943 struct property *oldprop)
1944{
Gaurav Minochaef69d742014-09-05 09:56:13 -07001945 if (!IS_ENABLED(CONFIG_SYSFS))
1946 return;
1947
Grant Likely8a2b22a2014-07-23 17:05:06 -06001948 /* At early boot, bail out and defer setup to of_init() */
1949 if (!of_kset)
1950 return;
1951
1952 if (oldprop)
Frank Rowandd9fc8802016-06-16 10:51:46 -07001953 __of_sysfs_remove_bin_file(np, oldprop);
Grant Likely8a2b22a2014-07-23 17:05:06 -06001954 __of_add_property_sysfs(np, newprop);
1955}
1956
Grant Likely02af11b2009-11-23 20:16:45 -07001957/*
Nathan Fontenot79d1c712012-10-02 16:58:46 +00001958 * of_update_property - Update a property in a node, if the property does
Dong Aisheng475d0092012-07-11 15:16:37 +10001959 * not exist, add it.
Grant Likely02af11b2009-11-23 20:16:45 -07001960 *
1961 * Note that we don't actually remove it, since we have given out
1962 * who-knows-how-many pointers to the data using get-property.
1963 * Instead we just move the property to the "dead properties" list,
1964 * and add the new property to the property list
1965 */
Nathan Fontenot79d1c712012-10-02 16:58:46 +00001966int of_update_property(struct device_node *np, struct property *newprop)
Grant Likely02af11b2009-11-23 20:16:45 -07001967{
Pantelis Antonioud8c50082014-07-04 19:58:46 +03001968 struct property *oldprop;
Grant Likely02af11b2009-11-23 20:16:45 -07001969 unsigned long flags;
Xiubo Li947fdaad02014-04-17 15:48:29 +08001970 int rc;
Nathan Fontenot1cf3d8b2012-10-02 16:57:57 +00001971
Dong Aisheng475d0092012-07-11 15:16:37 +10001972 if (!newprop->name)
1973 return -EINVAL;
1974
Grant Likely8a2b22a2014-07-23 17:05:06 -06001975 mutex_lock(&of_mutex);
Grant Likelyfcdeb7f2010-01-29 05:04:33 -07001976
Thomas Gleixnerd6d3c4e2013-02-06 15:30:56 -05001977 raw_spin_lock_irqsave(&devtree_lock, flags);
Pantelis Antonioud8c50082014-07-04 19:58:46 +03001978 rc = __of_update_property(np, newprop, &oldprop);
Thomas Gleixnerd6d3c4e2013-02-06 15:30:56 -05001979 raw_spin_unlock_irqrestore(&devtree_lock, flags);
Nathan Fontenote81b3292012-10-02 16:55:01 +00001980
Grant Likely8a2b22a2014-07-23 17:05:06 -06001981 if (!rc)
1982 __of_update_property_sysfs(np, newprop, oldprop);
Grant Likelyfcdeb7f2010-01-29 05:04:33 -07001983
Grant Likely8a2b22a2014-07-23 17:05:06 -06001984 mutex_unlock(&of_mutex);
Nathan Fontenot1cf3d8b2012-10-02 16:57:57 +00001985
Grant Likely259092a2014-07-16 12:48:23 -06001986 if (!rc)
1987 of_property_notify(OF_RECONFIG_UPDATE_PROPERTY, np, newprop, oldprop);
Grant Likelyfcdeb7f2010-01-29 05:04:33 -07001988
Nathan Fontenot1cf3d8b2012-10-02 16:57:57 +00001989 return rc;
Grant Likelyfcdeb7f2010-01-29 05:04:33 -07001990}
Grant Likelyfcdeb7f2010-01-29 05:04:33 -07001991
Shawn Guo611cad72011-08-15 15:28:14 +08001992static void of_alias_add(struct alias_prop *ap, struct device_node *np,
1993 int id, const char *stem, int stem_len)
1994{
1995 ap->np = np;
1996 ap->id = id;
1997 strncpy(ap->stem, stem, stem_len);
1998 ap->stem[stem_len] = 0;
1999 list_add_tail(&ap->link, &aliases_lookup);
2000 pr_debug("adding DT alias:%s: stem=%s id=%i node=%s\n",
Grant Likely74a7f082012-06-15 11:50:25 -06002001 ap->alias, ap->stem, ap->id, of_node_full_name(np));
Shawn Guo611cad72011-08-15 15:28:14 +08002002}
2003
2004/**
Geert Uytterhoeven1821dda2014-10-22 11:44:53 +02002005 * of_alias_scan - Scan all properties of the 'aliases' node
Shawn Guo611cad72011-08-15 15:28:14 +08002006 *
Geert Uytterhoeven1821dda2014-10-22 11:44:53 +02002007 * The function scans all the properties of the 'aliases' node and populates
2008 * the global lookup table with the properties. It returns the
2009 * number of alias properties found, or an error code in case of failure.
Shawn Guo611cad72011-08-15 15:28:14 +08002010 *
2011 * @dt_alloc: An allocator that provides a virtual address to memory
Geert Uytterhoeven1821dda2014-10-22 11:44:53 +02002012 * for storing the resulting tree
Shawn Guo611cad72011-08-15 15:28:14 +08002013 */
2014void of_alias_scan(void * (*dt_alloc)(u64 size, u64 align))
2015{
2016 struct property *pp;
2017
Laurentiu Tudor7dbe5842014-08-27 17:09:39 +03002018 of_aliases = of_find_node_by_path("/aliases");
Shawn Guo611cad72011-08-15 15:28:14 +08002019 of_chosen = of_find_node_by_path("/chosen");
2020 if (of_chosen == NULL)
2021 of_chosen = of_find_node_by_path("/chosen@0");
Sascha Hauer5c19e952013-08-05 14:40:44 +02002022
2023 if (of_chosen) {
Grant Likelya752ee52014-03-28 08:12:18 -07002024 /* linux,stdout-path and /aliases/stdout are for legacy compatibility */
Grant Likely676e1b22014-03-27 17:11:23 -07002025 const char *name = of_get_property(of_chosen, "stdout-path", NULL);
2026 if (!name)
2027 name = of_get_property(of_chosen, "linux,stdout-path", NULL);
Grant Likelya752ee52014-03-28 08:12:18 -07002028 if (IS_ENABLED(CONFIG_PPC) && !name)
2029 name = of_get_property(of_aliases, "stdout", NULL);
Peter Hurleyf64255b2015-03-17 16:46:33 -04002030 if (name)
Leif Lindholm7914a7c2014-11-27 17:56:07 +00002031 of_stdout = of_find_node_opts_by_path(name, &of_stdout_options);
Sascha Hauer5c19e952013-08-05 14:40:44 +02002032 }
2033
Shawn Guo611cad72011-08-15 15:28:14 +08002034 if (!of_aliases)
2035 return;
2036
Dong Aisheng8af0da92011-12-22 20:19:24 +08002037 for_each_property_of_node(of_aliases, pp) {
Shawn Guo611cad72011-08-15 15:28:14 +08002038 const char *start = pp->name;
2039 const char *end = start + strlen(start);
2040 struct device_node *np;
2041 struct alias_prop *ap;
2042 int id, len;
2043
2044 /* Skip those we do not want to proceed */
2045 if (!strcmp(pp->name, "name") ||
2046 !strcmp(pp->name, "phandle") ||
2047 !strcmp(pp->name, "linux,phandle"))
2048 continue;
2049
2050 np = of_find_node_by_path(pp->value);
2051 if (!np)
2052 continue;
2053
2054 /* walk the alias backwards to extract the id and work out
2055 * the 'stem' string */
2056 while (isdigit(*(end-1)) && end > start)
2057 end--;
2058 len = end - start;
2059
2060 if (kstrtoint(end, 10, &id) < 0)
2061 continue;
2062
2063 /* Allocate an alias_prop with enough space for the stem */
2064 ap = dt_alloc(sizeof(*ap) + len + 1, 4);
2065 if (!ap)
2066 continue;
Grant Likely0640332e2013-08-28 21:24:17 +01002067 memset(ap, 0, sizeof(*ap) + len + 1);
Shawn Guo611cad72011-08-15 15:28:14 +08002068 ap->alias = start;
2069 of_alias_add(ap, np, id, start, len);
2070 }
2071}
2072
2073/**
2074 * of_alias_get_id - Get alias id for the given device_node
2075 * @np: Pointer to the given device_node
2076 * @stem: Alias stem of the given device_node
2077 *
Geert Uytterhoeven5a53a072014-03-11 11:23:38 +01002078 * The function travels the lookup table to get the alias id for the given
2079 * device_node and alias stem. It returns the alias id if found.
Shawn Guo611cad72011-08-15 15:28:14 +08002080 */
2081int of_alias_get_id(struct device_node *np, const char *stem)
2082{
2083 struct alias_prop *app;
2084 int id = -ENODEV;
2085
Pantelis Antoniouc05aba22014-07-04 19:58:03 +03002086 mutex_lock(&of_mutex);
Shawn Guo611cad72011-08-15 15:28:14 +08002087 list_for_each_entry(app, &aliases_lookup, link) {
2088 if (strcmp(app->stem, stem) != 0)
2089 continue;
2090
2091 if (np == app->np) {
2092 id = app->id;
2093 break;
2094 }
2095 }
Pantelis Antoniouc05aba22014-07-04 19:58:03 +03002096 mutex_unlock(&of_mutex);
Shawn Guo611cad72011-08-15 15:28:14 +08002097
2098 return id;
2099}
2100EXPORT_SYMBOL_GPL(of_alias_get_id);
Stephen Warrenc541adc2012-04-04 09:27:46 -06002101
Wolfram Sang351d2242015-03-12 17:17:58 +01002102/**
2103 * of_alias_get_highest_id - Get highest alias id for the given stem
2104 * @stem: Alias stem to be examined
2105 *
2106 * The function travels the lookup table to get the highest alias id for the
2107 * given alias stem. It returns the alias id if found.
2108 */
2109int of_alias_get_highest_id(const char *stem)
2110{
2111 struct alias_prop *app;
2112 int id = -ENODEV;
2113
2114 mutex_lock(&of_mutex);
2115 list_for_each_entry(app, &aliases_lookup, link) {
2116 if (strcmp(app->stem, stem) != 0)
2117 continue;
2118
2119 if (app->id > id)
2120 id = app->id;
2121 }
2122 mutex_unlock(&of_mutex);
2123
2124 return id;
2125}
2126EXPORT_SYMBOL_GPL(of_alias_get_highest_id);
2127
Stephen Warrenc541adc2012-04-04 09:27:46 -06002128const __be32 *of_prop_next_u32(struct property *prop, const __be32 *cur,
2129 u32 *pu)
2130{
2131 const void *curv = cur;
2132
2133 if (!prop)
2134 return NULL;
2135
2136 if (!cur) {
2137 curv = prop->value;
2138 goto out_val;
2139 }
2140
2141 curv += sizeof(*cur);
2142 if (curv >= prop->value + prop->length)
2143 return NULL;
2144
2145out_val:
2146 *pu = be32_to_cpup(curv);
2147 return curv;
2148}
2149EXPORT_SYMBOL_GPL(of_prop_next_u32);
2150
2151const char *of_prop_next_string(struct property *prop, const char *cur)
2152{
2153 const void *curv = cur;
2154
2155 if (!prop)
2156 return NULL;
2157
2158 if (!cur)
2159 return prop->value;
2160
2161 curv += strlen(cur) + 1;
2162 if (curv >= prop->value + prop->length)
2163 return NULL;
2164
2165 return curv;
2166}
2167EXPORT_SYMBOL_GPL(of_prop_next_string);
Sascha Hauer5c19e952013-08-05 14:40:44 +02002168
2169/**
Grant Likely3482f2c2014-03-27 17:18:55 -07002170 * of_console_check() - Test and setup console for DT setup
2171 * @dn - Pointer to device node
2172 * @name - Name to use for preferred console without index. ex. "ttyS"
2173 * @index - Index to use for preferred console.
Sascha Hauer5c19e952013-08-05 14:40:44 +02002174 *
Grant Likely3482f2c2014-03-27 17:18:55 -07002175 * Check if the given device node matches the stdout-path property in the
2176 * /chosen node. If it does then register it as the preferred console and return
2177 * TRUE. Otherwise return FALSE.
Sascha Hauer5c19e952013-08-05 14:40:44 +02002178 */
Grant Likely3482f2c2014-03-27 17:18:55 -07002179bool of_console_check(struct device_node *dn, char *name, int index)
Sascha Hauer5c19e952013-08-05 14:40:44 +02002180{
Grant Likely3482f2c2014-03-27 17:18:55 -07002181 if (!dn || dn != of_stdout || console_set_on_cmdline)
Sascha Hauer5c19e952013-08-05 14:40:44 +02002182 return false;
Leif Lindholm7914a7c2014-11-27 17:56:07 +00002183 return !add_preferred_console(name, index,
2184 kstrdup(of_stdout_options, GFP_KERNEL));
Sascha Hauer5c19e952013-08-05 14:40:44 +02002185}
Grant Likely3482f2c2014-03-27 17:18:55 -07002186EXPORT_SYMBOL_GPL(of_console_check);
Sudeep KarkadaNageshaa3e31b42013-09-18 11:53:05 +01002187
2188/**
2189 * of_find_next_cache_node - Find a node's subsidiary cache
2190 * @np: node of type "cpu" or "cache"
2191 *
2192 * Returns a node pointer with refcount incremented, use
2193 * of_node_put() on it when done. Caller should hold a reference
2194 * to np.
2195 */
2196struct device_node *of_find_next_cache_node(const struct device_node *np)
2197{
2198 struct device_node *child;
2199 const phandle *handle;
2200
2201 handle = of_get_property(np, "l2-cache", NULL);
2202 if (!handle)
2203 handle = of_get_property(np, "next-level-cache", NULL);
2204
2205 if (handle)
2206 return of_find_node_by_phandle(be32_to_cpup(handle));
2207
2208 /* OF on pmac has nodes instead of properties named "l2-cache"
2209 * beneath CPU nodes.
2210 */
2211 if (!strcmp(np->type, "cpu"))
2212 for_each_child_of_node(np, child)
2213 if (!strcmp(child->type, "cache"))
2214 return child;
2215
2216 return NULL;
2217}
Philipp Zabelfd9fdb72014-02-10 22:01:48 +01002218
2219/**
Philipp Zabelf2a575f2014-02-14 11:53:56 +01002220 * of_graph_parse_endpoint() - parse common endpoint node properties
2221 * @node: pointer to endpoint device_node
2222 * @endpoint: pointer to the OF endpoint data structure
2223 *
2224 * The caller should hold a reference to @node.
2225 */
2226int of_graph_parse_endpoint(const struct device_node *node,
2227 struct of_endpoint *endpoint)
2228{
2229 struct device_node *port_node = of_get_parent(node);
2230
Philipp Zabeld4847002014-03-04 12:31:24 +01002231 WARN_ONCE(!port_node, "%s(): endpoint %s has no parent node\n",
2232 __func__, node->full_name);
2233
Philipp Zabelf2a575f2014-02-14 11:53:56 +01002234 memset(endpoint, 0, sizeof(*endpoint));
2235
2236 endpoint->local_node = node;
2237 /*
2238 * It doesn't matter whether the two calls below succeed.
2239 * If they don't then the default value 0 is used.
2240 */
2241 of_property_read_u32(port_node, "reg", &endpoint->port);
2242 of_property_read_u32(node, "reg", &endpoint->id);
2243
2244 of_node_put(port_node);
2245
2246 return 0;
2247}
2248EXPORT_SYMBOL(of_graph_parse_endpoint);
2249
2250/**
Philipp Zabelbfe446e2014-03-11 11:21:11 +01002251 * of_graph_get_port_by_id() - get the port matching a given id
2252 * @parent: pointer to the parent device node
2253 * @id: id of the port
2254 *
2255 * Return: A 'port' node pointer with refcount incremented. The caller
2256 * has to use of_node_put() on it when done.
2257 */
2258struct device_node *of_graph_get_port_by_id(struct device_node *parent, u32 id)
2259{
2260 struct device_node *node, *port;
2261
2262 node = of_get_child_by_name(parent, "ports");
2263 if (node)
2264 parent = node;
2265
2266 for_each_child_of_node(parent, port) {
2267 u32 port_id = 0;
2268
2269 if (of_node_cmp(port->name, "port") != 0)
2270 continue;
2271 of_property_read_u32(port, "reg", &port_id);
2272 if (id == port_id)
2273 break;
2274 }
2275
2276 of_node_put(node);
2277
2278 return port;
2279}
2280EXPORT_SYMBOL(of_graph_get_port_by_id);
2281
2282/**
Philipp Zabelfd9fdb72014-02-10 22:01:48 +01002283 * of_graph_get_next_endpoint() - get next endpoint node
2284 * @parent: pointer to the parent device node
2285 * @prev: previous endpoint node, or NULL to get first
2286 *
2287 * Return: An 'endpoint' node pointer with refcount incremented. Refcount
Philipp Zabelf033c0b2014-12-01 13:32:32 +01002288 * of the passed @prev node is decremented.
Philipp Zabelfd9fdb72014-02-10 22:01:48 +01002289 */
2290struct device_node *of_graph_get_next_endpoint(const struct device_node *parent,
2291 struct device_node *prev)
2292{
2293 struct device_node *endpoint;
Linus Torvalds3c83e612014-04-04 09:50:07 -07002294 struct device_node *port;
Philipp Zabelfd9fdb72014-02-10 22:01:48 +01002295
2296 if (!parent)
2297 return NULL;
2298
Linus Torvalds3c83e612014-04-04 09:50:07 -07002299 /*
2300 * Start by locating the port node. If no previous endpoint is specified
2301 * search for the first port node, otherwise get the previous endpoint
2302 * parent port node.
2303 */
Philipp Zabelfd9fdb72014-02-10 22:01:48 +01002304 if (!prev) {
2305 struct device_node *node;
Linus Torvalds3c83e612014-04-04 09:50:07 -07002306
Philipp Zabelfd9fdb72014-02-10 22:01:48 +01002307 node = of_get_child_by_name(parent, "ports");
2308 if (node)
2309 parent = node;
2310
2311 port = of_get_child_by_name(parent, "port");
Philipp Zabelfd9fdb72014-02-10 22:01:48 +01002312 of_node_put(node);
Philipp Zabelfd9fdb72014-02-10 22:01:48 +01002313
Linus Torvalds3c83e612014-04-04 09:50:07 -07002314 if (!port) {
Rob Herring606ad422016-06-15 08:32:18 -05002315 pr_err("graph: no port node found in %s\n",
2316 parent->full_name);
Philipp Zabel4329b932014-02-26 20:43:42 +01002317 return NULL;
Linus Torvalds3c83e612014-04-04 09:50:07 -07002318 }
2319 } else {
2320 port = of_get_parent(prev);
2321 if (WARN_ONCE(!port, "%s(): endpoint %s has no parent node\n",
2322 __func__, prev->full_name))
2323 return NULL;
Linus Torvalds3c83e612014-04-04 09:50:07 -07002324 }
Philipp Zabel4329b932014-02-26 20:43:42 +01002325
Linus Torvalds3c83e612014-04-04 09:50:07 -07002326 while (1) {
2327 /*
2328 * Now that we have a port node, get the next endpoint by
2329 * getting the next child. If the previous endpoint is NULL this
2330 * will return the first child.
2331 */
2332 endpoint = of_get_next_child(port, prev);
2333 if (endpoint) {
2334 of_node_put(port);
2335 return endpoint;
2336 }
2337
2338 /* No more endpoints under this port, try the next one. */
2339 prev = NULL;
2340
2341 do {
2342 port = of_get_next_child(parent, port);
2343 if (!port)
2344 return NULL;
2345 } while (of_node_cmp(port->name, "port"));
2346 }
Philipp Zabelfd9fdb72014-02-10 22:01:48 +01002347}
2348EXPORT_SYMBOL(of_graph_get_next_endpoint);
2349
2350/**
Hyungwon Hwang8ccd0d02015-06-12 21:59:01 +09002351 * of_graph_get_endpoint_by_regs() - get endpoint node of specific identifiers
2352 * @parent: pointer to the parent device node
2353 * @port_reg: identifier (value of reg property) of the parent port node
2354 * @reg: identifier (value of reg property) of the endpoint node
2355 *
2356 * Return: An 'endpoint' node pointer which is identified by reg and at the same
2357 * is the child of a port node identified by port_reg. reg and port_reg are
2358 * ignored when they are -1.
2359 */
2360struct device_node *of_graph_get_endpoint_by_regs(
2361 const struct device_node *parent, int port_reg, int reg)
2362{
2363 struct of_endpoint endpoint;
Lucas Stach34276bb2016-08-15 14:58:43 +02002364 struct device_node *node = NULL;
Hyungwon Hwang8ccd0d02015-06-12 21:59:01 +09002365
Lucas Stach34276bb2016-08-15 14:58:43 +02002366 for_each_endpoint_of_node(parent, node) {
Hyungwon Hwang8ccd0d02015-06-12 21:59:01 +09002367 of_graph_parse_endpoint(node, &endpoint);
2368 if (((port_reg == -1) || (endpoint.port == port_reg)) &&
2369 ((reg == -1) || (endpoint.id == reg)))
2370 return node;
Hyungwon Hwang8ccd0d02015-06-12 21:59:01 +09002371 }
2372
2373 return NULL;
2374}
Dave Airlie8ffaa902015-06-23 10:19:10 +10002375EXPORT_SYMBOL(of_graph_get_endpoint_by_regs);
Hyungwon Hwang8ccd0d02015-06-12 21:59:01 +09002376
2377/**
Philipp Zabelfd9fdb72014-02-10 22:01:48 +01002378 * of_graph_get_remote_port_parent() - get remote port's parent node
2379 * @node: pointer to a local endpoint device_node
2380 *
2381 * Return: Remote device node associated with remote endpoint node linked
2382 * to @node. Use of_node_put() on it when done.
2383 */
2384struct device_node *of_graph_get_remote_port_parent(
2385 const struct device_node *node)
2386{
2387 struct device_node *np;
2388 unsigned int depth;
2389
2390 /* Get remote endpoint node. */
2391 np = of_parse_phandle(node, "remote-endpoint", 0);
2392
2393 /* Walk 3 levels up only if there is 'ports' node. */
2394 for (depth = 3; depth && np; depth--) {
2395 np = of_get_next_parent(np);
2396 if (depth == 2 && of_node_cmp(np->name, "ports"))
2397 break;
2398 }
2399 return np;
2400}
2401EXPORT_SYMBOL(of_graph_get_remote_port_parent);
2402
2403/**
2404 * of_graph_get_remote_port() - get remote port node
2405 * @node: pointer to a local endpoint device_node
2406 *
2407 * Return: Remote port node associated with remote endpoint node linked
2408 * to @node. Use of_node_put() on it when done.
2409 */
2410struct device_node *of_graph_get_remote_port(const struct device_node *node)
2411{
2412 struct device_node *np;
2413
2414 /* Get remote endpoint node. */
2415 np = of_parse_phandle(node, "remote-endpoint", 0);
2416 if (!np)
2417 return NULL;
2418 return of_get_next_parent(np);
2419}
2420EXPORT_SYMBOL(of_graph_get_remote_port);