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