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