setup.c 24.2 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
/*
 *  linux/arch/arm/kernel/setup.c
 *
 *  Copyright (C) 1995-2001 Russell King
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/stddef.h>
#include <linux/ioport.h>
#include <linux/delay.h>
#include <linux/utsname.h>
#include <linux/initrd.h>
#include <linux/console.h>
#include <linux/bootmem.h>
#include <linux/seq_file.h>
20
#include <linux/screen_info.h>
Linus Torvalds's avatar
Linus Torvalds committed
21
#include <linux/init.h>
22
#include <linux/kexec.h>
23
#include <linux/crash_dump.h>
Linus Torvalds's avatar
Linus Torvalds committed
24 25 26
#include <linux/root_dev.h>
#include <linux/cpu.h>
#include <linux/interrupt.h>
27
#include <linux/smp.h>
Alexey Dobriyan's avatar
Alexey Dobriyan committed
28
#include <linux/fs.h>
29
#include <linux/proc_fs.h>
Russell King's avatar
Russell King committed
30
#include <linux/memblock.h>
Linus Torvalds's avatar
Linus Torvalds committed
31

32
#include <asm/unified.h>
Linus Torvalds's avatar
Linus Torvalds committed
33
#include <asm/cpu.h>
34
#include <asm/cputype.h>
Linus Torvalds's avatar
Linus Torvalds committed
35 36
#include <asm/elf.h>
#include <asm/procinfo.h>
Russell King's avatar
Russell King committed
37
#include <asm/sections.h>
Linus Torvalds's avatar
Linus Torvalds committed
38
#include <asm/setup.h>
39
#include <asm/smp_plat.h>
Linus Torvalds's avatar
Linus Torvalds committed
40 41
#include <asm/mach-types.h>
#include <asm/cacheflush.h>
42
#include <asm/cachetype.h>
Linus Torvalds's avatar
Linus Torvalds committed
43 44 45 46 47
#include <asm/tlbflush.h>

#include <asm/mach/arch.h>
#include <asm/mach/irq.h>
#include <asm/mach/time.h>
Jason Wessel's avatar
Jason Wessel committed
48
#include <asm/traps.h>
49
#include <asm/unwind.h>
Linus Torvalds's avatar
Linus Torvalds committed
50

51
#if defined(CONFIG_DEPRECATED_PARAM_STRUCT)
52
#include "compat.h"
53
#endif
54
#include "atags.h"
55
#include "tcm.h"
56

Linus Torvalds's avatar
Linus Torvalds committed
57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72
#ifndef MEM_SIZE
#define MEM_SIZE	(16*1024*1024)
#endif

#if defined(CONFIG_FPE_NWFPE) || defined(CONFIG_FPE_FASTFPE)
char fpe_type[8];

static int __init fpe_setup(char *line)
{
	memcpy(fpe_type, line, 8);
	return 1;
}

__setup("fpe=", fpe_setup);
#endif

73
extern void paging_init(struct machine_desc *desc);
Linus Torvalds's avatar
Linus Torvalds committed
74 75 76
extern void reboot_setup(char *str);

unsigned int processor_id;
77
EXPORT_SYMBOL(processor_id);
78
unsigned int __machine_arch_type __read_mostly;
Linus Torvalds's avatar
Linus Torvalds committed
79
EXPORT_SYMBOL(__machine_arch_type);
80
unsigned int cacheid __read_mostly;
81
EXPORT_SYMBOL(cacheid);
Linus Torvalds's avatar
Linus Torvalds committed
82

83 84
unsigned int __atags_pointer __initdata;

Linus Torvalds's avatar
Linus Torvalds committed
85 86 87 88 89 90 91 92 93
unsigned int system_rev;
EXPORT_SYMBOL(system_rev);

unsigned int system_serial_low;
EXPORT_SYMBOL(system_serial_low);

unsigned int system_serial_high;
EXPORT_SYMBOL(system_serial_high);

94
unsigned int elf_hwcap __read_mostly;
Linus Torvalds's avatar
Linus Torvalds committed
95 96 97 98
EXPORT_SYMBOL(elf_hwcap);


#ifdef MULTI_CPU
99
struct processor processor __read_mostly;
Linus Torvalds's avatar
Linus Torvalds committed
100 101
#endif
#ifdef MULTI_TLB
102
struct cpu_tlb_fns cpu_tlb __read_mostly;
Linus Torvalds's avatar
Linus Torvalds committed
103 104
#endif
#ifdef MULTI_USER
105
struct cpu_user_fns cpu_user __read_mostly;
Linus Torvalds's avatar
Linus Torvalds committed
106 107
#endif
#ifdef MULTI_CACHE
108
struct cpu_cache_fns cpu_cache __read_mostly;
Linus Torvalds's avatar
Linus Torvalds committed
109
#endif
110
#ifdef CONFIG_OUTER_CACHE
111
struct outer_cache_fns outer_cache __read_mostly;
112
EXPORT_SYMBOL(outer_cache);
113
#endif
Linus Torvalds's avatar
Linus Torvalds committed
114

115 116 117 118 119 120 121 122
struct stack {
	u32 irq[3];
	u32 abt[3];
	u32 und[3];
} ____cacheline_aligned;

static struct stack stacks[NR_CPUS];

Linus Torvalds's avatar
Linus Torvalds committed
123 124 125 126 127
char elf_platform[ELF_PLATFORM_SIZE];
EXPORT_SYMBOL(elf_platform);

static const char *cpu_name;
static const char *machine_name;
128
static char __initdata cmd_line[COMMAND_LINE_SIZE];
129
struct machine_desc *machine_desc __initdata;
Linus Torvalds's avatar
Linus Torvalds committed
130 131 132 133 134 135 136 137 138 139 140

static char default_command_line[COMMAND_LINE_SIZE] __initdata = CONFIG_CMDLINE;
static union { char c[4]; unsigned long l; } endian_test __initdata = { { 'l', '?', '?', 'b' } };
#define ENDIANNESS ((char)endian_test.l)

DEFINE_PER_CPU(struct cpuinfo_arm, cpu_data);

/*
 * Standard memory resources
 */
static struct resource mem_res[] = {
141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158
	{
		.name = "Video RAM",
		.start = 0,
		.end = 0,
		.flags = IORESOURCE_MEM
	},
	{
		.name = "Kernel text",
		.start = 0,
		.end = 0,
		.flags = IORESOURCE_MEM
	},
	{
		.name = "Kernel data",
		.start = 0,
		.end = 0,
		.flags = IORESOURCE_MEM
	}
Linus Torvalds's avatar
Linus Torvalds committed
159 160 161 162 163 164 165
};

#define video_ram   mem_res[0]
#define kernel_code mem_res[1]
#define kernel_data mem_res[2]

static struct resource io_res[] = {
166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183
	{
		.name = "reserved",
		.start = 0x3bc,
		.end = 0x3be,
		.flags = IORESOURCE_IO | IORESOURCE_BUSY
	},
	{
		.name = "reserved",
		.start = 0x378,
		.end = 0x37f,
		.flags = IORESOURCE_IO | IORESOURCE_BUSY
	},
	{
		.name = "reserved",
		.start = 0x278,
		.end = 0x27f,
		.flags = IORESOURCE_IO | IORESOURCE_BUSY
	}
Linus Torvalds's avatar
Linus Torvalds committed
184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199
};

#define lp0 io_res[0]
#define lp1 io_res[1]
#define lp2 io_res[2]

static const char *proc_arch[] = {
	"undefined/unknown",
	"3",
	"4",
	"4T",
	"5",
	"5T",
	"5TE",
	"5TEJ",
	"6TEJ",
200
	"7",
Linus Torvalds's avatar
Linus Torvalds committed
201 202 203 204 205 206 207 208 209 210 211 212 213
	"?(11)",
	"?(12)",
	"?(13)",
	"?(14)",
	"?(15)",
	"?(16)",
	"?(17)",
};

int cpu_architecture(void)
{
	int cpu_arch;

214
	if ((read_cpuid_id() & 0x0008f000) == 0) {
Linus Torvalds's avatar
Linus Torvalds committed
215
		cpu_arch = CPU_ARCH_UNKNOWN;
216 217 218 219
	} else if ((read_cpuid_id() & 0x0008f000) == 0x00007000) {
		cpu_arch = (read_cpuid_id() & (1 << 23)) ? CPU_ARCH_ARMv4T : CPU_ARCH_ARMv3;
	} else if ((read_cpuid_id() & 0x00080000) == 0x00000000) {
		cpu_arch = (read_cpuid_id() >> 16) & 7;
Linus Torvalds's avatar
Linus Torvalds committed
220 221
		if (cpu_arch)
			cpu_arch += CPU_ARCH_ARMv3;
222
	} else if ((read_cpuid_id() & 0x000f0000) == 0x000f0000) {
223 224 225 226 227 228
		unsigned int mmfr0;

		/* Revised CPUID format. Read the Memory Model Feature
		 * Register 0 and check for VMSAv7 or PMSAv7 */
		asm("mrc	p15, 0, %0, c0, c1, 4"
		    : "=r" (mmfr0));
229 230
		if ((mmfr0 & 0x0000000f) >= 0x00000003 ||
		    (mmfr0 & 0x000000f0) >= 0x00000030)
231 232 233 234 235 236 237 238
			cpu_arch = CPU_ARCH_ARMv7;
		else if ((mmfr0 & 0x0000000f) == 0x00000002 ||
			 (mmfr0 & 0x000000f0) == 0x00000020)
			cpu_arch = CPU_ARCH_ARMv6;
		else
			cpu_arch = CPU_ARCH_UNKNOWN;
	} else
		cpu_arch = CPU_ARCH_UNKNOWN;
Linus Torvalds's avatar
Linus Torvalds committed
239 240 241 242

	return cpu_arch;
}

243 244 245 246 247 248 249 250
static int cpu_has_aliasing_icache(unsigned int arch)
{
	int aliasing_icache;
	unsigned int id_reg, num_sets, line_size;

	/* arch specifies the register format */
	switch (arch) {
	case CPU_ARCH_ARMv7:
251 252
		asm("mcr	p15, 2, %0, c0, c0, 0 @ set CSSELR"
		    : /* No output operands */
253
		    : "r" (1));
254 255 256
		isb();
		asm("mrc	p15, 1, %0, c0, c0, 0 @ read CCSIDR"
		    : "=r" (id_reg));
257 258 259 260 261 262 263 264 265 266 267 268 269 270 271
		line_size = 4 << ((id_reg & 0x7) + 2);
		num_sets = ((id_reg >> 13) & 0x7fff) + 1;
		aliasing_icache = (line_size * num_sets) > PAGE_SIZE;
		break;
	case CPU_ARCH_ARMv6:
		aliasing_icache = read_cpuid_cachetype() & (1 << 11);
		break;
	default:
		/* I-cache aliases will be handled by D-cache aliasing code */
		aliasing_icache = 0;
	}

	return aliasing_icache;
}

272 273 274 275 276
static void __init cacheid_init(void)
{
	unsigned int cachetype = read_cpuid_cachetype();
	unsigned int arch = cpu_architecture();

277 278 279 280 281 282
	if (arch >= CPU_ARCH_ARMv6) {
		if ((cachetype & (7 << 29)) == 4 << 29) {
			/* ARMv7 register format */
			cacheid = CACHEID_VIPT_NONALIASING;
			if ((cachetype & (3 << 14)) == 1 << 14)
				cacheid |= CACHEID_ASID_TAGGED;
283 284 285
			else if (cpu_has_aliasing_icache(CPU_ARCH_ARMv7))
				cacheid |= CACHEID_VIPT_I_ALIASING;
		} else if (cachetype & (1 << 23)) {
286
			cacheid = CACHEID_VIPT_ALIASING;
287
		} else {
288
			cacheid = CACHEID_VIPT_NONALIASING;
289 290 291
			if (cpu_has_aliasing_icache(CPU_ARCH_ARMv6))
				cacheid |= CACHEID_VIPT_I_ALIASING;
		}
292 293 294
	} else {
		cacheid = CACHEID_VIVT;
	}
295 296 297 298 299 300 301

	printk("CPU: %s data cache, %s instruction cache\n",
		cache_is_vivt() ? "VIVT" :
		cache_is_vipt_aliasing() ? "VIPT aliasing" :
		cache_is_vipt_nonaliasing() ? "VIPT nonaliasing" : "unknown",
		cache_is_vivt() ? "VIVT" :
		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
}

Linus Torvalds's avatar
Linus Torvalds committed
306 307 308 309
/*
 * These functions re-use the assembly code in head.S, which
 * already provide the required functionality.
 */
310
extern struct proc_info_list *lookup_processor_type(unsigned int);
311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327

static void __init early_print(const char *str, ...)
{
	extern void printascii(const char *);
	char buf[256];
	va_list ap;

	va_start(ap, str);
	vsnprintf(buf, sizeof(buf), str, ap);
	va_end(ap);

#ifdef CONFIG_DEBUG_LL
	printascii(buf);
#endif
	printk("%s", buf);
}

328 329 330 331 332 333 334 335 336 337 338 339 340 341 342
static void __init feat_v6_fixup(void)
{
	int id = read_cpuid_id();

	if ((id & 0xff0f0000) != 0x41070000)
		return;

	/*
	 * HWCAP_TLS is available only on 1136 r1p0 and later,
	 * see also kuser_get_tls_init.
	 */
	if ((((id >> 4) & 0xfff) == 0xb36) && (((id >> 20) & 3) == 0))
		elf_hwcap &= ~HWCAP_TLS;
}

Linus Torvalds's avatar
Linus Torvalds committed
343 344 345 346 347 348 349 350 351
static void __init setup_processor(void)
{
	struct proc_info_list *list;

	/*
	 * locate processor in the list of supported processor
	 * types.  The linker builds this table for us from the
	 * entries in arch/arm/mm/proc-*.S
	 */
352
	list = lookup_processor_type(read_cpuid_id());
Linus Torvalds's avatar
Linus Torvalds committed
353 354
	if (!list) {
		printk("CPU configuration botched (ID %08x), unable "
355
		       "to continue.\n", read_cpuid_id());
Linus Torvalds's avatar
Linus Torvalds committed
356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373
		while (1);
	}

	cpu_name = list->cpu_name;

#ifdef MULTI_CPU
	processor = *list->proc;
#endif
#ifdef MULTI_TLB
	cpu_tlb = *list->tlb;
#endif
#ifdef MULTI_USER
	cpu_user = *list->user;
#endif
#ifdef MULTI_CACHE
	cpu_cache = *list->cache;
#endif

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);
Linus Torvalds's avatar
Linus Torvalds committed
377

378
	sprintf(init_utsname()->machine, "%s%c", list->arch_name, ENDIANNESS);
Linus Torvalds's avatar
Linus Torvalds committed
379 380
	sprintf(elf_platform, "%s%c", list->elf_name, ENDIANNESS);
	elf_hwcap = list->elf_hwcap;
381 382 383
#ifndef CONFIG_ARM_THUMB
	elf_hwcap &= ~HWCAP_THUMB;
#endif
Linus Torvalds's avatar
Linus Torvalds committed
384

385 386
	feat_v6_fixup();

387
	cacheid_init();
Linus Torvalds's avatar
Linus Torvalds committed
388 389 390
	cpu_proc_init();
}

391 392 393
/*
 * cpu_init - initialise one CPU.
 *
394
 * cpu_init sets up the per-CPU stacks.
395
 */
396
void cpu_init(void)
397 398 399 400 401 402 403 404 405
{
	unsigned int cpu = smp_processor_id();
	struct stack *stk = &stacks[cpu];

	if (cpu >= NR_CPUS) {
		printk(KERN_CRIT "CPU%u: bad primary CPU number\n", cpu);
		BUG();
	}

406 407 408 409 410 411 412 413 414 415
	/*
	 * Define the placement constraint for the inline asm directive below.
	 * In Thumb-2, msr with an immediate value is not allowed.
	 */
#ifdef CONFIG_THUMB2_KERNEL
#define PLC	"r"
#else
#define PLC	"I"
#endif

416 417 418 419 420
	/*
	 * setup stacks for re-entrant exception handlers
	 */
	__asm__ (
	"msr	cpsr_c, %1\n\t"
421 422
	"add	r14, %0, %2\n\t"
	"mov	sp, r14\n\t"
423
	"msr	cpsr_c, %3\n\t"
424 425
	"add	r14, %0, %4\n\t"
	"mov	sp, r14\n\t"
426
	"msr	cpsr_c, %5\n\t"
427 428
	"add	r14, %0, %6\n\t"
	"mov	sp, r14\n\t"
429 430 431
	"msr	cpsr_c, %7"
	    :
	    : "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
}

Linus Torvalds's avatar
Linus Torvalds committed
442 443
static struct machine_desc * __init setup_machine(unsigned int nr)
{
444 445
	extern struct machine_desc __arch_info_begin[], __arch_info_end[];
	struct machine_desc *p;
Linus Torvalds's avatar
Linus Torvalds committed
446 447 448 449

	/*
	 * locate machine in the list of supported machines.
	 */
450 451 452 453 454
	for (p = __arch_info_begin; p < __arch_info_end; p++)
		if (nr == p->nr) {
			printk("Machine: %s\n", p->name);
			return p;
		}
Linus Torvalds's avatar
Linus Torvalds committed
455

456 457 458 459 460 461
	early_print("\n"
		"Error: unrecognized/unsupported machine ID (r1 = 0x%08x).\n\n"
		"Available machine support:\n\nID (hex)\tNAME\n", nr);

	for (p = __arch_info_begin; p < __arch_info_end; p++)
		early_print("%08x\t%s\n", p->nr, p->name);
Linus Torvalds's avatar
Linus Torvalds committed
462

463
	early_print("\nPlease check your kernel config and/or bootloader.\n");
Linus Torvalds's avatar
Linus Torvalds committed
464

465 466
	while (true)
		/* can't use cpu_relax() here as it may require MMU setup */;
Linus Torvalds's avatar
Linus Torvalds committed
467 468
}

469
static int __init arm_add_memory(phys_addr_t start, unsigned long size)
470
{
471 472 473 474
	struct membank *bank = &meminfo.bank[meminfo.nr_banks];

	if (meminfo.nr_banks >= NR_BANKS) {
		printk(KERN_CRIT "NR_BANKS too low, "
475
			"ignoring memory at 0x%08llx\n", (long long)start);
476 477
		return -EINVAL;
	}
478

479 480 481 482 483
	/*
	 * Ensure that start/size are aligned to a page boundary.
	 * Size is appropriately rounded down, start is rounded up.
	 */
	size -= start & ~PAGE_MASK;
484 485
	bank->start = PAGE_ALIGN(start);
	bank->size  = size & PAGE_MASK;
486 487 488 489 490

	/*
	 * Check whether this memory region has non-zero size or
	 * invalid node number.
	 */
491
	if (bank->size == 0)
492 493 494 495
		return -EINVAL;

	meminfo.nr_banks++;
	return 0;
496 497
}

Linus Torvalds's avatar
Linus Torvalds committed
498 499 500 501
/*
 * Pick out the memory size.  We look for mem=size@start,
 * where start and size are "size[KkMm]"
 */
502
static int __init early_mem(char *p)
Linus Torvalds's avatar
Linus Torvalds committed
503 504
{
	static int usermem __initdata = 0;
505 506
	unsigned long size;
	phys_addr_t start;
507
	char *endp;
Linus Torvalds's avatar
Linus Torvalds committed
508 509 510 511 512 513 514 515 516 517 518 519

	/*
	 * If the user specifies memory size, we
	 * blow away any automatically generated
	 * size.
	 */
	if (usermem == 0) {
		usermem = 1;
		meminfo.nr_banks = 0;
	}

	start = PHYS_OFFSET;
520 521 522
	size  = memparse(p, &endp);
	if (*endp == '@')
		start = memparse(endp + 1, NULL);
Linus Torvalds's avatar
Linus Torvalds committed
523

Andrew Morton's avatar
Andrew Morton committed
524
	arm_add_memory(start, size);
Linus Torvalds's avatar
Linus Torvalds committed
525

526
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
527
}
528
early_param("mem", early_mem);
Linus Torvalds's avatar
Linus Torvalds committed
529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544

static void __init
setup_ramdisk(int doload, int prompt, int image_start, unsigned int rd_sz)
{
#ifdef CONFIG_BLK_DEV_RAM
	extern int rd_size, rd_image_start, rd_prompt, rd_doload;

	rd_image_start = image_start;
	rd_prompt = prompt;
	rd_doload = doload;

	if (rd_sz)
		rd_size = rd_sz;
#endif
}

545
static void __init request_standard_resources(struct machine_desc *mdesc)
Linus Torvalds's avatar
Linus Torvalds committed
546
{
547
	struct memblock_region *region;
Linus Torvalds's avatar
Linus Torvalds committed
548 549
	struct resource *res;

Russell King's avatar
Russell King committed
550 551
	kernel_code.start   = virt_to_phys(_text);
	kernel_code.end     = virt_to_phys(_etext - 1);
552
	kernel_data.start   = virt_to_phys(_sdata);
Russell King's avatar
Russell King committed
553
	kernel_data.end     = virt_to_phys(_end - 1);
Linus Torvalds's avatar
Linus Torvalds committed
554

555
	for_each_memblock(memory, region) {
Linus Torvalds's avatar
Linus Torvalds committed
556 557
		res = alloc_bootmem_low(sizeof(*res));
		res->name  = "System RAM";
558 559
		res->start = __pfn_to_phys(memblock_region_memory_base_pfn(region));
		res->end = __pfn_to_phys(memblock_region_memory_end_pfn(region)) - 1;
Linus Torvalds's avatar
Linus Torvalds committed
560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613
		res->flags = IORESOURCE_MEM | IORESOURCE_BUSY;

		request_resource(&iomem_resource, res);

		if (kernel_code.start >= res->start &&
		    kernel_code.end <= res->end)
			request_resource(res, &kernel_code);
		if (kernel_data.start >= res->start &&
		    kernel_data.end <= res->end)
			request_resource(res, &kernel_data);
	}

	if (mdesc->video_start) {
		video_ram.start = mdesc->video_start;
		video_ram.end   = mdesc->video_end;
		request_resource(&iomem_resource, &video_ram);
	}

	/*
	 * Some machines don't have the possibility of ever
	 * possessing lp0, lp1 or lp2
	 */
	if (mdesc->reserve_lp0)
		request_resource(&ioport_resource, &lp0);
	if (mdesc->reserve_lp1)
		request_resource(&ioport_resource, &lp1);
	if (mdesc->reserve_lp2)
		request_resource(&ioport_resource, &lp2);
}

/*
 *  Tag parsing.
 *
 * This is the new way of passing data to the kernel at boot time.  Rather
 * than passing a fixed inflexible structure to the kernel, we pass a list
 * of variable-sized tags to the kernel.  The first tag must be a ATAG_CORE
 * tag for the list to be recognised (to distinguish the tagged list from
 * a param_struct).  The list is terminated with a zero-length tag (this tag
 * is not parsed in any way).
 */
static int __init parse_tag_core(const struct tag *tag)
{
	if (tag->hdr.size > 2) {
		if ((tag->u.core.flags & 1) == 0)
			root_mountflags &= ~MS_RDONLY;
		ROOT_DEV = old_decode_dev(tag->u.core.rootdev);
	}
	return 0;
}

__tagtable(ATAG_CORE, parse_tag_core);

static int __init parse_tag_mem32(const struct tag *tag)
{
614
	return arm_add_memory(tag->u.mem.start, tag->u.mem.size);
Linus Torvalds's avatar
Linus Torvalds committed
615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674
}

__tagtable(ATAG_MEM, parse_tag_mem32);

#if defined(CONFIG_VGA_CONSOLE) || defined(CONFIG_DUMMY_CONSOLE)
struct screen_info screen_info = {
 .orig_video_lines	= 30,
 .orig_video_cols	= 80,
 .orig_video_mode	= 0,
 .orig_video_ega_bx	= 0,
 .orig_video_isVGA	= 1,
 .orig_video_points	= 8
};

static int __init parse_tag_videotext(const struct tag *tag)
{
	screen_info.orig_x            = tag->u.videotext.x;
	screen_info.orig_y            = tag->u.videotext.y;
	screen_info.orig_video_page   = tag->u.videotext.video_page;
	screen_info.orig_video_mode   = tag->u.videotext.video_mode;
	screen_info.orig_video_cols   = tag->u.videotext.video_cols;
	screen_info.orig_video_ega_bx = tag->u.videotext.video_ega_bx;
	screen_info.orig_video_lines  = tag->u.videotext.video_lines;
	screen_info.orig_video_isVGA  = tag->u.videotext.video_isvga;
	screen_info.orig_video_points = tag->u.videotext.video_points;
	return 0;
}

__tagtable(ATAG_VIDEOTEXT, parse_tag_videotext);
#endif

static int __init parse_tag_ramdisk(const struct tag *tag)
{
	setup_ramdisk((tag->u.ramdisk.flags & 1) == 0,
		      (tag->u.ramdisk.flags & 2) == 0,
		      tag->u.ramdisk.start, tag->u.ramdisk.size);
	return 0;
}

__tagtable(ATAG_RAMDISK, parse_tag_ramdisk);

static int __init parse_tag_serialnr(const struct tag *tag)
{
	system_serial_low = tag->u.serialnr.low;
	system_serial_high = tag->u.serialnr.high;
	return 0;
}

__tagtable(ATAG_SERIAL, parse_tag_serialnr);

static int __init parse_tag_revision(const struct tag *tag)
{
	system_rev = tag->u.revision.rev;
	return 0;
}

__tagtable(ATAG_REVISION, parse_tag_revision);

static int __init parse_tag_cmdline(const struct tag *tag)
{
675 676 677 678 679
#if defined(CONFIG_CMDLINE_EXTEND)
	strlcat(default_command_line, " ", COMMAND_LINE_SIZE);
	strlcat(default_command_line, tag->u.cmdline.cmdline,
		COMMAND_LINE_SIZE);
#elif defined(CONFIG_CMDLINE_FORCE)
680
	pr_warning("Ignoring tag cmdline (using the default kernel command line)\n");
681 682 683 684
#else
	strlcpy(default_command_line, tag->u.cmdline.cmdline,
		COMMAND_LINE_SIZE);
#endif
Linus Torvalds's avatar
Linus Torvalds committed
685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734
	return 0;
}

__tagtable(ATAG_CMDLINE, parse_tag_cmdline);

/*
 * Scan the tag table for this tag, and call its parse function.
 * The tag table is built by the linker from all the __tagtable
 * declarations.
 */
static int __init parse_tag(const struct tag *tag)
{
	extern struct tagtable __tagtable_begin, __tagtable_end;
	struct tagtable *t;

	for (t = &__tagtable_begin; t < &__tagtable_end; t++)
		if (tag->hdr.tag == t->tag) {
			t->parse(tag);
			break;
		}

	return t < &__tagtable_end;
}

/*
 * Parse all tags in the list, checking both the global and architecture
 * specific tag tables.
 */
static void __init parse_tags(const struct tag *t)
{
	for (; t->hdr.size; t = tag_next(t))
		if (!parse_tag(t))
			printk(KERN_WARNING
				"Ignoring unrecognised tag 0x%08x\n",
				t->hdr.tag);
}

/*
 * This holds our defaults.
 */
static struct init_tags {
	struct tag_header hdr1;
	struct tag_core   core;
	struct tag_header hdr2;
	struct tag_mem32  mem;
	struct tag_header hdr3;
} init_tags __initdata = {
	{ tag_size(tag_core), ATAG_CORE },
	{ 1, PAGE_SIZE, 0xff },
	{ tag_size(tag_mem32), ATAG_MEM },
735
	{ MEM_SIZE },
Linus Torvalds's avatar
Linus Torvalds committed
736 737 738 739 740 741
	{ 0, ATAG_NONE }
};

static int __init customize_machine(void)
{
	/* customizes platform devices, or adds new ones */
742 743
	if (machine_desc->init_machine)
		machine_desc->init_machine();
Linus Torvalds's avatar
Linus Torvalds committed
744 745 746 747
	return 0;
}
arch_initcall(customize_machine);

748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796
#ifdef CONFIG_KEXEC
static inline unsigned long long get_total_mem(void)
{
	unsigned long total;

	total = max_low_pfn - min_low_pfn;
	return total << PAGE_SHIFT;
}

/**
 * reserve_crashkernel() - reserves memory are for crash kernel
 *
 * This function reserves memory area given in "crashkernel=" kernel command
 * line parameter. The memory reserved is used by a dump capture kernel when
 * primary kernel is crashing.
 */
static void __init reserve_crashkernel(void)
{
	unsigned long long crash_size, crash_base;
	unsigned long long total_mem;
	int ret;

	total_mem = get_total_mem();
	ret = parse_crashkernel(boot_command_line, total_mem,
				&crash_size, &crash_base);
	if (ret)
		return;

	ret = reserve_bootmem(crash_base, crash_size, BOOTMEM_EXCLUSIVE);
	if (ret < 0) {
		printk(KERN_WARNING "crashkernel reservation failed - "
		       "memory is in use (0x%lx)\n", (unsigned long)crash_base);
		return;
	}

	printk(KERN_INFO "Reserving %ldMB of memory at %ldMB "
	       "for crashkernel (System RAM: %ldMB)\n",
	       (unsigned long)(crash_size >> 20),
	       (unsigned long)(crash_base >> 20),
	       (unsigned long)(total_mem >> 20));

	crashk_res.start = crash_base;
	crashk_res.end = crash_base + crash_size - 1;
	insert_resource(&iomem_resource, &crashk_res);
}
#else
static inline void reserve_crashkernel(void) {}
#endif /* CONFIG_KEXEC */

797 798 799 800 801 802 803
static void __init squash_mem_tags(struct tag *tag)
{
	for (; tag->hdr.size; tag = tag_next(tag))
		if (tag->hdr.tag == ATAG_MEM)
			tag->hdr.tag = ATAG_NONE;
}

Linus Torvalds's avatar
Linus Torvalds committed
804 805 806 807 808 809
void __init setup_arch(char **cmdline_p)
{
	struct tag *tags = (struct tag *)&init_tags;
	struct machine_desc *mdesc;
	char *from = default_command_line;

810 811
	init_tags.mem.start = PHYS_OFFSET;

812 813
	unwind_init();

Linus Torvalds's avatar
Linus Torvalds committed
814 815
	setup_processor();
	mdesc = setup_machine(machine_arch_type);
816
	machine_desc = mdesc;
Linus Torvalds's avatar
Linus Torvalds committed
817 818 819 820 821
	machine_name = mdesc->name;

	if (mdesc->soft_reboot)
		reboot_setup("s");

822 823
	if (__atags_pointer)
		tags = phys_to_virt(__atags_pointer);
824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842
	else if (mdesc->boot_params) {
#ifdef CONFIG_MMU
		/*
		 * We still are executing with a minimal MMU mapping created
		 * with the presumption that the machine default for this
		 * is located in the first MB of RAM.  Anything else will
		 * fault and silently hang the kernel at this point.
		 */
		if (mdesc->boot_params < PHYS_OFFSET ||
		    mdesc->boot_params >= PHYS_OFFSET + SZ_1M) {
			printk(KERN_WARNING
			       "Default boot params at physical 0x%08lx out of reach\n",
			       mdesc->boot_params);
		} else
#endif
		{
			tags = phys_to_virt(mdesc->boot_params);
		}
	}
Linus Torvalds's avatar
Linus Torvalds committed
843

844
#if defined(CONFIG_DEPRECATED_PARAM_STRUCT)
Linus Torvalds's avatar
Linus Torvalds committed
845 846 847 848 849 850
	/*
	 * If we have the old style parameters, convert them to
	 * a tag list.
	 */
	if (tags->hdr.tag != ATAG_CORE)
		convert_to_tag_list(tags);
851
#endif
Linus Torvalds's avatar
Linus Torvalds committed
852 853 854 855 856 857 858 859 860
	if (tags->hdr.tag != ATAG_CORE)
		tags = (struct tag *)&init_tags;

	if (mdesc->fixup)
		mdesc->fixup(mdesc, tags, &from, &meminfo);

	if (tags->hdr.tag == ATAG_CORE) {
		if (meminfo.nr_banks != 0)
			squash_mem_tags(tags);
861
		save_atags(tags);
Linus Torvalds's avatar
Linus Torvalds committed
862 863 864
		parse_tags(tags);
	}

Russell King's avatar
Russell King committed
865 866 867 868
	init_mm.start_code = (unsigned long) _text;
	init_mm.end_code   = (unsigned long) _etext;
	init_mm.end_data   = (unsigned long) _edata;
	init_mm.brk	   = (unsigned long) _end;
Linus Torvalds's avatar
Linus Torvalds committed
869

870 871 872
	/* parse_early_param needs a boot_command_line */
	strlcpy(boot_command_line, from, COMMAND_LINE_SIZE);

873 874 875
	/* populate cmd_line too for later use, preserving boot_command_line */
	strlcpy(cmd_line, boot_command_line, COMMAND_LINE_SIZE);
	*cmdline_p = cmd_line;
876 877 878

	parse_early_param();

879
	arm_memblock_init(&meminfo, mdesc);
Russell King's avatar
Russell King committed
880

881
	paging_init(mdesc);
882
	request_standard_resources(mdesc);
Linus Torvalds's avatar
Linus Torvalds committed
883

884
#ifdef CONFIG_SMP
885 886
	if (is_smp())
		smp_init_cpus();
887
#endif
888
	reserve_crashkernel();
889

890
	cpu_init();
891
	tcm_init();
892

893 894 895
#ifdef CONFIG_MULTI_IRQ_HANDLER
	handle_arch_irq = mdesc->handle_irq;
#endif
Linus Torvalds's avatar
Linus Torvalds committed
896 897 898 899 900 901 902 903

#ifdef CONFIG_VT
#if defined(CONFIG_VGA_CONSOLE)
	conswitchp = &vga_con;
#elif defined(CONFIG_DUMMY_CONSOLE)
	conswitchp = &dummy_con;
#endif
#endif
Jason Wessel's avatar
Jason Wessel committed
904
	early_trap_init();
905 906 907

	if (mdesc->init_early)
		mdesc->init_early();
Linus Torvalds's avatar
Linus Torvalds committed
908 909 910 911 912 913 914
}


static int __init topology_init(void)
{
	int cpu;

915 916 917 918 919
	for_each_possible_cpu(cpu) {
		struct cpuinfo_arm *cpuinfo = &per_cpu(cpu_data, cpu);
		cpuinfo->cpu.hotpluggable = 1;
		register_cpu(&cpuinfo->cpu, cpu);
	}
Linus Torvalds's avatar
Linus Torvalds committed
920 921 922 923 924

	return 0;
}
subsys_initcall(topology_init);

925 926 927 928 929 930 931 932 933 934 935 936 937
#ifdef CONFIG_HAVE_PROC_CPU
static int __init proc_cpu_init(void)
{
	struct proc_dir_entry *res;

	res = proc_mkdir("cpu", NULL);
	if (!res)
		return -ENOMEM;
	return 0;
}
fs_initcall(proc_cpu_init);
#endif

Linus Torvalds's avatar
Linus Torvalds committed
938 939 940 941 942 943 944 945 946 947
static const char *hwcap_str[] = {
	"swp",
	"half",
	"thumb",
	"26bit",
	"fastmult",
	"fpa",
	"vfp",
	"edsp",
	"java",
948
	"iwmmxt",
949
	"crunch",
950
	"thumbee",
951
	"neon",
952 953
	"vfpv3",
	"vfpv3d16",
Linus Torvalds's avatar
Linus Torvalds committed
954 955 956 957 958 959 960 961
	NULL
};

static int c_show(struct seq_file *m, void *v)
{
	int i;

	seq_printf(m, "Processor\t: %s rev %d (%s)\n",
962
		   cpu_name, read_cpuid_id() & 15, elf_platform);
Linus Torvalds's avatar
Linus Torvalds committed
963 964 965

#if defined(CONFIG_SMP)
	for_each_online_cpu(i) {
966 967 968 969 970 971
		/*
		 * glibc reads /proc/cpuinfo to determine the number of
		 * online processors, looking for lines beginning with
		 * "processor".  Give glibc what it expects.
		 */
		seq_printf(m, "processor\t: %d\n", i);
Linus Torvalds's avatar
Linus Torvalds committed
972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988
		seq_printf(m, "BogoMIPS\t: %lu.%02lu\n\n",
			   per_cpu(cpu_data, i).loops_per_jiffy / (500000UL/HZ),
			   (per_cpu(cpu_data, i).loops_per_jiffy / (5000UL/HZ)) % 100);
	}
#else /* CONFIG_SMP */
	seq_printf(m, "BogoMIPS\t: %lu.%02lu\n",
		   loops_per_jiffy / (500000/HZ),
		   (loops_per_jiffy / (5000/HZ)) % 100);
#endif

	/* dump out the processor features */
	seq_puts(m, "Features\t: ");

	for (i = 0; hwcap_str[i]; i++)
		if (elf_hwcap & (1 << i))
			seq_printf(m, "%s ", hwcap_str[i]);

989
	seq_printf(m, "\nCPU implementer\t: 0x%02x\n", read_cpuid_id() >> 24);
Linus Torvalds's avatar
Linus Torvalds committed
990 991
	seq_printf(m, "CPU architecture: %s\n", proc_arch[cpu_architecture()]);

992
	if ((read_cpuid_id() & 0x0008f000) == 0x00000000) {
Linus Torvalds's avatar
Linus Torvalds committed
993
		/* pre-ARM7 */
994
		seq_printf(m, "CPU part\t: %07x\n", read_cpuid_id() >> 4);
Linus Torvalds's avatar
Linus Torvalds committed
995
	} else {
996
		if ((read_cpuid_id() & 0x0008f000) == 0x00007000) {
Linus Torvalds's avatar
Linus Torvalds committed
997 998
			/* ARM7 */
			seq_printf(m, "CPU variant\t: 0x%02x\n",
999
				   (read_cpuid_id() >> 16) & 127);
Linus Torvalds's avatar
Linus Torvalds committed
1000 1001 1002
		} else {
			/* post-ARM7 */
			seq_printf(m, "CPU variant\t: 0x%x\n",
1003
				   (read_cpuid_id() >> 20) & 15);
Linus Torvalds's avatar
Linus Torvalds committed
1004 1005
		}
		seq_printf(m, "CPU part\t: 0x%03x\n",
1006
			   (read_cpuid_id() >> 4) & 0xfff);
Linus Torvalds's avatar
Linus Torvalds committed
1007
	}
1008
	seq_printf(m, "CPU revision\t: %d\n", read_cpuid_id() & 15);
Linus Torvalds's avatar
Linus Torvalds committed
1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034

	seq_puts(m, "\n");

	seq_printf(m, "Hardware\t: %s\n", machine_name);
	seq_printf(m, "Revision\t: %04x\n", system_rev);
	seq_printf(m, "Serial\t\t: %08x%08x\n",
		   system_serial_high, system_serial_low);

	return 0;
}

static void *c_start(struct seq_file *m, loff_t *pos)
{
	return *pos < 1 ? (void *)1 : NULL;
}

static void *c_next(struct seq_file *m, void *v, loff_t *pos)
{
	++*pos;
	return NULL;
}

static void c_stop(struct seq_file *m, void *v)
{
}

1035
const struct seq_operations cpuinfo_op = {
Linus Torvalds's avatar
Linus Torvalds committed
1036 1037 1038 1039 1040
	.start	= c_start,
	.next	= c_next,
	.stop	= c_stop,
	.show	= c_show
};