setup.c 9.3 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
/*
 * Based on arch/arm/kernel/setup.c
 *
 * Copyright (C) 1995-2001 Russell King
 * Copyright (C) 2012 ARM Ltd.
 *
 * 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.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

20
#include <linux/acpi.h>
21 22 23 24 25 26 27 28
#include <linux/export.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>
29
#include <linux/cache.h>
30 31 32 33 34 35 36 37 38 39 40 41 42
#include <linux/bootmem.h>
#include <linux/screen_info.h>
#include <linux/init.h>
#include <linux/kexec.h>
#include <linux/crash_dump.h>
#include <linux/root_dev.h>
#include <linux/cpu.h>
#include <linux/interrupt.h>
#include <linux/smp.h>
#include <linux/fs.h>
#include <linux/proc_fs.h>
#include <linux/memblock.h>
#include <linux/of_fdt.h>
M
Mark Salter 已提交
43
#include <linux/efi.h>
44
#include <linux/psci.h>
45

46
#include <asm/acpi.h>
M
Mark Salter 已提交
47
#include <asm/fixmap.h>
48
#include <asm/cpu.h>
49 50
#include <asm/cputype.h>
#include <asm/elf.h>
51
#include <asm/cpufeature.h>
M
Mark Rutland 已提交
52
#include <asm/cpu_ops.h>
A
Andrey Ryabinin 已提交
53
#include <asm/kasan.h>
54
#include <asm/numa.h>
55 56
#include <asm/sections.h>
#include <asm/setup.h>
57
#include <asm/smp_plat.h>
58 59 60 61
#include <asm/cacheflush.h>
#include <asm/tlbflush.h>
#include <asm/traps.h>
#include <asm/memblock.h>
M
Mark Salter 已提交
62
#include <asm/efi.h>
63
#include <asm/xen/hypervisor.h>
M
Mark Rutland 已提交
64
#include <asm/mmu_context.h>
65 66 67 68 69 70 71 72 73 74 75

phys_addr_t __fdt_pointer __initdata;

/*
 * Standard memory resources
 */
static struct resource mem_res[] = {
	{
		.name = "Kernel code",
		.start = 0,
		.end = 0,
76
		.flags = IORESOURCE_SYSTEM_RAM
77 78 79 80 81
	},
	{
		.name = "Kernel data",
		.start = 0,
		.end = 0,
82
		.flags = IORESOURCE_SYSTEM_RAM
83 84 85 86 87 88
	}
};

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

89 90 91 92 93
/*
 * The recorded values of x0 .. x3 upon kernel entry.
 */
u64 __cacheline_aligned boot_args[4];

94 95
void __init smp_setup_processor_id(void)
{
M
Mark Rutland 已提交
96 97 98
	u64 mpidr = read_cpuid_mpidr() & MPIDR_HWID_BITMASK;
	cpu_logical_map(0) = mpidr;

99 100 101 102 103 104
	/*
	 * 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);
M
Mark Rutland 已提交
105
	pr_info("Booting Linux on physical CPU 0x%lx\n", (unsigned long)mpidr);
106 107
}

108 109 110 111 112
bool arch_match_cpu_phys_id(int cpu, u64 phys_id)
{
	return phys_id == cpu_logical_map(cpu);
}

113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177
struct mpidr_hash mpidr_hash;
/**
 * 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, fs[4], bits[4], ls;
	u64 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 %#llx\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 < 4; 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_EL1 by isolating the
	 * significant bits at each affinity level and by shifting
	 * them in order to compress the 32 bits values space to a
	 * compressed set of values. This is equivalent to hashing
	 * the MPIDR_EL1 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_EL1[7:0] = {0x2, 0x80}.
	 */
	mpidr_hash.shift_aff[0] = MPIDR_LEVEL_SHIFT(0) + fs[0];
	mpidr_hash.shift_aff[1] = MPIDR_LEVEL_SHIFT(1) + fs[1] - bits[0];
	mpidr_hash.shift_aff[2] = MPIDR_LEVEL_SHIFT(2) + fs[2] -
						(bits[1] + bits[0]);
	mpidr_hash.shift_aff[3] = MPIDR_LEVEL_SHIFT(3) +
				  fs[3] - (bits[2] + bits[1] + bits[0]);
	mpidr_hash.mask = mask;
	mpidr_hash.bits = bits[3] + bits[2] + bits[1] + bits[0];
	pr_debug("MPIDR hash: aff0[%u] aff1[%u] aff2[%u] aff3[%u] mask[%#llx] bits[%u]\n",
		mpidr_hash.shift_aff[0],
		mpidr_hash.shift_aff[1],
		mpidr_hash.shift_aff[2],
		mpidr_hash.shift_aff[3],
		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");
}
178

179 180
static void __init setup_machine_fdt(phys_addr_t dt_phys)
{
181 182 183 184 185 186 187 188
	void *dt_virt = fixmap_remap_fdt(dt_phys);

	if (!dt_virt || !early_init_dt_scan(dt_virt)) {
		pr_crit("\n"
			"Error: invalid device tree blob at physical address %pa (virtual address 0x%p)\n"
			"The dtb must be 8-byte aligned and must not exceed 2 MB in size\n"
			"\nPlease check your bootloader.",
			&dt_phys, dt_virt);
189 190 191 192

		while (true)
			cpu_relax();
	}
193

M
Mark Rutland 已提交
194
	dump_stack_set_arch_desc("%s (DT)", of_flat_dt_get_machine_name());
195 196 197 198 199 200 201 202
}

static void __init request_standard_resources(void)
{
	struct memblock_region *region;
	struct resource *res;

	kernel_code.start   = virt_to_phys(_text);
203
	kernel_code.end     = virt_to_phys(__init_begin - 1);
204 205 206 207 208
	kernel_data.start   = virt_to_phys(_sdata);
	kernel_data.end     = virt_to_phys(_end - 1);

	for_each_memblock(memory, region) {
		res = alloc_bootmem_low(sizeof(*res));
209 210 211 212 213 214 215
		if (memblock_is_nomap(region)) {
			res->name  = "reserved";
			res->flags = IORESOURCE_MEM | IORESOURCE_BUSY;
		} else {
			res->name  = "System RAM";
			res->flags = IORESOURCE_SYSTEM_RAM | IORESOURCE_BUSY;
		}
216 217 218 219 220 221 222 223 224 225 226 227 228 229
		res->start = __pfn_to_phys(memblock_region_memory_base_pfn(region));
		res->end = __pfn_to_phys(memblock_region_memory_end_pfn(region)) - 1;

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

230 231
u64 __cpu_logical_map[NR_CPUS] = { [0 ... NR_CPUS-1] = INVALID_HWID };

232 233
void __init setup_arch(char **cmdline_p)
{
234
	pr_info("Boot CPU: AArch64 Processor [%08x]\n", read_cpuid_id());
235

236
	sprintf(init_utsname()->machine, UTS_MACHINE);
237 238 239 240 241 242 243
	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;

	*cmdline_p = boot_command_line;

244
	early_fixmap_init();
M
Mark Salter 已提交
245
	early_ioremap_init();
246

247 248
	setup_machine_fdt(__fdt_pointer);

249 250
	parse_early_param();

251 252 253 254 255 256
	/*
	 *  Unmask asynchronous aborts after bringing up possible earlycon.
	 * (Report possible System Errors once we can report this occurred)
	 */
	local_async_enable();

M
Mark Rutland 已提交
257 258 259 260 261 262
	/*
	 * TTBR0 is only used for the identity mapping at this stage. Make it
	 * point to zero page to avoid speculatively fetching new entries.
	 */
	cpu_uninstall_idmap();

263
	xen_early_init();
M
Mark Salter 已提交
264
	efi_init();
265 266
	arm64_memblock_init();

267 268 269 270
	paging_init();

	acpi_table_upgrade();

271 272 273
	/* Parse the ACPI tables for possible boot-time configuration */
	acpi_boot_table_init();

274 275 276 277 278
	if (acpi_disabled)
		unflatten_device_tree();

	bootmem_init();

A
Andrey Ryabinin 已提交
279 280
	kasan_init();

281 282
	request_standard_resources();

283
	early_ioremap_reset();
M
Mark Salter 已提交
284

285
	if (acpi_disabled)
286
		psci_dt_init();
287
	else
288
		psci_acpi_init();
289

290 291
	cpu_read_bootcpu_ops();
	smp_init_cpus();
292
	smp_build_mpidr_hash();
293 294 295 296 297 298 299 300

#ifdef CONFIG_VT
#if defined(CONFIG_VGA_CONSOLE)
	conswitchp = &vga_con;
#elif defined(CONFIG_DUMMY_CONSOLE)
	conswitchp = &dummy_con;
#endif
#endif
301 302 303 304 305 306
	if (boot_args[1] || boot_args[2] || boot_args[3]) {
		pr_err("WARNING: x1-x3 nonzero in violation of boot protocol:\n"
			"\tx1: %016llx\n\tx2: %016llx\n\tx3: %016llx\n"
			"This indicates a broken bootloader or old kernel\n",
			boot_args[1], boot_args[2], boot_args[3]);
	}
307 308 309 310 311 312
}

static int __init topology_init(void)
{
	int i;

313 314 315
	for_each_online_node(i)
		register_one_node(i);

316
	for_each_possible_cpu(i) {
317
		struct cpu *cpu = &per_cpu(cpu_data.cpu, i);
318 319 320 321 322 323 324
		cpu->hotpluggable = 1;
		register_cpu(cpu, i);
	}

	return 0;
}
subsys_initcall(topology_init);
325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353

/*
 * Dump out kernel offset information on panic.
 */
static int dump_kernel_offset(struct notifier_block *self, unsigned long v,
			      void *p)
{
	u64 const kaslr_offset = kimage_vaddr - KIMAGE_VADDR;

	if (IS_ENABLED(CONFIG_RANDOMIZE_BASE) && kaslr_offset > 0) {
		pr_emerg("Kernel Offset: 0x%llx from 0x%lx\n",
			 kaslr_offset, KIMAGE_VADDR);
	} else {
		pr_emerg("Kernel Offset: disabled\n");
	}
	return 0;
}

static struct notifier_block kernel_offset_notifier = {
	.notifier_call = dump_kernel_offset
};

static int __init register_kernel_offset_dumper(void)
{
	atomic_notifier_chain_register(&panic_notifier_list,
				       &kernel_offset_notifier);
	return 0;
}
__initcall(register_kernel_offset_dumper);