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