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();