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