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 527 #ifndef CONFIG_LPAE 528 if (bank->start + size < bank->start) { 529 printk(KERN_CRIT "Truncating memory at 0x%08llx to fit in " 530 "32-bit physical address space\n", (long long)start); 531 /* 532 * To ensure bank->start + bank->size is representable in 533 * 32 bits, we use ULONG_MAX as the upper limit rather than 4GB. 534 * This means we lose a page after masking. 535 */ 536 size = ULONG_MAX - bank->start; 537 } 538 #endif 539 540 bank->size = size & PAGE_MASK; 541 542 /* 543 * Check whether this memory region has non-zero size or 544 * invalid node number. 545 */ 546 if (bank->size == 0) 547 return -EINVAL; 548 549 meminfo.nr_banks++; 550 return 0; 551 } 552 553 /* 554 * Pick out the memory size. We look for mem=size@start, 555 * where start and size are "size[KkMm]" 556 */ 557 static int __init early_mem(char *p) 558 { 559 static int usermem __initdata = 0; 560 unsigned long size; 561 phys_addr_t start; 562 char *endp; 563 564 /* 565 * If the user specifies memory size, we 566 * blow away any automatically generated 567 * size. 568 */ 569 if (usermem == 0) { 570 usermem = 1; 571 meminfo.nr_banks = 0; 572 } 573 574 start = PHYS_OFFSET; 575 size = memparse(p, &endp); 576 if (*endp == '@') 577 start = memparse(endp + 1, NULL); 578 579 arm_add_memory(start, size); 580 581 return 0; 582 } 583 early_param("mem", early_mem); 584 585 static void __init 586 setup_ramdisk(int doload, int prompt, int image_start, unsigned int rd_sz) 587 { 588 #ifdef CONFIG_BLK_DEV_RAM 589 extern int rd_size, rd_image_start, rd_prompt, rd_doload; 590 591 rd_image_start = image_start; 592 rd_prompt = prompt; 593 rd_doload = doload; 594 595 if (rd_sz) 596 rd_size = rd_sz; 597 #endif 598 } 599 600 static void __init request_standard_resources(struct machine_desc *mdesc) 601 { 602 struct memblock_region *region; 603 struct resource *res; 604 605 kernel_code.start = virt_to_phys(_text); 606 kernel_code.end = virt_to_phys(_etext - 1); 607 kernel_data.start = virt_to_phys(_sdata); 608 kernel_data.end = virt_to_phys(_end - 1); 609 610 for_each_memblock(memory, region) { 611 res = alloc_bootmem_low(sizeof(*res)); 612 res->name = "System RAM"; 613 res->start = __pfn_to_phys(memblock_region_memory_base_pfn(region)); 614 res->end = __pfn_to_phys(memblock_region_memory_end_pfn(region)) - 1; 615 res->flags = IORESOURCE_MEM | IORESOURCE_BUSY; 616 617 request_resource(&iomem_resource, res); 618 619 if (kernel_code.start >= res->start && 620 kernel_code.end <= res->end) 621 request_resource(res, &kernel_code); 622 if (kernel_data.start >= res->start && 623 kernel_data.end <= res->end) 624 request_resource(res, &kernel_data); 625 } 626 627 if (mdesc->video_start) { 628 video_ram.start = mdesc->video_start; 629 video_ram.end = mdesc->video_end; 630 request_resource(&iomem_resource, &video_ram); 631 } 632 633 /* 634 * Some machines don't have the possibility of ever 635 * possessing lp0, lp1 or lp2 636 */ 637 if (mdesc->reserve_lp0) 638 request_resource(&ioport_resource, &lp0); 639 if (mdesc->reserve_lp1) 640 request_resource(&ioport_resource, &lp1); 641 if (mdesc->reserve_lp2) 642 request_resource(&ioport_resource, &lp2); 643 } 644 645 /* 646 * Tag parsing. 647 * 648 * This is the new way of passing data to the kernel at boot time. Rather 649 * than passing a fixed inflexible structure to the kernel, we pass a list 650 * of variable-sized tags to the kernel. The first tag must be a ATAG_CORE 651 * tag for the list to be recognised (to distinguish the tagged list from 652 * a param_struct). The list is terminated with a zero-length tag (this tag 653 * is not parsed in any way). 654 */ 655 static int __init parse_tag_core(const struct tag *tag) 656 { 657 if (tag->hdr.size > 2) { 658 if ((tag->u.core.flags & 1) == 0) 659 root_mountflags &= ~MS_RDONLY; 660 ROOT_DEV = old_decode_dev(tag->u.core.rootdev); 661 } 662 return 0; 663 } 664 665 __tagtable(ATAG_CORE, parse_tag_core); 666 667 static int __init parse_tag_mem32(const struct tag *tag) 668 { 669 return arm_add_memory(tag->u.mem.start, tag->u.mem.size); 670 } 671 672 __tagtable(ATAG_MEM, parse_tag_mem32); 673 674 #if defined(CONFIG_VGA_CONSOLE) || defined(CONFIG_DUMMY_CONSOLE) 675 struct screen_info screen_info = { 676 .orig_video_lines = 30, 677 .orig_video_cols = 80, 678 .orig_video_mode = 0, 679 .orig_video_ega_bx = 0, 680 .orig_video_isVGA = 1, 681 .orig_video_points = 8 682 }; 683 684 static int __init parse_tag_videotext(const struct tag *tag) 685 { 686 screen_info.orig_x = tag->u.videotext.x; 687 screen_info.orig_y = tag->u.videotext.y; 688 screen_info.orig_video_page = tag->u.videotext.video_page; 689 screen_info.orig_video_mode = tag->u.videotext.video_mode; 690 screen_info.orig_video_cols = tag->u.videotext.video_cols; 691 screen_info.orig_video_ega_bx = tag->u.videotext.video_ega_bx; 692 screen_info.orig_video_lines = tag->u.videotext.video_lines; 693 screen_info.orig_video_isVGA = tag->u.videotext.video_isvga; 694 screen_info.orig_video_points = tag->u.videotext.video_points; 695 return 0; 696 } 697 698 __tagtable(ATAG_VIDEOTEXT, parse_tag_videotext); 699 #endif 700 701 static int __init parse_tag_ramdisk(const struct tag *tag) 702 { 703 setup_ramdisk((tag->u.ramdisk.flags & 1) == 0, 704 (tag->u.ramdisk.flags & 2) == 0, 705 tag->u.ramdisk.start, tag->u.ramdisk.size); 706 return 0; 707 } 708 709 __tagtable(ATAG_RAMDISK, parse_tag_ramdisk); 710 711 static int __init parse_tag_serialnr(const struct tag *tag) 712 { 713 system_serial_low = tag->u.serialnr.low; 714 system_serial_high = tag->u.serialnr.high; 715 return 0; 716 } 717 718 __tagtable(ATAG_SERIAL, parse_tag_serialnr); 719 720 static int __init parse_tag_revision(const struct tag *tag) 721 { 722 system_rev = tag->u.revision.rev; 723 return 0; 724 } 725 726 __tagtable(ATAG_REVISION, parse_tag_revision); 727 728 static int __init parse_tag_cmdline(const struct tag *tag) 729 { 730 #if defined(CONFIG_CMDLINE_EXTEND) 731 strlcat(default_command_line, " ", COMMAND_LINE_SIZE); 732 strlcat(default_command_line, tag->u.cmdline.cmdline, 733 COMMAND_LINE_SIZE); 734 #elif defined(CONFIG_CMDLINE_FORCE) 735 pr_warning("Ignoring tag cmdline (using the default kernel command line)\n"); 736 #else 737 strlcpy(default_command_line, tag->u.cmdline.cmdline, 738 COMMAND_LINE_SIZE); 739 #endif 740 return 0; 741 } 742 743 __tagtable(ATAG_CMDLINE, parse_tag_cmdline); 744 745 /* 746 * Scan the tag table for this tag, and call its parse function. 747 * The tag table is built by the linker from all the __tagtable 748 * declarations. 749 */ 750 static int __init parse_tag(const struct tag *tag) 751 { 752 extern struct tagtable __tagtable_begin, __tagtable_end; 753 struct tagtable *t; 754 755 for (t = &__tagtable_begin; t < &__tagtable_end; t++) 756 if (tag->hdr.tag == t->tag) { 757 t->parse(tag); 758 break; 759 } 760 761 return t < &__tagtable_end; 762 } 763 764 /* 765 * Parse all tags in the list, checking both the global and architecture 766 * specific tag tables. 767 */ 768 static void __init parse_tags(const struct tag *t) 769 { 770 for (; t->hdr.size; t = tag_next(t)) 771 if (!parse_tag(t)) 772 printk(KERN_WARNING 773 "Ignoring unrecognised tag 0x%08x\n", 774 t->hdr.tag); 775 } 776 777 /* 778 * This holds our defaults. 779 */ 780 static struct init_tags { 781 struct tag_header hdr1; 782 struct tag_core core; 783 struct tag_header hdr2; 784 struct tag_mem32 mem; 785 struct tag_header hdr3; 786 } init_tags __initdata = { 787 { tag_size(tag_core), ATAG_CORE }, 788 { 1, PAGE_SIZE, 0xff }, 789 { tag_size(tag_mem32), ATAG_MEM }, 790 { MEM_SIZE }, 791 { 0, ATAG_NONE } 792 }; 793 794 static int __init customize_machine(void) 795 { 796 /* customizes platform devices, or adds new ones */ 797 if (machine_desc->init_machine) 798 machine_desc->init_machine(); 799 return 0; 800 } 801 arch_initcall(customize_machine); 802 803 #ifdef CONFIG_KEXEC 804 static inline unsigned long long get_total_mem(void) 805 { 806 unsigned long total; 807 808 total = max_low_pfn - min_low_pfn; 809 return total << PAGE_SHIFT; 810 } 811 812 /** 813 * reserve_crashkernel() - reserves memory are for crash kernel 814 * 815 * This function reserves memory area given in "crashkernel=" kernel command 816 * line parameter. The memory reserved is used by a dump capture kernel when 817 * primary kernel is crashing. 818 */ 819 static void __init reserve_crashkernel(void) 820 { 821 unsigned long long crash_size, crash_base; 822 unsigned long long total_mem; 823 int ret; 824 825 total_mem = get_total_mem(); 826 ret = parse_crashkernel(boot_command_line, total_mem, 827 &crash_size, &crash_base); 828 if (ret) 829 return; 830 831 ret = reserve_bootmem(crash_base, crash_size, BOOTMEM_EXCLUSIVE); 832 if (ret < 0) { 833 printk(KERN_WARNING "crashkernel reservation failed - " 834 "memory is in use (0x%lx)\n", (unsigned long)crash_base); 835 return; 836 } 837 838 printk(KERN_INFO "Reserving %ldMB of memory at %ldMB " 839 "for crashkernel (System RAM: %ldMB)\n", 840 (unsigned long)(crash_size >> 20), 841 (unsigned long)(crash_base >> 20), 842 (unsigned long)(total_mem >> 20)); 843 844 crashk_res.start = crash_base; 845 crashk_res.end = crash_base + crash_size - 1; 846 insert_resource(&iomem_resource, &crashk_res); 847 } 848 #else 849 static inline void reserve_crashkernel(void) {} 850 #endif /* CONFIG_KEXEC */ 851 852 static void __init squash_mem_tags(struct tag *tag) 853 { 854 for (; tag->hdr.size; tag = tag_next(tag)) 855 if (tag->hdr.tag == ATAG_MEM) 856 tag->hdr.tag = ATAG_NONE; 857 } 858 859 static struct machine_desc * __init setup_machine_tags(unsigned int nr) 860 { 861 struct tag *tags = (struct tag *)&init_tags; 862 struct machine_desc *mdesc = NULL, *p; 863 char *from = default_command_line; 864 865 init_tags.mem.start = PHYS_OFFSET; 866 867 /* 868 * locate machine in the list of supported machines. 869 */ 870 for_each_machine_desc(p) 871 if (nr == p->nr) { 872 printk("Machine: %s\n", p->name); 873 mdesc = p; 874 break; 875 } 876 877 if (!mdesc) { 878 early_print("\nError: unrecognized/unsupported machine ID" 879 " (r1 = 0x%08x).\n\n", nr); 880 dump_machine_table(); /* does not return */ 881 } 882 883 if (__atags_pointer) 884 tags = phys_to_virt(__atags_pointer); 885 else if (mdesc->atag_offset) 886 tags = (void *)(PAGE_OFFSET + mdesc->atag_offset); 887 888 #if defined(CONFIG_DEPRECATED_PARAM_STRUCT) 889 /* 890 * If we have the old style parameters, convert them to 891 * a tag list. 892 */ 893 if (tags->hdr.tag != ATAG_CORE) 894 convert_to_tag_list(tags); 895 #endif 896 897 if (tags->hdr.tag != ATAG_CORE) { 898 #if defined(CONFIG_OF) 899 /* 900 * If CONFIG_OF is set, then assume this is a reasonably 901 * modern system that should pass boot parameters 902 */ 903 early_print("Warning: Neither atags nor dtb found\n"); 904 #endif 905 tags = (struct tag *)&init_tags; 906 } 907 908 if (mdesc->fixup) 909 mdesc->fixup(tags, &from, &meminfo); 910 911 if (tags->hdr.tag == ATAG_CORE) { 912 if (meminfo.nr_banks != 0) 913 squash_mem_tags(tags); 914 save_atags(tags); 915 parse_tags(tags); 916 } 917 918 /* parse_early_param needs a boot_command_line */ 919 strlcpy(boot_command_line, from, COMMAND_LINE_SIZE); 920 921 return mdesc; 922 } 923 924 static int __init meminfo_cmp(const void *_a, const void *_b) 925 { 926 const struct membank *a = _a, *b = _b; 927 long cmp = bank_pfn_start(a) - bank_pfn_start(b); 928 return cmp < 0 ? -1 : cmp > 0 ? 1 : 0; 929 } 930 931 void __init setup_arch(char **cmdline_p) 932 { 933 struct machine_desc *mdesc; 934 935 setup_processor(); 936 mdesc = setup_machine_fdt(__atags_pointer); 937 if (!mdesc) 938 mdesc = setup_machine_tags(machine_arch_type); 939 machine_desc = mdesc; 940 machine_name = mdesc->name; 941 942 #ifdef CONFIG_ZONE_DMA 943 if (mdesc->dma_zone_size) { 944 extern unsigned long arm_dma_zone_size; 945 arm_dma_zone_size = mdesc->dma_zone_size; 946 } 947 #endif 948 if (mdesc->restart_mode) 949 reboot_setup(&mdesc->restart_mode); 950 951 init_mm.start_code = (unsigned long) _text; 952 init_mm.end_code = (unsigned long) _etext; 953 init_mm.end_data = (unsigned long) _edata; 954 init_mm.brk = (unsigned long) _end; 955 956 /* populate cmd_line too for later use, preserving boot_command_line */ 957 strlcpy(cmd_line, boot_command_line, COMMAND_LINE_SIZE); 958 *cmdline_p = cmd_line; 959 960 parse_early_param(); 961 962 sort(&meminfo.bank, meminfo.nr_banks, sizeof(meminfo.bank[0]), meminfo_cmp, NULL); 963 sanity_check_meminfo(); 964 arm_memblock_init(&meminfo, mdesc); 965 966 paging_init(mdesc); 967 request_standard_resources(mdesc); 968 969 if (mdesc->restart) 970 arm_pm_restart = mdesc->restart; 971 972 unflatten_device_tree(); 973 974 #ifdef CONFIG_SMP 975 if (is_smp()) 976 smp_init_cpus(); 977 #endif 978 reserve_crashkernel(); 979 980 tcm_init(); 981 982 #ifdef CONFIG_MULTI_IRQ_HANDLER 983 handle_arch_irq = mdesc->handle_irq; 984 #endif 985 986 #ifdef CONFIG_VT 987 #if defined(CONFIG_VGA_CONSOLE) 988 conswitchp = &vga_con; 989 #elif defined(CONFIG_DUMMY_CONSOLE) 990 conswitchp = &dummy_con; 991 #endif 992 #endif 993 994 if (mdesc->init_early) 995 mdesc->init_early(); 996 } 997 998 999 static int __init topology_init(void) 1000 { 1001 int cpu; 1002 1003 for_each_possible_cpu(cpu) { 1004 struct cpuinfo_arm *cpuinfo = &per_cpu(cpu_data, cpu); 1005 cpuinfo->cpu.hotpluggable = 1; 1006 register_cpu(&cpuinfo->cpu, cpu); 1007 } 1008 1009 return 0; 1010 } 1011 subsys_initcall(topology_init); 1012 1013 #ifdef CONFIG_HAVE_PROC_CPU 1014 static int __init proc_cpu_init(void) 1015 { 1016 struct proc_dir_entry *res; 1017 1018 res = proc_mkdir("cpu", NULL); 1019 if (!res) 1020 return -ENOMEM; 1021 return 0; 1022 } 1023 fs_initcall(proc_cpu_init); 1024 #endif 1025 1026 static const char *hwcap_str[] = { 1027 "swp", 1028 "half", 1029 "thumb", 1030 "26bit", 1031 "fastmult", 1032 "fpa", 1033 "vfp", 1034 "edsp", 1035 "java", 1036 "iwmmxt", 1037 "crunch", 1038 "thumbee", 1039 "neon", 1040 "vfpv3", 1041 "vfpv3d16", 1042 "tls", 1043 "vfpv4", 1044 "idiva", 1045 "idivt", 1046 NULL 1047 }; 1048 1049 static int c_show(struct seq_file *m, void *v) 1050 { 1051 int i; 1052 1053 seq_printf(m, "Processor\t: %s rev %d (%s)\n", 1054 cpu_name, read_cpuid_id() & 15, elf_platform); 1055 1056 #if defined(CONFIG_SMP) 1057 for_each_online_cpu(i) { 1058 /* 1059 * glibc reads /proc/cpuinfo to determine the number of 1060 * online processors, looking for lines beginning with 1061 * "processor". Give glibc what it expects. 1062 */ 1063 seq_printf(m, "processor\t: %d\n", i); 1064 seq_printf(m, "BogoMIPS\t: %lu.%02lu\n\n", 1065 per_cpu(cpu_data, i).loops_per_jiffy / (500000UL/HZ), 1066 (per_cpu(cpu_data, i).loops_per_jiffy / (5000UL/HZ)) % 100); 1067 } 1068 #else /* CONFIG_SMP */ 1069 seq_printf(m, "BogoMIPS\t: %lu.%02lu\n", 1070 loops_per_jiffy / (500000/HZ), 1071 (loops_per_jiffy / (5000/HZ)) % 100); 1072 #endif 1073 1074 /* dump out the processor features */ 1075 seq_puts(m, "Features\t: "); 1076 1077 for (i = 0; hwcap_str[i]; i++) 1078 if (elf_hwcap & (1 << i)) 1079 seq_printf(m, "%s ", hwcap_str[i]); 1080 1081 seq_printf(m, "\nCPU implementer\t: 0x%02x\n", read_cpuid_id() >> 24); 1082 seq_printf(m, "CPU architecture: %s\n", proc_arch[cpu_architecture()]); 1083 1084 if ((read_cpuid_id() & 0x0008f000) == 0x00000000) { 1085 /* pre-ARM7 */ 1086 seq_printf(m, "CPU part\t: %07x\n", read_cpuid_id() >> 4); 1087 } else { 1088 if ((read_cpuid_id() & 0x0008f000) == 0x00007000) { 1089 /* ARM7 */ 1090 seq_printf(m, "CPU variant\t: 0x%02x\n", 1091 (read_cpuid_id() >> 16) & 127); 1092 } else { 1093 /* post-ARM7 */ 1094 seq_printf(m, "CPU variant\t: 0x%x\n", 1095 (read_cpuid_id() >> 20) & 15); 1096 } 1097 seq_printf(m, "CPU part\t: 0x%03x\n", 1098 (read_cpuid_id() >> 4) & 0xfff); 1099 } 1100 seq_printf(m, "CPU revision\t: %d\n", read_cpuid_id() & 15); 1101 1102 seq_puts(m, "\n"); 1103 1104 seq_printf(m, "Hardware\t: %s\n", machine_name); 1105 seq_printf(m, "Revision\t: %04x\n", system_rev); 1106 seq_printf(m, "Serial\t\t: %08x%08x\n", 1107 system_serial_high, system_serial_low); 1108 1109 return 0; 1110 } 1111 1112 static void *c_start(struct seq_file *m, loff_t *pos) 1113 { 1114 return *pos < 1 ? (void *)1 : NULL; 1115 } 1116 1117 static void *c_next(struct seq_file *m, void *v, loff_t *pos) 1118 { 1119 ++*pos; 1120 return NULL; 1121 } 1122 1123 static void c_stop(struct seq_file *m, void *v) 1124 { 1125 } 1126 1127 const struct seq_operations cpuinfo_op = { 1128 .start = c_start, 1129 .next = c_next, 1130 .stop = c_stop, 1131 .show = c_show 1132 }; 1133