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/module.h>
22 #include <linux/of.h>
23 #include <linux/spinlock.h>
24 #include <linux/slab.h>
25 #include <linux/proc_fs.h>
27 /**
28 * struct alias_prop - Alias property in 'aliases' node
29 * @link: List node to link the structure in aliases_lookup list
30 * @alias: Alias property name
31 * @np: Pointer to device_node that the alias stands for
32 * @id: Index value from end of alias name
33 * @stem: Alias string without the index
34 *
35 * The structure represents one alias property of 'aliases' node as
36 * an entry in aliases_lookup list.
37 */
38 struct alias_prop {
39 struct list_head link;
40 const char *alias;
41 struct device_node *np;
42 int id;
43 char stem[0];
44 };
46 static LIST_HEAD(aliases_lookup);
48 struct device_node *of_allnodes;
49 EXPORT_SYMBOL(of_allnodes);
50 struct device_node *of_chosen;
51 struct device_node *of_aliases;
53 static DEFINE_MUTEX(of_aliases_mutex);
55 /* use when traversing tree through the allnext, child, sibling,
56 * or parent members of struct device_node.
57 */
58 DEFINE_RWLOCK(devtree_lock);
60 int of_n_addr_cells(struct device_node *np)
61 {
62 const __be32 *ip;
64 do {
65 if (np->parent)
66 np = np->parent;
67 ip = of_get_property(np, "#address-cells", NULL);
68 if (ip)
69 return be32_to_cpup(ip);
70 } while (np->parent);
71 /* No #address-cells property for the root node */
72 return OF_ROOT_NODE_ADDR_CELLS_DEFAULT;
73 }
74 EXPORT_SYMBOL(of_n_addr_cells);
76 int of_n_size_cells(struct device_node *np)
77 {
78 const __be32 *ip;
80 do {
81 if (np->parent)
82 np = np->parent;
83 ip = of_get_property(np, "#size-cells", NULL);
84 if (ip)
85 return be32_to_cpup(ip);
86 } while (np->parent);
87 /* No #size-cells property for the root node */
88 return OF_ROOT_NODE_SIZE_CELLS_DEFAULT;
89 }
90 EXPORT_SYMBOL(of_n_size_cells);
92 #if defined(CONFIG_OF_DYNAMIC)
93 /**
94 * of_node_get - Increment refcount of a node
95 * @node: Node to inc refcount, NULL is supported to
96 * simplify writing of callers
97 *
98 * Returns node.
99 */
100 struct device_node *of_node_get(struct device_node *node)
101 {
102 if (node)
103 kref_get(&node->kref);
104 return node;
105 }
106 EXPORT_SYMBOL(of_node_get);
108 static inline struct device_node *kref_to_device_node(struct kref *kref)
109 {
110 return container_of(kref, struct device_node, kref);
111 }
113 /**
114 * of_node_release - release a dynamically allocated node
115 * @kref: kref element of the node to be released
116 *
117 * In of_node_put() this function is passed to kref_put()
118 * as the destructor.
119 */
120 static void of_node_release(struct kref *kref)
121 {
122 struct device_node *node = kref_to_device_node(kref);
123 struct property *prop = node->properties;
125 /* We should never be releasing nodes that haven't been detached. */
126 if (!of_node_check_flag(node, OF_DETACHED)) {
127 pr_err("ERROR: Bad of_node_put() on %s\n", node->full_name);
128 dump_stack();
129 kref_init(&node->kref);
130 return;
131 }
133 if (!of_node_check_flag(node, OF_DYNAMIC))
134 return;
136 while (prop) {
137 struct property *next = prop->next;
138 kfree(prop->name);
139 kfree(prop->value);
140 kfree(prop);
141 prop = next;
143 if (!prop) {
144 prop = node->deadprops;
145 node->deadprops = NULL;
146 }
147 }
148 kfree(node->full_name);
149 kfree(node->data);
150 kfree(node);
151 }
153 /**
154 * of_node_put - Decrement refcount of a node
155 * @node: Node to dec refcount, NULL is supported to
156 * simplify writing of callers
157 *
158 */
159 void of_node_put(struct device_node *node)
160 {
161 if (node)
162 kref_put(&node->kref, of_node_release);
163 }
164 EXPORT_SYMBOL(of_node_put);
165 #endif /* CONFIG_OF_DYNAMIC */
167 struct property *of_find_property(const struct device_node *np,
168 const char *name,
169 int *lenp)
170 {
171 struct property *pp;
173 if (!np)
174 return NULL;
176 read_lock(&devtree_lock);
177 for (pp = np->properties; pp; pp = pp->next) {
178 if (of_prop_cmp(pp->name, name) == 0) {
179 if (lenp)
180 *lenp = pp->length;
181 break;
182 }
183 }
184 read_unlock(&devtree_lock);
186 return pp;
187 }
188 EXPORT_SYMBOL(of_find_property);
190 /**
191 * of_find_all_nodes - Get next node in global list
192 * @prev: Previous node or NULL to start iteration
193 * of_node_put() will be called on it
194 *
195 * Returns a node pointer with refcount incremented, use
196 * of_node_put() on it when done.
197 */
198 struct device_node *of_find_all_nodes(struct device_node *prev)
199 {
200 struct device_node *np;
202 read_lock(&devtree_lock);
203 np = prev ? prev->allnext : of_allnodes;
204 for (; np != NULL; np = np->allnext)
205 if (of_node_get(np))
206 break;
207 of_node_put(prev);
208 read_unlock(&devtree_lock);
209 return np;
210 }
211 EXPORT_SYMBOL(of_find_all_nodes);
213 /*
214 * Find a property with a given name for a given node
215 * and return the value.
216 */
217 const void *of_get_property(const struct device_node *np, const char *name,
218 int *lenp)
219 {
220 struct property *pp = of_find_property(np, name, lenp);
222 return pp ? pp->value : NULL;
223 }
224 EXPORT_SYMBOL(of_get_property);
226 /** Checks if the given "compat" string matches one of the strings in
227 * the device's "compatible" property
228 */
229 int of_device_is_compatible(const struct device_node *device,
230 const char *compat)
231 {
232 const char* cp;
233 int cplen, l;
235 cp = of_get_property(device, "compatible", &cplen);
236 if (cp == NULL)
237 return 0;
238 while (cplen > 0) {
239 if (of_compat_cmp(cp, compat, strlen(compat)) == 0)
240 return 1;
241 l = strlen(cp) + 1;
242 cp += l;
243 cplen -= l;
244 }
246 return 0;
247 }
248 EXPORT_SYMBOL(of_device_is_compatible);
250 /**
251 * of_machine_is_compatible - Test root of device tree for a given compatible value
252 * @compat: compatible string to look for in root node's compatible property.
253 *
254 * Returns true if the root node has the given value in its
255 * compatible property.
256 */
257 int of_machine_is_compatible(const char *compat)
258 {
259 struct device_node *root;
260 int rc = 0;
262 root = of_find_node_by_path("/");
263 if (root) {
264 rc = of_device_is_compatible(root, compat);
265 of_node_put(root);
266 }
267 return rc;
268 }
269 EXPORT_SYMBOL(of_machine_is_compatible);
271 /**
272 * of_device_is_available - check if a device is available for use
273 *
274 * @device: Node to check for availability
275 *
276 * Returns 1 if the status property is absent or set to "okay" or "ok",
277 * 0 otherwise
278 */
279 int of_device_is_available(const struct device_node *device)
280 {
281 const char *status;
282 int statlen;
284 status = of_get_property(device, "status", &statlen);
285 if (status == NULL)
286 return 1;
288 if (statlen > 0) {
289 if (!strcmp(status, "okay") || !strcmp(status, "ok"))
290 return 1;
291 }
293 return 0;
294 }
295 EXPORT_SYMBOL(of_device_is_available);
297 /**
298 * of_get_parent - Get a node's parent if any
299 * @node: Node to get parent
300 *
301 * Returns a node pointer with refcount incremented, use
302 * of_node_put() on it when done.
303 */
304 struct device_node *of_get_parent(const struct device_node *node)
305 {
306 struct device_node *np;
308 if (!node)
309 return NULL;
311 read_lock(&devtree_lock);
312 np = of_node_get(node->parent);
313 read_unlock(&devtree_lock);
314 return np;
315 }
316 EXPORT_SYMBOL(of_get_parent);
318 /**
319 * of_get_next_parent - Iterate to a node's parent
320 * @node: Node to get parent of
321 *
322 * This is like of_get_parent() except that it drops the
323 * refcount on the passed node, making it suitable for iterating
324 * through a node's parents.
325 *
326 * Returns a node pointer with refcount incremented, use
327 * of_node_put() on it when done.
328 */
329 struct device_node *of_get_next_parent(struct device_node *node)
330 {
331 struct device_node *parent;
333 if (!node)
334 return NULL;
336 read_lock(&devtree_lock);
337 parent = of_node_get(node->parent);
338 of_node_put(node);
339 read_unlock(&devtree_lock);
340 return parent;
341 }
343 /**
344 * of_get_next_child - Iterate a node childs
345 * @node: parent node
346 * @prev: previous child of the parent node, or NULL to get first
347 *
348 * Returns a node pointer with refcount incremented, use
349 * of_node_put() on it when done.
350 */
351 struct device_node *of_get_next_child(const struct device_node *node,
352 struct device_node *prev)
353 {
354 struct device_node *next;
356 read_lock(&devtree_lock);
357 next = prev ? prev->sibling : node->child;
358 for (; next; next = next->sibling)
359 if (of_node_get(next))
360 break;
361 of_node_put(prev);
362 read_unlock(&devtree_lock);
363 return next;
364 }
365 EXPORT_SYMBOL(of_get_next_child);
367 /**
368 * of_get_next_available_child - Find the next available child node
369 * @node: parent node
370 * @prev: previous child of the parent node, or NULL to get first
371 *
372 * This function is like of_get_next_child(), except that it
373 * automatically skips any disabled nodes (i.e. status = "disabled").
374 */
375 struct device_node *of_get_next_available_child(const struct device_node *node,
376 struct device_node *prev)
377 {
378 struct device_node *next;
380 read_lock(&devtree_lock);
381 next = prev ? prev->sibling : node->child;
382 for (; next; next = next->sibling) {
383 if (!of_device_is_available(next))
384 continue;
385 if (of_node_get(next))
386 break;
387 }
388 of_node_put(prev);
389 read_unlock(&devtree_lock);
390 return next;
391 }
392 EXPORT_SYMBOL(of_get_next_available_child);
394 /**
395 * of_get_child_by_name - Find the child node by name for a given parent
396 * @node: parent node
397 * @name: child name to look for.
398 *
399 * This function looks for child node for given matching name
400 *
401 * Returns a node pointer if found, with refcount incremented, use
402 * of_node_put() on it when done.
403 * Returns NULL if node is not found.
404 */
405 struct device_node *of_get_child_by_name(const struct device_node *node,
406 const char *name)
407 {
408 struct device_node *child;
410 for_each_child_of_node(node, child)
411 if (child->name && (of_node_cmp(child->name, name) == 0))
412 break;
413 return child;
414 }
415 EXPORT_SYMBOL(of_get_child_by_name);
417 /**
418 * of_find_node_by_path - Find a node matching a full OF path
419 * @path: The full path to match
420 *
421 * Returns a node pointer with refcount incremented, use
422 * of_node_put() on it when done.
423 */
424 struct device_node *of_find_node_by_path(const char *path)
425 {
426 struct device_node *np = of_allnodes;
428 read_lock(&devtree_lock);
429 for (; np; np = np->allnext) {
430 if (np->full_name && (of_node_cmp(np->full_name, path) == 0)
431 && of_node_get(np))
432 break;
433 }
434 read_unlock(&devtree_lock);
435 return np;
436 }
437 EXPORT_SYMBOL(of_find_node_by_path);
439 /**
440 * of_find_node_by_name - Find a node by its "name" property
441 * @from: The node to start searching from or NULL, the node
442 * you pass will not be searched, only the next one
443 * will; typically, you pass what the previous call
444 * returned. of_node_put() will be called on it
445 * @name: The name string to match against
446 *
447 * Returns a node pointer with refcount incremented, use
448 * of_node_put() on it when done.
449 */
450 struct device_node *of_find_node_by_name(struct device_node *from,
451 const char *name)
452 {
453 struct device_node *np;
455 read_lock(&devtree_lock);
456 np = from ? from->allnext : of_allnodes;
457 for (; np; np = np->allnext)
458 if (np->name && (of_node_cmp(np->name, name) == 0)
459 && of_node_get(np))
460 break;
461 of_node_put(from);
462 read_unlock(&devtree_lock);
463 return np;
464 }
465 EXPORT_SYMBOL(of_find_node_by_name);
467 /**
468 * of_find_node_by_type - Find a node by its "device_type" property
469 * @from: The node to start searching from, or NULL to start searching
470 * the entire device tree. The node you pass will not be
471 * searched, only the next one will; typically, you pass
472 * what the previous call returned. of_node_put() will be
473 * called on from for you.
474 * @type: The type string to match against
475 *
476 * Returns a node pointer with refcount incremented, use
477 * of_node_put() on it when done.
478 */
479 struct device_node *of_find_node_by_type(struct device_node *from,
480 const char *type)
481 {
482 struct device_node *np;
484 read_lock(&devtree_lock);
485 np = from ? from->allnext : of_allnodes;
486 for (; np; np = np->allnext)
487 if (np->type && (of_node_cmp(np->type, type) == 0)
488 && of_node_get(np))
489 break;
490 of_node_put(from);
491 read_unlock(&devtree_lock);
492 return np;
493 }
494 EXPORT_SYMBOL(of_find_node_by_type);
496 /**
497 * of_find_compatible_node - Find a node based on type and one of the
498 * tokens in its "compatible" property
499 * @from: The node to start searching from or NULL, the node
500 * you pass will not be searched, only the next one
501 * will; typically, you pass what the previous call
502 * returned. of_node_put() will be called on it
503 * @type: The type string to match "device_type" or NULL to ignore
504 * @compatible: The string to match to one of the tokens in the device
505 * "compatible" list.
506 *
507 * Returns a node pointer with refcount incremented, use
508 * of_node_put() on it when done.
509 */
510 struct device_node *of_find_compatible_node(struct device_node *from,
511 const char *type, const char *compatible)
512 {
513 struct device_node *np;
515 read_lock(&devtree_lock);
516 np = from ? from->allnext : of_allnodes;
517 for (; np; np = np->allnext) {
518 if (type
519 && !(np->type && (of_node_cmp(np->type, type) == 0)))
520 continue;
521 if (of_device_is_compatible(np, compatible) && of_node_get(np))
522 break;
523 }
524 of_node_put(from);
525 read_unlock(&devtree_lock);
526 return np;
527 }
528 EXPORT_SYMBOL(of_find_compatible_node);
530 /**
531 * of_find_node_with_property - Find a node which has a property with
532 * the given name.
533 * @from: The node to start searching from or NULL, the node
534 * you pass will not be searched, only the next one
535 * will; typically, you pass what the previous call
536 * returned. of_node_put() will be called on it
537 * @prop_name: The name of the property to look for.
538 *
539 * Returns a node pointer with refcount incremented, use
540 * of_node_put() on it when done.
541 */
542 struct device_node *of_find_node_with_property(struct device_node *from,
543 const char *prop_name)
544 {
545 struct device_node *np;
546 struct property *pp;
548 read_lock(&devtree_lock);
549 np = from ? from->allnext : of_allnodes;
550 for (; np; np = np->allnext) {
551 for (pp = np->properties; pp; pp = pp->next) {
552 if (of_prop_cmp(pp->name, prop_name) == 0) {
553 of_node_get(np);
554 goto out;
555 }
556 }
557 }
558 out:
559 of_node_put(from);
560 read_unlock(&devtree_lock);
561 return np;
562 }
563 EXPORT_SYMBOL(of_find_node_with_property);
565 /**
566 * of_match_node - Tell if an device_node has a matching of_match structure
567 * @matches: array of of device match structures to search in
568 * @node: the of device structure to match against
569 *
570 * Low level utility function used by device matching.
571 */
572 const struct of_device_id *of_match_node(const struct of_device_id *matches,
573 const struct device_node *node)
574 {
575 if (!matches)
576 return NULL;
578 while (matches->name[0] || matches->type[0] || matches->compatible[0]) {
579 int match = 1;
580 if (matches->name[0])
581 match &= node->name
582 && !strcmp(matches->name, node->name);
583 if (matches->type[0])
584 match &= node->type
585 && !strcmp(matches->type, node->type);
586 if (matches->compatible[0])
587 match &= of_device_is_compatible(node,
588 matches->compatible);
589 if (match)
590 return matches;
591 matches++;
592 }
593 return NULL;
594 }
595 EXPORT_SYMBOL(of_match_node);
597 /**
598 * of_find_matching_node_and_match - Find a node based on an of_device_id
599 * match table.
600 * @from: The node to start searching from or NULL, the node
601 * you pass will not be searched, only the next one
602 * will; typically, you pass what the previous call
603 * returned. of_node_put() will be called on it
604 * @matches: array of of device match structures to search in
605 * @match Updated to point at the matches entry which matched
606 *
607 * Returns a node pointer with refcount incremented, use
608 * of_node_put() on it when done.
609 */
610 struct device_node *of_find_matching_node_and_match(struct device_node *from,
611 const struct of_device_id *matches,
612 const struct of_device_id **match)
613 {
614 struct device_node *np;
616 if (match)
617 *match = NULL;
619 read_lock(&devtree_lock);
620 np = from ? from->allnext : of_allnodes;
621 for (; np; np = np->allnext) {
622 if (of_match_node(matches, np) && of_node_get(np)) {
623 if (match)
624 *match = matches;
625 break;
626 }
627 }
628 of_node_put(from);
629 read_unlock(&devtree_lock);
630 return np;
631 }
632 EXPORT_SYMBOL(of_find_matching_node);
634 /**
635 * of_modalias_node - Lookup appropriate modalias for a device node
636 * @node: pointer to a device tree node
637 * @modalias: Pointer to buffer that modalias value will be copied into
638 * @len: Length of modalias value
639 *
640 * Based on the value of the compatible property, this routine will attempt
641 * to choose an appropriate modalias value for a particular device tree node.
642 * It does this by stripping the manufacturer prefix (as delimited by a ',')
643 * from the first entry in the compatible list property.
644 *
645 * This routine returns 0 on success, <0 on failure.
646 */
647 int of_modalias_node(struct device_node *node, char *modalias, int len)
648 {
649 const char *compatible, *p;
650 int cplen;
652 compatible = of_get_property(node, "compatible", &cplen);
653 if (!compatible || strlen(compatible) > cplen)
654 return -ENODEV;
655 p = strchr(compatible, ',');
656 strlcpy(modalias, p ? p + 1 : compatible, len);
657 return 0;
658 }
659 EXPORT_SYMBOL_GPL(of_modalias_node);
661 /**
662 * of_find_node_by_phandle - Find a node given a phandle
663 * @handle: phandle of the node to find
664 *
665 * Returns a node pointer with refcount incremented, use
666 * of_node_put() on it when done.
667 */
668 struct device_node *of_find_node_by_phandle(phandle handle)
669 {
670 struct device_node *np;
672 read_lock(&devtree_lock);
673 for (np = of_allnodes; np; np = np->allnext)
674 if (np->phandle == handle)
675 break;
676 of_node_get(np);
677 read_unlock(&devtree_lock);
678 return np;
679 }
680 EXPORT_SYMBOL(of_find_node_by_phandle);
682 /**
683 * of_property_read_u8_array - Find and read an array of u8 from a property.
684 *
685 * @np: device node from which the property value is to be read.
686 * @propname: name of the property to be searched.
687 * @out_value: pointer to return value, modified only if return value is 0.
688 * @sz: number of array elements to read
689 *
690 * Search for a property in a device node and read 8-bit value(s) from
691 * it. Returns 0 on success, -EINVAL if the property does not exist,
692 * -ENODATA if property does not have a value, and -EOVERFLOW if the
693 * property data isn't large enough.
694 *
695 * dts entry of array should be like:
696 * property = /bits/ 8 <0x50 0x60 0x70>;
697 *
698 * The out_value is modified only if a valid u8 value can be decoded.
699 */
700 int of_property_read_u8_array(const struct device_node *np,
701 const char *propname, u8 *out_values, size_t sz)
702 {
703 struct property *prop = of_find_property(np, propname, NULL);
704 const u8 *val;
706 if (!prop)
707 return -EINVAL;
708 if (!prop->value)
709 return -ENODATA;
710 if ((sz * sizeof(*out_values)) > prop->length)
711 return -EOVERFLOW;
713 val = prop->value;
714 while (sz--)
715 *out_values++ = *val++;
716 return 0;
717 }
718 EXPORT_SYMBOL_GPL(of_property_read_u8_array);
720 /**
721 * of_property_read_u16_array - Find and read an array of u16 from a property.
722 *
723 * @np: device node from which the property value is to be read.
724 * @propname: name of the property to be searched.
725 * @out_value: pointer to return value, modified only if return value is 0.
726 * @sz: number of array elements to read
727 *
728 * Search for a property in a device node and read 16-bit value(s) from
729 * it. Returns 0 on success, -EINVAL if the property does not exist,
730 * -ENODATA if property does not have a value, and -EOVERFLOW if the
731 * property data isn't large enough.
732 *
733 * dts entry of array should be like:
734 * property = /bits/ 16 <0x5000 0x6000 0x7000>;
735 *
736 * The out_value is modified only if a valid u16 value can be decoded.
737 */
738 int of_property_read_u16_array(const struct device_node *np,
739 const char *propname, u16 *out_values, size_t sz)
740 {
741 struct property *prop = of_find_property(np, propname, NULL);
742 const __be16 *val;
744 if (!prop)
745 return -EINVAL;
746 if (!prop->value)
747 return -ENODATA;
748 if ((sz * sizeof(*out_values)) > prop->length)
749 return -EOVERFLOW;
751 val = prop->value;
752 while (sz--)
753 *out_values++ = be16_to_cpup(val++);
754 return 0;
755 }
756 EXPORT_SYMBOL_GPL(of_property_read_u16_array);
758 /**
759 * of_property_read_u32_array - Find and read an array of 32 bit integers
760 * from a property.
761 *
762 * @np: device node from which the property value is to be read.
763 * @propname: name of the property to be searched.
764 * @out_value: pointer to return value, modified only if return value is 0.
765 * @sz: number of array elements to read
766 *
767 * Search for a property in a device node and read 32-bit value(s) from
768 * it. Returns 0 on success, -EINVAL if the property does not exist,
769 * -ENODATA if property does not have a value, and -EOVERFLOW if the
770 * property data isn't large enough.
771 *
772 * The out_value is modified only if a valid u32 value can be decoded.
773 */
774 int of_property_read_u32_array(const struct device_node *np,
775 const char *propname, u32 *out_values,
776 size_t sz)
777 {
778 struct property *prop = of_find_property(np, propname, NULL);
779 const __be32 *val;
781 if (!prop)
782 return -EINVAL;
783 if (!prop->value)
784 return -ENODATA;
785 if ((sz * sizeof(*out_values)) > prop->length)
786 return -EOVERFLOW;
788 val = prop->value;
789 while (sz--)
790 *out_values++ = be32_to_cpup(val++);
791 return 0;
792 }
793 EXPORT_SYMBOL_GPL(of_property_read_u32_array);
795 /**
796 * of_property_read_u64 - Find and read a 64 bit integer from a property
797 * @np: device node from which the property value is to be read.
798 * @propname: name of the property to be searched.
799 * @out_value: pointer to return value, modified only if return value is 0.
800 *
801 * Search for a property in a device node and read a 64-bit value from
802 * it. Returns 0 on success, -EINVAL if the property does not exist,
803 * -ENODATA if property does not have a value, and -EOVERFLOW if the
804 * property data isn't large enough.
805 *
806 * The out_value is modified only if a valid u64 value can be decoded.
807 */
808 int of_property_read_u64(const struct device_node *np, const char *propname,
809 u64 *out_value)
810 {
811 struct property *prop = of_find_property(np, propname, NULL);
813 if (!prop)
814 return -EINVAL;
815 if (!prop->value)
816 return -ENODATA;
817 if (sizeof(*out_value) > prop->length)
818 return -EOVERFLOW;
819 *out_value = of_read_number(prop->value, 2);
820 return 0;
821 }
822 EXPORT_SYMBOL_GPL(of_property_read_u64);
824 /**
825 * of_property_read_string - Find and read a string from a property
826 * @np: device node from which the property value is to be read.
827 * @propname: name of the property to be searched.
828 * @out_string: pointer to null terminated return string, modified only if
829 * return value is 0.
830 *
831 * Search for a property in a device tree node and retrieve a null
832 * terminated string value (pointer to data, not a copy). Returns 0 on
833 * success, -EINVAL if the property does not exist, -ENODATA if property
834 * does not have a value, and -EILSEQ if the string is not null-terminated
835 * within the length of the property data.
836 *
837 * The out_string pointer is modified only if a valid string can be decoded.
838 */
839 int of_property_read_string(struct device_node *np, const char *propname,
840 const char **out_string)
841 {
842 struct property *prop = of_find_property(np, propname, NULL);
843 if (!prop)
844 return -EINVAL;
845 if (!prop->value)
846 return -ENODATA;
847 if (strnlen(prop->value, prop->length) >= prop->length)
848 return -EILSEQ;
849 *out_string = prop->value;
850 return 0;
851 }
852 EXPORT_SYMBOL_GPL(of_property_read_string);
854 /**
855 * of_property_read_string_index - Find and read a string from a multiple
856 * strings property.
857 * @np: device node from which the property value is to be read.
858 * @propname: name of the property to be searched.
859 * @index: index of the string in the list of strings
860 * @out_string: pointer to null terminated return string, modified only if
861 * return value is 0.
862 *
863 * Search for a property in a device tree node and retrieve a null
864 * terminated string value (pointer to data, not a copy) in the list of strings
865 * contained in that property.
866 * Returns 0 on success, -EINVAL if the property does not exist, -ENODATA if
867 * property does not have a value, and -EILSEQ if the string is not
868 * null-terminated within the length of the property data.
869 *
870 * The out_string pointer is modified only if a valid string can be decoded.
871 */
872 int of_property_read_string_index(struct device_node *np, const char *propname,
873 int index, const char **output)
874 {
875 struct property *prop = of_find_property(np, propname, NULL);
876 int i = 0;
877 size_t l = 0, total = 0;
878 const char *p;
880 if (!prop)
881 return -EINVAL;
882 if (!prop->value)
883 return -ENODATA;
884 if (strnlen(prop->value, prop->length) >= prop->length)
885 return -EILSEQ;
887 p = prop->value;
889 for (i = 0; total < prop->length; total += l, p += l) {
890 l = strlen(p) + 1;
891 if (i++ == index) {
892 *output = p;
893 return 0;
894 }
895 }
896 return -ENODATA;
897 }
898 EXPORT_SYMBOL_GPL(of_property_read_string_index);
900 /**
901 * of_property_match_string() - Find string in a list and return index
902 * @np: pointer to node containing string list property
903 * @propname: string list property name
904 * @string: pointer to string to search for in string list
905 *
906 * This function searches a string list property and returns the index
907 * of a specific string value.
908 */
909 int of_property_match_string(struct device_node *np, const char *propname,
910 const char *string)
911 {
912 struct property *prop = of_find_property(np, propname, NULL);
913 size_t l;
914 int i;
915 const char *p, *end;
917 if (!prop)
918 return -EINVAL;
919 if (!prop->value)
920 return -ENODATA;
922 p = prop->value;
923 end = p + prop->length;
925 for (i = 0; p < end; i++, p += l) {
926 l = strlen(p) + 1;
927 if (p + l > end)
928 return -EILSEQ;
929 pr_debug("comparing %s with %s\n", string, p);
930 if (strcmp(string, p) == 0)
931 return i; /* Found it; return index */
932 }
933 return -ENODATA;
934 }
935 EXPORT_SYMBOL_GPL(of_property_match_string);
937 /**
938 * of_property_count_strings - Find and return the number of strings from a
939 * multiple strings property.
940 * @np: device node from which the property value is to be read.
941 * @propname: name of the property to be searched.
942 *
943 * Search for a property in a device tree node and retrieve the number of null
944 * terminated string contain in it. Returns the number of strings on
945 * success, -EINVAL if the property does not exist, -ENODATA if property
946 * does not have a value, and -EILSEQ if the string is not null-terminated
947 * within the length of the property data.
948 */
949 int of_property_count_strings(struct device_node *np, const char *propname)
950 {
951 struct property *prop = of_find_property(np, propname, NULL);
952 int i = 0;
953 size_t l = 0, total = 0;
954 const char *p;
956 if (!prop)
957 return -EINVAL;
958 if (!prop->value)
959 return -ENODATA;
960 if (strnlen(prop->value, prop->length) >= prop->length)
961 return -EILSEQ;
963 p = prop->value;
965 for (i = 0; total < prop->length; total += l, p += l, i++)
966 l = strlen(p) + 1;
968 return i;
969 }
970 EXPORT_SYMBOL_GPL(of_property_count_strings);
972 /**
973 * of_parse_phandle - Resolve a phandle property to a device_node pointer
974 * @np: Pointer to device node holding phandle property
975 * @phandle_name: Name of property holding a phandle value
976 * @index: For properties holding a table of phandles, this is the index into
977 * the table
978 *
979 * Returns the device_node pointer with refcount incremented. Use
980 * of_node_put() on it when done.
981 */
982 struct device_node *of_parse_phandle(const struct device_node *np,
983 const char *phandle_name, int index)
984 {
985 const __be32 *phandle;
986 int size;
988 phandle = of_get_property(np, phandle_name, &size);
989 if ((!phandle) || (size < sizeof(*phandle) * (index + 1)))
990 return NULL;
992 return of_find_node_by_phandle(be32_to_cpup(phandle + index));
993 }
994 EXPORT_SYMBOL(of_parse_phandle);
996 /**
997 * of_parse_phandle_with_args() - Find a node pointed by phandle in a list
998 * @np: pointer to a device tree node containing a list
999 * @list_name: property name that contains a list
1000 * @cells_name: property name that specifies phandles' arguments count
1001 * @index: index of a phandle to parse out
1002 * @out_args: optional pointer to output arguments structure (will be filled)
1003 *
1004 * This function is useful to parse lists of phandles and their arguments.
1005 * Returns 0 on success and fills out_args, on error returns appropriate
1006 * errno value.
1007 *
1008 * Caller is responsible to call of_node_put() on the returned out_args->node
1009 * pointer.
1010 *
1011 * Example:
1012 *
1013 * phandle1: node1 {
1014 * #list-cells = <2>;
1015 * }
1016 *
1017 * phandle2: node2 {
1018 * #list-cells = <1>;
1019 * }
1020 *
1021 * node3 {
1022 * list = <&phandle1 1 2 &phandle2 3>;
1023 * }
1024 *
1025 * To get a device_node of the `node2' node you may call this:
1026 * of_parse_phandle_with_args(node3, "list", "#list-cells", 1, &args);
1027 */
1028 int of_parse_phandle_with_args(const struct device_node *np, const char *list_name,
1029 const char *cells_name, int index,
1030 struct of_phandle_args *out_args)
1031 {
1032 const __be32 *list, *list_end;
1033 int size, cur_index = 0;
1034 uint32_t count = 0;
1035 struct device_node *node = NULL;
1036 phandle phandle;
1038 /* Retrieve the phandle list property */
1039 list = of_get_property(np, list_name, &size);
1040 if (!list)
1041 return -ENOENT;
1042 list_end = list + size / sizeof(*list);
1044 /* Loop over the phandles until all the requested entry is found */
1045 while (list < list_end) {
1046 count = 0;
1048 /*
1049 * If phandle is 0, then it is an empty entry with no
1050 * arguments. Skip forward to the next entry.
1051 */
1052 phandle = be32_to_cpup(list++);
1053 if (phandle) {
1054 /*
1055 * Find the provider node and parse the #*-cells
1056 * property to determine the argument length
1057 */
1058 node = of_find_node_by_phandle(phandle);
1059 if (!node) {
1060 pr_err("%s: could not find phandle\n",
1061 np->full_name);
1062 break;
1063 }
1064 if (of_property_read_u32(node, cells_name, &count)) {
1065 pr_err("%s: could not get %s for %s\n",
1066 np->full_name, cells_name,
1067 node->full_name);
1068 break;
1069 }
1071 /*
1072 * Make sure that the arguments actually fit in the
1073 * remaining property data length
1074 */
1075 if (list + count > list_end) {
1076 pr_err("%s: arguments longer than property\n",
1077 np->full_name);
1078 break;
1079 }
1080 }
1082 /*
1083 * All of the error cases above bail out of the loop, so at
1084 * this point, the parsing is successful. If the requested
1085 * index matches, then fill the out_args structure and return,
1086 * or return -ENOENT for an empty entry.
1087 */
1088 if (cur_index == index) {
1089 if (!phandle)
1090 return -ENOENT;
1092 if (out_args) {
1093 int i;
1094 if (WARN_ON(count > MAX_PHANDLE_ARGS))
1095 count = MAX_PHANDLE_ARGS;
1096 out_args->np = node;
1097 out_args->args_count = count;
1098 for (i = 0; i < count; i++)
1099 out_args->args[i] = be32_to_cpup(list++);
1100 }
1101 return 0;
1102 }
1104 of_node_put(node);
1105 node = NULL;
1106 list += count;
1107 cur_index++;
1108 }
1110 /* Loop exited without finding a valid entry; return an error */
1111 if (node)
1112 of_node_put(node);
1113 return -EINVAL;
1114 }
1115 EXPORT_SYMBOL(of_parse_phandle_with_args);
1117 /**
1118 * prom_add_property - Add a property to a node
1119 */
1120 int prom_add_property(struct device_node *np, struct property *prop)
1121 {
1122 struct property **next;
1123 unsigned long flags;
1125 prop->next = NULL;
1126 write_lock_irqsave(&devtree_lock, flags);
1127 next = &np->properties;
1128 while (*next) {
1129 if (strcmp(prop->name, (*next)->name) == 0) {
1130 /* duplicate ! don't insert it */
1131 write_unlock_irqrestore(&devtree_lock, flags);
1132 return -1;
1133 }
1134 next = &(*next)->next;
1135 }
1136 *next = prop;
1137 write_unlock_irqrestore(&devtree_lock, flags);
1139 #ifdef CONFIG_PROC_DEVICETREE
1140 /* try to add to proc as well if it was initialized */
1141 if (np->pde)
1142 proc_device_tree_add_prop(np->pde, prop);
1143 #endif /* CONFIG_PROC_DEVICETREE */
1145 return 0;
1146 }
1148 /**
1149 * prom_remove_property - Remove a property from a node.
1150 *
1151 * Note that we don't actually remove it, since we have given out
1152 * who-knows-how-many pointers to the data using get-property.
1153 * Instead we just move the property to the "dead properties"
1154 * list, so it won't be found any more.
1155 */
1156 int prom_remove_property(struct device_node *np, struct property *prop)
1157 {
1158 struct property **next;
1159 unsigned long flags;
1160 int found = 0;
1162 write_lock_irqsave(&devtree_lock, flags);
1163 next = &np->properties;
1164 while (*next) {
1165 if (*next == prop) {
1166 /* found the node */
1167 *next = prop->next;
1168 prop->next = np->deadprops;
1169 np->deadprops = prop;
1170 found = 1;
1171 break;
1172 }
1173 next = &(*next)->next;
1174 }
1175 write_unlock_irqrestore(&devtree_lock, flags);
1177 if (!found)
1178 return -ENODEV;
1180 #ifdef CONFIG_PROC_DEVICETREE
1181 /* try to remove the proc node as well */
1182 if (np->pde)
1183 proc_device_tree_remove_prop(np->pde, prop);
1184 #endif /* CONFIG_PROC_DEVICETREE */
1186 return 0;
1187 }
1189 /*
1190 * prom_update_property - Update a property in a node, if the property does
1191 * not exist, add it.
1192 *
1193 * Note that we don't actually remove it, since we have given out
1194 * who-knows-how-many pointers to the data using get-property.
1195 * Instead we just move the property to the "dead properties" list,
1196 * and add the new property to the property list
1197 */
1198 int prom_update_property(struct device_node *np,
1199 struct property *newprop)
1200 {
1201 struct property **next, *oldprop;
1202 unsigned long flags;
1203 int found = 0;
1205 if (!newprop->name)
1206 return -EINVAL;
1208 oldprop = of_find_property(np, newprop->name, NULL);
1209 if (!oldprop)
1210 return prom_add_property(np, newprop);
1212 write_lock_irqsave(&devtree_lock, flags);
1213 next = &np->properties;
1214 while (*next) {
1215 if (*next == oldprop) {
1216 /* found the node */
1217 newprop->next = oldprop->next;
1218 *next = newprop;
1219 oldprop->next = np->deadprops;
1220 np->deadprops = oldprop;
1221 found = 1;
1222 break;
1223 }
1224 next = &(*next)->next;
1225 }
1226 write_unlock_irqrestore(&devtree_lock, flags);
1228 if (!found)
1229 return -ENODEV;
1231 #ifdef CONFIG_PROC_DEVICETREE
1232 /* try to add to proc as well if it was initialized */
1233 if (np->pde)
1234 proc_device_tree_update_prop(np->pde, newprop, oldprop);
1235 #endif /* CONFIG_PROC_DEVICETREE */
1237 return 0;
1238 }
1240 #if defined(CONFIG_OF_DYNAMIC)
1241 /*
1242 * Support for dynamic device trees.
1243 *
1244 * On some platforms, the device tree can be manipulated at runtime.
1245 * The routines in this section support adding, removing and changing
1246 * device tree nodes.
1247 */
1249 /**
1250 * of_attach_node - Plug a device node into the tree and global list.
1251 */
1252 void of_attach_node(struct device_node *np)
1253 {
1254 unsigned long flags;
1256 write_lock_irqsave(&devtree_lock, flags);
1257 np->sibling = np->parent->child;
1258 np->allnext = of_allnodes;
1259 np->parent->child = np;
1260 of_allnodes = np;
1261 write_unlock_irqrestore(&devtree_lock, flags);
1262 }
1264 /**
1265 * of_detach_node - "Unplug" a node from the device tree.
1266 *
1267 * The caller must hold a reference to the node. The memory associated with
1268 * the node is not freed until its refcount goes to zero.
1269 */
1270 void of_detach_node(struct device_node *np)
1271 {
1272 struct device_node *parent;
1273 unsigned long flags;
1275 write_lock_irqsave(&devtree_lock, flags);
1277 parent = np->parent;
1278 if (!parent)
1279 goto out_unlock;
1281 if (of_allnodes == np)
1282 of_allnodes = np->allnext;
1283 else {
1284 struct device_node *prev;
1285 for (prev = of_allnodes;
1286 prev->allnext != np;
1287 prev = prev->allnext)
1288 ;
1289 prev->allnext = np->allnext;
1290 }
1292 if (parent->child == np)
1293 parent->child = np->sibling;
1294 else {
1295 struct device_node *prevsib;
1296 for (prevsib = np->parent->child;
1297 prevsib->sibling != np;
1298 prevsib = prevsib->sibling)
1299 ;
1300 prevsib->sibling = np->sibling;
1301 }
1303 of_node_set_flag(np, OF_DETACHED);
1305 out_unlock:
1306 write_unlock_irqrestore(&devtree_lock, flags);
1307 }
1308 #endif /* defined(CONFIG_OF_DYNAMIC) */
1310 static void of_alias_add(struct alias_prop *ap, struct device_node *np,
1311 int id, const char *stem, int stem_len)
1312 {
1313 ap->np = np;
1314 ap->id = id;
1315 strncpy(ap->stem, stem, stem_len);
1316 ap->stem[stem_len] = 0;
1317 list_add_tail(&ap->link, &aliases_lookup);
1318 pr_debug("adding DT alias:%s: stem=%s id=%i node=%s\n",
1319 ap->alias, ap->stem, ap->id, of_node_full_name(np));
1320 }
1322 /**
1323 * of_alias_scan - Scan all properties of 'aliases' node
1324 *
1325 * The function scans all the properties of 'aliases' node and populate
1326 * the the global lookup table with the properties. It returns the
1327 * number of alias_prop found, or error code in error case.
1328 *
1329 * @dt_alloc: An allocator that provides a virtual address to memory
1330 * for the resulting tree
1331 */
1332 void of_alias_scan(void * (*dt_alloc)(u64 size, u64 align))
1333 {
1334 struct property *pp;
1336 of_chosen = of_find_node_by_path("/chosen");
1337 if (of_chosen == NULL)
1338 of_chosen = of_find_node_by_path("/chosen@0");
1339 of_aliases = of_find_node_by_path("/aliases");
1340 if (!of_aliases)
1341 return;
1343 for_each_property_of_node(of_aliases, pp) {
1344 const char *start = pp->name;
1345 const char *end = start + strlen(start);
1346 struct device_node *np;
1347 struct alias_prop *ap;
1348 int id, len;
1350 /* Skip those we do not want to proceed */
1351 if (!strcmp(pp->name, "name") ||
1352 !strcmp(pp->name, "phandle") ||
1353 !strcmp(pp->name, "linux,phandle"))
1354 continue;
1356 np = of_find_node_by_path(pp->value);
1357 if (!np)
1358 continue;
1360 /* walk the alias backwards to extract the id and work out
1361 * the 'stem' string */
1362 while (isdigit(*(end-1)) && end > start)
1363 end--;
1364 len = end - start;
1366 if (kstrtoint(end, 10, &id) < 0)
1367 continue;
1369 /* Allocate an alias_prop with enough space for the stem */
1370 ap = dt_alloc(sizeof(*ap) + len + 1, 4);
1371 if (!ap)
1372 continue;
1373 ap->alias = start;
1374 of_alias_add(ap, np, id, start, len);
1375 }
1376 }
1378 /**
1379 * of_alias_get_id - Get alias id for the given device_node
1380 * @np: Pointer to the given device_node
1381 * @stem: Alias stem of the given device_node
1382 *
1383 * The function travels the lookup table to get alias id for the given
1384 * device_node and alias stem. It returns the alias id if find it.
1385 */
1386 int of_alias_get_id(struct device_node *np, const char *stem)
1387 {
1388 struct alias_prop *app;
1389 int id = -ENODEV;
1391 mutex_lock(&of_aliases_mutex);
1392 list_for_each_entry(app, &aliases_lookup, link) {
1393 if (strcmp(app->stem, stem) != 0)
1394 continue;
1396 if (np == app->np) {
1397 id = app->id;
1398 break;
1399 }
1400 }
1401 mutex_unlock(&of_aliases_mutex);
1403 return id;
1404 }
1405 EXPORT_SYMBOL_GPL(of_alias_get_id);
1407 const __be32 *of_prop_next_u32(struct property *prop, const __be32 *cur,
1408 u32 *pu)
1409 {
1410 const void *curv = cur;
1412 if (!prop)
1413 return NULL;
1415 if (!cur) {
1416 curv = prop->value;
1417 goto out_val;
1418 }
1420 curv += sizeof(*cur);
1421 if (curv >= prop->value + prop->length)
1422 return NULL;
1424 out_val:
1425 *pu = be32_to_cpup(curv);
1426 return curv;
1427 }
1428 EXPORT_SYMBOL_GPL(of_prop_next_u32);
1430 const char *of_prop_next_string(struct property *prop, const char *cur)
1431 {
1432 const void *curv = cur;
1434 if (!prop)
1435 return NULL;
1437 if (!cur)
1438 return prop->value;
1440 curv += strlen(cur) + 1;
1441 if (curv >= prop->value + prop->length)
1442 return NULL;
1444 return curv;
1445 }
1446 EXPORT_SYMBOL_GPL(of_prop_next_string);