setup.c 9.47 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
#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>
42
#include <linux/of_iommu.h>
43
#include <linux/of_fdt.h>
44
#include <linux/of_platform.h>
Mark Salter's avatar
Mark Salter committed
45
#include <linux/efi.h>
46
#include <linux/psci.h>
47

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

phys_addr_t __fdt_pointer __initdata;

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

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

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

95 96
void __init smp_setup_processor_id(void)
{
97 98 99
	u64 mpidr = read_cpuid_mpidr() & MPIDR_HWID_BITMASK;
	cpu_logical_map(0) = mpidr;

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

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

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 178 179
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");
	__flush_dcache_area(&mpidr_hash, sizeof(struct mpidr_hash));
}
180

181 182
static void __init setup_machine_fdt(phys_addr_t dt_phys)
{
183 184 185 186 187 188 189 190
	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);
191 192 193 194

		while (true)
			cpu_relax();
	}
195

Mark Rutland's avatar
Mark Rutland committed
196
	dump_stack_set_arch_desc("%s (DT)", of_flat_dt_get_machine_name());
197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213
}

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

	kernel_code.start   = virt_to_phys(_text);
	kernel_code.end     = virt_to_phys(_etext - 1);
	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));
		res->name  = "System RAM";
		res->start = __pfn_to_phys(memblock_region_memory_base_pfn(region));
		res->end = __pfn_to_phys(memblock_region_memory_end_pfn(region)) - 1;
214
		res->flags = IORESOURCE_SYSTEM_RAM | IORESOURCE_BUSY;
215 216 217 218 219 220 221 222 223 224 225 226

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

227 228
u64 __cpu_logical_map[NR_CPUS] = { [0 ... NR_CPUS-1] = INVALID_HWID };

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

233
	sprintf(init_utsname()->machine, ELF_PLATFORM);
234 235 236 237 238 239 240
	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;

241
	early_fixmap_init();
Mark Salter's avatar
Mark Salter committed
242
	early_ioremap_init();
243

244 245
	setup_machine_fdt(__fdt_pointer);

246 247
	parse_early_param();

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

Mark Rutland's avatar
Mark Rutland committed
254 255 256 257 258 259
	/*
	 * 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();

Mark Salter's avatar
Mark Salter committed
260
	efi_init();
261 262
	arm64_memblock_init();

263 264 265
	/* Parse the ACPI tables for possible boot-time configuration */
	acpi_boot_table_init();

266
	paging_init();
Andrey Ryabinin's avatar
Andrey Ryabinin committed
267

268 269 270 271 272
	if (acpi_disabled)
		unflatten_device_tree();

	bootmem_init();

Andrey Ryabinin's avatar
Andrey Ryabinin committed
273 274
	kasan_init();

275 276
	request_standard_resources();

277
	early_ioremap_reset();
Mark Salter's avatar
Mark Salter committed
278

279
	if (acpi_disabled)
280
		psci_dt_init();
281
	else
282
		psci_acpi_init();
283

284
	xen_early_init();
285

286 287
	cpu_read_bootcpu_ops();
	smp_init_cpus();
288
	smp_build_mpidr_hash();
289 290 291 292 293 294 295 296

#ifdef CONFIG_VT
#if defined(CONFIG_VGA_CONSOLE)
	conswitchp = &vga_con;
#elif defined(CONFIG_DUMMY_CONSOLE)
	conswitchp = &dummy_con;
#endif
#endif
297 298 299 300 301 302
	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]);
	}
303 304
}

305
static int __init arm64_device_init(void)
306
{
307 308 309 310 311 312 313
	if (of_have_populated_dt()) {
		of_iommu_init();
		of_platform_populate(NULL, of_default_bus_match_table,
				     NULL, NULL);
	} else if (acpi_disabled) {
		pr_crit("Device tree not populated\n");
	}
314 315
	return 0;
}
316
arch_initcall_sync(arm64_device_init);
317

318 319 320 321 322
static int __init topology_init(void)
{
	int i;

	for_each_possible_cpu(i) {
323
		struct cpu *cpu = &per_cpu(cpu_data.cpu, i);
324 325 326 327 328 329 330
		cpu->hotpluggable = 1;
		register_cpu(cpu, i);
	}

	return 0;
}
subsys_initcall(topology_init);
331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359

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