setup.c 25.2 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>
21
#include <linux/of_platform.h>
Linus Torvalds's avatar
Linus Torvalds committed
22
#include <linux/init.h>
23
#include <linux/kexec.h>
24
#include <linux/of_fdt.h>
Linus Torvalds's avatar
Linus Torvalds committed
25 26
#include <linux/cpu.h>
#include <linux/interrupt.h>
27
#include <linux/smp.h>
28
#include <linux/proc_fs.h>
Russell King's avatar
Russell King committed
29
#include <linux/memblock.h>
30 31
#include <linux/bug.h>
#include <linux/compiler.h>
32
#include <linux/sort.h>
Linus Torvalds's avatar
Linus Torvalds committed
33

34
#include <asm/unified.h>
35
#include <asm/cp15.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>
40
#include <asm/psci.h>
Russell King's avatar
Russell King committed
41
#include <asm/sections.h>
Linus Torvalds's avatar
Linus Torvalds committed
42
#include <asm/setup.h>
43
#include <asm/smp_plat.h>
Linus Torvalds's avatar
Linus Torvalds committed
44 45
#include <asm/mach-types.h>
#include <asm/cacheflush.h>
46
#include <asm/cachetype.h>
Linus Torvalds's avatar
Linus Torvalds committed
47 48
#include <asm/tlbflush.h>

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>
53 54
#include <asm/system_info.h>
#include <asm/system_misc.h>
Jason Wessel's avatar
Jason Wessel committed
55
#include <asm/traps.h>
56
#include <asm/unwind.h>
57
#include <asm/memblock.h>
58
#include <asm/virt.h>
Linus Torvalds's avatar
Linus Torvalds committed
59

60
#include "atags.h"
61

Linus Torvalds's avatar
Linus Torvalds committed
62 63 64 65 66 67 68 69 70 71 72 73 74

#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

75
extern void paging_init(const struct machine_desc *desc);
76 77
extern void early_paging_init(const struct machine_desc *,
			      struct proc_info_list *);
78
extern void sanity_check_meminfo(void);
79
extern enum reboot_mode reboot_mode;
80
extern void setup_dma_zone(const struct machine_desc *desc);
Linus Torvalds's avatar
Linus Torvalds committed
81 82

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
EXPORT_SYMBOL(elf_hwcap);

103 104 105
unsigned int elf_hwcap2 __read_mostly;
EXPORT_SYMBOL(elf_hwcap2);

Linus Torvalds's avatar
Linus Torvalds committed
106 107

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

124 125 126 127 128 129 130
/*
 * 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;

131 132 133 134 135 136
struct stack {
	u32 irq[3];
	u32 abt[3];
	u32 und[3];
} ____cacheline_aligned;

137
#ifndef CONFIG_CPU_V7M
138
static struct stack stacks[NR_CPUS];
139
#endif
140

Linus Torvalds's avatar
Linus Torvalds committed
141 142 143 144 145
char elf_platform[ELF_PLATFORM_SIZE];
EXPORT_SYMBOL(elf_platform);

static const char *cpu_name;
static const char *machine_name;
146
static char __initdata cmd_line[COMMAND_LINE_SIZE];
147
const struct machine_desc *machine_desc __initdata;
Linus Torvalds's avatar
Linus Torvalds committed
148 149 150 151 152 153 154 155 156 157

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[] = {
158 159 160 161 162 163 164
	{
		.name = "Video RAM",
		.start = 0,
		.end = 0,
		.flags = IORESOURCE_MEM
	},
	{
165
		.name = "Kernel code",
166 167 168 169 170 171 172 173 174 175
		.start = 0,
		.end = 0,
		.flags = IORESOURCE_MEM
	},
	{
		.name = "Kernel data",
		.start = 0,
		.end = 0,
		.flags = IORESOURCE_MEM
	}
Linus Torvalds's avatar
Linus Torvalds committed
176 177 178 179 180 181 182
};

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

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

#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",
217
	"7",
218
	"7M",
Linus Torvalds's avatar
Linus Torvalds committed
219 220 221 222 223 224 225 226
	"?(12)",
	"?(13)",
	"?(14)",
	"?(15)",
	"?(16)",
	"?(17)",
};

227 228 229 230 231 232
#ifdef CONFIG_CPU_V7M
static int __get_cpu_architecture(void)
{
	return CPU_ARCH_ARMv7M;
}
#else
233
static int __get_cpu_architecture(void)
Linus Torvalds's avatar
Linus Torvalds committed
234 235 236
{
	int cpu_arch;

237
	if ((read_cpuid_id() & 0x0008f000) == 0) {
Linus Torvalds's avatar
Linus Torvalds committed
238
		cpu_arch = CPU_ARCH_UNKNOWN;
239 240 241 242
	} 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
243 244
		if (cpu_arch)
			cpu_arch += CPU_ARCH_ARMv3;
245
	} else if ((read_cpuid_id() & 0x000f0000) == 0x000f0000) {
246 247 248 249 250 251
		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));
252 253
		if ((mmfr0 & 0x0000000f) >= 0x00000003 ||
		    (mmfr0 & 0x000000f0) >= 0x00000030)
254 255 256 257 258 259 260 261
			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
262 263 264

	return cpu_arch;
}
265
#endif
Linus Torvalds's avatar
Linus Torvalds committed
266

267 268 269 270 271 272 273
int __pure cpu_architecture(void)
{
	BUG_ON(__cpu_architecture == CPU_ARCH_UNKNOWN);

	return __cpu_architecture;
}

274 275 276 277 278
static int cpu_has_aliasing_icache(unsigned int arch)
{
	int aliasing_icache;
	unsigned int id_reg, num_sets, line_size;

279 280 281 282
	/* PIPT caches never alias. */
	if (icache_is_pipt())
		return 0;

283 284 285
	/* arch specifies the register format */
	switch (arch) {
	case CPU_ARCH_ARMv7:
286 287
		asm("mcr	p15, 2, %0, c0, c0, 0 @ set CSSELR"
		    : /* No output operands */
288
		    : "r" (1));
289 290 291
		isb();
		asm("mrc	p15, 1, %0, c0, c0, 0 @ read CCSIDR"
		    : "=r" (id_reg));
292 293 294 295 296 297 298 299 300 301 302 303 304 305 306
		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;
}

307 308 309 310
static void __init cacheid_init(void)
{
	unsigned int arch = cpu_architecture();

311 312 313
	if (arch == CPU_ARCH_ARMv7M) {
		cacheid = 0;
	} else if (arch >= CPU_ARCH_ARMv6) {
314
		unsigned int cachetype = read_cpuid_cachetype();
315 316
		if ((cachetype & (7 << 29)) == 4 << 29) {
			/* ARMv7 register format */
317
			arch = CPU_ARCH_ARMv7;
318
			cacheid = CACHEID_VIPT_NONALIASING;
319 320
			switch (cachetype & (3 << 14)) {
			case (1 << 14):
321
				cacheid |= CACHEID_ASID_TAGGED;
322 323 324 325 326
				break;
			case (3 << 14):
				cacheid |= CACHEID_PIPT;
				break;
			}
327
		} else {
328 329 330 331 332
			arch = CPU_ARCH_ARMv6;
			if (cachetype & (1 << 23))
				cacheid = CACHEID_VIPT_ALIASING;
			else
				cacheid = CACHEID_VIPT_NONALIASING;
333
		}
334 335
		if (cpu_has_aliasing_icache(arch))
			cacheid |= CACHEID_VIPT_I_ALIASING;
336 337 338
	} else {
		cacheid = CACHEID_VIVT;
	}
339

340
	pr_info("CPU: %s data cache, %s instruction cache\n",
341 342
		cache_is_vivt() ? "VIVT" :
		cache_is_vipt_aliasing() ? "VIPT aliasing" :
343
		cache_is_vipt_nonaliasing() ? "PIPT / VIPT nonaliasing" : "unknown",
344 345
		cache_is_vivt() ? "VIVT" :
		icache_is_vivt_asid_tagged() ? "VIVT ASID tagged" :
346
		icache_is_vipt_aliasing() ? "VIPT aliasing" :
347
		icache_is_pipt() ? "PIPT" :
348
		cache_is_vipt_nonaliasing() ? "VIPT nonaliasing" : "unknown");
349 350
}

Linus Torvalds's avatar
Linus Torvalds committed
351 352 353 354
/*
 * These functions re-use the assembly code in head.S, which
 * already provide the required functionality.
 */
355
extern struct proc_info_list *lookup_processor_type(unsigned int);
356

357
void __init early_print(const char *str, ...)
358 359 360 361 362 363 364 365 366 367 368 369 370 371 372
{
	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);
}

373 374
static void __init cpuid_init_hwcaps(void)
{
375
	unsigned int divide_instrs, vmsa;
376 377 378 379 380 381 382 383 384 385 386 387

	if (cpu_architecture() < CPU_ARCH_ARMv7)
		return;

	divide_instrs = (read_cpuid_ext(CPUID_EXT_ISAR0) & 0x0f000000) >> 24;

	switch (divide_instrs) {
	case 2:
		elf_hwcap |= HWCAP_IDIVA;
	case 1:
		elf_hwcap |= HWCAP_IDIVT;
	}
388 389 390 391 392

	/* LPAE implies atomic ldrd/strd instructions */
	vmsa = (read_cpuid_ext(CPUID_EXT_MMFR0) & 0xf) >> 0;
	if (vmsa >= 5)
		elf_hwcap |= HWCAP_LPAE;
393 394
}

395 396 397 398 399 400 401 402 403 404 405 406 407 408 409
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;
}

410 411 412
/*
 * cpu_init - initialise one CPU.
 *
Russell King's avatar
Russell King committed
413
 * cpu_init sets up the per-CPU stacks.
414
 */
415
void notrace cpu_init(void)
416
{
417
#ifndef CONFIG_CPU_V7M
418 419 420 421
	unsigned int cpu = smp_processor_id();
	struct stack *stk = &stacks[cpu];

	if (cpu >= NR_CPUS) {
422
		pr_crit("CPU%u: bad primary CPU number\n", cpu);
423 424 425
		BUG();
	}

426 427 428 429 430 431
	/*
	 * This only works on resume and secondary cores. For booting on the
	 * boot cpu, smp_prepare_boot_cpu is called after percpu area setup.
	 */
	set_my_cpu_offset(per_cpu_offset(cpu));

432 433
	cpu_proc_init();

434 435 436 437 438 439 440 441 442 443
	/*
	 * 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

444 445 446 447 448
	/*
	 * setup stacks for re-entrant exception handlers
	 */
	__asm__ (
	"msr	cpsr_c, %1\n\t"
449 450
	"add	r14, %0, %2\n\t"
	"mov	sp, r14\n\t"
451
	"msr	cpsr_c, %3\n\t"
452 453
	"add	r14, %0, %4\n\t"
	"mov	sp, r14\n\t"
454
	"msr	cpsr_c, %5\n\t"
455 456
	"add	r14, %0, %6\n\t"
	"mov	sp, r14\n\t"
457 458 459
	"msr	cpsr_c, %7"
	    :
	    : "r" (stk),
460
	      PLC (PSR_F_BIT | PSR_I_BIT | IRQ_MODE),
461
	      "I" (offsetof(struct stack, irq[0])),
462
	      PLC (PSR_F_BIT | PSR_I_BIT | ABT_MODE),
463
	      "I" (offsetof(struct stack, abt[0])),
464
	      PLC (PSR_F_BIT | PSR_I_BIT | UND_MODE),
465
	      "I" (offsetof(struct stack, und[0])),
466
	      PLC (PSR_F_BIT | PSR_I_BIT | SVC_MODE)
467
	    : "r14");
468
#endif
469 470
}

471
u32 __cpu_logical_map[NR_CPUS] = { [0 ... NR_CPUS-1] = MPIDR_INVALID };
472 473 474 475

void __init smp_setup_processor_id(void)
{
	int i;
476 477
	u32 mpidr = is_smp() ? read_cpuid_mpidr() & MPIDR_HWID_BITMASK : 0;
	u32 cpu = MPIDR_AFFINITY_LEVEL(mpidr, 0);
478 479

	cpu_logical_map(0) = cpu;
480
	for (i = 1; i < nr_cpu_ids; ++i)
481 482
		cpu_logical_map(i) = i == cpu ? 0 : i;

483 484 485 486 487 488 489
	/*
	 * clear __my_cpu_offset on boot CPU to avoid hang caused by
	 * using percpu variable early, for example, lockdep will
	 * access percpu variable inside lock_release
	 */
	set_my_cpu_offset(0);

490
	pr_info("Booting Linux on physical CPU 0x%x\n", mpidr);
491 492
}

493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558
struct mpidr_hash mpidr_hash;
#ifdef CONFIG_SMP
/**
 * smp_build_mpidr_hash - Pre-compute shifts required at each affinity
 *			  level in order to build a linear index from an
 *			  MPIDR value. Resulting algorithm is a collision
 *			  free hash carried out through shifting and ORing
 */
static void __init smp_build_mpidr_hash(void)
{
	u32 i, affinity;
	u32 fs[3], bits[3], ls, mask = 0;
	/*
	 * Pre-scan the list of MPIDRS and filter out bits that do
	 * not contribute to affinity levels, ie they never toggle.
	 */
	for_each_possible_cpu(i)
		mask |= (cpu_logical_map(i) ^ cpu_logical_map(0));
	pr_debug("mask of set bits 0x%x\n", mask);
	/*
	 * Find and stash the last and first bit set at all affinity levels to
	 * check how many bits are required to represent them.
	 */
	for (i = 0; i < 3; i++) {
		affinity = MPIDR_AFFINITY_LEVEL(mask, i);
		/*
		 * Find the MSB bit and LSB bits position
		 * to determine how many bits are required
		 * to express the affinity level.
		 */
		ls = fls(affinity);
		fs[i] = affinity ? ffs(affinity) - 1 : 0;
		bits[i] = ls - fs[i];
	}
	/*
	 * An index can be created from the MPIDR by isolating the
	 * significant bits at each affinity level and by shifting
	 * them in order to compress the 24 bits values space to a
	 * compressed set of values. This is equivalent to hashing
	 * the MPIDR through shifting and ORing. It is a collision free
	 * hash though not minimal since some levels might contain a number
	 * of CPUs that is not an exact power of 2 and their bit
	 * representation might contain holes, eg MPIDR[7:0] = {0x2, 0x80}.
	 */
	mpidr_hash.shift_aff[0] = fs[0];
	mpidr_hash.shift_aff[1] = MPIDR_LEVEL_BITS + fs[1] - bits[0];
	mpidr_hash.shift_aff[2] = 2*MPIDR_LEVEL_BITS + fs[2] -
						(bits[1] + bits[0]);
	mpidr_hash.mask = mask;
	mpidr_hash.bits = bits[2] + bits[1] + bits[0];
	pr_debug("MPIDR hash: aff0[%u] aff1[%u] aff2[%u] mask[0x%x] bits[%u]\n",
				mpidr_hash.shift_aff[0],
				mpidr_hash.shift_aff[1],
				mpidr_hash.shift_aff[2],
				mpidr_hash.mask,
				mpidr_hash.bits);
	/*
	 * 4x is an arbitrary value used to warn on a hash table much bigger
	 * than expected on most systems.
	 */
	if (mpidr_hash_size() > 4 * num_possible_cpus())
		pr_warn("Large number of MPIDR hash buckets detected\n");
	sync_cache_w(&mpidr_hash);
}
#endif

559 560 561 562 563 564 565 566 567 568 569
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) {
570 571
		pr_err("CPU configuration botched (ID %08x), unable to continue.\n",
		       read_cpuid_id());
572 573 574 575
		while (1);
	}

	cpu_name = list->cpu_name;
576
	__cpu_architecture = __get_cpu_architecture();
577 578 579 580 581 582 583 584 585 586 587 588 589 590

#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

591 592 593
	pr_info("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);
594

595 596 597 598
	snprintf(init_utsname()->machine, __NEW_UTS_LEN + 1, "%s%c",
		 list->arch_name, ENDIANNESS);
	snprintf(elf_platform, ELF_PLATFORM_SIZE, "%s%c",
		 list->elf_name, ENDIANNESS);
599
	elf_hwcap = list->elf_hwcap;
600 601 602

	cpuid_init_hwcaps();

603
#ifndef CONFIG_ARM_THUMB
604
	elf_hwcap &= ~(HWCAP_THUMB | HWCAP_IDIVT);
605 606
#endif

607 608
	erratum_a15_798181_init();

609 610 611 612 613 614
	feat_v6_fixup();

	cacheid_init();
	cpu_init();
}

615
void __init dump_machine_table(void)
Linus Torvalds's avatar
Linus Torvalds committed
616
{
617
	const struct machine_desc *p;
Linus Torvalds's avatar
Linus Torvalds committed
618

619 620
	early_print("Available machine support:\n\nID (hex)\tNAME\n");
	for_each_machine_desc(p)
621
		early_print("%08x\t%s\n", p->nr, p->name);
Linus Torvalds's avatar
Linus Torvalds committed
622

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

625 626
	while (true)
		/* can't use cpu_relax() here as it may require MMU setup */;
Linus Torvalds's avatar
Linus Torvalds committed
627 628
}

629
int __init arm_add_memory(u64 start, u64 size)
630
{
631
	u64 aligned_start;
632

633 634 635 636 637
	/*
	 * Ensure that start/size are aligned to a page boundary.
	 * Size is appropriately rounded down, start is rounded up.
	 */
	size -= start & ~PAGE_MASK;
638
	aligned_start = PAGE_ALIGN(start);
639

640 641
#ifndef CONFIG_ARCH_PHYS_ADDR_T_64BIT
	if (aligned_start > ULONG_MAX) {
642 643
		pr_crit("Ignoring memory at 0x%08llx outside 32-bit physical address space\n",
			(long long)start);
644 645 646 647
		return -EINVAL;
	}

	if (aligned_start + size > ULONG_MAX) {
648 649
		pr_crit("Truncating memory at 0x%08llx to fit in 32-bit physical address space\n",
			(long long)start);
650 651 652 653 654
		/*
		 * To ensure bank->start + bank->size is representable in
		 * 32 bits, we use ULONG_MAX as the upper limit rather than 4GB.
		 * This means we lose a page after masking.
		 */
655
		size = ULONG_MAX - aligned_start;
656 657 658
	}
#endif

659 660 661 662 663 664 665 666 667 668 669 670 671 672
	if (aligned_start < PHYS_OFFSET) {
		if (aligned_start + size <= PHYS_OFFSET) {
			pr_info("Ignoring memory below PHYS_OFFSET: 0x%08llx-0x%08llx\n",
				aligned_start, aligned_start + size);
			return -EINVAL;
		}

		pr_info("Ignoring memory below PHYS_OFFSET: 0x%08llx-0x%08llx\n",
			aligned_start, (u64)PHYS_OFFSET);

		size -= PHYS_OFFSET - aligned_start;
		aligned_start = PHYS_OFFSET;
	}

Laura Abbott's avatar
Laura Abbott committed
673 674
	start = aligned_start;
	size = size & ~(phys_addr_t)(PAGE_SIZE - 1);
675 676 677 678 679

	/*
	 * Check whether this memory region has non-zero size or
	 * invalid node number.
	 */
Laura Abbott's avatar
Laura Abbott committed
680
	if (size == 0)
681 682
		return -EINVAL;

Laura Abbott's avatar
Laura Abbott committed
683
	memblock_add(start, size);
684
	return 0;
685 686
}

Linus Torvalds's avatar
Linus Torvalds committed
687 688 689 690
/*
 * Pick out the memory size.  We look for mem=size@start,
 * where start and size are "size[KkMm]"
 */
Laura Abbott's avatar
Laura Abbott committed
691

692
static int __init early_mem(char *p)
Linus Torvalds's avatar
Linus Torvalds committed
693 694
{
	static int usermem __initdata = 0;
695 696
	u64 size;
	u64 start;
697
	char *endp;
Linus Torvalds's avatar
Linus Torvalds committed
698 699 700 701 702 703 704 705

	/*
	 * If the user specifies memory size, we
	 * blow away any automatically generated
	 * size.
	 */
	if (usermem == 0) {
		usermem = 1;
Laura Abbott's avatar
Laura Abbott committed
706 707
		memblock_remove(memblock_start_of_DRAM(),
			memblock_end_of_DRAM() - memblock_start_of_DRAM());
Linus Torvalds's avatar
Linus Torvalds committed
708 709 710
	}

	start = PHYS_OFFSET;
711 712 713
	size  = memparse(p, &endp);
	if (*endp == '@')
		start = memparse(endp + 1, NULL);
Linus Torvalds's avatar
Linus Torvalds committed
714

Andrew Morton's avatar
Andrew Morton committed
715
	arm_add_memory(start, size);
Linus Torvalds's avatar
Linus Torvalds committed
716

717
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
718
}
719
early_param("mem", early_mem);
Linus Torvalds's avatar
Linus Torvalds committed
720

721
static void __init request_standard_resources(const struct machine_desc *mdesc)
Linus Torvalds's avatar
Linus Torvalds committed
722
{
723
	struct memblock_region *region;
Linus Torvalds's avatar
Linus Torvalds committed
724 725
	struct resource *res;

Russell King's avatar
Russell King committed
726 727
	kernel_code.start   = virt_to_phys(_text);
	kernel_code.end     = virt_to_phys(_etext - 1);
728
	kernel_data.start   = virt_to_phys(_sdata);
Russell King's avatar
Russell King committed
729
	kernel_data.end     = virt_to_phys(_end - 1);
Linus Torvalds's avatar
Linus Torvalds committed
730

731
	for_each_memblock(memory, region) {
732
		res = memblock_virt_alloc(sizeof(*res), 0);
Linus Torvalds's avatar
Linus Torvalds committed
733
		res->name  = "System RAM";
734 735
		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
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 770 771 772 773 774
		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);
}

#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
};
775
#endif
Linus Torvalds's avatar
Linus Torvalds committed
776 777 778

static int __init customize_machine(void)
{
779 780 781 782 783 784
	/*
	 * customizes platform devices, or adds new ones
	 * On DT based machines, we fall back to populating the
	 * machine from the device tree, if no callback is provided,
	 * otherwise we would always need an init_machine callback.
	 */
785 786
	if (machine_desc->init_machine)
		machine_desc->init_machine();
787 788 789 790 791
#ifdef CONFIG_OF
	else
		of_platform_populate(NULL, of_default_bus_match_table,
					NULL, NULL);
#endif
Linus Torvalds's avatar
Linus Torvalds committed
792 793 794 795
	return 0;
}
arch_initcall(customize_machine);

796 797 798 799 800 801 802 803
static int __init init_machine_late(void)
{
	if (machine_desc->init_late)
		machine_desc->init_late();
	return 0;
}
late_initcall(init_machine_late);

804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831
#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;

832
	ret = memblock_reserve(crash_base, crash_size);
833
	if (ret < 0) {
834 835
		pr_warn("crashkernel reservation failed - memory is in use (0x%lx)\n",
			(unsigned long)crash_base);
836 837 838
		return;
	}

839 840 841 842
	pr_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));
843 844 845 846 847 848 849 850 851

	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 */

852 853 854
void __init hyp_mode_check(void)
{
#ifdef CONFIG_ARM_VIRT_EXT
855 856
	sync_boot_mode();

857 858 859 860 861 862 863 864 865 866 867 868
	if (is_hyp_mode_available()) {
		pr_info("CPU: All CPU(s) started in HYP mode.\n");
		pr_info("CPU: Virtualization extensions available.\n");
	} else if (is_hyp_mode_mismatched()) {
		pr_warn("CPU: WARNING: CPU(s) started in wrong/inconsistent modes (primary CPU mode 0x%x)\n",
			__boot_cpu_mode & MODE_MASK);
		pr_warn("CPU: This may indicate a broken bootloader or firmware.\n");
	} else
		pr_info("CPU: All CPU(s) started in SVC mode.\n");
#endif
}

869 870
void __init setup_arch(char **cmdline_p)
{
871
	const struct machine_desc *mdesc;
872 873

	setup_processor();
874 875
	mdesc = setup_machine_fdt(__atags_pointer);
	if (!mdesc)
876
		mdesc = setup_machine_tags(__atags_pointer, __machine_arch_type);
877 878 879
	machine_desc = mdesc;
	machine_name = mdesc->name;

880 881
	if (mdesc->reboot_mode != REBOOT_HARD)
		reboot_mode = mdesc->reboot_mode;
882

Russell King's avatar
Russell King committed
883 884 885 886
	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
887

888 889 890
	/* populate cmd_line too for later use, preserving boot_command_line */
	strlcpy(cmd_line, boot_command_line, COMMAND_LINE_SIZE);
	*cmdline_p = cmd_line;
891 892 893

	parse_early_param();

894
	early_paging_init(mdesc, lookup_processor_type(read_cpuid_id()));
895
	setup_dma_zone(mdesc);
896
	sanity_check_meminfo();
Laura Abbott's avatar
Laura Abbott committed
897
	arm_memblock_init(mdesc);
Russell King's avatar
Russell King committed
898

899
	paging_init(mdesc);
900
	request_standard_resources(mdesc);
Linus Torvalds's avatar
Linus Torvalds committed
901

902 903 904
	if (mdesc->restart)
		arm_pm_restart = mdesc->restart;

905 906
	unflatten_device_tree();

907
	arm_dt_init_cpu_maps();
908
	psci_init();
909
#ifdef CONFIG_SMP
910
	if (is_smp()) {
911 912 913 914 915 916
		if (!mdesc->smp_init || !mdesc->smp_init()) {
			if (psci_smp_available())
				smp_set_ops(&psci_smp_ops);
			else if (mdesc->smp)
				smp_set_ops(mdesc->smp);
		}
917
		smp_init_cpus();
918
		smp_build_mpidr_hash();
919
	}
920
#endif
921 922 923 924

	if (!is_smp())
		hyp_mode_check();

925
	reserve_crashkernel();
926

927 928 929
#ifdef CONFIG_MULTI_IRQ_HANDLER
	handle_arch_irq = mdesc->handle_irq;
#endif
Linus Torvalds's avatar
Linus Torvalds committed
930 931 932 933 934 935 936 937

#ifdef CONFIG_VT
#if defined(CONFIG_VGA_CONSOLE)
	conswitchp = &vga_con;
#elif defined(CONFIG_DUMMY_CONSOLE)
	conswitchp = &dummy_con;
#endif
#endif
938 939 940

	if (mdesc->init_early)
		mdesc->init_early();
Linus Torvalds's avatar
Linus Torvalds committed
941 942 943 944 945 946 947
}


static int __init topology_init(void)
{
	int cpu;

948 949 950 951 952
	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
953 954 955 956 957

	return 0;
}
subsys_initcall(topology_init);

958 959 960 961 962 963 964 965 966 967 968 969 970
#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
971 972 973 974 975 976 977 978 979 980
static const char *hwcap_str[] = {
	"swp",
	"half",
	"thumb",
	"26bit",
	"fastmult",
	"fpa",
	"vfp",
	"edsp",
	"java",
981
	"iwmmxt",
982
	"crunch",
983
	"thumbee",
984
	"neon",
985 986
	"vfpv3",
	"vfpv3d16",
987 988 989 990
	"tls",
	"vfpv4",
	"idiva",
	"idivt",
991
	"vfpd32",
992
	"lpae",
993
	"evtstrm",
Linus Torvalds's avatar
Linus Torvalds committed
994 995 996
	NULL
};

997
static const char *hwcap2_str[] = {
998 999 1000 1001 1002
	"aes",
	"pmull",
	"sha1",
	"sha2",
	"crc32",
1003 1004 1005
	NULL
};

Linus Torvalds's avatar
Linus Torvalds committed
1006 1007
static int c_show(struct seq_file *m, void *v)
{
1008 1009
	int i, j;
	u32 cpuid;
Linus Torvalds's avatar
Linus Torvalds committed
1010 1011

	for_each_online_cpu(i) {
1012 1013 1014 1015 1016 1017
		/*
		 * 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);
1018 1019 1020 1021 1022 1023
		cpuid = is_smp() ? per_cpu(cpu_data, i).cpuid : read_cpuid_id();
		seq_printf(m, "model name\t: %s rev %d (%s)\n",
			   cpu_name, cpuid & 15, elf_platform);

		/* dump out the processor features */
		seq_puts(m, "Features\t: ");
Linus Torvalds's avatar
Linus Torvalds committed
1024

1025 1026 1027
		for (j = 0; hwcap_str[j]; j++)
			if (elf_hwcap & (1 << j))
				seq_printf(m, "%s ", hwcap_str[j]);
Linus Torvalds's avatar
Linus Torvalds committed
1028

1029 1030 1031 1032
		for (j = 0; hwcap2_str[j]; j++)
			if (elf_hwcap2 & (1 << j))
				seq_printf(m, "%s ", hwcap2_str[j]);

1033 1034 1035
		seq_printf(m, "\nCPU implementer\t: 0x%02x\n", cpuid >> 24);
		seq_printf(m, "CPU architecture: %s\n",
			   proc_arch[cpu_architecture()]);
Linus Torvalds's avatar
Linus Torvalds committed
1036

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

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

1079
const struct seq_operations cpuinfo_op = {
Linus Torvalds's avatar
Linus Torvalds committed
1080 1081 1082 1083 1084
	.start	= c_start,
	.next	= c_next,
	.stop	= c_stop,
	.show	= c_show
};