2 * Procedures for creating, accessing and interpreting the device tree.
4 * Paul Mackerras August 1996.
5 * Copyright (C) 1996-2005 Paul Mackerras.
7 * Adapted for 64bit PowerPC by Dave Engebretsen and Peter Bergner.
8 * {engebret|bergner}@us.ibm.com
10 * Adapted for sparc64 by David S. Miller davem@davemloft.net
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation; either version
15 * 2 of the License, or (at your option) any later version.
18 #include <linux/kernel.h>
19 #include <linux/types.h>
20 #include <linux/string.h>
22 #include <linux/module.h>
23 #include <linux/lmb.h>
24 #include <linux/of_device.h>
27 #include <asm/oplib.h>
35 static unsigned int prom_early_allocated __initdata
;
37 void * __init
prom_early_alloc(unsigned long size
)
39 unsigned long paddr
= lmb_alloc(size
, SMP_CACHE_BYTES
);
43 prom_printf("prom_early_alloc(%lu) failed\n");
49 prom_early_allocated
+= size
;
54 static int is_root_node(const struct device_node
*dp
)
59 return (dp
->parent
== NULL
);
62 /* The following routines deal with the black magic of fully naming a
65 * Certain well known named nodes are just the simple name string.
67 * Actual devices have an address specifier appended to the base name
68 * string, like this "foo@addr". The "addr" can be in any number of
69 * formats, and the platform plus the type of the node determine the
70 * format and how it is constructed.
72 * For children of the ROOT node, the naming convention is fixed and
73 * determined by whether this is a sun4u or sun4v system.
75 * For children of other nodes, it is bus type specific. So
76 * we walk up the tree until we discover a "device_type" property
77 * we recognize and we go from there.
79 * As an example, the boot device on my workstation has a full path:
81 * /pci@1e,600000/ide@d/disk@0,0:c
83 static void __init
sun4v_path_component(struct device_node
*dp
, char *tmp_buf
)
85 struct linux_prom64_registers
*regs
;
86 struct property
*rprop
;
87 u32 high_bits
, low_bits
, type
;
89 rprop
= of_find_property(dp
, "reg", NULL
);
94 if (!is_root_node(dp
->parent
)) {
95 sprintf(tmp_buf
, "%s@%x,%x",
97 (unsigned int) (regs
->phys_addr
>> 32UL),
98 (unsigned int) (regs
->phys_addr
& 0xffffffffUL
));
102 type
= regs
->phys_addr
>> 60UL;
103 high_bits
= (regs
->phys_addr
>> 32UL) & 0x0fffffffUL
;
104 low_bits
= (regs
->phys_addr
& 0xffffffffUL
);
106 if (type
== 0 || type
== 8) {
107 const char *prefix
= (type
== 0) ? "m" : "i";
110 sprintf(tmp_buf
, "%s@%s%x,%x",
112 high_bits
, low_bits
);
114 sprintf(tmp_buf
, "%s@%s%x",
118 } else if (type
== 12) {
119 sprintf(tmp_buf
, "%s@%x",
120 dp
->name
, high_bits
);
124 static void __init
sun4u_path_component(struct device_node
*dp
, char *tmp_buf
)
126 struct linux_prom64_registers
*regs
;
127 struct property
*prop
;
129 prop
= of_find_property(dp
, "reg", NULL
);
134 if (!is_root_node(dp
->parent
)) {
135 sprintf(tmp_buf
, "%s@%x,%x",
137 (unsigned int) (regs
->phys_addr
>> 32UL),
138 (unsigned int) (regs
->phys_addr
& 0xffffffffUL
));
142 prop
= of_find_property(dp
, "upa-portid", NULL
);
144 prop
= of_find_property(dp
, "portid", NULL
);
146 unsigned long mask
= 0xffffffffUL
;
148 if (tlb_type
>= cheetah
)
151 sprintf(tmp_buf
, "%s@%x,%x",
154 (unsigned int) (regs
->phys_addr
& mask
));
158 /* "name@slot,offset" */
159 static void __init
sbus_path_component(struct device_node
*dp
, char *tmp_buf
)
161 struct linux_prom_registers
*regs
;
162 struct property
*prop
;
164 prop
= of_find_property(dp
, "reg", NULL
);
169 sprintf(tmp_buf
, "%s@%x,%x",
175 /* "name@devnum[,func]" */
176 static void __init
pci_path_component(struct device_node
*dp
, char *tmp_buf
)
178 struct linux_prom_pci_registers
*regs
;
179 struct property
*prop
;
182 prop
= of_find_property(dp
, "reg", NULL
);
187 devfn
= (regs
->phys_hi
>> 8) & 0xff;
189 sprintf(tmp_buf
, "%s@%x,%x",
194 sprintf(tmp_buf
, "%s@%x",
200 /* "name@UPA_PORTID,offset" */
201 static void __init
upa_path_component(struct device_node
*dp
, char *tmp_buf
)
203 struct linux_prom64_registers
*regs
;
204 struct property
*prop
;
206 prop
= of_find_property(dp
, "reg", NULL
);
212 prop
= of_find_property(dp
, "upa-portid", NULL
);
216 sprintf(tmp_buf
, "%s@%x,%x",
218 *(u32
*) prop
->value
,
219 (unsigned int) (regs
->phys_addr
& 0xffffffffUL
));
223 static void __init
vdev_path_component(struct device_node
*dp
, char *tmp_buf
)
225 struct property
*prop
;
228 prop
= of_find_property(dp
, "reg", NULL
);
234 sprintf(tmp_buf
, "%s@%x", dp
->name
, *regs
);
237 /* "name@addrhi,addrlo" */
238 static void __init
ebus_path_component(struct device_node
*dp
, char *tmp_buf
)
240 struct linux_prom64_registers
*regs
;
241 struct property
*prop
;
243 prop
= of_find_property(dp
, "reg", NULL
);
249 sprintf(tmp_buf
, "%s@%x,%x",
251 (unsigned int) (regs
->phys_addr
>> 32UL),
252 (unsigned int) (regs
->phys_addr
& 0xffffffffUL
));
255 /* "name@bus,addr" */
256 static void __init
i2c_path_component(struct device_node
*dp
, char *tmp_buf
)
258 struct property
*prop
;
261 prop
= of_find_property(dp
, "reg", NULL
);
267 /* This actually isn't right... should look at the #address-cells
268 * property of the i2c bus node etc. etc.
270 sprintf(tmp_buf
, "%s@%x,%x",
271 dp
->name
, regs
[0], regs
[1]);
274 /* "name@reg0[,reg1]" */
275 static void __init
usb_path_component(struct device_node
*dp
, char *tmp_buf
)
277 struct property
*prop
;
280 prop
= of_find_property(dp
, "reg", NULL
);
286 if (prop
->length
== sizeof(u32
) || regs
[1] == 1) {
287 sprintf(tmp_buf
, "%s@%x",
290 sprintf(tmp_buf
, "%s@%x,%x",
291 dp
->name
, regs
[0], regs
[1]);
295 /* "name@reg0reg1[,reg2reg3]" */
296 static void __init
ieee1394_path_component(struct device_node
*dp
, char *tmp_buf
)
298 struct property
*prop
;
301 prop
= of_find_property(dp
, "reg", NULL
);
307 if (regs
[2] || regs
[3]) {
308 sprintf(tmp_buf
, "%s@%08x%08x,%04x%08x",
309 dp
->name
, regs
[0], regs
[1], regs
[2], regs
[3]);
311 sprintf(tmp_buf
, "%s@%08x%08x",
312 dp
->name
, regs
[0], regs
[1]);
316 static void __init
__build_path_component(struct device_node
*dp
, char *tmp_buf
)
318 struct device_node
*parent
= dp
->parent
;
320 if (parent
!= NULL
) {
321 if (!strcmp(parent
->type
, "pci") ||
322 !strcmp(parent
->type
, "pciex")) {
323 pci_path_component(dp
, tmp_buf
);
326 if (!strcmp(parent
->type
, "sbus")) {
327 sbus_path_component(dp
, tmp_buf
);
330 if (!strcmp(parent
->type
, "upa")) {
331 upa_path_component(dp
, tmp_buf
);
334 if (!strcmp(parent
->type
, "ebus")) {
335 ebus_path_component(dp
, tmp_buf
);
338 if (!strcmp(parent
->name
, "usb") ||
339 !strcmp(parent
->name
, "hub")) {
340 usb_path_component(dp
, tmp_buf
);
343 if (!strcmp(parent
->type
, "i2c")) {
344 i2c_path_component(dp
, tmp_buf
);
347 if (!strcmp(parent
->type
, "firewire")) {
348 ieee1394_path_component(dp
, tmp_buf
);
351 if (!strcmp(parent
->type
, "virtual-devices")) {
352 vdev_path_component(dp
, tmp_buf
);
355 /* "isa" is handled with platform naming */
358 /* Use platform naming convention. */
359 if (tlb_type
== hypervisor
) {
360 sun4v_path_component(dp
, tmp_buf
);
363 sun4u_path_component(dp
, tmp_buf
);
367 static char * __init
build_path_component(struct device_node
*dp
)
369 char tmp_buf
[64], *n
;
372 __build_path_component(dp
, tmp_buf
);
373 if (tmp_buf
[0] == '\0')
374 strcpy(tmp_buf
, dp
->name
);
376 n
= prom_early_alloc(strlen(tmp_buf
) + 1);
382 static char * __init
build_full_name(struct device_node
*dp
)
384 int len
, ourlen
, plen
;
387 plen
= strlen(dp
->parent
->full_name
);
388 ourlen
= strlen(dp
->path_component_name
);
389 len
= ourlen
+ plen
+ 2;
391 n
= prom_early_alloc(len
);
392 strcpy(n
, dp
->parent
->full_name
);
393 if (!is_root_node(dp
->parent
)) {
394 strcpy(n
+ plen
, "/");
397 strcpy(n
+ plen
, dp
->path_component_name
);
402 static struct property
* __init
build_one_prop(phandle node
, char *prev
, char *special_name
, void *special_val
, int special_len
)
404 static struct property
*tmp
= NULL
;
409 memset(p
, 0, sizeof(*p
) + 32);
412 p
= prom_early_alloc(sizeof(struct property
) + 32);
413 p
->unique_id
= prom_unique_id
++;
416 p
->name
= (char *) (p
+ 1);
418 strcpy(p
->name
, special_name
);
419 p
->length
= special_len
;
420 p
->value
= prom_early_alloc(special_len
);
421 memcpy(p
->value
, special_val
, special_len
);
424 prom_firstprop(node
, p
->name
);
426 prom_nextprop(node
, prev
, p
->name
);
428 if (strlen(p
->name
) == 0) {
432 p
->length
= prom_getproplen(node
, p
->name
);
433 if (p
->length
<= 0) {
436 p
->value
= prom_early_alloc(p
->length
+ 1);
437 prom_getproperty(node
, p
->name
, p
->value
, p
->length
);
438 ((unsigned char *)p
->value
)[p
->length
] = '\0';
444 static struct property
* __init
build_prop_list(phandle node
)
446 struct property
*head
, *tail
;
448 head
= tail
= build_one_prop(node
, NULL
,
449 ".node", &node
, sizeof(node
));
451 tail
->next
= build_one_prop(node
, NULL
, NULL
, NULL
, 0);
454 tail
->next
= build_one_prop(node
, tail
->name
,
462 static char * __init
get_one_property(phandle node
, const char *name
)
464 char *buf
= "<NULL>";
467 len
= prom_getproplen(node
, name
);
469 buf
= prom_early_alloc(len
);
470 prom_getproperty(node
, name
, buf
, len
);
476 static struct device_node
* __init
create_node(phandle node
, struct device_node
*parent
)
478 struct device_node
*dp
;
483 dp
= prom_early_alloc(sizeof(*dp
));
484 dp
->unique_id
= prom_unique_id
++;
487 kref_init(&dp
->kref
);
489 dp
->name
= get_one_property(node
, "name");
490 dp
->type
= get_one_property(node
, "device_type");
493 dp
->properties
= build_prop_list(node
);
500 static struct device_node
* __init
build_tree(struct device_node
*parent
, phandle node
, struct device_node
***nextp
)
502 struct device_node
*ret
= NULL
, *prev_sibling
= NULL
;
503 struct device_node
*dp
;
506 dp
= create_node(node
, parent
);
511 prev_sibling
->sibling
= dp
;
518 *nextp
= &dp
->allnext
;
520 dp
->path_component_name
= build_path_component(dp
);
521 dp
->full_name
= build_full_name(dp
);
523 dp
->child
= build_tree(dp
, prom_getchild(node
), nextp
);
525 node
= prom_getsibling(node
);
531 static const char *get_mid_prop(void)
533 return (tlb_type
== spitfire
? "upa-portid" : "portid");
536 struct device_node
*of_find_node_by_cpuid(int cpuid
)
538 struct device_node
*dp
;
539 const char *mid_prop
= get_mid_prop();
541 for_each_node_by_type(dp
, "cpu") {
542 int id
= of_getintprop_default(dp
, mid_prop
, -1);
543 const char *this_mid_prop
= mid_prop
;
546 this_mid_prop
= "cpuid";
547 id
= of_getintprop_default(dp
, this_mid_prop
, -1);
551 prom_printf("OF: Serious problem, cpu lacks "
552 "%s property", this_mid_prop
);
561 static void __init
of_fill_in_cpu_data(void)
563 struct device_node
*dp
;
564 const char *mid_prop
= get_mid_prop();
567 for_each_node_by_type(dp
, "cpu") {
568 int cpuid
= of_getintprop_default(dp
, mid_prop
, -1);
569 const char *this_mid_prop
= mid_prop
;
570 struct device_node
*portid_parent
;
573 portid_parent
= NULL
;
575 this_mid_prop
= "cpuid";
576 cpuid
= of_getintprop_default(dp
, this_mid_prop
, -1);
582 portid_parent
= portid_parent
->parent
;
585 portid
= of_getintprop_default(portid_parent
,
594 prom_printf("OF: Serious problem, cpu lacks "
595 "%s property", this_mid_prop
);
602 if (cpuid
>= NR_CPUS
) {
603 printk(KERN_WARNING
"Ignoring CPU %d which is "
609 /* On uniprocessor we only want the values for the
610 * real physical cpu the kernel booted onto, however
611 * cpu_data() only has one entry at index 0.
613 if (cpuid
!= real_hard_smp_processor_id())
618 cpu_data(cpuid
).clock_tick
=
619 of_getintprop_default(dp
, "clock-frequency", 0);
622 cpu_data(cpuid
).dcache_size
=
623 of_getintprop_default(dp
, "l1-dcache-size",
625 cpu_data(cpuid
).dcache_line_size
=
626 of_getintprop_default(dp
, "l1-dcache-line-size",
628 cpu_data(cpuid
).icache_size
=
629 of_getintprop_default(dp
, "l1-icache-size",
631 cpu_data(cpuid
).icache_line_size
=
632 of_getintprop_default(dp
, "l1-icache-line-size",
634 cpu_data(cpuid
).ecache_size
=
635 of_getintprop_default(dp
, "l2-cache-size", 0);
636 cpu_data(cpuid
).ecache_line_size
=
637 of_getintprop_default(dp
, "l2-cache-line-size", 0);
638 if (!cpu_data(cpuid
).ecache_size
||
639 !cpu_data(cpuid
).ecache_line_size
) {
640 cpu_data(cpuid
).ecache_size
=
641 of_getintprop_default(portid_parent
,
644 cpu_data(cpuid
).ecache_line_size
=
645 of_getintprop_default(portid_parent
,
646 "l2-cache-line-size", 64);
649 cpu_data(cpuid
).core_id
= portid
+ 1;
650 cpu_data(cpuid
).proc_id
= portid
;
652 sparc64_multi_core
= 1;
655 cpu_data(cpuid
).dcache_size
=
656 of_getintprop_default(dp
, "dcache-size", 16 * 1024);
657 cpu_data(cpuid
).dcache_line_size
=
658 of_getintprop_default(dp
, "dcache-line-size", 32);
660 cpu_data(cpuid
).icache_size
=
661 of_getintprop_default(dp
, "icache-size", 16 * 1024);
662 cpu_data(cpuid
).icache_line_size
=
663 of_getintprop_default(dp
, "icache-line-size", 32);
665 cpu_data(cpuid
).ecache_size
=
666 of_getintprop_default(dp
, "ecache-size",
668 cpu_data(cpuid
).ecache_line_size
=
669 of_getintprop_default(dp
, "ecache-line-size", 64);
671 cpu_data(cpuid
).core_id
= 0;
672 cpu_data(cpuid
).proc_id
= -1;
676 cpu_set(cpuid
, cpu_present_map
);
677 cpu_set(cpuid
, cpu_possible_map
);
681 smp_fill_in_sib_core_maps();
684 struct device_node
*of_console_device
;
685 EXPORT_SYMBOL(of_console_device
);
687 char *of_console_path
;
688 EXPORT_SYMBOL(of_console_path
);
690 char *of_console_options
;
691 EXPORT_SYMBOL(of_console_options
);
693 static void __init
of_console_init(void)
695 char *msg
= "OF stdout device is: %s\n";
696 struct device_node
*dp
;
700 of_console_path
= prom_early_alloc(256);
701 if (prom_ihandle2path(prom_stdout
, of_console_path
, 256) < 0) {
702 prom_printf("Cannot obtain path of stdout.\n");
705 of_console_options
= strrchr(of_console_path
, ':');
706 if (of_console_options
) {
707 of_console_options
++;
708 if (*of_console_options
== '\0')
709 of_console_options
= NULL
;
712 node
= prom_inst2pkg(prom_stdout
);
714 prom_printf("Cannot resolve stdout node from "
715 "instance %08x.\n", prom_stdout
);
719 dp
= of_find_node_by_phandle(node
);
720 type
= of_get_property(dp
, "device_type", NULL
);
722 prom_printf("Console stdout lacks device_type property.\n");
726 if (strcmp(type
, "display") && strcmp(type
, "serial")) {
727 prom_printf("Console device_type is neither display "
732 of_console_device
= dp
;
734 printk(msg
, of_console_path
);
737 void __init
prom_build_devicetree(void)
739 struct device_node
**nextp
;
741 allnodes
= create_node(prom_root_node
, NULL
);
742 allnodes
->path_component_name
= "";
743 allnodes
->full_name
= "/";
745 nextp
= &allnodes
->allnext
;
746 allnodes
->child
= build_tree(allnodes
,
747 prom_getchild(allnodes
->node
),
751 printk("PROM: Built device tree with %u bytes of memory.\n",
752 prom_early_allocated
);
754 if (tlb_type
!= hypervisor
)
755 of_fill_in_cpu_data();