1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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>
26
27
28
29
30
31
32
33
34
35
36
37
38struct alias_prop {
39 struct list_head link;
40 const char *alias;
41 struct device_node *np;
42 int id;
43 char stem[0];
44};
45
46static LIST_HEAD(aliases_lookup);
47
48struct device_node *of_allnodes;
49EXPORT_SYMBOL(of_allnodes);
50struct device_node *of_chosen;
51struct device_node *of_aliases;
52
53static DEFINE_MUTEX(of_aliases_mutex);
54
55
56
57
58DEFINE_RWLOCK(devtree_lock);
59
60int of_n_addr_cells(struct device_node *np)
61{
62 const __be32 *ip;
63
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
72 return OF_ROOT_NODE_ADDR_CELLS_DEFAULT;
73}
74EXPORT_SYMBOL(of_n_addr_cells);
75
76int of_n_size_cells(struct device_node *np)
77{
78 const __be32 *ip;
79
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
88 return OF_ROOT_NODE_SIZE_CELLS_DEFAULT;
89}
90EXPORT_SYMBOL(of_n_size_cells);
91
92#if defined(CONFIG_OF_DYNAMIC)
93
94
95
96
97
98
99
100struct device_node *of_node_get(struct device_node *node)
101{
102 if (node)
103 kref_get(&node->kref);
104 return node;
105}
106EXPORT_SYMBOL(of_node_get);
107
108static inline struct device_node *kref_to_device_node(struct kref *kref)
109{
110 return container_of(kref, struct device_node, kref);
111}
112
113
114
115
116
117
118
119
120static void of_node_release(struct kref *kref)
121{
122 struct device_node *node = kref_to_device_node(kref);
123 struct property *prop = node->properties;
124
125
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 }
132
133 if (!of_node_check_flag(node, OF_DYNAMIC))
134 return;
135
136 while (prop) {
137 struct property *next = prop->next;
138 kfree(prop->name);
139 kfree(prop->value);
140 kfree(prop);
141 prop = next;
142
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}
152
153
154
155
156
157
158
159void of_node_put(struct device_node *node)
160{
161 if (node)
162 kref_put(&node->kref, of_node_release);
163}
164EXPORT_SYMBOL(of_node_put);
165#endif
166
167struct property *of_find_property(const struct device_node *np,
168 const char *name,
169 int *lenp)
170{
171 struct property *pp;
172
173 if (!np)
174 return NULL;
175
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);
185
186 return pp;
187}
188EXPORT_SYMBOL(of_find_property);
189
190
191
192
193
194
195
196
197
198struct device_node *of_find_all_nodes(struct device_node *prev)
199{
200 struct device_node *np;
201
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}
211EXPORT_SYMBOL(of_find_all_nodes);
212
213
214
215
216
217const 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);
221
222 return pp ? pp->value : NULL;
223}
224EXPORT_SYMBOL(of_get_property);
225
226
227
228
229int of_device_is_compatible(const struct device_node *device,
230 const char *compat)
231{
232 const char* cp;
233 int cplen, l;
234
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 }
245
246 return 0;
247}
248EXPORT_SYMBOL(of_device_is_compatible);
249
250
251
252
253
254
255
256
257int of_machine_is_compatible(const char *compat)
258{
259 struct device_node *root;
260 int rc = 0;
261
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}
269EXPORT_SYMBOL(of_machine_is_compatible);
270
271
272
273
274
275
276
277
278
279int of_device_is_available(const struct device_node *device)
280{
281 const char *status;
282 int statlen;
283
284 status = of_get_property(device, "status", &statlen);
285 if (status == NULL)
286 return 1;
287
288 if (statlen > 0) {
289 if (!strcmp(status, "okay") || !strcmp(status, "ok"))
290 return 1;
291 }
292
293 return 0;
294}
295EXPORT_SYMBOL(of_device_is_available);
296
297
298
299
300
301
302
303
304struct device_node *of_get_parent(const struct device_node *node)
305{
306 struct device_node *np;
307
308 if (!node)
309 return NULL;
310
311 read_lock(&devtree_lock);
312 np = of_node_get(node->parent);
313 read_unlock(&devtree_lock);
314 return np;
315}
316EXPORT_SYMBOL(of_get_parent);
317
318
319
320
321
322
323
324
325
326
327
328
329struct device_node *of_get_next_parent(struct device_node *node)
330{
331 struct device_node *parent;
332
333 if (!node)
334 return NULL;
335
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}
342
343
344
345
346
347
348
349
350
351struct device_node *of_get_next_child(const struct device_node *node,
352 struct device_node *prev)
353{
354 struct device_node *next;
355
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}
365EXPORT_SYMBOL(of_get_next_child);
366
367
368
369
370
371
372
373
374
375struct device_node *of_get_next_available_child(const struct device_node *node,
376 struct device_node *prev)
377{
378 struct device_node *next;
379
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}
392EXPORT_SYMBOL(of_get_next_available_child);
393
394
395
396
397
398
399
400
401
402
403
404
405struct device_node *of_get_child_by_name(const struct device_node *node,
406 const char *name)
407{
408 struct device_node *child;
409
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}
415EXPORT_SYMBOL(of_get_child_by_name);
416
417
418
419
420
421
422
423
424struct device_node *of_find_node_by_path(const char *path)
425{
426 struct device_node *np = of_allnodes;
427
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}
437EXPORT_SYMBOL(of_find_node_by_path);
438
439
440
441
442
443
444
445
446
447
448
449
450struct device_node *of_find_node_by_name(struct device_node *from,
451 const char *name)
452{
453 struct device_node *np;
454
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}
465EXPORT_SYMBOL(of_find_node_by_name);
466
467
468
469
470
471
472
473
474
475
476
477
478
479struct device_node *of_find_node_by_type(struct device_node *from,
480 const char *type)
481{
482 struct device_node *np;
483
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}
494EXPORT_SYMBOL(of_find_node_by_type);
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510struct device_node *of_find_compatible_node(struct device_node *from,
511 const char *type, const char *compatible)
512{
513 struct device_node *np;
514
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}
528EXPORT_SYMBOL(of_find_compatible_node);
529
530
531
532
533
534
535
536
537
538
539
540
541
542struct 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;
547
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 }
558out:
559 of_node_put(from);
560 read_unlock(&devtree_lock);
561 return np;
562}
563EXPORT_SYMBOL(of_find_node_with_property);
564
565
566
567
568
569
570
571
572const 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;
577
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}
595EXPORT_SYMBOL(of_match_node);
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610struct 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;
615
616 if (match)
617 *match = NULL;
618
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}
632EXPORT_SYMBOL(of_find_matching_node_and_match);
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647int of_modalias_node(struct device_node *node, char *modalias, int len)
648{
649 const char *compatible, *p;
650 int cplen;
651
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}
659EXPORT_SYMBOL_GPL(of_modalias_node);
660
661
662
663
664
665
666
667
668struct device_node *of_find_node_by_phandle(phandle handle)
669{
670 struct device_node *np;
671
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}
680EXPORT_SYMBOL(of_find_node_by_phandle);
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700int 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;
705
706 if (!prop)
707 return -EINVAL;
708 if (!prop->value)
709 return -ENODATA;
710 if ((sz * sizeof(*out_values)) > prop->length)
711 return -EOVERFLOW;
712
713 val = prop->value;
714 while (sz--)
715 *out_values++ = *val++;
716 return 0;
717}
718EXPORT_SYMBOL_GPL(of_property_read_u8_array);
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738int 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;
743
744 if (!prop)
745 return -EINVAL;
746 if (!prop->value)
747 return -ENODATA;
748 if ((sz * sizeof(*out_values)) > prop->length)
749 return -EOVERFLOW;
750
751 val = prop->value;
752 while (sz--)
753 *out_values++ = be16_to_cpup(val++);
754 return 0;
755}
756EXPORT_SYMBOL_GPL(of_property_read_u16_array);
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774int 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;
780
781 if (!prop)
782 return -EINVAL;
783 if (!prop->value)
784 return -ENODATA;
785 if ((sz * sizeof(*out_values)) > prop->length)
786 return -EOVERFLOW;
787
788 val = prop->value;
789 while (sz--)
790 *out_values++ = be32_to_cpup(val++);
791 return 0;
792}
793EXPORT_SYMBOL_GPL(of_property_read_u32_array);
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808int 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);
812
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}
822EXPORT_SYMBOL_GPL(of_property_read_u64);
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839int 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}
852EXPORT_SYMBOL_GPL(of_property_read_string);
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872int 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;
879
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;
886
887 p = prop->value;
888
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}
898EXPORT_SYMBOL_GPL(of_property_read_string_index);
899
900
901
902
903
904
905
906
907
908
909int 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;
916
917 if (!prop)
918 return -EINVAL;
919 if (!prop->value)
920 return -ENODATA;
921
922 p = prop->value;
923 end = p + prop->length;
924
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;
932 }
933 return -ENODATA;
934}
935EXPORT_SYMBOL_GPL(of_property_match_string);
936
937
938
939
940
941
942
943
944
945
946
947
948
949int 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;
955
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;
962
963 p = prop->value;
964
965 for (i = 0; total < prop->length; total += l, p += l, i++)
966 l = strlen(p) + 1;
967
968 return i;
969}
970EXPORT_SYMBOL_GPL(of_property_count_strings);
971
972
973
974
975
976
977
978
979
980
981
982struct 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;
987
988 phandle = of_get_property(np, phandle_name, &size);
989 if ((!phandle) || (size < sizeof(*phandle) * (index + 1)))
990 return NULL;
991
992 return of_find_node_by_phandle(be32_to_cpup(phandle + index));
993}
994EXPORT_SYMBOL(of_parse_phandle);
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028int 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;
1037
1038
1039 list = of_get_property(np, list_name, &size);
1040 if (!list)
1041 return -ENOENT;
1042 list_end = list + size / sizeof(*list);
1043
1044
1045 while (list < list_end) {
1046 count = 0;
1047
1048
1049
1050
1051
1052 phandle = be32_to_cpup(list++);
1053 if (phandle) {
1054
1055
1056
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 }
1070
1071
1072
1073
1074
1075 if (list + count > list_end) {
1076 pr_err("%s: arguments longer than property\n",
1077 np->full_name);
1078 break;
1079 }
1080 }
1081
1082
1083
1084
1085
1086
1087
1088 if (cur_index == index) {
1089 if (!phandle)
1090 return -ENOENT;
1091
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 }
1103
1104 of_node_put(node);
1105 node = NULL;
1106 list += count;
1107 cur_index++;
1108 }
1109
1110
1111 if (node)
1112 of_node_put(node);
1113 return -EINVAL;
1114}
1115EXPORT_SYMBOL(of_parse_phandle_with_args);
1116
1117#if defined(CONFIG_OF_DYNAMIC)
1118static int of_property_notify(int action, struct device_node *np,
1119 struct property *prop)
1120{
1121 struct of_prop_reconfig pr;
1122
1123 pr.dn = np;
1124 pr.prop = prop;
1125 return of_reconfig_notify(action, &pr);
1126}
1127#else
1128static int of_property_notify(int action, struct device_node *np,
1129 struct property *prop)
1130{
1131 return 0;
1132}
1133#endif
1134
1135
1136
1137
1138int of_add_property(struct device_node *np, struct property *prop)
1139{
1140 struct property **next;
1141 unsigned long flags;
1142 int rc;
1143
1144 rc = of_property_notify(OF_RECONFIG_ADD_PROPERTY, np, prop);
1145 if (rc)
1146 return rc;
1147
1148 prop->next = NULL;
1149 write_lock_irqsave(&devtree_lock, flags);
1150 next = &np->properties;
1151 while (*next) {
1152 if (strcmp(prop->name, (*next)->name) == 0) {
1153
1154 write_unlock_irqrestore(&devtree_lock, flags);
1155 return -1;
1156 }
1157 next = &(*next)->next;
1158 }
1159 *next = prop;
1160 write_unlock_irqrestore(&devtree_lock, flags);
1161
1162#ifdef CONFIG_PROC_DEVICETREE
1163
1164 if (np->pde)
1165 proc_device_tree_add_prop(np->pde, prop);
1166#endif
1167
1168 return 0;
1169}
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179int of_remove_property(struct device_node *np, struct property *prop)
1180{
1181 struct property **next;
1182 unsigned long flags;
1183 int found = 0;
1184 int rc;
1185
1186 rc = of_property_notify(OF_RECONFIG_REMOVE_PROPERTY, np, prop);
1187 if (rc)
1188 return rc;
1189
1190 write_lock_irqsave(&devtree_lock, flags);
1191 next = &np->properties;
1192 while (*next) {
1193 if (*next == prop) {
1194
1195 *next = prop->next;
1196 prop->next = np->deadprops;
1197 np->deadprops = prop;
1198 found = 1;
1199 break;
1200 }
1201 next = &(*next)->next;
1202 }
1203 write_unlock_irqrestore(&devtree_lock, flags);
1204
1205 if (!found)
1206 return -ENODEV;
1207
1208#ifdef CONFIG_PROC_DEVICETREE
1209
1210 if (np->pde)
1211 proc_device_tree_remove_prop(np->pde, prop);
1212#endif
1213
1214 return 0;
1215}
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226int of_update_property(struct device_node *np, struct property *newprop)
1227{
1228 struct property **next, *oldprop;
1229 unsigned long flags;
1230 int rc, found = 0;
1231
1232 rc = of_property_notify(OF_RECONFIG_UPDATE_PROPERTY, np, newprop);
1233 if (rc)
1234 return rc;
1235
1236 if (!newprop->name)
1237 return -EINVAL;
1238
1239 oldprop = of_find_property(np, newprop->name, NULL);
1240 if (!oldprop)
1241 return of_add_property(np, newprop);
1242
1243 write_lock_irqsave(&devtree_lock, flags);
1244 next = &np->properties;
1245 while (*next) {
1246 if (*next == oldprop) {
1247
1248 newprop->next = oldprop->next;
1249 *next = newprop;
1250 oldprop->next = np->deadprops;
1251 np->deadprops = oldprop;
1252 found = 1;
1253 break;
1254 }
1255 next = &(*next)->next;
1256 }
1257 write_unlock_irqrestore(&devtree_lock, flags);
1258
1259 if (!found)
1260 return -ENODEV;
1261
1262#ifdef CONFIG_PROC_DEVICETREE
1263
1264 if (np->pde)
1265 proc_device_tree_update_prop(np->pde, newprop, oldprop);
1266#endif
1267
1268 return 0;
1269}
1270
1271#if defined(CONFIG_OF_DYNAMIC)
1272
1273
1274
1275
1276
1277
1278
1279
1280static BLOCKING_NOTIFIER_HEAD(of_reconfig_chain);
1281
1282int of_reconfig_notifier_register(struct notifier_block *nb)
1283{
1284 return blocking_notifier_chain_register(&of_reconfig_chain, nb);
1285}
1286EXPORT_SYMBOL_GPL(of_reconfig_notifier_register);
1287
1288int of_reconfig_notifier_unregister(struct notifier_block *nb)
1289{
1290 return blocking_notifier_chain_unregister(&of_reconfig_chain, nb);
1291}
1292EXPORT_SYMBOL_GPL(of_reconfig_notifier_unregister);
1293
1294int of_reconfig_notify(unsigned long action, void *p)
1295{
1296 int rc;
1297
1298 rc = blocking_notifier_call_chain(&of_reconfig_chain, action, p);
1299 return notifier_to_errno(rc);
1300}
1301
1302#ifdef CONFIG_PROC_DEVICETREE
1303static void of_add_proc_dt_entry(struct device_node *dn)
1304{
1305 struct proc_dir_entry *ent;
1306
1307 ent = proc_mkdir(strrchr(dn->full_name, '/') + 1, dn->parent->pde);
1308 if (ent)
1309 proc_device_tree_add_node(dn, ent);
1310}
1311#else
1312static void of_add_proc_dt_entry(struct device_node *dn)
1313{
1314 return;
1315}
1316#endif
1317
1318
1319
1320
1321int of_attach_node(struct device_node *np)
1322{
1323 unsigned long flags;
1324 int rc;
1325
1326 rc = of_reconfig_notify(OF_RECONFIG_ATTACH_NODE, np);
1327 if (rc)
1328 return rc;
1329
1330 write_lock_irqsave(&devtree_lock, flags);
1331 np->sibling = np->parent->child;
1332 np->allnext = of_allnodes;
1333 np->parent->child = np;
1334 of_allnodes = np;
1335 write_unlock_irqrestore(&devtree_lock, flags);
1336
1337 of_add_proc_dt_entry(np);
1338 return 0;
1339}
1340
1341#ifdef CONFIG_PROC_DEVICETREE
1342static void of_remove_proc_dt_entry(struct device_node *dn)
1343{
1344 struct device_node *parent = dn->parent;
1345 struct property *prop = dn->properties;
1346
1347 while (prop) {
1348 remove_proc_entry(prop->name, dn->pde);
1349 prop = prop->next;
1350 }
1351
1352 if (dn->pde)
1353 remove_proc_entry(dn->pde->name, parent->pde);
1354}
1355#else
1356static void of_remove_proc_dt_entry(struct device_node *dn)
1357{
1358 return;
1359}
1360#endif
1361
1362
1363
1364
1365
1366
1367
1368int of_detach_node(struct device_node *np)
1369{
1370 struct device_node *parent;
1371 unsigned long flags;
1372 int rc = 0;
1373
1374 rc = of_reconfig_notify(OF_RECONFIG_DETACH_NODE, np);
1375 if (rc)
1376 return rc;
1377
1378 write_lock_irqsave(&devtree_lock, flags);
1379
1380 if (of_node_check_flag(np, OF_DETACHED)) {
1381
1382 write_unlock_irqrestore(&devtree_lock, flags);
1383 return rc;
1384 }
1385
1386 parent = np->parent;
1387 if (!parent) {
1388 write_unlock_irqrestore(&devtree_lock, flags);
1389 return rc;
1390 }
1391
1392 if (of_allnodes == np)
1393 of_allnodes = np->allnext;
1394 else {
1395 struct device_node *prev;
1396 for (prev = of_allnodes;
1397 prev->allnext != np;
1398 prev = prev->allnext)
1399 ;
1400 prev->allnext = np->allnext;
1401 }
1402
1403 if (parent->child == np)
1404 parent->child = np->sibling;
1405 else {
1406 struct device_node *prevsib;
1407 for (prevsib = np->parent->child;
1408 prevsib->sibling != np;
1409 prevsib = prevsib->sibling)
1410 ;
1411 prevsib->sibling = np->sibling;
1412 }
1413
1414 of_node_set_flag(np, OF_DETACHED);
1415 write_unlock_irqrestore(&devtree_lock, flags);
1416
1417 of_remove_proc_dt_entry(np);
1418 return rc;
1419}
1420#endif
1421
1422static void of_alias_add(struct alias_prop *ap, struct device_node *np,
1423 int id, const char *stem, int stem_len)
1424{
1425 ap->np = np;
1426 ap->id = id;
1427 strncpy(ap->stem, stem, stem_len);
1428 ap->stem[stem_len] = 0;
1429 list_add_tail(&ap->link, &aliases_lookup);
1430 pr_debug("adding DT alias:%s: stem=%s id=%i node=%s\n",
1431 ap->alias, ap->stem, ap->id, of_node_full_name(np));
1432}
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444void of_alias_scan(void * (*dt_alloc)(u64 size, u64 align))
1445{
1446 struct property *pp;
1447
1448 of_chosen = of_find_node_by_path("/chosen");
1449 if (of_chosen == NULL)
1450 of_chosen = of_find_node_by_path("/chosen@0");
1451 of_aliases = of_find_node_by_path("/aliases");
1452 if (!of_aliases)
1453 return;
1454
1455 for_each_property_of_node(of_aliases, pp) {
1456 const char *start = pp->name;
1457 const char *end = start + strlen(start);
1458 struct device_node *np;
1459 struct alias_prop *ap;
1460 int id, len;
1461
1462
1463 if (!strcmp(pp->name, "name") ||
1464 !strcmp(pp->name, "phandle") ||
1465 !strcmp(pp->name, "linux,phandle"))
1466 continue;
1467
1468 np = of_find_node_by_path(pp->value);
1469 if (!np)
1470 continue;
1471
1472
1473
1474 while (isdigit(*(end-1)) && end > start)
1475 end--;
1476 len = end - start;
1477
1478 if (kstrtoint(end, 10, &id) < 0)
1479 continue;
1480
1481
1482 ap = dt_alloc(sizeof(*ap) + len + 1, 4);
1483 if (!ap)
1484 continue;
1485 ap->alias = start;
1486 of_alias_add(ap, np, id, start, len);
1487 }
1488}
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498int of_alias_get_id(struct device_node *np, const char *stem)
1499{
1500 struct alias_prop *app;
1501 int id = -ENODEV;
1502
1503 mutex_lock(&of_aliases_mutex);
1504 list_for_each_entry(app, &aliases_lookup, link) {
1505 if (strcmp(app->stem, stem) != 0)
1506 continue;
1507
1508 if (np == app->np) {
1509 id = app->id;
1510 break;
1511 }
1512 }
1513 mutex_unlock(&of_aliases_mutex);
1514
1515 return id;
1516}
1517EXPORT_SYMBOL_GPL(of_alias_get_id);
1518
1519const __be32 *of_prop_next_u32(struct property *prop, const __be32 *cur,
1520 u32 *pu)
1521{
1522 const void *curv = cur;
1523
1524 if (!prop)
1525 return NULL;
1526
1527 if (!cur) {
1528 curv = prop->value;
1529 goto out_val;
1530 }
1531
1532 curv += sizeof(*cur);
1533 if (curv >= prop->value + prop->length)
1534 return NULL;
1535
1536out_val:
1537 *pu = be32_to_cpup(curv);
1538 return curv;
1539}
1540EXPORT_SYMBOL_GPL(of_prop_next_u32);
1541
1542const char *of_prop_next_string(struct property *prop, const char *cur)
1543{
1544 const void *curv = cur;
1545
1546 if (!prop)
1547 return NULL;
1548
1549 if (!cur)
1550 return prop->value;
1551
1552 curv += strlen(cur) + 1;
1553 if (curv >= prop->value + prop->length)
1554 return NULL;
1555
1556 return curv;
1557}
1558EXPORT_SYMBOL_GPL(of_prop_next_string);
1559