setup.c 25 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5 6 7 8 9
/*
 *  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.
 */
10
#include <linux/export.h>
Linus Torvalds's avatar
Linus Torvalds committed
11 12 13 14 15 16 17 18 19
#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/of_fdt.h>
24
#include <linux/crash_dump.h>
Linus Torvalds's avatar
Linus Torvalds committed
25 26 27
#include <linux/root_dev.h>
#include <linux/cpu.h>
#include <linux/interrupt.h>
28
#include <linux/smp.h>
Alexey Dobriyan's avatar
Alexey Dobriyan committed
29
#include <linux/fs.h>
30
#include <linux/proc_fs.h>
Russell King's avatar
Russell King committed
31
#include <linux/memblock.h>
32 33
#include <linux/bug.h>
#include <linux/compiler.h>
Linus Torvalds's avatar
Linus Torvalds committed
34

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

49
#include <asm/prom.h>
Linus Torvalds's avatar
Linus Torvalds committed
50 51 52
#include <asm/mach/arch.h>
#include <asm/mach/irq.h>
#include <asm/mach/time.h>
Jason Wessel's avatar
Jason Wessel committed
53
#include <asm/traps.h>
54
#include <asm/unwind.h>
Linus Torvalds's avatar
Linus Torvalds committed
55

56
#if defined(CONFIG_DEPRECATED_PARAM_STRUCT)
57
#include "compat.h"
58
#endif
59
#include "atags.h"
60
#include "tcm.h"
61

Linus Torvalds's avatar
Linus Torvalds committed
62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77
#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

78
extern void paging_init(struct machine_desc *desc);
79
extern void sanity_check_meminfo(void);
Linus Torvalds's avatar
Linus Torvalds committed
80 81 82
extern void reboot_setup(char *str);

unsigned int processor_id;
83
EXPORT_SYMBOL(processor_id);
84
unsigned int __machine_arch_type __read_mostly;
Linus Torvalds's avatar
Linus Torvalds committed
85
EXPORT_SYMBOL(__machine_arch_type);
86
unsigned int cacheid __read_mostly;
87
EXPORT_SYMBOL(cacheid);
Linus Torvalds's avatar
Linus Torvalds committed
88

Bill Gatliff's avatar
Bill Gatliff committed
89 90
unsigned int __atags_pointer __initdata;

Linus Torvalds's avatar
Linus Torvalds committed
91 92 93 94 95 96 97 98 99
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);

100
unsigned int elf_hwcap __read_mostly;
Linus Torvalds's avatar
Linus Torvalds committed
101 102 103 104
EXPORT_SYMBOL(elf_hwcap);


#ifdef MULTI_CPU
105
struct processor processor __read_mostly;
Linus Torvalds's avatar
Linus Torvalds committed
106 107
#endif
#ifdef MULTI_TLB
108
struct cpu_tlb_fns cpu_tlb __read_mostly;
Linus Torvalds's avatar
Linus Torvalds committed
109 110
#endif
#ifdef MULTI_USER
111
struct cpu_user_fns cpu_user __read_mostly;
Linus Torvalds's avatar
Linus Torvalds committed
112 113
#endif
#ifdef MULTI_CACHE
114
struct cpu_cache_fns cpu_cache __read_mostly;
Linus Torvalds's avatar
Linus Torvalds committed
115
#endif
116
#ifdef CONFIG_OUTER_CACHE
117
struct outer_cache_fns outer_cache __read_mostly;
118
EXPORT_SYMBOL(outer_cache);
119
#endif
Linus Torvalds's avatar
Linus Torvalds committed
120

121 122 123 124 125 126 127
/*
 * Cached cpu_architecture() result for use by assembler code.
 * C code should use the cpu_architecture() function instead of accessing this
 * variable directly.
 */
int __cpu_architecture __read_mostly = CPU_ARCH_UNKNOWN;

128 129 130 131 132 133 134 135
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
136 137 138 139 140
char elf_platform[ELF_PLATFORM_SIZE];
EXPORT_SYMBOL(elf_platform);

static const char *cpu_name;
static const char *machine_name;
141
static char __initdata cmd_line[COMMAND_LINE_SIZE];
142
struct machine_desc *machine_desc __initdata;
Linus Torvalds's avatar
Linus Torvalds committed
143 144 145 146 147 148 149 150 151 152 153

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[] = {
154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171
	{
		.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
172 173 174 175 176 177 178
};

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

static struct resource io_res[] = {
179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196
	{
		.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
197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212
};

#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",
213
	"7",
Linus Torvalds's avatar
Linus Torvalds committed
214 215 216 217 218 219 220 221 222
	"?(11)",
	"?(12)",
	"?(13)",
	"?(14)",
	"?(15)",
	"?(16)",
	"?(17)",
};

223
static int __get_cpu_architecture(void)
Linus Torvalds's avatar
Linus Torvalds committed
224 225 226
{
	int cpu_arch;

227
	if ((read_cpuid_id() & 0x0008f000) == 0) {
Linus Torvalds's avatar
Linus Torvalds committed
228
		cpu_arch = CPU_ARCH_UNKNOWN;
229 230 231 232
	} 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
233 234
		if (cpu_arch)
			cpu_arch += CPU_ARCH_ARMv3;
235
	} else if ((read_cpuid_id() & 0x000f0000) == 0x000f0000) {
236 237 238 239 240 241
		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));
242 243
		if ((mmfr0 & 0x0000000f) >= 0x00000003 ||
		    (mmfr0 & 0x000000f0) >= 0x00000030)
244 245 246 247 248 249 250 251
			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
252 253 254 255

	return cpu_arch;
}

256 257 258 259 260 261 262
int __pure cpu_architecture(void)
{
	BUG_ON(__cpu_architecture == CPU_ARCH_UNKNOWN);

	return __cpu_architecture;
}

263 264 265 266 267
static int cpu_has_aliasing_icache(unsigned int arch)
{
	int aliasing_icache;
	unsigned int id_reg, num_sets, line_size;

268 269 270 271
	/* PIPT caches never alias. */
	if (icache_is_pipt())
		return 0;

272 273 274
	/* arch specifies the register format */
	switch (arch) {
	case CPU_ARCH_ARMv7:
275 276
		asm("mcr	p15, 2, %0, c0, c0, 0 @ set CSSELR"
		    : /* No output operands */
277
		    : "r" (1));
278 279 280
		isb();
		asm("mrc	p15, 1, %0, c0, c0, 0 @ read CCSIDR"
		    : "=r" (id_reg));
281 282 283 284 285 286 287 288 289 290 291 292 293 294 295
		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;
}

296 297 298 299 300
static void __init cacheid_init(void)
{
	unsigned int cachetype = read_cpuid_cachetype();
	unsigned int arch = cpu_architecture();

301 302 303
	if (arch >= CPU_ARCH_ARMv6) {
		if ((cachetype & (7 << 29)) == 4 << 29) {
			/* ARMv7 register format */
304
			arch = CPU_ARCH_ARMv7;
305
			cacheid = CACHEID_VIPT_NONALIASING;
306 307
			switch (cachetype & (3 << 14)) {
			case (1 << 14):
308
				cacheid |= CACHEID_ASID_TAGGED;
309 310 311 312 313
				break;
			case (3 << 14):
				cacheid |= CACHEID_PIPT;
				break;
			}
314
		} else {
315 316 317 318 319
			arch = CPU_ARCH_ARMv6;
			if (cachetype & (1 << 23))
				cacheid = CACHEID_VIPT_ALIASING;
			else
				cacheid = CACHEID_VIPT_NONALIASING;
320
		}
321 322
		if (cpu_has_aliasing_icache(arch))
			cacheid |= CACHEID_VIPT_I_ALIASING;
323 324 325
	} else {
		cacheid = CACHEID_VIVT;
	}
326 327 328 329

	printk("CPU: %s data cache, %s instruction cache\n",
		cache_is_vivt() ? "VIVT" :
		cache_is_vipt_aliasing() ? "VIPT aliasing" :
330
		cache_is_vipt_nonaliasing() ? "PIPT / VIPT nonaliasing" : "unknown",
331 332
		cache_is_vivt() ? "VIVT" :
		icache_is_vivt_asid_tagged() ? "VIVT ASID tagged" :
333
		icache_is_vipt_aliasing() ? "VIPT aliasing" :
334
		icache_is_pipt() ? "PIPT" :
335
		cache_is_vipt_nonaliasing() ? "VIPT nonaliasing" : "unknown");
336 337
}

Linus Torvalds's avatar
Linus Torvalds committed
338 339 340 341
/*
 * These functions re-use the assembly code in head.S, which
 * already provide the required functionality.
 */
342
extern struct proc_info_list *lookup_processor_type(unsigned int);
343

344
void __init early_print(const char *str, ...)
345 346 347 348 349 350 351 352 353 354 355 356 357 358 359
{
	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);
}

360 361 362 363 364 365 366 367 368 369 370 371 372 373 374
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;
}

375 376 377
/*
 * cpu_init - initialise one CPU.
 *
Russell King's avatar
Russell King committed
378
 * cpu_init sets up the per-CPU stacks.
379
 */
380
void cpu_init(void)
381 382 383 384 385 386 387 388 389
{
	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();
	}

390 391
	cpu_proc_init();

392 393 394 395 396 397 398 399 400 401
	/*
	 * 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

402 403 404 405 406
	/*
	 * setup stacks for re-entrant exception handlers
	 */
	__asm__ (
	"msr	cpsr_c, %1\n\t"
407 408
	"add	r14, %0, %2\n\t"
	"mov	sp, r14\n\t"
409
	"msr	cpsr_c, %3\n\t"
410 411
	"add	r14, %0, %4\n\t"
	"mov	sp, r14\n\t"
412
	"msr	cpsr_c, %5\n\t"
413 414
	"add	r14, %0, %6\n\t"
	"mov	sp, r14\n\t"
415 416 417
	"msr	cpsr_c, %7"
	    :
	    : "r" (stk),
418
	      PLC (PSR_F_BIT | PSR_I_BIT | IRQ_MODE),
419
	      "I" (offsetof(struct stack, irq[0])),
420
	      PLC (PSR_F_BIT | PSR_I_BIT | ABT_MODE),
421
	      "I" (offsetof(struct stack, abt[0])),
422
	      PLC (PSR_F_BIT | PSR_I_BIT | UND_MODE),
423
	      "I" (offsetof(struct stack, und[0])),
424
	      PLC (PSR_F_BIT | PSR_I_BIT | SVC_MODE)
425
	    : "r14");
426 427
}

428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444
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
	 */
	list = lookup_processor_type(read_cpuid_id());
	if (!list) {
		printk("CPU configuration botched (ID %08x), unable "
		       "to continue.\n", read_cpuid_id());
		while (1);
	}

	cpu_name = list->cpu_name;
445
	__cpu_architecture = __get_cpu_architecture();
446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476

#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

	printk("CPU: %s [%08x] revision %d (ARMv%s), cr=%08lx\n",
	       cpu_name, read_cpuid_id(), read_cpuid_id() & 15,
	       proc_arch[cpu_architecture()], cr_alignment);

	sprintf(init_utsname()->machine, "%s%c", list->arch_name, ENDIANNESS);
	sprintf(elf_platform, "%s%c", list->elf_name, ENDIANNESS);
	elf_hwcap = list->elf_hwcap;
#ifndef CONFIG_ARM_THUMB
	elf_hwcap &= ~HWCAP_THUMB;
#endif

	feat_v6_fixup();

	cacheid_init();
	cpu_init();
}

477
void __init dump_machine_table(void)
Linus Torvalds's avatar
Linus Torvalds committed
478
{
479
	struct machine_desc *p;
Linus Torvalds's avatar
Linus Torvalds committed
480

481 482
	early_print("Available machine support:\n\nID (hex)\tNAME\n");
	for_each_machine_desc(p)
483
		early_print("%08x\t%s\n", p->nr, p->name);
Linus Torvalds's avatar
Linus Torvalds committed
484

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

487 488
	while (true)
		/* can't use cpu_relax() here as it may require MMU setup */;
Linus Torvalds's avatar
Linus Torvalds committed
489 490
}

Grant Likely's avatar
Grant Likely committed
491
int __init arm_add_memory(phys_addr_t start, unsigned long size)
492
{
493 494 495 496
	struct membank *bank = &meminfo.bank[meminfo.nr_banks];

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

501 502 503 504 505
	/*
	 * Ensure that start/size are aligned to a page boundary.
	 * Size is appropriately rounded down, start is rounded up.
	 */
	size -= start & ~PAGE_MASK;
506 507
	bank->start = PAGE_ALIGN(start);
	bank->size  = size & PAGE_MASK;
508 509 510 511 512

	/*
	 * Check whether this memory region has non-zero size or
	 * invalid node number.
	 */
513
	if (bank->size == 0)
514 515 516 517
		return -EINVAL;

	meminfo.nr_banks++;
	return 0;
518 519
}

Linus Torvalds's avatar
Linus Torvalds committed
520 521 522 523
/*
 * Pick out the memory size.  We look for mem=size@start,
 * where start and size are "size[KkMm]"
 */
524
static int __init early_mem(char *p)
Linus Torvalds's avatar
Linus Torvalds committed
525 526
{
	static int usermem __initdata = 0;
527 528
	unsigned long size;
	phys_addr_t start;
529
	char *endp;
Linus Torvalds's avatar
Linus Torvalds committed
530 531 532 533 534 535 536 537 538 539 540 541

	/*
	 * 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;
542 543 544
	size  = memparse(p, &endp);
	if (*endp == '@')
		start = memparse(endp + 1, NULL);
Linus Torvalds's avatar
Linus Torvalds committed
545

Andrew Morton's avatar
Andrew Morton committed
546
	arm_add_memory(start, size);
Linus Torvalds's avatar
Linus Torvalds committed
547

548
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
549
}
550
early_param("mem", early_mem);
Linus Torvalds's avatar
Linus Torvalds committed
551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566

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
}

567
static void __init request_standard_resources(struct machine_desc *mdesc)
Linus Torvalds's avatar
Linus Torvalds committed
568
{
569
	struct memblock_region *region;
Linus Torvalds's avatar
Linus Torvalds committed
570 571
	struct resource *res;

Russell King's avatar
Russell King committed
572 573
	kernel_code.start   = virt_to_phys(_text);
	kernel_code.end     = virt_to_phys(_etext - 1);
574
	kernel_data.start   = virt_to_phys(_sdata);
Russell King's avatar
Russell King committed
575
	kernel_data.end     = virt_to_phys(_end - 1);
Linus Torvalds's avatar
Linus Torvalds committed
576

577
	for_each_memblock(memory, region) {
Linus Torvalds's avatar
Linus Torvalds committed
578 579
		res = alloc_bootmem_low(sizeof(*res));
		res->name  = "System RAM";
580 581
		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
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 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635
		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)
{
636
	return arm_add_memory(tag->u.mem.start, tag->u.mem.size);
Linus Torvalds's avatar
Linus Torvalds committed
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 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696
}

__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)
{
697 698 699 700 701
#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)
702
	pr_warning("Ignoring tag cmdline (using the default kernel command line)\n");
703 704 705 706
#else
	strlcpy(default_command_line, tag->u.cmdline.cmdline,
		COMMAND_LINE_SIZE);
#endif
Linus Torvalds's avatar
Linus Torvalds committed
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 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756
	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 },
757
	{ MEM_SIZE },
Linus Torvalds's avatar
Linus Torvalds committed
758 759 760 761 762 763
	{ 0, ATAG_NONE }
};

static int __init customize_machine(void)
{
	/* customizes platform devices, or adds new ones */
764 765
	if (machine_desc->init_machine)
		machine_desc->init_machine();
Linus Torvalds's avatar
Linus Torvalds committed
766 767 768 769
	return 0;
}
arch_initcall(customize_machine);

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 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818
#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 */

819 820 821 822 823 824 825
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;
}

826
static struct machine_desc * __init setup_machine_tags(unsigned int nr)
Linus Torvalds's avatar
Linus Torvalds committed
827 828
{
	struct tag *tags = (struct tag *)&init_tags;
829
	struct machine_desc *mdesc = NULL, *p;
Linus Torvalds's avatar
Linus Torvalds committed
830 831
	char *from = default_command_line;

832 833
	init_tags.mem.start = PHYS_OFFSET;

834 835 836 837 838 839 840 841 842
	/*
	 * locate machine in the list of supported machines.
	 */
	for_each_machine_desc(p)
		if (nr == p->nr) {
			printk("Machine: %s\n", p->name);
			mdesc = p;
			break;
		}
Linus Torvalds's avatar
Linus Torvalds committed
843

844 845 846 847 848
	if (!mdesc) {
		early_print("\nError: unrecognized/unsupported machine ID"
			" (r1 = 0x%08x).\n\n", nr);
		dump_machine_table(); /* does not return */
	}
Linus Torvalds's avatar
Linus Torvalds committed
849

Bill Gatliff's avatar
Bill Gatliff committed
850 851
	if (__atags_pointer)
		tags = phys_to_virt(__atags_pointer);
852 853
	else if (mdesc->atag_offset)
		tags = (void *)(PAGE_OFFSET + mdesc->atag_offset);
Linus Torvalds's avatar
Linus Torvalds committed
854

855
#if defined(CONFIG_DEPRECATED_PARAM_STRUCT)
Linus Torvalds's avatar
Linus Torvalds committed
856 857 858 859 860 861
	/*
	 * If we have the old style parameters, convert them to
	 * a tag list.
	 */
	if (tags->hdr.tag != ATAG_CORE)
		convert_to_tag_list(tags);
862
#endif
863 864 865 866 867 868 869 870 871

	if (tags->hdr.tag != ATAG_CORE) {
#if defined(CONFIG_OF)
		/*
		 * If CONFIG_OF is set, then assume this is a reasonably
		 * modern system that should pass boot parameters
		 */
		early_print("Warning: Neither atags nor dtb found\n");
#endif
Linus Torvalds's avatar
Linus Torvalds committed
872
		tags = (struct tag *)&init_tags;
873
	}
Linus Torvalds's avatar
Linus Torvalds committed
874 875

	if (mdesc->fixup)
876
		mdesc->fixup(tags, &from, &meminfo);
Linus Torvalds's avatar
Linus Torvalds committed
877 878 879 880

	if (tags->hdr.tag == ATAG_CORE) {
		if (meminfo.nr_banks != 0)
			squash_mem_tags(tags);
881
		save_atags(tags);
Linus Torvalds's avatar
Linus Torvalds committed
882 883 884
		parse_tags(tags);
	}

885 886 887 888 889 890 891 892 893 894 895 896 897 898
	/* parse_early_param needs a boot_command_line */
	strlcpy(boot_command_line, from, COMMAND_LINE_SIZE);

	return mdesc;
}


void __init setup_arch(char **cmdline_p)
{
	struct machine_desc *mdesc;

	unwind_init();

	setup_processor();
899 900 901
	mdesc = setup_machine_fdt(__atags_pointer);
	if (!mdesc)
		mdesc = setup_machine_tags(machine_arch_type);
902 903 904 905 906 907
	machine_desc = mdesc;
	machine_name = mdesc->name;

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

Russell King's avatar
Russell King committed
908 909 910 911
	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
912

913 914 915
	/* populate cmd_line too for later use, preserving boot_command_line */
	strlcpy(cmd_line, boot_command_line, COMMAND_LINE_SIZE);
	*cmdline_p = cmd_line;
916 917 918

	parse_early_param();

919
	sanity_check_meminfo();
920
	arm_memblock_init(&meminfo, mdesc);
Russell King's avatar
Russell King committed
921

922
	paging_init(mdesc);
923
	request_standard_resources(mdesc);
Linus Torvalds's avatar
Linus Torvalds committed
924

925 926
	unflatten_device_tree();

927
#ifdef CONFIG_SMP
928 929
	if (is_smp())
		smp_init_cpus();
930
#endif
931
	reserve_crashkernel();
932

933
	tcm_init();
934

935 936 937 938 939 940
#ifdef CONFIG_ZONE_DMA
	if (mdesc->dma_zone_size) {
		extern unsigned long arm_dma_zone_size;
		arm_dma_zone_size = mdesc->dma_zone_size;
	}
#endif
941 942 943
#ifdef CONFIG_MULTI_IRQ_HANDLER
	handle_arch_irq = mdesc->handle_irq;
#endif
Linus Torvalds's avatar
Linus Torvalds committed
944 945 946 947 948 949 950 951

#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
952
	early_trap_init();
953 954 955

	if (mdesc->init_early)
		mdesc->init_early();
Linus Torvalds's avatar
Linus Torvalds committed
956 957 958 959 960 961 962
}


static int __init topology_init(void)
{
	int cpu;

963 964 965 966 967
	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
968 969 970 971 972

	return 0;
}
subsys_initcall(topology_init);

973 974 975 976 977 978 979 980 981 982 983 984 985
#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
986 987 988 989 990 991 992 993 994 995
static const char *hwcap_str[] = {
	"swp",
	"half",
	"thumb",
	"26bit",
	"fastmult",
	"fpa",
	"vfp",
	"edsp",
	"java",
996
	"iwmmxt",
997
	"crunch",
998
	"thumbee",
999
	"neon",
1000 1001
	"vfpv3",
	"vfpv3d16",
1002 1003 1004 1005
	"tls",
	"vfpv4",
	"idiva",
	"idivt",
Linus Torvalds's avatar
Linus Torvalds committed
1006 1007 1008 1009 1010 1011 1012 1013
	NULL
};

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

	seq_printf(m, "Processor\t: %s rev %d (%s)\n",
1014
		   cpu_name, read_cpuid_id() & 15, elf_platform);
Linus Torvalds's avatar
Linus Torvalds committed
1015 1016 1017

#if defined(CONFIG_SMP)
	for_each_online_cpu(i) {
1018 1019 1020 1021 1022 1023
		/*
		 * 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
1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040
		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]);

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

1044
	if ((read_cpuid_id() & 0x0008f000) == 0x00000000) {
Linus Torvalds's avatar
Linus Torvalds committed
1045
		/* pre-ARM7 */
1046
		seq_printf(m, "CPU part\t: %07x\n", read_cpuid_id() >> 4);
Linus Torvalds's avatar
Linus Torvalds committed
1047
	} else {
1048
		if ((read_cpuid_id() & 0x0008f000) == 0x00007000) {
Linus Torvalds's avatar
Linus Torvalds committed
1049 1050
			/* ARM7 */
			seq_printf(m, "CPU variant\t: 0x%02x\n",
1051
				   (read_cpuid_id() >> 16) & 127);
Linus Torvalds's avatar
Linus Torvalds committed
1052 1053 1054
		} else {
			/* post-ARM7 */
			seq_printf(m, "CPU variant\t: 0x%x\n",
1055
				   (read_cpuid_id() >> 20) & 15);
Linus Torvalds's avatar
Linus Torvalds committed
1056 1057
		}
		seq_printf(m, "CPU part\t: 0x%03x\n",
1058
			   (read_cpuid_id() >> 4) & 0xfff);
Linus Torvalds's avatar
Linus Torvalds committed
1059
	}
1060
	seq_printf(m, "CPU revision\t: %d\n", read_cpuid_id() & 15);
Linus Torvalds's avatar
Linus Torvalds committed
1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086

	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)
{
}

1087
const struct seq_operations cpuinfo_op = {
Linus Torvalds's avatar
Linus Torvalds committed
1088 1089 1090 1091 1092
	.start	= c_start,
	.next	= c_next,
	.stop	= c_stop,
	.show	= c_show
};