1 /* 2 * Powermac setup and early boot code plus other random bits. 3 * 4 * PowerPC version 5 * Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org) 6 * 7 * Adapted for Power Macintosh by Paul Mackerras 8 * Copyright (C) 1996 Paul Mackerras (paulus@samba.org) 9 * 10 * Derived from "arch/alpha/kernel/setup.c" 11 * Copyright (C) 1995 Linus Torvalds 12 * 13 * Maintained by Benjamin Herrenschmidt (benh@kernel.crashing.org) 14 * 15 * This program is free software; you can redistribute it and/or 16 * modify it under the terms of the GNU General Public License 17 * as published by the Free Software Foundation; either version 18 * 2 of the License, or (at your option) any later version. 19 * 20 */ 21 22 /* 23 * bootup setup stuff.. 24 */ 25 26 #include <linux/init.h> 27 #include <linux/errno.h> 28 #include <linux/sched.h> 29 #include <linux/kernel.h> 30 #include <linux/mm.h> 31 #include <linux/stddef.h> 32 #include <linux/unistd.h> 33 #include <linux/ptrace.h> 34 #include <linux/export.h> 35 #include <linux/user.h> 36 #include <linux/tty.h> 37 #include <linux/string.h> 38 #include <linux/delay.h> 39 #include <linux/ioport.h> 40 #include <linux/major.h> 41 #include <linux/initrd.h> 42 #include <linux/vt_kern.h> 43 #include <linux/console.h> 44 #include <linux/pci.h> 45 #include <linux/adb.h> 46 #include <linux/cuda.h> 47 #include <linux/pmu.h> 48 #include <linux/irq.h> 49 #include <linux/seq_file.h> 50 #include <linux/root_dev.h> 51 #include <linux/bitops.h> 52 #include <linux/suspend.h> 53 #include <linux/of_device.h> 54 #include <linux/of_platform.h> 55 56 #include <asm/reg.h> 57 #include <asm/sections.h> 58 #include <asm/prom.h> 59 #include <asm/pgtable.h> 60 #include <asm/io.h> 61 #include <asm/pci-bridge.h> 62 #include <asm/ohare.h> 63 #include <asm/mediabay.h> 64 #include <asm/machdep.h> 65 #include <asm/dma.h> 66 #include <asm/cputable.h> 67 #include <asm/btext.h> 68 #include <asm/pmac_feature.h> 69 #include <asm/time.h> 70 #include <asm/mmu_context.h> 71 #include <asm/iommu.h> 72 #include <asm/smu.h> 73 #include <asm/pmc.h> 74 #include <asm/udbg.h> 75 76 #include "pmac.h" 77 78 #undef SHOW_GATWICK_IRQS 79 80 int ppc_override_l2cr = 0; 81 int ppc_override_l2cr_value; 82 int has_l2cache = 0; 83 84 int pmac_newworld; 85 86 static int current_root_goodness = -1; 87 88 extern struct machdep_calls pmac_md; 89 90 #define DEFAULT_ROOT_DEVICE Root_SDA1 /* sda1 - slightly silly choice */ 91 92 #ifdef CONFIG_PPC64 93 int sccdbg; 94 #endif 95 96 sys_ctrler_t sys_ctrler = SYS_CTRLER_UNKNOWN; 97 EXPORT_SYMBOL(sys_ctrler); 98 99 static void pmac_show_cpuinfo(struct seq_file *m) 100 { 101 struct device_node *np; 102 const char *pp; 103 int plen; 104 int mbmodel; 105 unsigned int mbflags; 106 char* mbname; 107 108 mbmodel = pmac_call_feature(PMAC_FTR_GET_MB_INFO, NULL, 109 PMAC_MB_INFO_MODEL, 0); 110 mbflags = pmac_call_feature(PMAC_FTR_GET_MB_INFO, NULL, 111 PMAC_MB_INFO_FLAGS, 0); 112 if (pmac_call_feature(PMAC_FTR_GET_MB_INFO, NULL, PMAC_MB_INFO_NAME, 113 (long) &mbname) != 0) 114 mbname = "Unknown"; 115 116 /* find motherboard type */ 117 seq_printf(m, "machine\t\t: "); 118 np = of_find_node_by_path("/"); 119 if (np != NULL) { 120 pp = of_get_property(np, "model", NULL); 121 if (pp != NULL) 122 seq_printf(m, "%s\n", pp); 123 else 124 seq_printf(m, "PowerMac\n"); 125 pp = of_get_property(np, "compatible", &plen); 126 if (pp != NULL) { 127 seq_printf(m, "motherboard\t:"); 128 while (plen > 0) { 129 int l = strlen(pp) + 1; 130 seq_printf(m, " %s", pp); 131 plen -= l; 132 pp += l; 133 } 134 seq_printf(m, "\n"); 135 } 136 of_node_put(np); 137 } else 138 seq_printf(m, "PowerMac\n"); 139 140 /* print parsed model */ 141 seq_printf(m, "detected as\t: %d (%s)\n", mbmodel, mbname); 142 seq_printf(m, "pmac flags\t: %08x\n", mbflags); 143 144 /* find l2 cache info */ 145 np = of_find_node_by_name(NULL, "l2-cache"); 146 if (np == NULL) 147 np = of_find_node_by_type(NULL, "cache"); 148 if (np != NULL) { 149 const unsigned int *ic = 150 of_get_property(np, "i-cache-size", NULL); 151 const unsigned int *dc = 152 of_get_property(np, "d-cache-size", NULL); 153 seq_printf(m, "L2 cache\t:"); 154 has_l2cache = 1; 155 if (of_get_property(np, "cache-unified", NULL) && dc) { 156 seq_printf(m, " %dK unified", *dc / 1024); 157 } else { 158 if (ic) 159 seq_printf(m, " %dK instruction", *ic / 1024); 160 if (dc) 161 seq_printf(m, "%s %dK data", 162 (ic? " +": ""), *dc / 1024); 163 } 164 pp = of_get_property(np, "ram-type", NULL); 165 if (pp) 166 seq_printf(m, " %s", pp); 167 seq_printf(m, "\n"); 168 of_node_put(np); 169 } 170 171 /* Indicate newworld/oldworld */ 172 seq_printf(m, "pmac-generation\t: %s\n", 173 pmac_newworld ? "NewWorld" : "OldWorld"); 174 } 175 176 #ifndef CONFIG_ADB_CUDA 177 int find_via_cuda(void) 178 { 179 struct device_node *dn = of_find_node_by_name(NULL, "via-cuda"); 180 181 if (!dn) 182 return 0; 183 of_node_put(dn); 184 printk("WARNING ! Your machine is CUDA-based but your kernel\n"); 185 printk(" wasn't compiled with CONFIG_ADB_CUDA option !\n"); 186 return 0; 187 } 188 #endif 189 190 #ifndef CONFIG_ADB_PMU 191 int find_via_pmu(void) 192 { 193 struct device_node *dn = of_find_node_by_name(NULL, "via-pmu"); 194 195 if (!dn) 196 return 0; 197 of_node_put(dn); 198 printk("WARNING ! Your machine is PMU-based but your kernel\n"); 199 printk(" wasn't compiled with CONFIG_ADB_PMU option !\n"); 200 return 0; 201 } 202 #endif 203 204 #ifndef CONFIG_PMAC_SMU 205 int smu_init(void) 206 { 207 /* should check and warn if SMU is present */ 208 return 0; 209 } 210 #endif 211 212 #ifdef CONFIG_PPC32 213 static volatile u32 *sysctrl_regs; 214 215 static void __init ohare_init(void) 216 { 217 struct device_node *dn; 218 219 /* this area has the CPU identification register 220 and some registers used by smp boards */ 221 sysctrl_regs = (volatile u32 *) ioremap(0xf8000000, 0x1000); 222 223 /* 224 * Turn on the L2 cache. 225 * We assume that we have a PSX memory controller iff 226 * we have an ohare I/O controller. 227 */ 228 dn = of_find_node_by_name(NULL, "ohare"); 229 if (dn) { 230 of_node_put(dn); 231 if (((sysctrl_regs[2] >> 24) & 0xf) >= 3) { 232 if (sysctrl_regs[4] & 0x10) 233 sysctrl_regs[4] |= 0x04000020; 234 else 235 sysctrl_regs[4] |= 0x04000000; 236 if(has_l2cache) 237 printk(KERN_INFO "Level 2 cache enabled\n"); 238 } 239 } 240 } 241 242 static void __init l2cr_init(void) 243 { 244 /* Checks "l2cr-value" property in the registry */ 245 if (cpu_has_feature(CPU_FTR_L2CR)) { 246 struct device_node *np; 247 248 for_each_of_cpu_node(np) { 249 const unsigned int *l2cr = 250 of_get_property(np, "l2cr-value", NULL); 251 if (l2cr) { 252 ppc_override_l2cr = 1; 253 ppc_override_l2cr_value = *l2cr; 254 _set_L2CR(0); 255 _set_L2CR(ppc_override_l2cr_value); 256 } 257 of_node_put(np); 258 break; 259 } 260 } 261 262 if (ppc_override_l2cr) 263 printk(KERN_INFO "L2CR overridden (0x%x), " 264 "backside cache is %s\n", 265 ppc_override_l2cr_value, 266 (ppc_override_l2cr_value & 0x80000000) 267 ? "enabled" : "disabled"); 268 } 269 #endif 270 271 static void __init pmac_setup_arch(void) 272 { 273 struct device_node *cpu, *ic; 274 const int *fp; 275 unsigned long pvr; 276 277 pvr = PVR_VER(mfspr(SPRN_PVR)); 278 279 /* Set loops_per_jiffy to a half-way reasonable value, 280 for use until calibrate_delay gets called. */ 281 loops_per_jiffy = 50000000 / HZ; 282 283 for_each_of_cpu_node(cpu) { 284 fp = of_get_property(cpu, "clock-frequency", NULL); 285 if (fp != NULL) { 286 if (pvr >= 0x30 && pvr < 0x80) 287 /* PPC970 etc. */ 288 loops_per_jiffy = *fp / (3 * HZ); 289 else if (pvr == 4 || pvr >= 8) 290 /* 604, G3, G4 etc. */ 291 loops_per_jiffy = *fp / HZ; 292 else 293 /* 601, 603, etc. */ 294 loops_per_jiffy = *fp / (2 * HZ); 295 of_node_put(cpu); 296 break; 297 } 298 } 299 300 /* See if newworld or oldworld */ 301 ic = of_find_node_with_property(NULL, "interrupt-controller"); 302 if (ic) { 303 pmac_newworld = 1; 304 of_node_put(ic); 305 } 306 307 /* Lookup PCI hosts */ 308 pmac_pci_init(); 309 310 #ifdef CONFIG_PPC32 311 ohare_init(); 312 l2cr_init(); 313 #endif /* CONFIG_PPC32 */ 314 315 find_via_cuda(); 316 find_via_pmu(); 317 smu_init(); 318 319 #if IS_ENABLED(CONFIG_NVRAM) 320 pmac_nvram_init(); 321 #endif 322 #ifdef CONFIG_PPC32 323 #ifdef CONFIG_BLK_DEV_INITRD 324 if (initrd_start) 325 ROOT_DEV = Root_RAM0; 326 else 327 #endif 328 ROOT_DEV = DEFAULT_ROOT_DEVICE; 329 #endif 330 331 #ifdef CONFIG_ADB 332 if (strstr(boot_command_line, "adb_sync")) { 333 extern int __adb_probe_sync; 334 __adb_probe_sync = 1; 335 } 336 #endif /* CONFIG_ADB */ 337 } 338 339 #ifdef CONFIG_SCSI 340 void note_scsi_host(struct device_node *node, void *host) 341 { 342 } 343 EXPORT_SYMBOL(note_scsi_host); 344 #endif 345 346 static int initializing = 1; 347 348 static int pmac_late_init(void) 349 { 350 initializing = 0; 351 return 0; 352 } 353 machine_late_initcall(powermac, pmac_late_init); 354 355 void note_bootable_part(dev_t dev, int part, int goodness); 356 /* 357 * This is __ref because we check for "initializing" before 358 * touching any of the __init sensitive things and "initializing" 359 * will be false after __init time. This can't be __init because it 360 * can be called whenever a disk is first accessed. 361 */ 362 void __ref note_bootable_part(dev_t dev, int part, int goodness) 363 { 364 char *p; 365 366 if (!initializing) 367 return; 368 if ((goodness <= current_root_goodness) && 369 ROOT_DEV != DEFAULT_ROOT_DEVICE) 370 return; 371 p = strstr(boot_command_line, "root="); 372 if (p != NULL && (p == boot_command_line || p[-1] == ' ')) 373 return; 374 375 ROOT_DEV = dev + part; 376 current_root_goodness = goodness; 377 } 378 379 #ifdef CONFIG_ADB_CUDA 380 static void __noreturn cuda_restart(void) 381 { 382 struct adb_request req; 383 384 cuda_request(&req, NULL, 2, CUDA_PACKET, CUDA_RESET_SYSTEM); 385 for (;;) 386 cuda_poll(); 387 } 388 389 static void __noreturn cuda_shutdown(void) 390 { 391 struct adb_request req; 392 393 cuda_request(&req, NULL, 2, CUDA_PACKET, CUDA_POWERDOWN); 394 for (;;) 395 cuda_poll(); 396 } 397 398 #else 399 #define cuda_restart() 400 #define cuda_shutdown() 401 #endif 402 403 #ifndef CONFIG_ADB_PMU 404 #define pmu_restart() 405 #define pmu_shutdown() 406 #endif 407 408 #ifndef CONFIG_PMAC_SMU 409 #define smu_restart() 410 #define smu_shutdown() 411 #endif 412 413 static void __noreturn pmac_restart(char *cmd) 414 { 415 switch (sys_ctrler) { 416 case SYS_CTRLER_CUDA: 417 cuda_restart(); 418 break; 419 case SYS_CTRLER_PMU: 420 pmu_restart(); 421 break; 422 case SYS_CTRLER_SMU: 423 smu_restart(); 424 break; 425 default: ; 426 } 427 while (1) ; 428 } 429 430 static void __noreturn pmac_power_off(void) 431 { 432 switch (sys_ctrler) { 433 case SYS_CTRLER_CUDA: 434 cuda_shutdown(); 435 break; 436 case SYS_CTRLER_PMU: 437 pmu_shutdown(); 438 break; 439 case SYS_CTRLER_SMU: 440 smu_shutdown(); 441 break; 442 default: ; 443 } 444 while (1) ; 445 } 446 447 static void __noreturn 448 pmac_halt(void) 449 { 450 pmac_power_off(); 451 } 452 453 /* 454 * Early initialization. 455 */ 456 static void __init pmac_init(void) 457 { 458 /* Enable early btext debug if requested */ 459 if (strstr(boot_command_line, "btextdbg")) { 460 udbg_adb_init_early(); 461 register_early_udbg_console(); 462 } 463 464 /* Probe motherboard chipset */ 465 pmac_feature_init(); 466 467 /* Initialize debug stuff */ 468 udbg_scc_init(!!strstr(boot_command_line, "sccdbg")); 469 udbg_adb_init(!!strstr(boot_command_line, "btextdbg")); 470 471 #ifdef CONFIG_PPC64 472 iommu_init_early_dart(&pmac_pci_controller_ops); 473 #endif 474 475 /* SMP Init has to be done early as we need to patch up 476 * cpu_possible_mask before interrupt stacks are allocated 477 * or kaboom... 478 */ 479 #ifdef CONFIG_SMP 480 pmac_setup_smp(); 481 #endif 482 } 483 484 static int __init pmac_declare_of_platform_devices(void) 485 { 486 struct device_node *np; 487 488 np = of_find_node_by_name(NULL, "valkyrie"); 489 if (np) { 490 of_platform_device_create(np, "valkyrie", NULL); 491 of_node_put(np); 492 } 493 np = of_find_node_by_name(NULL, "platinum"); 494 if (np) { 495 of_platform_device_create(np, "platinum", NULL); 496 of_node_put(np); 497 } 498 np = of_find_node_by_type(NULL, "smu"); 499 if (np) { 500 of_platform_device_create(np, "smu", NULL); 501 of_node_put(np); 502 } 503 np = of_find_node_by_type(NULL, "fcu"); 504 if (np == NULL) { 505 /* Some machines have strangely broken device-tree */ 506 np = of_find_node_by_path("/u3@0,f8000000/i2c@f8001000/fan@15e"); 507 } 508 if (np) { 509 of_platform_device_create(np, "temperature", NULL); 510 of_node_put(np); 511 } 512 513 return 0; 514 } 515 machine_device_initcall(powermac, pmac_declare_of_platform_devices); 516 517 #ifdef CONFIG_SERIAL_PMACZILOG_CONSOLE 518 /* 519 * This is called very early, as part of console_init() (typically just after 520 * time_init()). This function is respondible for trying to find a good 521 * default console on serial ports. It tries to match the open firmware 522 * default output with one of the available serial console drivers. 523 */ 524 static int __init check_pmac_serial_console(void) 525 { 526 struct device_node *prom_stdout = NULL; 527 int offset = 0; 528 const char *name; 529 #ifdef CONFIG_SERIAL_PMACZILOG_TTYS 530 char *devname = "ttyS"; 531 #else 532 char *devname = "ttyPZ"; 533 #endif 534 535 pr_debug(" -> check_pmac_serial_console()\n"); 536 537 /* The user has requested a console so this is already set up. */ 538 if (strstr(boot_command_line, "console=")) { 539 pr_debug(" console was specified !\n"); 540 return -EBUSY; 541 } 542 543 if (!of_chosen) { 544 pr_debug(" of_chosen is NULL !\n"); 545 return -ENODEV; 546 } 547 548 /* We are getting a weird phandle from OF ... */ 549 /* ... So use the full path instead */ 550 name = of_get_property(of_chosen, "linux,stdout-path", NULL); 551 if (name == NULL) { 552 pr_debug(" no linux,stdout-path !\n"); 553 return -ENODEV; 554 } 555 prom_stdout = of_find_node_by_path(name); 556 if (!prom_stdout) { 557 pr_debug(" can't find stdout package %s !\n", name); 558 return -ENODEV; 559 } 560 pr_debug("stdout is %pOF\n", prom_stdout); 561 562 if (of_node_name_eq(prom_stdout, "ch-a")) 563 offset = 0; 564 else if (of_node_name_eq(prom_stdout, "ch-b")) 565 offset = 1; 566 else 567 goto not_found; 568 of_node_put(prom_stdout); 569 570 pr_debug("Found serial console at %s%d\n", devname, offset); 571 572 return add_preferred_console(devname, offset, NULL); 573 574 not_found: 575 pr_debug("No preferred console found !\n"); 576 of_node_put(prom_stdout); 577 return -ENODEV; 578 } 579 console_initcall(check_pmac_serial_console); 580 581 #endif /* CONFIG_SERIAL_PMACZILOG_CONSOLE */ 582 583 /* 584 * Called very early, MMU is off, device-tree isn't unflattened 585 */ 586 static int __init pmac_probe(void) 587 { 588 if (!of_machine_is_compatible("Power Macintosh") && 589 !of_machine_is_compatible("MacRISC")) 590 return 0; 591 592 #ifdef CONFIG_PPC32 593 /* isa_io_base gets set in pmac_pci_init */ 594 ISA_DMA_THRESHOLD = ~0L; 595 DMA_MODE_READ = 1; 596 DMA_MODE_WRITE = 2; 597 #endif /* CONFIG_PPC32 */ 598 599 pm_power_off = pmac_power_off; 600 601 pmac_init(); 602 603 return 1; 604 } 605 606 define_machine(powermac) { 607 .name = "PowerMac", 608 .probe = pmac_probe, 609 .setup_arch = pmac_setup_arch, 610 .show_cpuinfo = pmac_show_cpuinfo, 611 .init_IRQ = pmac_pic_init, 612 .get_irq = NULL, /* changed later */ 613 .pci_irq_fixup = pmac_pci_irq_fixup, 614 .restart = pmac_restart, 615 .halt = pmac_halt, 616 .time_init = pmac_time_init, 617 .get_boot_time = pmac_get_boot_time, 618 .set_rtc_time = pmac_set_rtc_time, 619 .get_rtc_time = pmac_get_rtc_time, 620 .calibrate_decr = pmac_calibrate_decr, 621 .feature_call = pmac_do_feature_call, 622 .progress = udbg_progress, 623 #ifdef CONFIG_PPC64 624 .power_save = power4_idle, 625 .enable_pmcs = power4_enable_pmcs, 626 #endif /* CONFIG_PPC64 */ 627 #ifdef CONFIG_PPC32 628 .pcibios_after_init = pmac_pcibios_after_init, 629 .phys_mem_access_prot = pci_phys_mem_access_prot, 630 #endif 631 }; 632