setup.c 23.4 KB
Newer Older
L
Linus Torvalds 已提交
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>
L
Linus Torvalds 已提交
21
#include <linux/init.h>
22
#include <linux/kexec.h>
23
#include <linux/crash_dump.h>
L
Linus Torvalds 已提交
24 25 26
#include <linux/root_dev.h>
#include <linux/cpu.h>
#include <linux/interrupt.h>
R
Russell King 已提交
27
#include <linux/smp.h>
A
Alexey Dobriyan 已提交
28
#include <linux/fs.h>
29
#include <linux/proc_fs.h>
R
Russell King 已提交
30
#include <linux/memblock.h>
L
Linus Torvalds 已提交
31

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

#include <asm/mach/arch.h>
#include <asm/mach/irq.h>
#include <asm/mach/time.h>
J
Jason Wessel 已提交
48
#include <asm/traps.h>
49
#include <asm/unwind.h>
L
Linus Torvalds 已提交
50

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

L
Linus Torvalds 已提交
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);
L
Linus Torvalds 已提交
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;
L
Linus Torvalds 已提交
79
EXPORT_SYMBOL(__machine_arch_type);
80
unsigned int cacheid __read_mostly;
81
EXPORT_SYMBOL(cacheid);
L
Linus Torvalds 已提交
82

B
Bill Gatliff 已提交
83 84
unsigned int __atags_pointer __initdata;

L
Linus Torvalds 已提交
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;
L
Linus Torvalds 已提交
95 96 97 98
EXPORT_SYMBOL(elf_hwcap);


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

R
Russell King 已提交
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];

L
Linus Torvalds 已提交
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;
L
Linus Torvalds 已提交
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
	}
L
Linus Torvalds 已提交
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
	}
L
Linus Torvalds 已提交
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",
L
Linus Torvalds 已提交
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) {
L
Linus Torvalds 已提交
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;
L
Linus Torvalds 已提交
220 221
		if (cpu_arch)
			cpu_arch += CPU_ARCH_ARMv3;
222
	} else if ((read_cpuid_id() & 0x000f0000) == 0x000f0000) {
223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238
		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));
		if ((mmfr0 & 0x0000000f) == 0x00000003 ||
		    (mmfr0 & 0x000000f0) == 0x00000030)
			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;
L
Linus Torvalds 已提交
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
}

L
Linus Torvalds 已提交
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);
L
Linus Torvalds 已提交
311 312
extern struct machine_desc *lookup_machine_type(unsigned int);

313 314 315 316 317 318 319 320 321 322 323 324 325 326 327
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;
}

L
Linus Torvalds 已提交
328 329 330 331 332 333 334 335 336
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
	 */
337
	list = lookup_processor_type(read_cpuid_id());
L
Linus Torvalds 已提交
338 339
	if (!list) {
		printk("CPU configuration botched (ID %08x), unable "
340
		       "to continue.\n", read_cpuid_id());
L
Linus Torvalds 已提交
341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358
		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

359
	printk("CPU: %s [%08x] revision %d (ARMv%s), cr=%08lx\n",
360
	       cpu_name, read_cpuid_id(), read_cpuid_id() & 15,
361
	       proc_arch[cpu_architecture()], cr_alignment);
L
Linus Torvalds 已提交
362

363
	sprintf(init_utsname()->machine, "%s%c", list->arch_name, ENDIANNESS);
L
Linus Torvalds 已提交
364 365
	sprintf(elf_platform, "%s%c", list->elf_name, ENDIANNESS);
	elf_hwcap = list->elf_hwcap;
366 367 368
#ifndef CONFIG_ARM_THUMB
	elf_hwcap &= ~HWCAP_THUMB;
#endif
L
Linus Torvalds 已提交
369

370 371
	feat_v6_fixup();

372
	cacheid_init();
L
Linus Torvalds 已提交
373 374 375
	cpu_proc_init();
}

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

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

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

L
Linus Torvalds 已提交
427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445
static struct machine_desc * __init setup_machine(unsigned int nr)
{
	struct machine_desc *list;

	/*
	 * locate machine in the list of supported machines.
	 */
	list = lookup_machine_type(nr);
	if (!list) {
		printk("Machine configuration botched (nr %d), unable "
		       "to continue.\n", nr);
		while (1);
	}

	printk("Machine: %s\n", list->name);

	return list;
}

446
static int __init arm_add_memory(unsigned long start, unsigned long size)
447
{
448 449 450 451 452 453 454
	struct membank *bank = &meminfo.bank[meminfo.nr_banks];

	if (meminfo.nr_banks >= NR_BANKS) {
		printk(KERN_CRIT "NR_BANKS too low, "
			"ignoring memory at %#lx\n", start);
		return -EINVAL;
	}
455

456 457 458 459 460
	/*
	 * Ensure that start/size are aligned to a page boundary.
	 * Size is appropriately rounded down, start is rounded up.
	 */
	size -= start & ~PAGE_MASK;
461 462
	bank->start = PAGE_ALIGN(start);
	bank->size  = size & PAGE_MASK;
463 464 465 466 467

	/*
	 * Check whether this memory region has non-zero size or
	 * invalid node number.
	 */
R
Russell King 已提交
468
	if (bank->size == 0)
469 470 471 472
		return -EINVAL;

	meminfo.nr_banks++;
	return 0;
473 474
}

L
Linus Torvalds 已提交
475 476 477 478
/*
 * Pick out the memory size.  We look for mem=size@start,
 * where start and size are "size[KkMm]"
 */
479
static int __init early_mem(char *p)
L
Linus Torvalds 已提交
480 481 482
{
	static int usermem __initdata = 0;
	unsigned long size, start;
483
	char *endp;
L
Linus Torvalds 已提交
484 485 486 487 488 489 490 491 492 493 494 495

	/*
	 * 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;
496 497 498
	size  = memparse(p, &endp);
	if (*endp == '@')
		start = memparse(endp + 1, NULL);
L
Linus Torvalds 已提交
499

A
Andrew Morton 已提交
500
	arm_add_memory(start, size);
L
Linus Torvalds 已提交
501

502
	return 0;
L
Linus Torvalds 已提交
503
}
504
early_param("mem", early_mem);
L
Linus Torvalds 已提交
505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526

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
}

static void __init
request_standard_resources(struct meminfo *mi, struct machine_desc *mdesc)
{
	struct resource *res;
	int i;

R
Russell King 已提交
527 528
	kernel_code.start   = virt_to_phys(_text);
	kernel_code.end     = virt_to_phys(_etext - 1);
529
	kernel_data.start   = virt_to_phys(_sdata);
R
Russell King 已提交
530
	kernel_data.end     = virt_to_phys(_end - 1);
L
Linus Torvalds 已提交
531 532 533 534 535 536 537

	for (i = 0; i < mi->nr_banks; i++) {
		if (mi->bank[i].size == 0)
			continue;

		res = alloc_bootmem_low(sizeof(*res));
		res->name  = "System RAM";
538 539
		res->start = mi->bank[i].start;
		res->end   = mi->bank[i].start + mi->bank[i].size - 1;
L
Linus Torvalds 已提交
540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 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
		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)
{
594
	return arm_add_memory(tag->u.mem.start, tag->u.mem.size);
L
Linus Torvalds 已提交
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 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652
}

__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);

653
#ifndef CONFIG_CMDLINE_FORCE
L
Linus Torvalds 已提交
654 655 656 657 658 659 660
static int __init parse_tag_cmdline(const struct tag *tag)
{
	strlcpy(default_command_line, tag->u.cmdline.cmdline, COMMAND_LINE_SIZE);
	return 0;
}

__tagtable(ATAG_CMDLINE, parse_tag_cmdline);
661
#endif /* CONFIG_CMDLINE_FORCE */
L
Linus Torvalds 已提交
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 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714

/*
 * 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 },
	{ MEM_SIZE, PHYS_OFFSET },
	{ 0, ATAG_NONE }
};

static int __init customize_machine(void)
{
	/* customizes platform devices, or adds new ones */
715 716
	if (machine_desc->init_machine)
		machine_desc->init_machine();
L
Linus Torvalds 已提交
717 718 719 720
	return 0;
}
arch_initcall(customize_machine);

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 757 758 759 760 761 762 763 764 765 766 767 768 769
#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 */

770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793
/*
 * Note: elfcorehdr_addr is not just limited to vmcore. It is also used by
 * is_kdump_kernel() to determine if we are booting after a panic. Hence
 * ifdef it under CONFIG_CRASH_DUMP and not CONFIG_PROC_VMCORE.
 */

#ifdef CONFIG_CRASH_DUMP
/*
 * elfcorehdr= specifies the location of elf core header stored by the crashed
 * kernel. This option will be passed by kexec loader to the capture kernel.
 */
static int __init setup_elfcorehdr(char *arg)
{
	char *end;

	if (!arg)
		return -EINVAL;

	elfcorehdr_addr = memparse(arg, &end);
	return end > arg ? 0 : -EINVAL;
}
early_param("elfcorehdr", setup_elfcorehdr);
#endif /* CONFIG_CRASH_DUMP */

794 795 796 797 798 799 800
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;
}

L
Linus Torvalds 已提交
801 802 803 804 805 806
void __init setup_arch(char **cmdline_p)
{
	struct tag *tags = (struct tag *)&init_tags;
	struct machine_desc *mdesc;
	char *from = default_command_line;

807 808
	unwind_init();

L
Linus Torvalds 已提交
809 810
	setup_processor();
	mdesc = setup_machine(machine_arch_type);
811
	machine_desc = mdesc;
L
Linus Torvalds 已提交
812 813 814 815 816
	machine_name = mdesc->name;

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

B
Bill Gatliff 已提交
817 818 819
	if (__atags_pointer)
		tags = phys_to_virt(__atags_pointer);
	else if (mdesc->boot_params)
820
		tags = phys_to_virt(mdesc->boot_params);
L
Linus Torvalds 已提交
821

822
#if defined(CONFIG_DEPRECATED_PARAM_STRUCT)
L
Linus Torvalds 已提交
823 824 825 826 827 828
	/*
	 * If we have the old style parameters, convert them to
	 * a tag list.
	 */
	if (tags->hdr.tag != ATAG_CORE)
		convert_to_tag_list(tags);
829
#endif
L
Linus Torvalds 已提交
830 831 832 833 834 835 836 837 838
	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);
839
		save_atags(tags);
L
Linus Torvalds 已提交
840 841 842
		parse_tags(tags);
	}

R
Russell King 已提交
843 844 845 846
	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;
L
Linus Torvalds 已提交
847

848 849 850
	/* parse_early_param needs a boot_command_line */
	strlcpy(boot_command_line, from, COMMAND_LINE_SIZE);

851 852 853
	/* populate cmd_line too for later use, preserving boot_command_line */
	strlcpy(cmd_line, boot_command_line, COMMAND_LINE_SIZE);
	*cmdline_p = cmd_line;
854 855 856

	parse_early_param();

857
	arm_memblock_init(&meminfo, mdesc);
R
Russell King 已提交
858

859
	paging_init(mdesc);
L
Linus Torvalds 已提交
860 861
	request_standard_resources(&meminfo, mdesc);

R
Russell King 已提交
862
#ifdef CONFIG_SMP
863 864
	if (is_smp())
		smp_init_cpus();
R
Russell King 已提交
865
#endif
866
	reserve_crashkernel();
R
Russell King 已提交
867

R
Russell King 已提交
868
	cpu_init();
869
	tcm_init();
R
Russell King 已提交
870

871 872 873
#ifdef CONFIG_MULTI_IRQ_HANDLER
	handle_arch_irq = mdesc->handle_irq;
#endif
L
Linus Torvalds 已提交
874 875 876 877 878 879 880 881

#ifdef CONFIG_VT
#if defined(CONFIG_VGA_CONSOLE)
	conswitchp = &vga_con;
#elif defined(CONFIG_DUMMY_CONSOLE)
	conswitchp = &dummy_con;
#endif
#endif
J
Jason Wessel 已提交
882
	early_trap_init();
L
Linus Torvalds 已提交
883 884 885 886 887 888 889
}


static int __init topology_init(void)
{
	int cpu;

890 891 892 893 894
	for_each_possible_cpu(cpu) {
		struct cpuinfo_arm *cpuinfo = &per_cpu(cpu_data, cpu);
		cpuinfo->cpu.hotpluggable = 1;
		register_cpu(&cpuinfo->cpu, cpu);
	}
L
Linus Torvalds 已提交
895 896 897 898 899

	return 0;
}
subsys_initcall(topology_init);

900 901 902 903 904 905 906 907 908 909 910 911 912
#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

L
Linus Torvalds 已提交
913 914 915 916 917 918 919 920 921 922
static const char *hwcap_str[] = {
	"swp",
	"half",
	"thumb",
	"26bit",
	"fastmult",
	"fpa",
	"vfp",
	"edsp",
	"java",
923
	"iwmmxt",
924
	"crunch",
925
	"thumbee",
926
	"neon",
927 928
	"vfpv3",
	"vfpv3d16",
L
Linus Torvalds 已提交
929 930 931 932 933 934 935 936
	NULL
};

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

	seq_printf(m, "Processor\t: %s rev %d (%s)\n",
937
		   cpu_name, read_cpuid_id() & 15, elf_platform);
L
Linus Torvalds 已提交
938 939 940

#if defined(CONFIG_SMP)
	for_each_online_cpu(i) {
941 942 943 944 945 946
		/*
		 * 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);
L
Linus Torvalds 已提交
947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963
		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]);

964
	seq_printf(m, "\nCPU implementer\t: 0x%02x\n", read_cpuid_id() >> 24);
L
Linus Torvalds 已提交
965 966
	seq_printf(m, "CPU architecture: %s\n", proc_arch[cpu_architecture()]);

967
	if ((read_cpuid_id() & 0x0008f000) == 0x00000000) {
L
Linus Torvalds 已提交
968
		/* pre-ARM7 */
969
		seq_printf(m, "CPU part\t: %07x\n", read_cpuid_id() >> 4);
L
Linus Torvalds 已提交
970
	} else {
971
		if ((read_cpuid_id() & 0x0008f000) == 0x00007000) {
L
Linus Torvalds 已提交
972 973
			/* ARM7 */
			seq_printf(m, "CPU variant\t: 0x%02x\n",
974
				   (read_cpuid_id() >> 16) & 127);
L
Linus Torvalds 已提交
975 976 977
		} else {
			/* post-ARM7 */
			seq_printf(m, "CPU variant\t: 0x%x\n",
978
				   (read_cpuid_id() >> 20) & 15);
L
Linus Torvalds 已提交
979 980
		}
		seq_printf(m, "CPU part\t: 0x%03x\n",
981
			   (read_cpuid_id() >> 4) & 0xfff);
L
Linus Torvalds 已提交
982
	}
983
	seq_printf(m, "CPU revision\t: %d\n", read_cpuid_id() & 15);
L
Linus Torvalds 已提交
984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009

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

1010
const struct seq_operations cpuinfo_op = {
L
Linus Torvalds 已提交
1011 1012 1013 1014 1015
	.start	= c_start,
	.next	= c_next,
	.stop	= c_stop,
	.show	= c_show
};