1 /* 2 * 3 * Common boot and setup code. 4 * 5 * Copyright (C) 2001 PPC64 Team, IBM Corp 6 * 7 * This program is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU General Public License 9 * as published by the Free Software Foundation; either version 10 * 2 of the License, or (at your option) any later version. 11 */ 12 13 #undef DEBUG 14 15 #include <linux/config.h> 16 #include <linux/module.h> 17 #include <linux/string.h> 18 #include <linux/sched.h> 19 #include <linux/init.h> 20 #include <linux/kernel.h> 21 #include <linux/reboot.h> 22 #include <linux/delay.h> 23 #include <linux/initrd.h> 24 #include <linux/ide.h> 25 #include <linux/seq_file.h> 26 #include <linux/ioport.h> 27 #include <linux/console.h> 28 #include <linux/utsname.h> 29 #include <linux/tty.h> 30 #include <linux/root_dev.h> 31 #include <linux/notifier.h> 32 #include <linux/cpu.h> 33 #include <linux/unistd.h> 34 #include <linux/serial.h> 35 #include <linux/serial_8250.h> 36 #include <linux/bootmem.h> 37 #include <asm/io.h> 38 #include <asm/kdump.h> 39 #include <asm/prom.h> 40 #include <asm/processor.h> 41 #include <asm/pgtable.h> 42 #include <asm/smp.h> 43 #include <asm/elf.h> 44 #include <asm/machdep.h> 45 #include <asm/paca.h> 46 #include <asm/time.h> 47 #include <asm/cputable.h> 48 #include <asm/sections.h> 49 #include <asm/btext.h> 50 #include <asm/nvram.h> 51 #include <asm/setup.h> 52 #include <asm/system.h> 53 #include <asm/rtas.h> 54 #include <asm/iommu.h> 55 #include <asm/serial.h> 56 #include <asm/cache.h> 57 #include <asm/page.h> 58 #include <asm/mmu.h> 59 #include <asm/lmb.h> 60 #include <asm/iseries/it_lp_naca.h> 61 #include <asm/firmware.h> 62 #include <asm/xmon.h> 63 #include <asm/udbg.h> 64 #include <asm/kexec.h> 65 66 #include "setup.h" 67 68 #ifdef DEBUG 69 #define DBG(fmt...) udbg_printf(fmt) 70 #else 71 #define DBG(fmt...) 72 #endif 73 74 int have_of = 1; 75 int boot_cpuid = 0; 76 int boot_cpuid_phys = 0; 77 dev_t boot_dev; 78 u64 ppc64_pft_size; 79 80 /* Pick defaults since we might want to patch instructions 81 * before we've read this from the device tree. 82 */ 83 struct ppc64_caches ppc64_caches = { 84 .dline_size = 0x80, 85 .log_dline_size = 7, 86 .iline_size = 0x80, 87 .log_iline_size = 7 88 }; 89 EXPORT_SYMBOL_GPL(ppc64_caches); 90 91 /* 92 * These are used in binfmt_elf.c to put aux entries on the stack 93 * for each elf executable being started. 94 */ 95 int dcache_bsize; 96 int icache_bsize; 97 int ucache_bsize; 98 99 /* The main machine-dep calls structure 100 */ 101 struct machdep_calls ppc_md; 102 EXPORT_SYMBOL(ppc_md); 103 104 #ifdef CONFIG_MAGIC_SYSRQ 105 unsigned long SYSRQ_KEY; 106 #endif /* CONFIG_MAGIC_SYSRQ */ 107 108 109 static int ppc64_panic_event(struct notifier_block *, unsigned long, void *); 110 static struct notifier_block ppc64_panic_block = { 111 .notifier_call = ppc64_panic_event, 112 .priority = INT_MIN /* may not return; must be done last */ 113 }; 114 115 #ifdef CONFIG_SMP 116 117 static int smt_enabled_cmdline; 118 119 /* Look for ibm,smt-enabled OF option */ 120 static void check_smt_enabled(void) 121 { 122 struct device_node *dn; 123 char *smt_option; 124 125 /* Allow the command line to overrule the OF option */ 126 if (smt_enabled_cmdline) 127 return; 128 129 dn = of_find_node_by_path("/options"); 130 131 if (dn) { 132 smt_option = (char *)get_property(dn, "ibm,smt-enabled", NULL); 133 134 if (smt_option) { 135 if (!strcmp(smt_option, "on")) 136 smt_enabled_at_boot = 1; 137 else if (!strcmp(smt_option, "off")) 138 smt_enabled_at_boot = 0; 139 } 140 } 141 } 142 143 /* Look for smt-enabled= cmdline option */ 144 static int __init early_smt_enabled(char *p) 145 { 146 smt_enabled_cmdline = 1; 147 148 if (!p) 149 return 0; 150 151 if (!strcmp(p, "on") || !strcmp(p, "1")) 152 smt_enabled_at_boot = 1; 153 else if (!strcmp(p, "off") || !strcmp(p, "0")) 154 smt_enabled_at_boot = 0; 155 156 return 0; 157 } 158 early_param("smt-enabled", early_smt_enabled); 159 160 #else 161 #define check_smt_enabled() 162 #endif /* CONFIG_SMP */ 163 164 extern struct machdep_calls pSeries_md; 165 extern struct machdep_calls pmac_md; 166 extern struct machdep_calls maple_md; 167 extern struct machdep_calls cell_md; 168 extern struct machdep_calls iseries_md; 169 170 /* Ultimately, stuff them in an elf section like initcalls... */ 171 static struct machdep_calls __initdata *machines[] = { 172 #ifdef CONFIG_PPC_PSERIES 173 &pSeries_md, 174 #endif /* CONFIG_PPC_PSERIES */ 175 #ifdef CONFIG_PPC_PMAC 176 &pmac_md, 177 #endif /* CONFIG_PPC_PMAC */ 178 #ifdef CONFIG_PPC_MAPLE 179 &maple_md, 180 #endif /* CONFIG_PPC_MAPLE */ 181 #ifdef CONFIG_PPC_CELL 182 &cell_md, 183 #endif 184 #ifdef CONFIG_PPC_ISERIES 185 &iseries_md, 186 #endif 187 NULL 188 }; 189 190 /* 191 * Early initialization entry point. This is called by head.S 192 * with MMU translation disabled. We rely on the "feature" of 193 * the CPU that ignores the top 2 bits of the address in real 194 * mode so we can access kernel globals normally provided we 195 * only toy with things in the RMO region. From here, we do 196 * some early parsing of the device-tree to setup out LMB 197 * data structures, and allocate & initialize the hash table 198 * and segment tables so we can start running with translation 199 * enabled. 200 * 201 * It is this function which will call the probe() callback of 202 * the various platform types and copy the matching one to the 203 * global ppc_md structure. Your platform can eventually do 204 * some very early initializations from the probe() routine, but 205 * this is not recommended, be very careful as, for example, the 206 * device-tree is not accessible via normal means at this point. 207 */ 208 209 void __init early_setup(unsigned long dt_ptr) 210 { 211 struct paca_struct *lpaca = get_paca(); 212 static struct machdep_calls **mach; 213 214 /* Enable early debugging if any specified (see udbg.h) */ 215 udbg_early_init(); 216 217 DBG(" -> early_setup()\n"); 218 219 /* 220 * Do early initializations using the flattened device 221 * tree, like retreiving the physical memory map or 222 * calculating/retreiving the hash table size 223 */ 224 early_init_devtree(__va(dt_ptr)); 225 226 /* 227 * Iterate all ppc_md structures until we find the proper 228 * one for the current machine type 229 */ 230 DBG("Probing machine type for platform %x...\n", _machine); 231 232 for (mach = machines; *mach; mach++) { 233 if ((*mach)->probe(_machine)) 234 break; 235 } 236 /* What can we do if we didn't find ? */ 237 if (*mach == NULL) { 238 DBG("No suitable machine found !\n"); 239 for (;;); 240 } 241 ppc_md = **mach; 242 243 #ifdef CONFIG_CRASH_DUMP 244 kdump_setup(); 245 #endif 246 247 DBG("Found, Initializing memory management...\n"); 248 249 /* 250 * Initialize the MMU Hash table and create the linear mapping 251 * of memory. Has to be done before stab/slb initialization as 252 * this is currently where the page size encoding is obtained 253 */ 254 htab_initialize(); 255 256 /* 257 * Initialize stab / SLB management except on iSeries 258 */ 259 if (!firmware_has_feature(FW_FEATURE_ISERIES)) { 260 if (cpu_has_feature(CPU_FTR_SLB)) 261 slb_initialize(); 262 else 263 stab_initialize(lpaca->stab_real); 264 } 265 266 DBG(" <- early_setup()\n"); 267 } 268 269 #ifdef CONFIG_SMP 270 void early_setup_secondary(void) 271 { 272 struct paca_struct *lpaca = get_paca(); 273 274 /* Mark enabled in PACA */ 275 lpaca->proc_enabled = 0; 276 277 /* Initialize hash table for that CPU */ 278 htab_initialize_secondary(); 279 280 /* Initialize STAB/SLB. We use a virtual address as it works 281 * in real mode on pSeries and we want a virutal address on 282 * iSeries anyway 283 */ 284 if (cpu_has_feature(CPU_FTR_SLB)) 285 slb_initialize(); 286 else 287 stab_initialize(lpaca->stab_addr); 288 } 289 290 #endif /* CONFIG_SMP */ 291 292 #if defined(CONFIG_SMP) || defined(CONFIG_KEXEC) 293 void smp_release_cpus(void) 294 { 295 extern unsigned long __secondary_hold_spinloop; 296 unsigned long *ptr; 297 298 DBG(" -> smp_release_cpus()\n"); 299 300 /* All secondary cpus are spinning on a common spinloop, release them 301 * all now so they can start to spin on their individual paca 302 * spinloops. For non SMP kernels, the secondary cpus never get out 303 * of the common spinloop. 304 * This is useless but harmless on iSeries, secondaries are already 305 * waiting on their paca spinloops. */ 306 307 ptr = (unsigned long *)((unsigned long)&__secondary_hold_spinloop 308 - PHYSICAL_START); 309 *ptr = 1; 310 mb(); 311 312 DBG(" <- smp_release_cpus()\n"); 313 } 314 #else 315 #define smp_release_cpus() 316 #endif /* CONFIG_SMP || CONFIG_KEXEC */ 317 318 /* 319 * Initialize some remaining members of the ppc64_caches and systemcfg 320 * structures 321 * (at least until we get rid of them completely). This is mostly some 322 * cache informations about the CPU that will be used by cache flush 323 * routines and/or provided to userland 324 */ 325 static void __init initialize_cache_info(void) 326 { 327 struct device_node *np; 328 unsigned long num_cpus = 0; 329 330 DBG(" -> initialize_cache_info()\n"); 331 332 for (np = NULL; (np = of_find_node_by_type(np, "cpu"));) { 333 num_cpus += 1; 334 335 /* We're assuming *all* of the CPUs have the same 336 * d-cache and i-cache sizes... -Peter 337 */ 338 339 if ( num_cpus == 1 ) { 340 u32 *sizep, *lsizep; 341 u32 size, lsize; 342 const char *dc, *ic; 343 344 /* Then read cache informations */ 345 if (_machine == PLATFORM_POWERMAC) { 346 dc = "d-cache-block-size"; 347 ic = "i-cache-block-size"; 348 } else { 349 dc = "d-cache-line-size"; 350 ic = "i-cache-line-size"; 351 } 352 353 size = 0; 354 lsize = cur_cpu_spec->dcache_bsize; 355 sizep = (u32 *)get_property(np, "d-cache-size", NULL); 356 if (sizep != NULL) 357 size = *sizep; 358 lsizep = (u32 *) get_property(np, dc, NULL); 359 if (lsizep != NULL) 360 lsize = *lsizep; 361 if (sizep == 0 || lsizep == 0) 362 DBG("Argh, can't find dcache properties ! " 363 "sizep: %p, lsizep: %p\n", sizep, lsizep); 364 365 ppc64_caches.dsize = size; 366 ppc64_caches.dline_size = lsize; 367 ppc64_caches.log_dline_size = __ilog2(lsize); 368 ppc64_caches.dlines_per_page = PAGE_SIZE / lsize; 369 370 size = 0; 371 lsize = cur_cpu_spec->icache_bsize; 372 sizep = (u32 *)get_property(np, "i-cache-size", NULL); 373 if (sizep != NULL) 374 size = *sizep; 375 lsizep = (u32 *)get_property(np, ic, NULL); 376 if (lsizep != NULL) 377 lsize = *lsizep; 378 if (sizep == 0 || lsizep == 0) 379 DBG("Argh, can't find icache properties ! " 380 "sizep: %p, lsizep: %p\n", sizep, lsizep); 381 382 ppc64_caches.isize = size; 383 ppc64_caches.iline_size = lsize; 384 ppc64_caches.log_iline_size = __ilog2(lsize); 385 ppc64_caches.ilines_per_page = PAGE_SIZE / lsize; 386 } 387 } 388 389 DBG(" <- initialize_cache_info()\n"); 390 } 391 392 393 /* 394 * Do some initial setup of the system. The parameters are those which 395 * were passed in from the bootloader. 396 */ 397 void __init setup_system(void) 398 { 399 DBG(" -> setup_system()\n"); 400 401 #ifdef CONFIG_KEXEC 402 kdump_move_device_tree(); 403 #endif 404 /* 405 * Unflatten the device-tree passed by prom_init or kexec 406 */ 407 unflatten_device_tree(); 408 409 #ifdef CONFIG_KEXEC 410 kexec_setup(); /* requires unflattened device tree. */ 411 #endif 412 413 /* 414 * Fill the ppc64_caches & systemcfg structures with informations 415 * retrieved from the device-tree. Need to be called before 416 * finish_device_tree() since the later requires some of the 417 * informations filled up here to properly parse the interrupt 418 * tree. 419 * It also sets up the cache line sizes which allows to call 420 * routines like flush_icache_range (used by the hash init 421 * later on). 422 */ 423 initialize_cache_info(); 424 425 #ifdef CONFIG_PPC_RTAS 426 /* 427 * Initialize RTAS if available 428 */ 429 rtas_initialize(); 430 #endif /* CONFIG_PPC_RTAS */ 431 432 /* 433 * Check if we have an initrd provided via the device-tree 434 */ 435 check_for_initrd(); 436 437 /* 438 * Do some platform specific early initializations, that includes 439 * setting up the hash table pointers. It also sets up some interrupt-mapping 440 * related options that will be used by finish_device_tree() 441 */ 442 ppc_md.init_early(); 443 444 /* 445 * We can discover serial ports now since the above did setup the 446 * hash table management for us, thus ioremap works. We do that early 447 * so that further code can be debugged 448 */ 449 find_legacy_serial_ports(); 450 451 /* 452 * "Finish" the device-tree, that is do the actual parsing of 453 * some of the properties like the interrupt map 454 */ 455 finish_device_tree(); 456 457 /* 458 * Initialize xmon 459 */ 460 #ifdef CONFIG_XMON_DEFAULT 461 xmon_init(1); 462 #endif 463 /* 464 * Register early console 465 */ 466 register_early_udbg_console(); 467 468 /* Save unparsed command line copy for /proc/cmdline */ 469 strlcpy(saved_command_line, cmd_line, COMMAND_LINE_SIZE); 470 471 parse_early_param(); 472 473 check_smt_enabled(); 474 smp_setup_cpu_maps(); 475 476 /* Release secondary cpus out of their spinloops at 0x60 now that 477 * we can map physical -> logical CPU ids 478 */ 479 smp_release_cpus(); 480 481 printk("Starting Linux PPC64 %s\n", system_utsname.version); 482 483 printk("-----------------------------------------------------\n"); 484 printk("ppc64_pft_size = 0x%lx\n", ppc64_pft_size); 485 printk("ppc64_interrupt_controller = 0x%ld\n", 486 ppc64_interrupt_controller); 487 printk("platform = 0x%x\n", _machine); 488 printk("physicalMemorySize = 0x%lx\n", lmb_phys_mem_size()); 489 printk("ppc64_caches.dcache_line_size = 0x%x\n", 490 ppc64_caches.dline_size); 491 printk("ppc64_caches.icache_line_size = 0x%x\n", 492 ppc64_caches.iline_size); 493 printk("htab_address = 0x%p\n", htab_address); 494 printk("htab_hash_mask = 0x%lx\n", htab_hash_mask); 495 #if PHYSICAL_START > 0 496 printk("physical_start = 0x%x\n", PHYSICAL_START); 497 #endif 498 printk("-----------------------------------------------------\n"); 499 500 mm_init_ppc64(); 501 502 DBG(" <- setup_system()\n"); 503 } 504 505 static int ppc64_panic_event(struct notifier_block *this, 506 unsigned long event, void *ptr) 507 { 508 ppc_md.panic((char *)ptr); /* May not return */ 509 return NOTIFY_DONE; 510 } 511 512 #ifdef CONFIG_IRQSTACKS 513 static void __init irqstack_early_init(void) 514 { 515 unsigned int i; 516 517 /* 518 * interrupt stacks must be under 256MB, we cannot afford to take 519 * SLB misses on them. 520 */ 521 for_each_cpu(i) { 522 softirq_ctx[i] = (struct thread_info *) 523 __va(lmb_alloc_base(THREAD_SIZE, 524 THREAD_SIZE, 0x10000000)); 525 hardirq_ctx[i] = (struct thread_info *) 526 __va(lmb_alloc_base(THREAD_SIZE, 527 THREAD_SIZE, 0x10000000)); 528 } 529 } 530 #else 531 #define irqstack_early_init() 532 #endif 533 534 /* 535 * Stack space used when we detect a bad kernel stack pointer, and 536 * early in SMP boots before relocation is enabled. 537 */ 538 static void __init emergency_stack_init(void) 539 { 540 unsigned long limit; 541 unsigned int i; 542 543 /* 544 * Emergency stacks must be under 256MB, we cannot afford to take 545 * SLB misses on them. The ABI also requires them to be 128-byte 546 * aligned. 547 * 548 * Since we use these as temporary stacks during secondary CPU 549 * bringup, we need to get at them in real mode. This means they 550 * must also be within the RMO region. 551 */ 552 limit = min(0x10000000UL, lmb.rmo_size); 553 554 for_each_cpu(i) 555 paca[i].emergency_sp = 556 __va(lmb_alloc_base(HW_PAGE_SIZE, 128, limit)) + HW_PAGE_SIZE; 557 } 558 559 /* 560 * Called into from start_kernel, after lock_kernel has been called. 561 * Initializes bootmem, which is unsed to manage page allocation until 562 * mem_init is called. 563 */ 564 void __init setup_arch(char **cmdline_p) 565 { 566 extern void do_init_bootmem(void); 567 568 ppc64_boot_msg(0x12, "Setup Arch"); 569 570 *cmdline_p = cmd_line; 571 572 /* 573 * Set cache line size based on type of cpu as a default. 574 * Systems with OF can look in the properties on the cpu node(s) 575 * for a possibly more accurate value. 576 */ 577 dcache_bsize = ppc64_caches.dline_size; 578 icache_bsize = ppc64_caches.iline_size; 579 580 /* reboot on panic */ 581 panic_timeout = 180; 582 583 if (ppc_md.panic) 584 notifier_chain_register(&panic_notifier_list, &ppc64_panic_block); 585 586 init_mm.start_code = PAGE_OFFSET; 587 init_mm.end_code = (unsigned long) _etext; 588 init_mm.end_data = (unsigned long) _edata; 589 init_mm.brk = klimit; 590 591 irqstack_early_init(); 592 emergency_stack_init(); 593 594 stabs_alloc(); 595 596 /* set up the bootmem stuff with available memory */ 597 do_init_bootmem(); 598 sparse_init(); 599 600 #ifdef CONFIG_DUMMY_CONSOLE 601 conswitchp = &dummy_con; 602 #endif 603 604 ppc_md.setup_arch(); 605 606 /* Use the default idle loop if the platform hasn't provided one. */ 607 if (NULL == ppc_md.idle_loop) { 608 ppc_md.idle_loop = default_idle; 609 printk(KERN_INFO "Using default idle loop\n"); 610 } 611 612 paging_init(); 613 ppc64_boot_msg(0x15, "Setup Done"); 614 } 615 616 617 /* ToDo: do something useful if ppc_md is not yet setup. */ 618 #define PPC64_LINUX_FUNCTION 0x0f000000 619 #define PPC64_IPL_MESSAGE 0xc0000000 620 #define PPC64_TERM_MESSAGE 0xb0000000 621 622 static void ppc64_do_msg(unsigned int src, const char *msg) 623 { 624 if (ppc_md.progress) { 625 char buf[128]; 626 627 sprintf(buf, "%08X\n", src); 628 ppc_md.progress(buf, 0); 629 snprintf(buf, 128, "%s", msg); 630 ppc_md.progress(buf, 0); 631 } 632 } 633 634 /* Print a boot progress message. */ 635 void ppc64_boot_msg(unsigned int src, const char *msg) 636 { 637 ppc64_do_msg(PPC64_LINUX_FUNCTION|PPC64_IPL_MESSAGE|src, msg); 638 printk("[boot]%04x %s\n", src, msg); 639 } 640 641 /* Print a termination message (print only -- does not stop the kernel) */ 642 void ppc64_terminate_msg(unsigned int src, const char *msg) 643 { 644 ppc64_do_msg(PPC64_LINUX_FUNCTION|PPC64_TERM_MESSAGE|src, msg); 645 printk("[terminate]%04x %s\n", src, msg); 646 } 647 648 int check_legacy_ioport(unsigned long base_port) 649 { 650 if (ppc_md.check_legacy_ioport == NULL) 651 return 0; 652 return ppc_md.check_legacy_ioport(base_port); 653 } 654 EXPORT_SYMBOL(check_legacy_ioport); 655 656 void cpu_die(void) 657 { 658 if (ppc_md.cpu_die) 659 ppc_md.cpu_die(); 660 } 661 662 #ifdef CONFIG_SMP 663 void __init setup_per_cpu_areas(void) 664 { 665 int i; 666 unsigned long size; 667 char *ptr; 668 669 /* Copy section for each CPU (we discard the original) */ 670 size = ALIGN(__per_cpu_end - __per_cpu_start, SMP_CACHE_BYTES); 671 #ifdef CONFIG_MODULES 672 if (size < PERCPU_ENOUGH_ROOM) 673 size = PERCPU_ENOUGH_ROOM; 674 #endif 675 676 for_each_cpu(i) { 677 ptr = alloc_bootmem_node(NODE_DATA(cpu_to_node(i)), size); 678 if (!ptr) 679 panic("Cannot allocate cpu data for CPU %d\n", i); 680 681 paca[i].data_offset = ptr - __per_cpu_start; 682 memcpy(ptr, __per_cpu_start, __per_cpu_end - __per_cpu_start); 683 } 684 } 685 #endif 686