xref: /kvm-unit-tests/lib/arm/setup.c (revision 2e080dafec2a4724f92f6973609680ab4f5ecbb8)
15e61cba0SAndrew Jones /*
25e61cba0SAndrew Jones  * Initialize machine setup information and I/O.
35e61cba0SAndrew Jones  *
45e61cba0SAndrew Jones  * After running setup() unit tests may query how many cpus they have
55e61cba0SAndrew Jones  * (nr_cpus), how much memory they have (PHYS_END - PHYS_OFFSET), may
65e61cba0SAndrew Jones  * use dynamic memory allocation (malloc, etc.), printf, and exit.
75e61cba0SAndrew Jones  * Finally, argc and argv are also ready to be passed to main().
85e61cba0SAndrew Jones  *
95e61cba0SAndrew Jones  * Copyright (C) 2014, Red Hat Inc, Andrew Jones <drjones@redhat.com>
105e61cba0SAndrew Jones  *
115e61cba0SAndrew Jones  * This work is licensed under the terms of the GNU LGPL, version 2.
125e61cba0SAndrew Jones  */
138cca5668SAndrew Jones #include <libcflat.h>
148cca5668SAndrew Jones #include <libfdt/libfdt.h>
158cca5668SAndrew Jones #include <devicetree.h>
168cca5668SAndrew Jones #include <alloc.h>
17dc47ac61SPaolo Bonzini #include <alloc_phys.h>
1862bdc67fSAndrew Jones #include <alloc_page.h>
19c0edb3d2SAndrew Jones #include <vmalloc.h>
20c0edb3d2SAndrew Jones #include <auxinfo.h>
2163d5cbecSThomas Huth #include <argv.h>
22f6d10793SAndrew Jones #include <asm/thread_info.h>
238cca5668SAndrew Jones #include <asm/setup.h>
248cca5668SAndrew Jones #include <asm/page.h>
25410b3bf0SAlexandru Elisei #include <asm/processor.h>
2668ea0e0bSAndrew Jones #include <asm/smp.h>
27a4110027SAndrew Jones #include <asm/timer.h>
28bd5bd157SAndrew Jones #include <asm/psci.h>
295e61cba0SAndrew Jones 
300df901e0SAndrew Jones #include "io.h"
310df901e0SAndrew Jones 
325a2a7371SAndrew Jones #define MAX_DT_MEM_REGIONS	16
3323e17626SNikos Nikoleris #define NR_EXTRA_MEM_REGIONS	64
345a2a7371SAndrew Jones #define NR_INITIAL_MEM_REGIONS	(MAX_DT_MEM_REGIONS + NR_EXTRA_MEM_REGIONS)
35ef31e31dSAndrew Jones 
3623e17626SNikos Nikoleris extern unsigned long _text, _etext, _data, _edata;
375e61cba0SAndrew Jones 
382c2545b0SAndrew Jones char *initrd;
392c2545b0SAndrew Jones u32 initrd_size;
402c2545b0SAndrew Jones 
41da905c9dSAndrew Jones u64 cpus[NR_CPUS] = { [0 ... NR_CPUS-1] = (u64)~0 };
425e61cba0SAndrew Jones int nr_cpus;
435e61cba0SAndrew Jones 
44ef31e31dSAndrew Jones static struct mem_region __initial_mem_regions[NR_INITIAL_MEM_REGIONS + 1];
45ef31e31dSAndrew Jones struct mem_region *mem_regions = __initial_mem_regions;
4623e17626SNikos Nikoleris phys_addr_t __phys_offset = (phys_addr_t)-1, __phys_end = 0;
4723e17626SNikos Nikoleris 
4823e17626SNikos Nikoleris extern void exceptions_init(void);
4923e17626SNikos Nikoleris extern void asm_mmu_disable(void);
505e61cba0SAndrew Jones 
51d9729025SAndrew Jones int mpidr_to_cpu(uint64_t mpidr)
52d9729025SAndrew Jones {
53d9729025SAndrew Jones 	int i;
54d9729025SAndrew Jones 
55d9729025SAndrew Jones 	for (i = 0; i < nr_cpus; ++i)
56d9729025SAndrew Jones 		if (cpus[i] == (mpidr & MPIDR_HWID_BITMASK))
57d9729025SAndrew Jones 			return i;
58d9729025SAndrew Jones 	return -1;
59d9729025SAndrew Jones }
60d9729025SAndrew Jones 
613d29f825SNikos Nikoleris static void cpu_set_fdt(int fdtnode __unused, u64 regval, void *info __unused)
625e61cba0SAndrew Jones {
6368ea0e0bSAndrew Jones 	int cpu = nr_cpus++;
6462de081aSAndrew Jones 
653a9d03a4SAndrew Jones 	assert_msg(cpu < NR_CPUS, "Number cpus exceeds maximum supported (%d).", NR_CPUS);
663a9d03a4SAndrew Jones 
6768ea0e0bSAndrew Jones 	cpus[cpu] = regval;
6868ea0e0bSAndrew Jones 	set_cpu_present(cpu, true);
695e61cba0SAndrew Jones }
705e61cba0SAndrew Jones 
713d29f825SNikos Nikoleris #ifdef CONFIG_EFI
723d29f825SNikos Nikoleris 
733d29f825SNikos Nikoleris #include <acpi.h>
743d29f825SNikos Nikoleris 
753d29f825SNikos Nikoleris static int cpu_set_acpi(struct acpi_subtable_header *header)
763d29f825SNikos Nikoleris {
773d29f825SNikos Nikoleris 	int cpu = nr_cpus++;
783d29f825SNikos Nikoleris 	struct acpi_madt_generic_interrupt *gicc = (void *)header;
793d29f825SNikos Nikoleris 
803d29f825SNikos Nikoleris 	assert_msg(cpu < NR_CPUS, "Number cpus exceeds maximum supported (%d).", NR_CPUS);
813d29f825SNikos Nikoleris 
823d29f825SNikos Nikoleris 	cpus[cpu] = gicc->arm_mpidr;
833d29f825SNikos Nikoleris 	set_cpu_present(cpu, true);
843d29f825SNikos Nikoleris 
853d29f825SNikos Nikoleris 	return 0;
863d29f825SNikos Nikoleris }
873d29f825SNikos Nikoleris 
883d29f825SNikos Nikoleris static void cpu_init_acpi(void)
893d29f825SNikos Nikoleris {
903d29f825SNikos Nikoleris 	acpi_table_parse_madt(ACPI_MADT_TYPE_GENERIC_INTERRUPT, cpu_set_acpi);
913d29f825SNikos Nikoleris }
923d29f825SNikos Nikoleris 
933d29f825SNikos Nikoleris #else
943d29f825SNikos Nikoleris 
953d29f825SNikos Nikoleris static void cpu_init_acpi(void)
963d29f825SNikos Nikoleris {
973d29f825SNikos Nikoleris 	assert_msg(false, "ACPI not available");
983d29f825SNikos Nikoleris }
993d29f825SNikos Nikoleris 
1003d29f825SNikos Nikoleris #endif
1013d29f825SNikos Nikoleris 
1025e61cba0SAndrew Jones static void cpu_init(void)
1035e61cba0SAndrew Jones {
10418ab6cadSAndrew Jones 	int ret;
10518ab6cadSAndrew Jones 
1065e61cba0SAndrew Jones 	nr_cpus = 0;
1073d29f825SNikos Nikoleris 	if (dt_available()) {
1083d29f825SNikos Nikoleris 		ret = dt_for_each_cpu_node(cpu_set_fdt, NULL);
10918ab6cadSAndrew Jones 		assert(ret == 0);
1103d29f825SNikos Nikoleris 	} else {
1113d29f825SNikos Nikoleris 		cpu_init_acpi();
1123d29f825SNikos Nikoleris 	}
1133d29f825SNikos Nikoleris 
11468ea0e0bSAndrew Jones 	set_cpu_online(0, true);
1155e61cba0SAndrew Jones }
1165e61cba0SAndrew Jones 
1175a2a7371SAndrew Jones static void mem_region_add(struct mem_region *r)
1185a2a7371SAndrew Jones {
1195a2a7371SAndrew Jones 	struct mem_region *r_next = mem_regions;
1205a2a7371SAndrew Jones 	int i = 0;
1215a2a7371SAndrew Jones 
1225a2a7371SAndrew Jones 	for (; r_next->end; ++r_next, ++i)
1235a2a7371SAndrew Jones 		;
1245a2a7371SAndrew Jones 	assert(i < NR_INITIAL_MEM_REGIONS);
1255a2a7371SAndrew Jones 
1265a2a7371SAndrew Jones 	*r_next = *r;
1275a2a7371SAndrew Jones }
1285a2a7371SAndrew Jones 
1295a2a7371SAndrew Jones static void mem_regions_add_dt_regions(void)
1305a2a7371SAndrew Jones {
1315a2a7371SAndrew Jones 	struct dt_pbus_reg regs[MAX_DT_MEM_REGIONS];
1325a2a7371SAndrew Jones 	int nr_regs, i;
1335a2a7371SAndrew Jones 
1345a2a7371SAndrew Jones 	nr_regs = dt_get_memory_params(regs, MAX_DT_MEM_REGIONS);
1355a2a7371SAndrew Jones 	assert(nr_regs > 0);
1365a2a7371SAndrew Jones 
1375a2a7371SAndrew Jones 	for (i = 0; i < nr_regs; ++i) {
1385a2a7371SAndrew Jones 		mem_region_add(&(struct mem_region){
1395a2a7371SAndrew Jones 			.start = regs[i].addr,
1405a2a7371SAndrew Jones 			.end = regs[i].addr + regs[i].size,
1415a2a7371SAndrew Jones 		});
1425a2a7371SAndrew Jones 	}
1435a2a7371SAndrew Jones }
1445a2a7371SAndrew Jones 
1455a2a7371SAndrew Jones struct mem_region *mem_region_find(phys_addr_t paddr)
146ef31e31dSAndrew Jones {
147ef31e31dSAndrew Jones 	struct mem_region *r;
148ef31e31dSAndrew Jones 
1495a2a7371SAndrew Jones 	for (r = mem_regions; r->end; ++r)
150ef31e31dSAndrew Jones 		if (paddr >= r->start && paddr < r->end)
1515a2a7371SAndrew Jones 			return r;
1525a2a7371SAndrew Jones 	return NULL;
153ef31e31dSAndrew Jones }
154ef31e31dSAndrew Jones 
1555a2a7371SAndrew Jones unsigned int mem_region_get_flags(phys_addr_t paddr)
1565a2a7371SAndrew Jones {
1575a2a7371SAndrew Jones 	struct mem_region *r = mem_region_find(paddr);
1585a2a7371SAndrew Jones 	return r ? r->flags : MR_F_UNKNOWN;
159ef31e31dSAndrew Jones }
160ef31e31dSAndrew Jones 
1615a2a7371SAndrew Jones static void mem_regions_add_assumed(void)
1625e61cba0SAndrew Jones {
1632b9c908eSAndrew Jones 	phys_addr_t code_end = (phys_addr_t)(unsigned long)&_etext;
1645a2a7371SAndrew Jones 	struct mem_region *r;
1655a2a7371SAndrew Jones 
1665a2a7371SAndrew Jones 	r = mem_region_find(code_end - 1);
1675a2a7371SAndrew Jones 	assert(r);
1685a2a7371SAndrew Jones 
1695a2a7371SAndrew Jones 	/* Split the region with the code into two regions; code and data */
1705a2a7371SAndrew Jones 	mem_region_add(&(struct mem_region){
1715a2a7371SAndrew Jones 		.start = code_end,
1725a2a7371SAndrew Jones 		.end = r->end,
1735a2a7371SAndrew Jones 	});
1745a2a7371SAndrew Jones 	*r = (struct mem_region){
1755a2a7371SAndrew Jones 		.start = r->start,
1765a2a7371SAndrew Jones 		.end = code_end,
1775a2a7371SAndrew Jones 		.flags = MR_F_CODE,
17862de081aSAndrew Jones 	};
1795e61cba0SAndrew Jones 
180ef31e31dSAndrew Jones 	/*
181ef31e31dSAndrew Jones 	 * mach-virt I/O regions:
182ef31e31dSAndrew Jones 	 *   - The first 1G (arm/arm64)
183ef31e31dSAndrew Jones 	 *   - 512M at 256G (arm64, arm uses highmem=off)
184ef31e31dSAndrew Jones 	 *   - 512G at 512G (arm64, arm uses highmem=off)
185ef31e31dSAndrew Jones 	 */
1865a2a7371SAndrew Jones 	mem_region_add(&(struct mem_region){ 0, (1ul << 30), MR_F_IO });
187ef31e31dSAndrew Jones #ifdef __aarch64__
1885a2a7371SAndrew Jones 	mem_region_add(&(struct mem_region){ (1ul << 38), (1ul << 38) | (1ul << 29), MR_F_IO });
1895a2a7371SAndrew Jones 	mem_region_add(&(struct mem_region){ (1ul << 39), (1ul << 40), MR_F_IO });
190ef31e31dSAndrew Jones #endif
19162de081aSAndrew Jones }
1925e61cba0SAndrew Jones 
1935a2a7371SAndrew Jones static void mem_init(phys_addr_t freemem_start)
1945a2a7371SAndrew Jones {
1955a2a7371SAndrew Jones 	phys_addr_t base, top;
1965a2a7371SAndrew Jones 	struct mem_region *freemem, *r, mem = {
1975a2a7371SAndrew Jones 		.start = (phys_addr_t)-1,
1985a2a7371SAndrew Jones 	};
1995a2a7371SAndrew Jones 
2005a2a7371SAndrew Jones 	freemem = mem_region_find(freemem_start);
2015a2a7371SAndrew Jones 	assert(freemem && !(freemem->flags & (MR_F_IO | MR_F_CODE)));
2025a2a7371SAndrew Jones 
2035a2a7371SAndrew Jones 	for (r = mem_regions; r->end; ++r) {
2045a2a7371SAndrew Jones 		if (!(r->flags & MR_F_IO)) {
205ef31e31dSAndrew Jones 			if (r->start < mem.start)
206ef31e31dSAndrew Jones 				mem.start = r->start;
207ef31e31dSAndrew Jones 			if (r->end > mem.end)
208ef31e31dSAndrew Jones 				mem.end = r->end;
20962de081aSAndrew Jones 		}
2105a2a7371SAndrew Jones 	}
2115a2a7371SAndrew Jones 	assert(mem.end && !(mem.start & ~PHYS_MASK));
2125a2a7371SAndrew Jones 	mem.end &= PHYS_MASK;
21362de081aSAndrew Jones 
2145a2a7371SAndrew Jones 	/* Check for holes */
2155a2a7371SAndrew Jones 	r = mem_region_find(mem.start);
2165a2a7371SAndrew Jones 	while (r && r->end != mem.end)
2175a2a7371SAndrew Jones 		r = mem_region_find(r->end);
2185a2a7371SAndrew Jones 	assert(r);
21962de081aSAndrew Jones 
2205a2a7371SAndrew Jones 	/* Ensure our selected freemem range is somewhere in our full range */
2215a2a7371SAndrew Jones 	assert(freemem_start >= mem.start && freemem->end <= mem.end);
222c1cd1a2bSAndrew Jones 
2235a2a7371SAndrew Jones 	__phys_offset = mem.start;	/* PHYS_OFFSET */
2245a2a7371SAndrew Jones 	__phys_end = mem.end;		/* PHYS_END */
2255a2a7371SAndrew Jones 
2265a2a7371SAndrew Jones 	phys_alloc_init(freemem_start, freemem->end - freemem_start);
2275e61cba0SAndrew Jones 	phys_alloc_set_minimum_alignment(SMP_CACHE_BYTES);
228153d1936SAndrew Jones 
22962bdc67fSAndrew Jones 	phys_alloc_get_unused(&base, &top);
23062bdc67fSAndrew Jones 	base = PAGE_ALIGN(base);
23162bdc67fSAndrew Jones 	top = top & PAGE_MASK;
23262bdc67fSAndrew Jones 	assert(sizeof(long) == 8 || !(base >> 32));
23362bdc67fSAndrew Jones 	if (sizeof(long) != 8 && (top >> 32) != 0)
23462bdc67fSAndrew Jones 		top = ((uint64_t)1 << 32);
2358131e91aSClaudio Imbrenda 	page_alloc_init_area(0, base >> PAGE_SHIFT, top >> PAGE_SHIFT);
23662bdc67fSAndrew Jones 	page_alloc_ops_enable();
2375e61cba0SAndrew Jones }
2385e61cba0SAndrew Jones 
2395a2a7371SAndrew Jones void setup(const void *fdt, phys_addr_t freemem_start)
2405e61cba0SAndrew Jones {
2415a2a7371SAndrew Jones 	void *freemem;
2422c2545b0SAndrew Jones 	const char *bootargs, *tmp;
2435e61cba0SAndrew Jones 	u32 fdt_size;
24418ab6cadSAndrew Jones 	int ret;
2455e61cba0SAndrew Jones 
2465a2a7371SAndrew Jones 	assert(sizeof(long) == 8 || freemem_start < (3ul << 30));
2475a2a7371SAndrew Jones 	freemem = (void *)(unsigned long)freemem_start;
2485a2a7371SAndrew Jones 
2495a2a7371SAndrew Jones 	/* Move the FDT to the base of free memory */
2505e61cba0SAndrew Jones 	fdt_size = fdt_totalsize(fdt);
2513a98026dSAndrew Jones 	ret = fdt_move(fdt, freemem, fdt_size);
25218ab6cadSAndrew Jones 	assert(ret == 0);
2533a98026dSAndrew Jones 	ret = dt_init(freemem);
25418ab6cadSAndrew Jones 	assert(ret == 0);
2553a98026dSAndrew Jones 	freemem += fdt_size;
2565e61cba0SAndrew Jones 
2575a2a7371SAndrew Jones 	/* Move the initrd to the top of the FDT */
2582c2545b0SAndrew Jones 	ret = dt_get_initrd(&tmp, &initrd_size);
2592c2545b0SAndrew Jones 	assert(ret == 0 || ret == -FDT_ERR_NOTFOUND);
2602c2545b0SAndrew Jones 	if (ret == 0) {
2612c2545b0SAndrew Jones 		initrd = freemem;
2622c2545b0SAndrew Jones 		memmove(initrd, tmp, initrd_size);
2632c2545b0SAndrew Jones 		freemem += initrd_size;
2642c2545b0SAndrew Jones 	}
2652c2545b0SAndrew Jones 
2665a2a7371SAndrew Jones 	mem_regions_add_dt_regions();
2675a2a7371SAndrew Jones 	mem_regions_add_assumed();
26862bdc67fSAndrew Jones 	mem_init(PAGE_ALIGN((unsigned long)freemem));
2695a2a7371SAndrew Jones 
270bd5bd157SAndrew Jones 	psci_set_conduit();
2715e61cba0SAndrew Jones 	cpu_init();
2725e61cba0SAndrew Jones 
2734f58b399SAndrew Jones 	/* cpu_init must be called before thread_info_init */
274f6d10793SAndrew Jones 	thread_info_init(current_thread_info(), 0);
275f6d10793SAndrew Jones 
2764f58b399SAndrew Jones 	/* mem_init must be called before io_init */
2774f58b399SAndrew Jones 	io_init();
2784f58b399SAndrew Jones 
279a4110027SAndrew Jones 	timer_save_state();
280a4110027SAndrew Jones 
28118ab6cadSAndrew Jones 	ret = dt_get_bootargs(&bootargs);
282d81b83fdSAndrew Jones 	assert(ret == 0 || ret == -FDT_ERR_NOTFOUND);
283809ebcb3SAndrew Jones 	setup_args_progname(bootargs);
2844968651eSAndrew Jones 
2854968651eSAndrew Jones 	if (initrd) {
2864968651eSAndrew Jones 		/* environ is currently the only file in the initrd */
2874968651eSAndrew Jones 		char *env = malloc(initrd_size);
2884968651eSAndrew Jones 		memcpy(env, initrd, initrd_size);
2894968651eSAndrew Jones 		setup_env(env, initrd_size);
2904968651eSAndrew Jones 	}
291c0edb3d2SAndrew Jones 
292c0edb3d2SAndrew Jones 	if (!(auxinfo.flags & AUXINFO_MMU_OFF))
293c0edb3d2SAndrew Jones 		setup_vm();
2945e61cba0SAndrew Jones }
29523e17626SNikos Nikoleris 
29623e17626SNikos Nikoleris #ifdef CONFIG_EFI
29723e17626SNikos Nikoleris 
29823e17626SNikos Nikoleris #include <efi.h>
29923e17626SNikos Nikoleris 
30023e17626SNikos Nikoleris static efi_status_t setup_rsdp(efi_bootinfo_t *efi_bootinfo)
30123e17626SNikos Nikoleris {
30223e17626SNikos Nikoleris 	efi_status_t status;
30323e17626SNikos Nikoleris 	struct acpi_table_rsdp *rsdp;
30423e17626SNikos Nikoleris 
30523e17626SNikos Nikoleris 	/*
30623e17626SNikos Nikoleris 	 * RSDP resides in an EFI_ACPI_RECLAIM_MEMORY region, which is not used
30723e17626SNikos Nikoleris 	 * by kvm-unit-tests arm64 memory allocator. So it is not necessary to
30823e17626SNikos Nikoleris 	 * copy the data structure to another memory region to prevent
30923e17626SNikos Nikoleris 	 * unintentional overwrite.
31023e17626SNikos Nikoleris 	 */
31123e17626SNikos Nikoleris 	status = efi_get_system_config_table(ACPI_20_TABLE_GUID, (void **)&rsdp);
31223e17626SNikos Nikoleris 	if (status != EFI_SUCCESS)
31323e17626SNikos Nikoleris 		return status;
31423e17626SNikos Nikoleris 
31523e17626SNikos Nikoleris 	set_efi_rsdp(rsdp);
31623e17626SNikos Nikoleris 
31723e17626SNikos Nikoleris 	return EFI_SUCCESS;
31823e17626SNikos Nikoleris }
31923e17626SNikos Nikoleris 
32023e17626SNikos Nikoleris static efi_status_t efi_mem_init(efi_bootinfo_t *efi_bootinfo)
32123e17626SNikos Nikoleris {
32223e17626SNikos Nikoleris 	int i;
32323e17626SNikos Nikoleris 	unsigned long free_mem_pages = 0;
32423e17626SNikos Nikoleris 	unsigned long free_mem_start = 0;
32523e17626SNikos Nikoleris 	struct efi_boot_memmap *map = &(efi_bootinfo->mem_map);
32623e17626SNikos Nikoleris 	efi_memory_desc_t *buffer = *map->map;
32723e17626SNikos Nikoleris 	efi_memory_desc_t *d = NULL;
32823e17626SNikos Nikoleris 	phys_addr_t base, top;
32923e17626SNikos Nikoleris 	struct mem_region r;
33023e17626SNikos Nikoleris 	uintptr_t text = (uintptr_t)&_text, etext = ALIGN((uintptr_t)&_etext, 4096);
33123e17626SNikos Nikoleris 	uintptr_t data = (uintptr_t)&_data, edata = ALIGN((uintptr_t)&_edata, 4096);
332*2e080dafSNikos Nikoleris 	const void *fdt = efi_bootinfo->fdt;
333*2e080dafSNikos Nikoleris 	int fdt_size, ret;
33423e17626SNikos Nikoleris 
33523e17626SNikos Nikoleris 	/*
33623e17626SNikos Nikoleris 	 * Record the largest free EFI_CONVENTIONAL_MEMORY region
33723e17626SNikos Nikoleris 	 * which will be used to set up the memory allocator, so that
33823e17626SNikos Nikoleris 	 * the memory allocator can work in the largest free
33923e17626SNikos Nikoleris 	 * continuous memory region.
34023e17626SNikos Nikoleris 	 */
34123e17626SNikos Nikoleris 	for (i = 0; i < *(map->map_size); i += *(map->desc_size)) {
34223e17626SNikos Nikoleris 		d = (efi_memory_desc_t *)(&((u8 *)buffer)[i]);
34323e17626SNikos Nikoleris 
34423e17626SNikos Nikoleris 		r.start = d->phys_addr;
34523e17626SNikos Nikoleris 		r.end = d->phys_addr + d->num_pages * EFI_PAGE_SIZE;
34623e17626SNikos Nikoleris 		r.flags = 0;
34723e17626SNikos Nikoleris 
34823e17626SNikos Nikoleris 		switch (d->type) {
34923e17626SNikos Nikoleris 		case EFI_RESERVED_TYPE:
35023e17626SNikos Nikoleris 		case EFI_LOADER_DATA:
35123e17626SNikos Nikoleris 		case EFI_BOOT_SERVICES_CODE:
35223e17626SNikos Nikoleris 		case EFI_BOOT_SERVICES_DATA:
35323e17626SNikos Nikoleris 		case EFI_RUNTIME_SERVICES_CODE:
35423e17626SNikos Nikoleris 		case EFI_RUNTIME_SERVICES_DATA:
35523e17626SNikos Nikoleris 		case EFI_UNUSABLE_MEMORY:
35623e17626SNikos Nikoleris 		case EFI_ACPI_RECLAIM_MEMORY:
35723e17626SNikos Nikoleris 		case EFI_ACPI_MEMORY_NVS:
35823e17626SNikos Nikoleris 		case EFI_PAL_CODE:
35923e17626SNikos Nikoleris 			r.flags = MR_F_RESERVED;
36023e17626SNikos Nikoleris 			break;
36123e17626SNikos Nikoleris 		case EFI_MEMORY_MAPPED_IO:
36223e17626SNikos Nikoleris 		case EFI_MEMORY_MAPPED_IO_PORT_SPACE:
36323e17626SNikos Nikoleris 			r.flags = MR_F_IO;
36423e17626SNikos Nikoleris 			break;
36523e17626SNikos Nikoleris 		case EFI_LOADER_CODE:
36623e17626SNikos Nikoleris 			if (r.start <= text && r.end > text) {
36723e17626SNikos Nikoleris 				/* This is the unit test region. Flag the code separately. */
36823e17626SNikos Nikoleris 				phys_addr_t tmp = r.end;
36923e17626SNikos Nikoleris 
37023e17626SNikos Nikoleris 				assert(etext <= data);
37123e17626SNikos Nikoleris 				assert(edata <= r.end);
37223e17626SNikos Nikoleris 				r.flags = MR_F_CODE;
37323e17626SNikos Nikoleris 				r.end = data;
37423e17626SNikos Nikoleris 				mem_region_add(&r);
37523e17626SNikos Nikoleris 				r.start = data;
37623e17626SNikos Nikoleris 				r.end = tmp;
37723e17626SNikos Nikoleris 				r.flags = 0;
37823e17626SNikos Nikoleris 			} else {
37923e17626SNikos Nikoleris 				r.flags = MR_F_RESERVED;
38023e17626SNikos Nikoleris 			}
38123e17626SNikos Nikoleris 			break;
38223e17626SNikos Nikoleris 		case EFI_CONVENTIONAL_MEMORY:
38323e17626SNikos Nikoleris 			if (free_mem_pages < d->num_pages) {
38423e17626SNikos Nikoleris 				free_mem_pages = d->num_pages;
38523e17626SNikos Nikoleris 				free_mem_start = d->phys_addr;
38623e17626SNikos Nikoleris 			}
38723e17626SNikos Nikoleris 			break;
38823e17626SNikos Nikoleris 		}
38923e17626SNikos Nikoleris 
39023e17626SNikos Nikoleris 		if (!(r.flags & MR_F_IO)) {
39123e17626SNikos Nikoleris 			if (r.start < __phys_offset)
39223e17626SNikos Nikoleris 				__phys_offset = r.start;
39323e17626SNikos Nikoleris 			if (r.end > __phys_end)
39423e17626SNikos Nikoleris 				__phys_end = r.end;
39523e17626SNikos Nikoleris 		}
39623e17626SNikos Nikoleris 		mem_region_add(&r);
39723e17626SNikos Nikoleris 	}
398*2e080dafSNikos Nikoleris 	if (fdt) {
399*2e080dafSNikos Nikoleris 		/* Move the FDT to the base of free memory */
400*2e080dafSNikos Nikoleris 		fdt_size = fdt_totalsize(fdt);
401*2e080dafSNikos Nikoleris 		ret = fdt_move(fdt, (void *)free_mem_start, fdt_size);
402*2e080dafSNikos Nikoleris 		assert(ret == 0);
403*2e080dafSNikos Nikoleris 		ret = dt_init((void *)free_mem_start);
404*2e080dafSNikos Nikoleris 		assert(ret == 0);
405*2e080dafSNikos Nikoleris 		free_mem_start += ALIGN(fdt_size, EFI_PAGE_SIZE);
406*2e080dafSNikos Nikoleris 		free_mem_pages -= ALIGN(fdt_size, EFI_PAGE_SIZE) >> EFI_PAGE_SHIFT;
407*2e080dafSNikos Nikoleris 	}
408*2e080dafSNikos Nikoleris 
40923e17626SNikos Nikoleris 	__phys_end &= PHYS_MASK;
41023e17626SNikos Nikoleris 	asm_mmu_disable();
41123e17626SNikos Nikoleris 
41223e17626SNikos Nikoleris 	if (free_mem_pages == 0)
41323e17626SNikos Nikoleris 		return EFI_OUT_OF_RESOURCES;
41423e17626SNikos Nikoleris 
41523e17626SNikos Nikoleris 	assert(sizeof(long) == 8 || free_mem_start < (3ul << 30));
41623e17626SNikos Nikoleris 
41723e17626SNikos Nikoleris 	phys_alloc_init(free_mem_start, free_mem_pages << EFI_PAGE_SHIFT);
41823e17626SNikos Nikoleris 	phys_alloc_set_minimum_alignment(SMP_CACHE_BYTES);
41923e17626SNikos Nikoleris 
42023e17626SNikos Nikoleris 	phys_alloc_get_unused(&base, &top);
42123e17626SNikos Nikoleris 	base = PAGE_ALIGN(base);
42223e17626SNikos Nikoleris 	top = top & PAGE_MASK;
42323e17626SNikos Nikoleris 	assert(sizeof(long) == 8 || !(base >> 32));
42423e17626SNikos Nikoleris 	if (sizeof(long) != 8 && (top >> 32) != 0)
42523e17626SNikos Nikoleris 		top = ((uint64_t)1 << 32);
42623e17626SNikos Nikoleris 	page_alloc_init_area(0, base >> PAGE_SHIFT, top >> PAGE_SHIFT);
42723e17626SNikos Nikoleris 	page_alloc_ops_enable();
42823e17626SNikos Nikoleris 
42923e17626SNikos Nikoleris 	return EFI_SUCCESS;
43023e17626SNikos Nikoleris }
43123e17626SNikos Nikoleris 
43223e17626SNikos Nikoleris efi_status_t setup_efi(efi_bootinfo_t *efi_bootinfo)
43323e17626SNikos Nikoleris {
43423e17626SNikos Nikoleris 	efi_status_t status;
43523e17626SNikos Nikoleris 
43623e17626SNikos Nikoleris 	struct thread_info *ti = current_thread_info();
43723e17626SNikos Nikoleris 
43823e17626SNikos Nikoleris 	memset(ti, 0, sizeof(*ti));
43923e17626SNikos Nikoleris 
44023e17626SNikos Nikoleris 	exceptions_init();
44123e17626SNikos Nikoleris 
44223e17626SNikos Nikoleris 	status = efi_mem_init(efi_bootinfo);
44323e17626SNikos Nikoleris 	if (status != EFI_SUCCESS) {
44423e17626SNikos Nikoleris 		printf("Failed to initialize memory: ");
44523e17626SNikos Nikoleris 		switch (status) {
44623e17626SNikos Nikoleris 		case EFI_OUT_OF_RESOURCES:
44723e17626SNikos Nikoleris 			printf("No free memory region\n");
44823e17626SNikos Nikoleris 			break;
44923e17626SNikos Nikoleris 		default:
45023e17626SNikos Nikoleris 			printf("Unknown error\n");
45123e17626SNikos Nikoleris 			break;
45223e17626SNikos Nikoleris 		}
45323e17626SNikos Nikoleris 		return status;
45423e17626SNikos Nikoleris 	}
45523e17626SNikos Nikoleris 
456*2e080dafSNikos Nikoleris 	if (!dt_available()) {
45723e17626SNikos Nikoleris 		status = setup_rsdp(efi_bootinfo);
45823e17626SNikos Nikoleris 		if (status != EFI_SUCCESS) {
45923e17626SNikos Nikoleris 			printf("Cannot find RSDP in EFI system table\n");
46023e17626SNikos Nikoleris 			return status;
46123e17626SNikos Nikoleris 		}
462*2e080dafSNikos Nikoleris 	}
46323e17626SNikos Nikoleris 
46423e17626SNikos Nikoleris 	psci_set_conduit();
46523e17626SNikos Nikoleris 	cpu_init();
46623e17626SNikos Nikoleris 	/* cpu_init must be called before thread_info_init */
46723e17626SNikos Nikoleris 	thread_info_init(current_thread_info(), 0);
46823e17626SNikos Nikoleris 	/* mem_init must be called before io_init */
46923e17626SNikos Nikoleris 	io_init();
47023e17626SNikos Nikoleris 
47123e17626SNikos Nikoleris 	timer_save_state();
47223e17626SNikos Nikoleris 	if (initrd) {
47323e17626SNikos Nikoleris 		/* environ is currently the only file in the initrd */
47423e17626SNikos Nikoleris 		char *env = malloc(initrd_size);
47523e17626SNikos Nikoleris 
47623e17626SNikos Nikoleris 		memcpy(env, initrd, initrd_size);
47723e17626SNikos Nikoleris 		setup_env(env, initrd_size);
47823e17626SNikos Nikoleris 	}
47923e17626SNikos Nikoleris 
48023e17626SNikos Nikoleris 	if (!(auxinfo.flags & AUXINFO_MMU_OFF))
48123e17626SNikos Nikoleris 		setup_vm();
48223e17626SNikos Nikoleris 
48323e17626SNikos Nikoleris 	return EFI_SUCCESS;
48423e17626SNikos Nikoleris }
48523e17626SNikos Nikoleris 
48623e17626SNikos Nikoleris #endif
487