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