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