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