1 /* 2 * linux/arch/arm/kernel/setup.c 3 * 4 * Copyright (C) 1995-2001 Russell King 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License version 2 as 8 * published by the Free Software Foundation. 9 */ 10 #include <linux/module.h> 11 #include <linux/kernel.h> 12 #include <linux/stddef.h> 13 #include <linux/ioport.h> 14 #include <linux/delay.h> 15 #include <linux/utsname.h> 16 #include <linux/initrd.h> 17 #include <linux/console.h> 18 #include <linux/bootmem.h> 19 #include <linux/seq_file.h> 20 #include <linux/screen_info.h> 21 #include <linux/init.h> 22 #include <linux/kexec.h> 23 #include <linux/crash_dump.h> 24 #include <linux/root_dev.h> 25 #include <linux/cpu.h> 26 #include <linux/interrupt.h> 27 #include <linux/smp.h> 28 #include <linux/fs.h> 29 #include <linux/proc_fs.h> 30 #include <linux/memblock.h> 31 32 #include <asm/unified.h> 33 #include <asm/cpu.h> 34 #include <asm/cputype.h> 35 #include <asm/elf.h> 36 #include <asm/procinfo.h> 37 #include <asm/sections.h> 38 #include <asm/setup.h> 39 #include <asm/mach-types.h> 40 #include <asm/cacheflush.h> 41 #include <asm/cachetype.h> 42 #include <asm/tlbflush.h> 43 44 #include <asm/mach/arch.h> 45 #include <asm/mach/irq.h> 46 #include <asm/mach/time.h> 47 #include <asm/traps.h> 48 #include <asm/unwind.h> 49 50 #if defined(CONFIG_DEPRECATED_PARAM_STRUCT) 51 #include "compat.h" 52 #endif 53 #include "atags.h" 54 #include "tcm.h" 55 56 #ifndef MEM_SIZE 57 #define MEM_SIZE (16*1024*1024) 58 #endif 59 60 #if defined(CONFIG_FPE_NWFPE) || defined(CONFIG_FPE_FASTFPE) 61 char fpe_type[8]; 62 63 static int __init fpe_setup(char *line) 64 { 65 memcpy(fpe_type, line, 8); 66 return 1; 67 } 68 69 __setup("fpe=", fpe_setup); 70 #endif 71 72 extern void paging_init(struct machine_desc *desc); 73 extern void reboot_setup(char *str); 74 75 unsigned int processor_id; 76 EXPORT_SYMBOL(processor_id); 77 unsigned int __machine_arch_type; 78 EXPORT_SYMBOL(__machine_arch_type); 79 unsigned int cacheid; 80 EXPORT_SYMBOL(cacheid); 81 82 unsigned int __atags_pointer __initdata; 83 84 unsigned int system_rev; 85 EXPORT_SYMBOL(system_rev); 86 87 unsigned int system_serial_low; 88 EXPORT_SYMBOL(system_serial_low); 89 90 unsigned int system_serial_high; 91 EXPORT_SYMBOL(system_serial_high); 92 93 unsigned int elf_hwcap; 94 EXPORT_SYMBOL(elf_hwcap); 95 96 97 #ifdef MULTI_CPU 98 struct processor processor; 99 #endif 100 #ifdef MULTI_TLB 101 struct cpu_tlb_fns cpu_tlb; 102 #endif 103 #ifdef MULTI_USER 104 struct cpu_user_fns cpu_user; 105 #endif 106 #ifdef MULTI_CACHE 107 struct cpu_cache_fns cpu_cache; 108 #endif 109 #ifdef CONFIG_OUTER_CACHE 110 struct outer_cache_fns outer_cache; 111 EXPORT_SYMBOL(outer_cache); 112 #endif 113 114 struct stack { 115 u32 irq[3]; 116 u32 abt[3]; 117 u32 und[3]; 118 } ____cacheline_aligned; 119 120 static struct stack stacks[NR_CPUS]; 121 122 char elf_platform[ELF_PLATFORM_SIZE]; 123 EXPORT_SYMBOL(elf_platform); 124 125 static const char *cpu_name; 126 static const char *machine_name; 127 static char __initdata cmd_line[COMMAND_LINE_SIZE]; 128 129 static char default_command_line[COMMAND_LINE_SIZE] __initdata = CONFIG_CMDLINE; 130 static union { char c[4]; unsigned long l; } endian_test __initdata = { { 'l', '?', '?', 'b' } }; 131 #define ENDIANNESS ((char)endian_test.l) 132 133 DEFINE_PER_CPU(struct cpuinfo_arm, cpu_data); 134 135 /* 136 * Standard memory resources 137 */ 138 static struct resource mem_res[] = { 139 { 140 .name = "Video RAM", 141 .start = 0, 142 .end = 0, 143 .flags = IORESOURCE_MEM 144 }, 145 { 146 .name = "Kernel text", 147 .start = 0, 148 .end = 0, 149 .flags = IORESOURCE_MEM 150 }, 151 { 152 .name = "Kernel data", 153 .start = 0, 154 .end = 0, 155 .flags = IORESOURCE_MEM 156 } 157 }; 158 159 #define video_ram mem_res[0] 160 #define kernel_code mem_res[1] 161 #define kernel_data mem_res[2] 162 163 static struct resource io_res[] = { 164 { 165 .name = "reserved", 166 .start = 0x3bc, 167 .end = 0x3be, 168 .flags = IORESOURCE_IO | IORESOURCE_BUSY 169 }, 170 { 171 .name = "reserved", 172 .start = 0x378, 173 .end = 0x37f, 174 .flags = IORESOURCE_IO | IORESOURCE_BUSY 175 }, 176 { 177 .name = "reserved", 178 .start = 0x278, 179 .end = 0x27f, 180 .flags = IORESOURCE_IO | IORESOURCE_BUSY 181 } 182 }; 183 184 #define lp0 io_res[0] 185 #define lp1 io_res[1] 186 #define lp2 io_res[2] 187 188 static const char *proc_arch[] = { 189 "undefined/unknown", 190 "3", 191 "4", 192 "4T", 193 "5", 194 "5T", 195 "5TE", 196 "5TEJ", 197 "6TEJ", 198 "7", 199 "?(11)", 200 "?(12)", 201 "?(13)", 202 "?(14)", 203 "?(15)", 204 "?(16)", 205 "?(17)", 206 }; 207 208 int cpu_architecture(void) 209 { 210 int cpu_arch; 211 212 if ((read_cpuid_id() & 0x0008f000) == 0) { 213 cpu_arch = CPU_ARCH_UNKNOWN; 214 } else if ((read_cpuid_id() & 0x0008f000) == 0x00007000) { 215 cpu_arch = (read_cpuid_id() & (1 << 23)) ? CPU_ARCH_ARMv4T : CPU_ARCH_ARMv3; 216 } else if ((read_cpuid_id() & 0x00080000) == 0x00000000) { 217 cpu_arch = (read_cpuid_id() >> 16) & 7; 218 if (cpu_arch) 219 cpu_arch += CPU_ARCH_ARMv3; 220 } else if ((read_cpuid_id() & 0x000f0000) == 0x000f0000) { 221 unsigned int mmfr0; 222 223 /* Revised CPUID format. Read the Memory Model Feature 224 * Register 0 and check for VMSAv7 or PMSAv7 */ 225 asm("mrc p15, 0, %0, c0, c1, 4" 226 : "=r" (mmfr0)); 227 if ((mmfr0 & 0x0000000f) == 0x00000003 || 228 (mmfr0 & 0x000000f0) == 0x00000030) 229 cpu_arch = CPU_ARCH_ARMv7; 230 else if ((mmfr0 & 0x0000000f) == 0x00000002 || 231 (mmfr0 & 0x000000f0) == 0x00000020) 232 cpu_arch = CPU_ARCH_ARMv6; 233 else 234 cpu_arch = CPU_ARCH_UNKNOWN; 235 } else 236 cpu_arch = CPU_ARCH_UNKNOWN; 237 238 return cpu_arch; 239 } 240 241 static void __init cacheid_init(void) 242 { 243 unsigned int cachetype = read_cpuid_cachetype(); 244 unsigned int arch = cpu_architecture(); 245 246 if (arch >= CPU_ARCH_ARMv6) { 247 if ((cachetype & (7 << 29)) == 4 << 29) { 248 /* ARMv7 register format */ 249 cacheid = CACHEID_VIPT_NONALIASING; 250 if ((cachetype & (3 << 14)) == 1 << 14) 251 cacheid |= CACHEID_ASID_TAGGED; 252 } else if (cachetype & (1 << 23)) 253 cacheid = CACHEID_VIPT_ALIASING; 254 else 255 cacheid = CACHEID_VIPT_NONALIASING; 256 } else { 257 cacheid = CACHEID_VIVT; 258 } 259 260 printk("CPU: %s data cache, %s instruction cache\n", 261 cache_is_vivt() ? "VIVT" : 262 cache_is_vipt_aliasing() ? "VIPT aliasing" : 263 cache_is_vipt_nonaliasing() ? "VIPT nonaliasing" : "unknown", 264 cache_is_vivt() ? "VIVT" : 265 icache_is_vivt_asid_tagged() ? "VIVT ASID tagged" : 266 cache_is_vipt_aliasing() ? "VIPT aliasing" : 267 cache_is_vipt_nonaliasing() ? "VIPT nonaliasing" : "unknown"); 268 } 269 270 /* 271 * These functions re-use the assembly code in head.S, which 272 * already provide the required functionality. 273 */ 274 extern struct proc_info_list *lookup_processor_type(unsigned int); 275 extern struct machine_desc *lookup_machine_type(unsigned int); 276 277 static void __init feat_v6_fixup(void) 278 { 279 int id = read_cpuid_id(); 280 281 if ((id & 0xff0f0000) != 0x41070000) 282 return; 283 284 /* 285 * HWCAP_TLS is available only on 1136 r1p0 and later, 286 * see also kuser_get_tls_init. 287 */ 288 if ((((id >> 4) & 0xfff) == 0xb36) && (((id >> 20) & 3) == 0)) 289 elf_hwcap &= ~HWCAP_TLS; 290 } 291 292 static void __init setup_processor(void) 293 { 294 struct proc_info_list *list; 295 296 /* 297 * locate processor in the list of supported processor 298 * types. The linker builds this table for us from the 299 * entries in arch/arm/mm/proc-*.S 300 */ 301 list = lookup_processor_type(read_cpuid_id()); 302 if (!list) { 303 printk("CPU configuration botched (ID %08x), unable " 304 "to continue.\n", read_cpuid_id()); 305 while (1); 306 } 307 308 cpu_name = list->cpu_name; 309 310 #ifdef MULTI_CPU 311 processor = *list->proc; 312 #endif 313 #ifdef MULTI_TLB 314 cpu_tlb = *list->tlb; 315 #endif 316 #ifdef MULTI_USER 317 cpu_user = *list->user; 318 #endif 319 #ifdef MULTI_CACHE 320 cpu_cache = *list->cache; 321 #endif 322 323 printk("CPU: %s [%08x] revision %d (ARMv%s), cr=%08lx\n", 324 cpu_name, read_cpuid_id(), read_cpuid_id() & 15, 325 proc_arch[cpu_architecture()], cr_alignment); 326 327 sprintf(init_utsname()->machine, "%s%c", list->arch_name, ENDIANNESS); 328 sprintf(elf_platform, "%s%c", list->elf_name, ENDIANNESS); 329 elf_hwcap = list->elf_hwcap; 330 #ifndef CONFIG_ARM_THUMB 331 elf_hwcap &= ~HWCAP_THUMB; 332 #endif 333 334 feat_v6_fixup(); 335 336 cacheid_init(); 337 cpu_proc_init(); 338 } 339 340 /* 341 * cpu_init - initialise one CPU. 342 * 343 * cpu_init sets up the per-CPU stacks. 344 */ 345 void cpu_init(void) 346 { 347 unsigned int cpu = smp_processor_id(); 348 struct stack *stk = &stacks[cpu]; 349 350 if (cpu >= NR_CPUS) { 351 printk(KERN_CRIT "CPU%u: bad primary CPU number\n", cpu); 352 BUG(); 353 } 354 355 /* 356 * Define the placement constraint for the inline asm directive below. 357 * In Thumb-2, msr with an immediate value is not allowed. 358 */ 359 #ifdef CONFIG_THUMB2_KERNEL 360 #define PLC "r" 361 #else 362 #define PLC "I" 363 #endif 364 365 /* 366 * setup stacks for re-entrant exception handlers 367 */ 368 __asm__ ( 369 "msr cpsr_c, %1\n\t" 370 "add r14, %0, %2\n\t" 371 "mov sp, r14\n\t" 372 "msr cpsr_c, %3\n\t" 373 "add r14, %0, %4\n\t" 374 "mov sp, r14\n\t" 375 "msr cpsr_c, %5\n\t" 376 "add r14, %0, %6\n\t" 377 "mov sp, r14\n\t" 378 "msr cpsr_c, %7" 379 : 380 : "r" (stk), 381 PLC (PSR_F_BIT | PSR_I_BIT | IRQ_MODE), 382 "I" (offsetof(struct stack, irq[0])), 383 PLC (PSR_F_BIT | PSR_I_BIT | ABT_MODE), 384 "I" (offsetof(struct stack, abt[0])), 385 PLC (PSR_F_BIT | PSR_I_BIT | UND_MODE), 386 "I" (offsetof(struct stack, und[0])), 387 PLC (PSR_F_BIT | PSR_I_BIT | SVC_MODE) 388 : "r14"); 389 } 390 391 static struct machine_desc * __init setup_machine(unsigned int nr) 392 { 393 struct machine_desc *list; 394 395 /* 396 * locate machine in the list of supported machines. 397 */ 398 list = lookup_machine_type(nr); 399 if (!list) { 400 printk("Machine configuration botched (nr %d), unable " 401 "to continue.\n", nr); 402 while (1); 403 } 404 405 printk("Machine: %s\n", list->name); 406 407 return list; 408 } 409 410 static int __init arm_add_memory(unsigned long start, unsigned long size) 411 { 412 struct membank *bank = &meminfo.bank[meminfo.nr_banks]; 413 414 if (meminfo.nr_banks >= NR_BANKS) { 415 printk(KERN_CRIT "NR_BANKS too low, " 416 "ignoring memory at %#lx\n", start); 417 return -EINVAL; 418 } 419 420 /* 421 * Ensure that start/size are aligned to a page boundary. 422 * Size is appropriately rounded down, start is rounded up. 423 */ 424 size -= start & ~PAGE_MASK; 425 bank->start = PAGE_ALIGN(start); 426 bank->size = size & PAGE_MASK; 427 428 /* 429 * Check whether this memory region has non-zero size or 430 * invalid node number. 431 */ 432 if (bank->size == 0) 433 return -EINVAL; 434 435 meminfo.nr_banks++; 436 return 0; 437 } 438 439 /* 440 * Pick out the memory size. We look for mem=size@start, 441 * where start and size are "size[KkMm]" 442 */ 443 static int __init early_mem(char *p) 444 { 445 static int usermem __initdata = 0; 446 unsigned long size, start; 447 char *endp; 448 449 /* 450 * If the user specifies memory size, we 451 * blow away any automatically generated 452 * size. 453 */ 454 if (usermem == 0) { 455 usermem = 1; 456 meminfo.nr_banks = 0; 457 } 458 459 start = PHYS_OFFSET; 460 size = memparse(p, &endp); 461 if (*endp == '@') 462 start = memparse(endp + 1, NULL); 463 464 arm_add_memory(start, size); 465 466 return 0; 467 } 468 early_param("mem", early_mem); 469 470 static void __init 471 setup_ramdisk(int doload, int prompt, int image_start, unsigned int rd_sz) 472 { 473 #ifdef CONFIG_BLK_DEV_RAM 474 extern int rd_size, rd_image_start, rd_prompt, rd_doload; 475 476 rd_image_start = image_start; 477 rd_prompt = prompt; 478 rd_doload = doload; 479 480 if (rd_sz) 481 rd_size = rd_sz; 482 #endif 483 } 484 485 static void __init 486 request_standard_resources(struct meminfo *mi, struct machine_desc *mdesc) 487 { 488 struct resource *res; 489 int i; 490 491 kernel_code.start = virt_to_phys(_text); 492 kernel_code.end = virt_to_phys(_etext - 1); 493 kernel_data.start = virt_to_phys(_data); 494 kernel_data.end = virt_to_phys(_end - 1); 495 496 for (i = 0; i < mi->nr_banks; i++) { 497 if (mi->bank[i].size == 0) 498 continue; 499 500 res = alloc_bootmem_low(sizeof(*res)); 501 res->name = "System RAM"; 502 res->start = mi->bank[i].start; 503 res->end = mi->bank[i].start + mi->bank[i].size - 1; 504 res->flags = IORESOURCE_MEM | IORESOURCE_BUSY; 505 506 request_resource(&iomem_resource, res); 507 508 if (kernel_code.start >= res->start && 509 kernel_code.end <= res->end) 510 request_resource(res, &kernel_code); 511 if (kernel_data.start >= res->start && 512 kernel_data.end <= res->end) 513 request_resource(res, &kernel_data); 514 } 515 516 if (mdesc->video_start) { 517 video_ram.start = mdesc->video_start; 518 video_ram.end = mdesc->video_end; 519 request_resource(&iomem_resource, &video_ram); 520 } 521 522 /* 523 * Some machines don't have the possibility of ever 524 * possessing lp0, lp1 or lp2 525 */ 526 if (mdesc->reserve_lp0) 527 request_resource(&ioport_resource, &lp0); 528 if (mdesc->reserve_lp1) 529 request_resource(&ioport_resource, &lp1); 530 if (mdesc->reserve_lp2) 531 request_resource(&ioport_resource, &lp2); 532 } 533 534 /* 535 * Tag parsing. 536 * 537 * This is the new way of passing data to the kernel at boot time. Rather 538 * than passing a fixed inflexible structure to the kernel, we pass a list 539 * of variable-sized tags to the kernel. The first tag must be a ATAG_CORE 540 * tag for the list to be recognised (to distinguish the tagged list from 541 * a param_struct). The list is terminated with a zero-length tag (this tag 542 * is not parsed in any way). 543 */ 544 static int __init parse_tag_core(const struct tag *tag) 545 { 546 if (tag->hdr.size > 2) { 547 if ((tag->u.core.flags & 1) == 0) 548 root_mountflags &= ~MS_RDONLY; 549 ROOT_DEV = old_decode_dev(tag->u.core.rootdev); 550 } 551 return 0; 552 } 553 554 __tagtable(ATAG_CORE, parse_tag_core); 555 556 static int __init parse_tag_mem32(const struct tag *tag) 557 { 558 return arm_add_memory(tag->u.mem.start, tag->u.mem.size); 559 } 560 561 __tagtable(ATAG_MEM, parse_tag_mem32); 562 563 #if defined(CONFIG_VGA_CONSOLE) || defined(CONFIG_DUMMY_CONSOLE) 564 struct screen_info screen_info = { 565 .orig_video_lines = 30, 566 .orig_video_cols = 80, 567 .orig_video_mode = 0, 568 .orig_video_ega_bx = 0, 569 .orig_video_isVGA = 1, 570 .orig_video_points = 8 571 }; 572 573 static int __init parse_tag_videotext(const struct tag *tag) 574 { 575 screen_info.orig_x = tag->u.videotext.x; 576 screen_info.orig_y = tag->u.videotext.y; 577 screen_info.orig_video_page = tag->u.videotext.video_page; 578 screen_info.orig_video_mode = tag->u.videotext.video_mode; 579 screen_info.orig_video_cols = tag->u.videotext.video_cols; 580 screen_info.orig_video_ega_bx = tag->u.videotext.video_ega_bx; 581 screen_info.orig_video_lines = tag->u.videotext.video_lines; 582 screen_info.orig_video_isVGA = tag->u.videotext.video_isvga; 583 screen_info.orig_video_points = tag->u.videotext.video_points; 584 return 0; 585 } 586 587 __tagtable(ATAG_VIDEOTEXT, parse_tag_videotext); 588 #endif 589 590 static int __init parse_tag_ramdisk(const struct tag *tag) 591 { 592 setup_ramdisk((tag->u.ramdisk.flags & 1) == 0, 593 (tag->u.ramdisk.flags & 2) == 0, 594 tag->u.ramdisk.start, tag->u.ramdisk.size); 595 return 0; 596 } 597 598 __tagtable(ATAG_RAMDISK, parse_tag_ramdisk); 599 600 static int __init parse_tag_serialnr(const struct tag *tag) 601 { 602 system_serial_low = tag->u.serialnr.low; 603 system_serial_high = tag->u.serialnr.high; 604 return 0; 605 } 606 607 __tagtable(ATAG_SERIAL, parse_tag_serialnr); 608 609 static int __init parse_tag_revision(const struct tag *tag) 610 { 611 system_rev = tag->u.revision.rev; 612 return 0; 613 } 614 615 __tagtable(ATAG_REVISION, parse_tag_revision); 616 617 #ifndef CONFIG_CMDLINE_FORCE 618 static int __init parse_tag_cmdline(const struct tag *tag) 619 { 620 strlcpy(default_command_line, tag->u.cmdline.cmdline, COMMAND_LINE_SIZE); 621 return 0; 622 } 623 624 __tagtable(ATAG_CMDLINE, parse_tag_cmdline); 625 #endif /* CONFIG_CMDLINE_FORCE */ 626 627 /* 628 * Scan the tag table for this tag, and call its parse function. 629 * The tag table is built by the linker from all the __tagtable 630 * declarations. 631 */ 632 static int __init parse_tag(const struct tag *tag) 633 { 634 extern struct tagtable __tagtable_begin, __tagtable_end; 635 struct tagtable *t; 636 637 for (t = &__tagtable_begin; t < &__tagtable_end; t++) 638 if (tag->hdr.tag == t->tag) { 639 t->parse(tag); 640 break; 641 } 642 643 return t < &__tagtable_end; 644 } 645 646 /* 647 * Parse all tags in the list, checking both the global and architecture 648 * specific tag tables. 649 */ 650 static void __init parse_tags(const struct tag *t) 651 { 652 for (; t->hdr.size; t = tag_next(t)) 653 if (!parse_tag(t)) 654 printk(KERN_WARNING 655 "Ignoring unrecognised tag 0x%08x\n", 656 t->hdr.tag); 657 } 658 659 /* 660 * This holds our defaults. 661 */ 662 static struct init_tags { 663 struct tag_header hdr1; 664 struct tag_core core; 665 struct tag_header hdr2; 666 struct tag_mem32 mem; 667 struct tag_header hdr3; 668 } init_tags __initdata = { 669 { tag_size(tag_core), ATAG_CORE }, 670 { 1, PAGE_SIZE, 0xff }, 671 { tag_size(tag_mem32), ATAG_MEM }, 672 { MEM_SIZE, PHYS_OFFSET }, 673 { 0, ATAG_NONE } 674 }; 675 676 static void (*init_machine)(void) __initdata; 677 678 static int __init customize_machine(void) 679 { 680 /* customizes platform devices, or adds new ones */ 681 if (init_machine) 682 init_machine(); 683 return 0; 684 } 685 arch_initcall(customize_machine); 686 687 #ifdef CONFIG_KEXEC 688 static inline unsigned long long get_total_mem(void) 689 { 690 unsigned long total; 691 692 total = max_low_pfn - min_low_pfn; 693 return total << PAGE_SHIFT; 694 } 695 696 /** 697 * reserve_crashkernel() - reserves memory are for crash kernel 698 * 699 * This function reserves memory area given in "crashkernel=" kernel command 700 * line parameter. The memory reserved is used by a dump capture kernel when 701 * primary kernel is crashing. 702 */ 703 static void __init reserve_crashkernel(void) 704 { 705 unsigned long long crash_size, crash_base; 706 unsigned long long total_mem; 707 int ret; 708 709 total_mem = get_total_mem(); 710 ret = parse_crashkernel(boot_command_line, total_mem, 711 &crash_size, &crash_base); 712 if (ret) 713 return; 714 715 ret = reserve_bootmem(crash_base, crash_size, BOOTMEM_EXCLUSIVE); 716 if (ret < 0) { 717 printk(KERN_WARNING "crashkernel reservation failed - " 718 "memory is in use (0x%lx)\n", (unsigned long)crash_base); 719 return; 720 } 721 722 printk(KERN_INFO "Reserving %ldMB of memory at %ldMB " 723 "for crashkernel (System RAM: %ldMB)\n", 724 (unsigned long)(crash_size >> 20), 725 (unsigned long)(crash_base >> 20), 726 (unsigned long)(total_mem >> 20)); 727 728 crashk_res.start = crash_base; 729 crashk_res.end = crash_base + crash_size - 1; 730 insert_resource(&iomem_resource, &crashk_res); 731 } 732 #else 733 static inline void reserve_crashkernel(void) {} 734 #endif /* CONFIG_KEXEC */ 735 736 /* 737 * Note: elfcorehdr_addr is not just limited to vmcore. It is also used by 738 * is_kdump_kernel() to determine if we are booting after a panic. Hence 739 * ifdef it under CONFIG_CRASH_DUMP and not CONFIG_PROC_VMCORE. 740 */ 741 742 #ifdef CONFIG_CRASH_DUMP 743 /* 744 * elfcorehdr= specifies the location of elf core header stored by the crashed 745 * kernel. This option will be passed by kexec loader to the capture kernel. 746 */ 747 static int __init setup_elfcorehdr(char *arg) 748 { 749 char *end; 750 751 if (!arg) 752 return -EINVAL; 753 754 elfcorehdr_addr = memparse(arg, &end); 755 return end > arg ? 0 : -EINVAL; 756 } 757 early_param("elfcorehdr", setup_elfcorehdr); 758 #endif /* CONFIG_CRASH_DUMP */ 759 760 static void __init squash_mem_tags(struct tag *tag) 761 { 762 for (; tag->hdr.size; tag = tag_next(tag)) 763 if (tag->hdr.tag == ATAG_MEM) 764 tag->hdr.tag = ATAG_NONE; 765 } 766 767 void __init setup_arch(char **cmdline_p) 768 { 769 struct tag *tags = (struct tag *)&init_tags; 770 struct machine_desc *mdesc; 771 char *from = default_command_line; 772 773 unwind_init(); 774 775 setup_processor(); 776 mdesc = setup_machine(machine_arch_type); 777 machine_name = mdesc->name; 778 779 if (mdesc->soft_reboot) 780 reboot_setup("s"); 781 782 if (__atags_pointer) 783 tags = phys_to_virt(__atags_pointer); 784 else if (mdesc->boot_params) 785 tags = phys_to_virt(mdesc->boot_params); 786 787 #if defined(CONFIG_DEPRECATED_PARAM_STRUCT) 788 /* 789 * If we have the old style parameters, convert them to 790 * a tag list. 791 */ 792 if (tags->hdr.tag != ATAG_CORE) 793 convert_to_tag_list(tags); 794 #endif 795 if (tags->hdr.tag != ATAG_CORE) 796 tags = (struct tag *)&init_tags; 797 798 if (mdesc->fixup) 799 mdesc->fixup(mdesc, tags, &from, &meminfo); 800 801 if (tags->hdr.tag == ATAG_CORE) { 802 if (meminfo.nr_banks != 0) 803 squash_mem_tags(tags); 804 save_atags(tags); 805 parse_tags(tags); 806 } 807 808 init_mm.start_code = (unsigned long) _text; 809 init_mm.end_code = (unsigned long) _etext; 810 init_mm.end_data = (unsigned long) _edata; 811 init_mm.brk = (unsigned long) _end; 812 813 /* parse_early_param needs a boot_command_line */ 814 strlcpy(boot_command_line, from, COMMAND_LINE_SIZE); 815 816 /* populate cmd_line too for later use, preserving boot_command_line */ 817 strlcpy(cmd_line, boot_command_line, COMMAND_LINE_SIZE); 818 *cmdline_p = cmd_line; 819 820 parse_early_param(); 821 822 arm_memblock_init(&meminfo, mdesc); 823 824 paging_init(mdesc); 825 request_standard_resources(&meminfo, mdesc); 826 827 #ifdef CONFIG_SMP 828 smp_init_cpus(); 829 #endif 830 reserve_crashkernel(); 831 832 cpu_init(); 833 tcm_init(); 834 835 /* 836 * Set up various architecture-specific pointers 837 */ 838 arch_nr_irqs = mdesc->nr_irqs; 839 init_arch_irq = mdesc->init_irq; 840 system_timer = mdesc->timer; 841 init_machine = mdesc->init_machine; 842 843 #ifdef CONFIG_VT 844 #if defined(CONFIG_VGA_CONSOLE) 845 conswitchp = &vga_con; 846 #elif defined(CONFIG_DUMMY_CONSOLE) 847 conswitchp = &dummy_con; 848 #endif 849 #endif 850 early_trap_init(); 851 } 852 853 854 static int __init topology_init(void) 855 { 856 int cpu; 857 858 for_each_possible_cpu(cpu) { 859 struct cpuinfo_arm *cpuinfo = &per_cpu(cpu_data, cpu); 860 cpuinfo->cpu.hotpluggable = 1; 861 register_cpu(&cpuinfo->cpu, cpu); 862 } 863 864 return 0; 865 } 866 subsys_initcall(topology_init); 867 868 #ifdef CONFIG_HAVE_PROC_CPU 869 static int __init proc_cpu_init(void) 870 { 871 struct proc_dir_entry *res; 872 873 res = proc_mkdir("cpu", NULL); 874 if (!res) 875 return -ENOMEM; 876 return 0; 877 } 878 fs_initcall(proc_cpu_init); 879 #endif 880 881 static const char *hwcap_str[] = { 882 "swp", 883 "half", 884 "thumb", 885 "26bit", 886 "fastmult", 887 "fpa", 888 "vfp", 889 "edsp", 890 "java", 891 "iwmmxt", 892 "crunch", 893 "thumbee", 894 "neon", 895 "vfpv3", 896 "vfpv3d16", 897 NULL 898 }; 899 900 static int c_show(struct seq_file *m, void *v) 901 { 902 int i; 903 904 seq_printf(m, "Processor\t: %s rev %d (%s)\n", 905 cpu_name, read_cpuid_id() & 15, elf_platform); 906 907 #if defined(CONFIG_SMP) 908 for_each_online_cpu(i) { 909 /* 910 * glibc reads /proc/cpuinfo to determine the number of 911 * online processors, looking for lines beginning with 912 * "processor". Give glibc what it expects. 913 */ 914 seq_printf(m, "processor\t: %d\n", i); 915 seq_printf(m, "BogoMIPS\t: %lu.%02lu\n\n", 916 per_cpu(cpu_data, i).loops_per_jiffy / (500000UL/HZ), 917 (per_cpu(cpu_data, i).loops_per_jiffy / (5000UL/HZ)) % 100); 918 } 919 #else /* CONFIG_SMP */ 920 seq_printf(m, "BogoMIPS\t: %lu.%02lu\n", 921 loops_per_jiffy / (500000/HZ), 922 (loops_per_jiffy / (5000/HZ)) % 100); 923 #endif 924 925 /* dump out the processor features */ 926 seq_puts(m, "Features\t: "); 927 928 for (i = 0; hwcap_str[i]; i++) 929 if (elf_hwcap & (1 << i)) 930 seq_printf(m, "%s ", hwcap_str[i]); 931 932 seq_printf(m, "\nCPU implementer\t: 0x%02x\n", read_cpuid_id() >> 24); 933 seq_printf(m, "CPU architecture: %s\n", proc_arch[cpu_architecture()]); 934 935 if ((read_cpuid_id() & 0x0008f000) == 0x00000000) { 936 /* pre-ARM7 */ 937 seq_printf(m, "CPU part\t: %07x\n", read_cpuid_id() >> 4); 938 } else { 939 if ((read_cpuid_id() & 0x0008f000) == 0x00007000) { 940 /* ARM7 */ 941 seq_printf(m, "CPU variant\t: 0x%02x\n", 942 (read_cpuid_id() >> 16) & 127); 943 } else { 944 /* post-ARM7 */ 945 seq_printf(m, "CPU variant\t: 0x%x\n", 946 (read_cpuid_id() >> 20) & 15); 947 } 948 seq_printf(m, "CPU part\t: 0x%03x\n", 949 (read_cpuid_id() >> 4) & 0xfff); 950 } 951 seq_printf(m, "CPU revision\t: %d\n", read_cpuid_id() & 15); 952 953 seq_puts(m, "\n"); 954 955 seq_printf(m, "Hardware\t: %s\n", machine_name); 956 seq_printf(m, "Revision\t: %04x\n", system_rev); 957 seq_printf(m, "Serial\t\t: %08x%08x\n", 958 system_serial_high, system_serial_low); 959 960 return 0; 961 } 962 963 static void *c_start(struct seq_file *m, loff_t *pos) 964 { 965 return *pos < 1 ? (void *)1 : NULL; 966 } 967 968 static void *c_next(struct seq_file *m, void *v, loff_t *pos) 969 { 970 ++*pos; 971 return NULL; 972 } 973 974 static void c_stop(struct seq_file *m, void *v) 975 { 976 } 977 978 const struct seq_operations cpuinfo_op = { 979 .start = c_start, 980 .next = c_next, 981 .stop = c_stop, 982 .show = c_show 983 }; 984