1 /* 2 * Procedures for creating, accessing and interpreting the device tree. 3 * 4 * Paul Mackerras August 1996. 5 * Copyright (C) 1996-2005 Paul Mackerras. 6 * 7 * Adapted for 64bit PowerPC by Dave Engebretsen and Peter Bergner. 8 * {engebret|bergner}@us.ibm.com 9 * 10 * Adapted for sparc64 by David S. Miller davem@davemloft.net 11 * 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. 16 */ 17 18 #include <linux/kernel.h> 19 #include <linux/types.h> 20 #include <linux/string.h> 21 #include <linux/mm.h> 22 #include <linux/module.h> 23 #include <linux/lmb.h> 24 #include <linux/of_device.h> 25 26 #include <asm/prom.h> 27 #include <asm/oplib.h> 28 #include <asm/irq.h> 29 #include <asm/asi.h> 30 #include <asm/upa.h> 31 #include <asm/smp.h> 32 33 #include "prom.h" 34 35 void * __init prom_early_alloc(unsigned long size) 36 { 37 unsigned long paddr = lmb_alloc(size, SMP_CACHE_BYTES); 38 void *ret; 39 40 if (!paddr) { 41 prom_printf("prom_early_alloc(%lu) failed\n"); 42 prom_halt(); 43 } 44 45 ret = __va(paddr); 46 memset(ret, 0, size); 47 prom_early_allocated += size; 48 49 return ret; 50 } 51 52 /* The following routines deal with the black magic of fully naming a 53 * node. 54 * 55 * Certain well known named nodes are just the simple name string. 56 * 57 * Actual devices have an address specifier appended to the base name 58 * string, like this "foo@addr". The "addr" can be in any number of 59 * formats, and the platform plus the type of the node determine the 60 * format and how it is constructed. 61 * 62 * For children of the ROOT node, the naming convention is fixed and 63 * determined by whether this is a sun4u or sun4v system. 64 * 65 * For children of other nodes, it is bus type specific. So 66 * we walk up the tree until we discover a "device_type" property 67 * we recognize and we go from there. 68 * 69 * As an example, the boot device on my workstation has a full path: 70 * 71 * /pci@1e,600000/ide@d/disk@0,0:c 72 */ 73 static void __init sun4v_path_component(struct device_node *dp, char *tmp_buf) 74 { 75 struct linux_prom64_registers *regs; 76 struct property *rprop; 77 u32 high_bits, low_bits, type; 78 79 rprop = of_find_property(dp, "reg", NULL); 80 if (!rprop) 81 return; 82 83 regs = rprop->value; 84 if (!is_root_node(dp->parent)) { 85 sprintf(tmp_buf, "%s@%x,%x", 86 dp->name, 87 (unsigned int) (regs->phys_addr >> 32UL), 88 (unsigned int) (regs->phys_addr & 0xffffffffUL)); 89 return; 90 } 91 92 type = regs->phys_addr >> 60UL; 93 high_bits = (regs->phys_addr >> 32UL) & 0x0fffffffUL; 94 low_bits = (regs->phys_addr & 0xffffffffUL); 95 96 if (type == 0 || type == 8) { 97 const char *prefix = (type == 0) ? "m" : "i"; 98 99 if (low_bits) 100 sprintf(tmp_buf, "%s@%s%x,%x", 101 dp->name, prefix, 102 high_bits, low_bits); 103 else 104 sprintf(tmp_buf, "%s@%s%x", 105 dp->name, 106 prefix, 107 high_bits); 108 } else if (type == 12) { 109 sprintf(tmp_buf, "%s@%x", 110 dp->name, high_bits); 111 } 112 } 113 114 static void __init sun4u_path_component(struct device_node *dp, char *tmp_buf) 115 { 116 struct linux_prom64_registers *regs; 117 struct property *prop; 118 119 prop = of_find_property(dp, "reg", NULL); 120 if (!prop) 121 return; 122 123 regs = prop->value; 124 if (!is_root_node(dp->parent)) { 125 sprintf(tmp_buf, "%s@%x,%x", 126 dp->name, 127 (unsigned int) (regs->phys_addr >> 32UL), 128 (unsigned int) (regs->phys_addr & 0xffffffffUL)); 129 return; 130 } 131 132 prop = of_find_property(dp, "upa-portid", NULL); 133 if (!prop) 134 prop = of_find_property(dp, "portid", NULL); 135 if (prop) { 136 unsigned long mask = 0xffffffffUL; 137 138 if (tlb_type >= cheetah) 139 mask = 0x7fffff; 140 141 sprintf(tmp_buf, "%s@%x,%x", 142 dp->name, 143 *(u32 *)prop->value, 144 (unsigned int) (regs->phys_addr & mask)); 145 } 146 } 147 148 /* "name@slot,offset" */ 149 static void __init sbus_path_component(struct device_node *dp, char *tmp_buf) 150 { 151 struct linux_prom_registers *regs; 152 struct property *prop; 153 154 prop = of_find_property(dp, "reg", NULL); 155 if (!prop) 156 return; 157 158 regs = prop->value; 159 sprintf(tmp_buf, "%s@%x,%x", 160 dp->name, 161 regs->which_io, 162 regs->phys_addr); 163 } 164 165 /* "name@devnum[,func]" */ 166 static void __init pci_path_component(struct device_node *dp, char *tmp_buf) 167 { 168 struct linux_prom_pci_registers *regs; 169 struct property *prop; 170 unsigned int devfn; 171 172 prop = of_find_property(dp, "reg", NULL); 173 if (!prop) 174 return; 175 176 regs = prop->value; 177 devfn = (regs->phys_hi >> 8) & 0xff; 178 if (devfn & 0x07) { 179 sprintf(tmp_buf, "%s@%x,%x", 180 dp->name, 181 devfn >> 3, 182 devfn & 0x07); 183 } else { 184 sprintf(tmp_buf, "%s@%x", 185 dp->name, 186 devfn >> 3); 187 } 188 } 189 190 /* "name@UPA_PORTID,offset" */ 191 static void __init upa_path_component(struct device_node *dp, char *tmp_buf) 192 { 193 struct linux_prom64_registers *regs; 194 struct property *prop; 195 196 prop = of_find_property(dp, "reg", NULL); 197 if (!prop) 198 return; 199 200 regs = prop->value; 201 202 prop = of_find_property(dp, "upa-portid", NULL); 203 if (!prop) 204 return; 205 206 sprintf(tmp_buf, "%s@%x,%x", 207 dp->name, 208 *(u32 *) prop->value, 209 (unsigned int) (regs->phys_addr & 0xffffffffUL)); 210 } 211 212 /* "name@reg" */ 213 static void __init vdev_path_component(struct device_node *dp, char *tmp_buf) 214 { 215 struct property *prop; 216 u32 *regs; 217 218 prop = of_find_property(dp, "reg", NULL); 219 if (!prop) 220 return; 221 222 regs = prop->value; 223 224 sprintf(tmp_buf, "%s@%x", dp->name, *regs); 225 } 226 227 /* "name@addrhi,addrlo" */ 228 static void __init ebus_path_component(struct device_node *dp, char *tmp_buf) 229 { 230 struct linux_prom64_registers *regs; 231 struct property *prop; 232 233 prop = of_find_property(dp, "reg", NULL); 234 if (!prop) 235 return; 236 237 regs = prop->value; 238 239 sprintf(tmp_buf, "%s@%x,%x", 240 dp->name, 241 (unsigned int) (regs->phys_addr >> 32UL), 242 (unsigned int) (regs->phys_addr & 0xffffffffUL)); 243 } 244 245 /* "name@bus,addr" */ 246 static void __init i2c_path_component(struct device_node *dp, char *tmp_buf) 247 { 248 struct property *prop; 249 u32 *regs; 250 251 prop = of_find_property(dp, "reg", NULL); 252 if (!prop) 253 return; 254 255 regs = prop->value; 256 257 /* This actually isn't right... should look at the #address-cells 258 * property of the i2c bus node etc. etc. 259 */ 260 sprintf(tmp_buf, "%s@%x,%x", 261 dp->name, regs[0], regs[1]); 262 } 263 264 /* "name@reg0[,reg1]" */ 265 static void __init usb_path_component(struct device_node *dp, char *tmp_buf) 266 { 267 struct property *prop; 268 u32 *regs; 269 270 prop = of_find_property(dp, "reg", NULL); 271 if (!prop) 272 return; 273 274 regs = prop->value; 275 276 if (prop->length == sizeof(u32) || regs[1] == 1) { 277 sprintf(tmp_buf, "%s@%x", 278 dp->name, regs[0]); 279 } else { 280 sprintf(tmp_buf, "%s@%x,%x", 281 dp->name, regs[0], regs[1]); 282 } 283 } 284 285 /* "name@reg0reg1[,reg2reg3]" */ 286 static void __init ieee1394_path_component(struct device_node *dp, char *tmp_buf) 287 { 288 struct property *prop; 289 u32 *regs; 290 291 prop = of_find_property(dp, "reg", NULL); 292 if (!prop) 293 return; 294 295 regs = prop->value; 296 297 if (regs[2] || regs[3]) { 298 sprintf(tmp_buf, "%s@%08x%08x,%04x%08x", 299 dp->name, regs[0], regs[1], regs[2], regs[3]); 300 } else { 301 sprintf(tmp_buf, "%s@%08x%08x", 302 dp->name, regs[0], regs[1]); 303 } 304 } 305 306 static void __init __build_path_component(struct device_node *dp, char *tmp_buf) 307 { 308 struct device_node *parent = dp->parent; 309 310 if (parent != NULL) { 311 if (!strcmp(parent->type, "pci") || 312 !strcmp(parent->type, "pciex")) { 313 pci_path_component(dp, tmp_buf); 314 return; 315 } 316 if (!strcmp(parent->type, "sbus")) { 317 sbus_path_component(dp, tmp_buf); 318 return; 319 } 320 if (!strcmp(parent->type, "upa")) { 321 upa_path_component(dp, tmp_buf); 322 return; 323 } 324 if (!strcmp(parent->type, "ebus")) { 325 ebus_path_component(dp, tmp_buf); 326 return; 327 } 328 if (!strcmp(parent->name, "usb") || 329 !strcmp(parent->name, "hub")) { 330 usb_path_component(dp, tmp_buf); 331 return; 332 } 333 if (!strcmp(parent->type, "i2c")) { 334 i2c_path_component(dp, tmp_buf); 335 return; 336 } 337 if (!strcmp(parent->type, "firewire")) { 338 ieee1394_path_component(dp, tmp_buf); 339 return; 340 } 341 if (!strcmp(parent->type, "virtual-devices")) { 342 vdev_path_component(dp, tmp_buf); 343 return; 344 } 345 /* "isa" is handled with platform naming */ 346 } 347 348 /* Use platform naming convention. */ 349 if (tlb_type == hypervisor) { 350 sun4v_path_component(dp, tmp_buf); 351 return; 352 } else { 353 sun4u_path_component(dp, tmp_buf); 354 } 355 } 356 357 char * __init build_path_component(struct device_node *dp) 358 { 359 char tmp_buf[64], *n; 360 361 tmp_buf[0] = '\0'; 362 __build_path_component(dp, tmp_buf); 363 if (tmp_buf[0] == '\0') 364 strcpy(tmp_buf, dp->name); 365 366 n = prom_early_alloc(strlen(tmp_buf) + 1); 367 strcpy(n, tmp_buf); 368 369 return n; 370 } 371 372 static const char *get_mid_prop(void) 373 { 374 return (tlb_type == spitfire ? "upa-portid" : "portid"); 375 } 376 377 struct device_node *of_find_node_by_cpuid(int cpuid) 378 { 379 struct device_node *dp; 380 const char *mid_prop = get_mid_prop(); 381 382 for_each_node_by_type(dp, "cpu") { 383 int id = of_getintprop_default(dp, mid_prop, -1); 384 const char *this_mid_prop = mid_prop; 385 386 if (id < 0) { 387 this_mid_prop = "cpuid"; 388 id = of_getintprop_default(dp, this_mid_prop, -1); 389 } 390 391 if (id < 0) { 392 prom_printf("OF: Serious problem, cpu lacks " 393 "%s property", this_mid_prop); 394 prom_halt(); 395 } 396 if (cpuid == id) 397 return dp; 398 } 399 return NULL; 400 } 401 402 void __init of_fill_in_cpu_data(void) 403 { 404 struct device_node *dp; 405 const char *mid_prop; 406 407 if (tlb_type == hypervisor) 408 return; 409 410 mid_prop = get_mid_prop(); 411 ncpus_probed = 0; 412 for_each_node_by_type(dp, "cpu") { 413 int cpuid = of_getintprop_default(dp, mid_prop, -1); 414 const char *this_mid_prop = mid_prop; 415 struct device_node *portid_parent; 416 int portid = -1; 417 418 portid_parent = NULL; 419 if (cpuid < 0) { 420 this_mid_prop = "cpuid"; 421 cpuid = of_getintprop_default(dp, this_mid_prop, -1); 422 if (cpuid >= 0) { 423 int limit = 2; 424 425 portid_parent = dp; 426 while (limit--) { 427 portid_parent = portid_parent->parent; 428 if (!portid_parent) 429 break; 430 portid = of_getintprop_default(portid_parent, 431 "portid", -1); 432 if (portid >= 0) 433 break; 434 } 435 } 436 } 437 438 if (cpuid < 0) { 439 prom_printf("OF: Serious problem, cpu lacks " 440 "%s property", this_mid_prop); 441 prom_halt(); 442 } 443 444 ncpus_probed++; 445 446 #ifdef CONFIG_SMP 447 if (cpuid >= NR_CPUS) { 448 printk(KERN_WARNING "Ignoring CPU %d which is " 449 ">= NR_CPUS (%d)\n", 450 cpuid, NR_CPUS); 451 continue; 452 } 453 #else 454 /* On uniprocessor we only want the values for the 455 * real physical cpu the kernel booted onto, however 456 * cpu_data() only has one entry at index 0. 457 */ 458 if (cpuid != real_hard_smp_processor_id()) 459 continue; 460 cpuid = 0; 461 #endif 462 463 cpu_data(cpuid).clock_tick = 464 of_getintprop_default(dp, "clock-frequency", 0); 465 466 if (portid_parent) { 467 cpu_data(cpuid).dcache_size = 468 of_getintprop_default(dp, "l1-dcache-size", 469 16 * 1024); 470 cpu_data(cpuid).dcache_line_size = 471 of_getintprop_default(dp, "l1-dcache-line-size", 472 32); 473 cpu_data(cpuid).icache_size = 474 of_getintprop_default(dp, "l1-icache-size", 475 8 * 1024); 476 cpu_data(cpuid).icache_line_size = 477 of_getintprop_default(dp, "l1-icache-line-size", 478 32); 479 cpu_data(cpuid).ecache_size = 480 of_getintprop_default(dp, "l2-cache-size", 0); 481 cpu_data(cpuid).ecache_line_size = 482 of_getintprop_default(dp, "l2-cache-line-size", 0); 483 if (!cpu_data(cpuid).ecache_size || 484 !cpu_data(cpuid).ecache_line_size) { 485 cpu_data(cpuid).ecache_size = 486 of_getintprop_default(portid_parent, 487 "l2-cache-size", 488 (4 * 1024 * 1024)); 489 cpu_data(cpuid).ecache_line_size = 490 of_getintprop_default(portid_parent, 491 "l2-cache-line-size", 64); 492 } 493 494 cpu_data(cpuid).core_id = portid + 1; 495 cpu_data(cpuid).proc_id = portid; 496 #ifdef CONFIG_SMP 497 sparc64_multi_core = 1; 498 #endif 499 } else { 500 cpu_data(cpuid).dcache_size = 501 of_getintprop_default(dp, "dcache-size", 16 * 1024); 502 cpu_data(cpuid).dcache_line_size = 503 of_getintprop_default(dp, "dcache-line-size", 32); 504 505 cpu_data(cpuid).icache_size = 506 of_getintprop_default(dp, "icache-size", 16 * 1024); 507 cpu_data(cpuid).icache_line_size = 508 of_getintprop_default(dp, "icache-line-size", 32); 509 510 cpu_data(cpuid).ecache_size = 511 of_getintprop_default(dp, "ecache-size", 512 (4 * 1024 * 1024)); 513 cpu_data(cpuid).ecache_line_size = 514 of_getintprop_default(dp, "ecache-line-size", 64); 515 516 cpu_data(cpuid).core_id = 0; 517 cpu_data(cpuid).proc_id = -1; 518 } 519 520 #ifdef CONFIG_SMP 521 set_cpu_present(cpuid, true); 522 set_cpu_possible(cpuid, true); 523 #endif 524 } 525 526 smp_fill_in_sib_core_maps(); 527 } 528 529 void __init of_console_init(void) 530 { 531 char *msg = "OF stdout device is: %s\n"; 532 struct device_node *dp; 533 const char *type; 534 phandle node; 535 536 of_console_path = prom_early_alloc(256); 537 if (prom_ihandle2path(prom_stdout, of_console_path, 256) < 0) { 538 prom_printf("Cannot obtain path of stdout.\n"); 539 prom_halt(); 540 } 541 of_console_options = strrchr(of_console_path, ':'); 542 if (of_console_options) { 543 of_console_options++; 544 if (*of_console_options == '\0') 545 of_console_options = NULL; 546 } 547 548 node = prom_inst2pkg(prom_stdout); 549 if (!node) { 550 prom_printf("Cannot resolve stdout node from " 551 "instance %08x.\n", prom_stdout); 552 prom_halt(); 553 } 554 555 dp = of_find_node_by_phandle(node); 556 type = of_get_property(dp, "device_type", NULL); 557 if (!type) { 558 prom_printf("Console stdout lacks device_type property.\n"); 559 prom_halt(); 560 } 561 562 if (strcmp(type, "display") && strcmp(type, "serial")) { 563 prom_printf("Console device_type is neither display " 564 "nor serial.\n"); 565 prom_halt(); 566 } 567 568 of_console_device = dp; 569 570 printk(msg, of_console_path); 571 } 572