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 device_node
* __init
build_tree(struct device_node
*parent
, phandle node
, struct device_node
***nextp
)
404 struct device_node
*ret
= NULL
, *prev_sibling
= NULL
;
405 struct device_node
*dp
;
408 dp
= create_node(node
, parent
);
413 prev_sibling
->sibling
= dp
;
420 *nextp
= &dp
->allnext
;
422 dp
->path_component_name
= build_path_component(dp
);
423 dp
->full_name
= build_full_name(dp
);
425 dp
->child
= build_tree(dp
, prom_getchild(node
), nextp
);
427 node
= prom_getsibling(node
);
433 static const char *get_mid_prop(void)
435 return (tlb_type
== spitfire
? "upa-portid" : "portid");
438 struct device_node
*of_find_node_by_cpuid(int cpuid
)
440 struct device_node
*dp
;
441 const char *mid_prop
= get_mid_prop();
443 for_each_node_by_type(dp
, "cpu") {
444 int id
= of_getintprop_default(dp
, mid_prop
, -1);
445 const char *this_mid_prop
= mid_prop
;
448 this_mid_prop
= "cpuid";
449 id
= of_getintprop_default(dp
, this_mid_prop
, -1);
453 prom_printf("OF: Serious problem, cpu lacks "
454 "%s property", this_mid_prop
);
463 static void __init
of_fill_in_cpu_data(void)
465 struct device_node
*dp
;
466 const char *mid_prop
= get_mid_prop();
469 for_each_node_by_type(dp
, "cpu") {
470 int cpuid
= of_getintprop_default(dp
, mid_prop
, -1);
471 const char *this_mid_prop
= mid_prop
;
472 struct device_node
*portid_parent
;
475 portid_parent
= NULL
;
477 this_mid_prop
= "cpuid";
478 cpuid
= of_getintprop_default(dp
, this_mid_prop
, -1);
484 portid_parent
= portid_parent
->parent
;
487 portid
= of_getintprop_default(portid_parent
,
496 prom_printf("OF: Serious problem, cpu lacks "
497 "%s property", this_mid_prop
);
504 if (cpuid
>= NR_CPUS
) {
505 printk(KERN_WARNING
"Ignoring CPU %d which is "
511 /* On uniprocessor we only want the values for the
512 * real physical cpu the kernel booted onto, however
513 * cpu_data() only has one entry at index 0.
515 if (cpuid
!= real_hard_smp_processor_id())
520 cpu_data(cpuid
).clock_tick
=
521 of_getintprop_default(dp
, "clock-frequency", 0);
524 cpu_data(cpuid
).dcache_size
=
525 of_getintprop_default(dp
, "l1-dcache-size",
527 cpu_data(cpuid
).dcache_line_size
=
528 of_getintprop_default(dp
, "l1-dcache-line-size",
530 cpu_data(cpuid
).icache_size
=
531 of_getintprop_default(dp
, "l1-icache-size",
533 cpu_data(cpuid
).icache_line_size
=
534 of_getintprop_default(dp
, "l1-icache-line-size",
536 cpu_data(cpuid
).ecache_size
=
537 of_getintprop_default(dp
, "l2-cache-size", 0);
538 cpu_data(cpuid
).ecache_line_size
=
539 of_getintprop_default(dp
, "l2-cache-line-size", 0);
540 if (!cpu_data(cpuid
).ecache_size
||
541 !cpu_data(cpuid
).ecache_line_size
) {
542 cpu_data(cpuid
).ecache_size
=
543 of_getintprop_default(portid_parent
,
546 cpu_data(cpuid
).ecache_line_size
=
547 of_getintprop_default(portid_parent
,
548 "l2-cache-line-size", 64);
551 cpu_data(cpuid
).core_id
= portid
+ 1;
552 cpu_data(cpuid
).proc_id
= portid
;
554 sparc64_multi_core
= 1;
557 cpu_data(cpuid
).dcache_size
=
558 of_getintprop_default(dp
, "dcache-size", 16 * 1024);
559 cpu_data(cpuid
).dcache_line_size
=
560 of_getintprop_default(dp
, "dcache-line-size", 32);
562 cpu_data(cpuid
).icache_size
=
563 of_getintprop_default(dp
, "icache-size", 16 * 1024);
564 cpu_data(cpuid
).icache_line_size
=
565 of_getintprop_default(dp
, "icache-line-size", 32);
567 cpu_data(cpuid
).ecache_size
=
568 of_getintprop_default(dp
, "ecache-size",
570 cpu_data(cpuid
).ecache_line_size
=
571 of_getintprop_default(dp
, "ecache-line-size", 64);
573 cpu_data(cpuid
).core_id
= 0;
574 cpu_data(cpuid
).proc_id
= -1;
578 cpu_set(cpuid
, cpu_present_map
);
579 cpu_set(cpuid
, cpu_possible_map
);
583 smp_fill_in_sib_core_maps();
586 struct device_node
*of_console_device
;
587 EXPORT_SYMBOL(of_console_device
);
589 char *of_console_path
;
590 EXPORT_SYMBOL(of_console_path
);
592 char *of_console_options
;
593 EXPORT_SYMBOL(of_console_options
);
595 static void __init
of_console_init(void)
597 char *msg
= "OF stdout device is: %s\n";
598 struct device_node
*dp
;
602 of_console_path
= prom_early_alloc(256);
603 if (prom_ihandle2path(prom_stdout
, of_console_path
, 256) < 0) {
604 prom_printf("Cannot obtain path of stdout.\n");
607 of_console_options
= strrchr(of_console_path
, ':');
608 if (of_console_options
) {
609 of_console_options
++;
610 if (*of_console_options
== '\0')
611 of_console_options
= NULL
;
614 node
= prom_inst2pkg(prom_stdout
);
616 prom_printf("Cannot resolve stdout node from "
617 "instance %08x.\n", prom_stdout
);
621 dp
= of_find_node_by_phandle(node
);
622 type
= of_get_property(dp
, "device_type", NULL
);
624 prom_printf("Console stdout lacks device_type property.\n");
628 if (strcmp(type
, "display") && strcmp(type
, "serial")) {
629 prom_printf("Console device_type is neither display "
634 of_console_device
= dp
;
636 printk(msg
, of_console_path
);
639 void __init
prom_build_devicetree(void)
641 struct device_node
**nextp
;
643 allnodes
= create_node(prom_root_node
, NULL
);
644 allnodes
->path_component_name
= "";
645 allnodes
->full_name
= "/";
647 nextp
= &allnodes
->allnext
;
648 allnodes
->child
= build_tree(allnodes
,
649 prom_getchild(allnodes
->node
),
653 printk("PROM: Built device tree with %u bytes of memory.\n",
654 prom_early_allocated
);
656 if (tlb_type
!= hypervisor
)
657 of_fill_in_cpu_data();