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