xref: /kvm-unit-tests/lib/arm/setup.c (revision e526bc786e9878c3880ae4b09b01a4572756e492) 
1 /*
2  * Initialize machine setup information and I/O.
3  *
4  * After running setup() unit tests may query how many cpus they have
5  * (nr_cpus), how much memory they have (PHYS_END - PHYS_OFFSET), may
6  * use dynamic memory allocation (malloc, etc.), printf, and exit.
7  * Finally, argc and argv are also ready to be passed to main().
8  *
9  * Copyright (C) 2014, Red Hat Inc, Andrew Jones <drjones@redhat.com>
10  *
11  * This work is licensed under the terms of the GNU LGPL, version 2.
12  */
13 #include <libcflat.h>
14 #include <libfdt/libfdt.h>
15 #include <devicetree.h>
16 #include <alloc.h>
17 #include <alloc_phys.h>
18 #include <alloc_page.h>
19 #include <vmalloc.h>
20 #include <auxinfo.h>
21 #include <argv.h>
22 #include <asm/thread_info.h>
23 #include <asm/setup.h>
24 #include <asm/page.h>
25 #include <asm/processor.h>
26 #include <asm/smp.h>
27 #include <asm/timer.h>
28 #include <asm/psci.h>
29 
30 #include "io.h"
31 
32 #define MAX_DT_MEM_REGIONS	16
33 #define NR_EXTRA_MEM_REGIONS	64
34 #define NR_INITIAL_MEM_REGIONS	(MAX_DT_MEM_REGIONS + NR_EXTRA_MEM_REGIONS)
35 
36 extern unsigned long _text, _etext, _data, _edata;
37 
38 char *initrd;
39 u32 initrd_size;
40 
41 u64 cpus[NR_CPUS] = { [0 ... NR_CPUS-1] = (u64)~0 };
42 int nr_cpus;
43 
44 static struct mem_region __initial_mem_regions[NR_INITIAL_MEM_REGIONS + 1];
45 struct mem_region *mem_regions = __initial_mem_regions;
46 phys_addr_t __phys_offset = (phys_addr_t)-1, __phys_end = 0;
47 
48 extern void exceptions_init(void);
49 extern void asm_mmu_disable(void);
50 
51 int mpidr_to_cpu(uint64_t mpidr)
52 {
53 	int i;
54 
55 	for (i = 0; i < nr_cpus; ++i)
56 		if (cpus[i] == (mpidr & MPIDR_HWID_BITMASK))
57 			return i;
58 	return -1;
59 }
60 
61 static void cpu_set_fdt(int fdtnode __unused, u64 regval, void *info __unused)
62 {
63 	int cpu = nr_cpus++;
64 
65 	assert_msg(cpu < NR_CPUS, "Number cpus exceeds maximum supported (%d).", NR_CPUS);
66 
67 	cpus[cpu] = regval;
68 	set_cpu_present(cpu, true);
69 }
70 
71 #ifdef CONFIG_EFI
72 
73 #include <acpi.h>
74 
75 static int cpu_set_acpi(struct acpi_subtable_header *header)
76 {
77 	int cpu = nr_cpus++;
78 	struct acpi_madt_generic_interrupt *gicc = (void *)header;
79 
80 	assert_msg(cpu < NR_CPUS, "Number cpus exceeds maximum supported (%d).", NR_CPUS);
81 
82 	cpus[cpu] = gicc->arm_mpidr;
83 	set_cpu_present(cpu, true);
84 
85 	return 0;
86 }
87 
88 static void cpu_init_acpi(void)
89 {
90 	acpi_table_parse_madt(ACPI_MADT_TYPE_GENERIC_INTERRUPT, cpu_set_acpi);
91 }
92 
93 #else
94 
95 static void cpu_init_acpi(void)
96 {
97 	assert_msg(false, "ACPI not available");
98 }
99 
100 #endif
101 
102 static void cpu_init(void)
103 {
104 	int ret;
105 
106 	nr_cpus = 0;
107 	if (dt_available()) {
108 		ret = dt_for_each_cpu_node(cpu_set_fdt, NULL);
109 		assert(ret == 0);
110 	} else {
111 		cpu_init_acpi();
112 	}
113 
114 	set_cpu_online(0, true);
115 }
116 
117 static void mem_region_add(struct mem_region *r)
118 {
119 	struct mem_region *r_next = mem_regions;
120 	int i = 0;
121 
122 	for (; r_next->end; ++r_next, ++i)
123 		;
124 	assert(i < NR_INITIAL_MEM_REGIONS);
125 
126 	*r_next = *r;
127 }
128 
129 static void mem_regions_add_dt_regions(void)
130 {
131 	struct dt_pbus_reg regs[MAX_DT_MEM_REGIONS];
132 	int nr_regs, i;
133 
134 	nr_regs = dt_get_memory_params(regs, MAX_DT_MEM_REGIONS);
135 	assert(nr_regs > 0);
136 
137 	for (i = 0; i < nr_regs; ++i) {
138 		mem_region_add(&(struct mem_region){
139 			.start = regs[i].addr,
140 			.end = regs[i].addr + regs[i].size,
141 		});
142 	}
143 }
144 
145 struct mem_region *mem_region_find(phys_addr_t paddr)
146 {
147 	struct mem_region *r;
148 
149 	for (r = mem_regions; r->end; ++r)
150 		if (paddr >= r->start && paddr < r->end)
151 			return r;
152 	return NULL;
153 }
154 
155 unsigned int mem_region_get_flags(phys_addr_t paddr)
156 {
157 	struct mem_region *r = mem_region_find(paddr);
158 	return r ? r->flags : MR_F_UNKNOWN;
159 }
160 
161 static void mem_regions_add_assumed(void)
162 {
163 	phys_addr_t code_end = (phys_addr_t)(unsigned long)&_etext;
164 	struct mem_region *r;
165 
166 	r = mem_region_find(code_end - 1);
167 	assert(r);
168 
169 	/* Split the region with the code into two regions; code and data */
170 	mem_region_add(&(struct mem_region){
171 		.start = code_end,
172 		.end = r->end,
173 	});
174 	*r = (struct mem_region){
175 		.start = r->start,
176 		.end = code_end,
177 		.flags = MR_F_CODE,
178 	};
179 
180 	/*
181 	 * mach-virt I/O regions:
182 	 *   - The first 1G (arm/arm64)
183 	 *   - 512M at 256G (arm64, arm uses highmem=off)
184 	 *   - 512G at 512G (arm64, arm uses highmem=off)
185 	 */
186 	mem_region_add(&(struct mem_region){ 0, (1ul << 30), MR_F_IO });
187 #ifdef __aarch64__
188 	mem_region_add(&(struct mem_region){ (1ul << 38), (1ul << 38) | (1ul << 29), MR_F_IO });
189 	mem_region_add(&(struct mem_region){ (1ul << 39), (1ul << 40), MR_F_IO });
190 #endif
191 }
192 
193 static void mem_init(phys_addr_t freemem_start)
194 {
195 	phys_addr_t base, top;
196 	struct mem_region *freemem, *r, mem = {
197 		.start = (phys_addr_t)-1,
198 	};
199 
200 	freemem = mem_region_find(freemem_start);
201 	assert(freemem && !(freemem->flags & (MR_F_IO | MR_F_CODE)));
202 
203 	for (r = mem_regions; r->end; ++r) {
204 		if (!(r->flags & MR_F_IO)) {
205 			if (r->start < mem.start)
206 				mem.start = r->start;
207 			if (r->end > mem.end)
208 				mem.end = r->end;
209 		}
210 	}
211 	assert(mem.end && !(mem.start & ~PHYS_MASK));
212 	mem.end &= PHYS_MASK;
213 
214 	/* Check for holes */
215 	r = mem_region_find(mem.start);
216 	while (r && r->end != mem.end)
217 		r = mem_region_find(r->end);
218 	assert(r);
219 
220 	/* Ensure our selected freemem range is somewhere in our full range */
221 	assert(freemem_start >= mem.start && freemem->end <= mem.end);
222 
223 	__phys_offset = mem.start;	/* PHYS_OFFSET */
224 	__phys_end = mem.end;		/* PHYS_END */
225 
226 	phys_alloc_init(freemem_start, freemem->end - freemem_start);
227 	phys_alloc_set_minimum_alignment(SMP_CACHE_BYTES);
228 
229 	phys_alloc_get_unused(&base, &top);
230 	base = PAGE_ALIGN(base);
231 	top = top & PAGE_MASK;
232 	assert(sizeof(long) == 8 || !(base >> 32));
233 	if (sizeof(long) != 8 && (top >> 32) != 0)
234 		top = ((uint64_t)1 << 32);
235 	page_alloc_init_area(0, base >> PAGE_SHIFT, top >> PAGE_SHIFT);
236 	page_alloc_ops_enable();
237 }
238 
239 void setup(const void *fdt, phys_addr_t freemem_start)
240 {
241 	void *freemem;
242 	const char *bootargs, *tmp;
243 	u32 fdt_size;
244 	int ret;
245 
246 	assert(sizeof(long) == 8 || freemem_start < (3ul << 30));
247 	freemem = (void *)(unsigned long)freemem_start;
248 
249 	/* Move the FDT to the base of free memory */
250 	fdt_size = fdt_totalsize(fdt);
251 	ret = fdt_move(fdt, freemem, fdt_size);
252 	assert(ret == 0);
253 	ret = dt_init(freemem);
254 	assert(ret == 0);
255 	freemem += fdt_size;
256 
257 	/* Move the initrd to the top of the FDT */
258 	ret = dt_get_initrd(&tmp, &initrd_size);
259 	assert(ret == 0 || ret == -FDT_ERR_NOTFOUND);
260 	if (ret == 0) {
261 		initrd = freemem;
262 		memmove(initrd, tmp, initrd_size);
263 		freemem += initrd_size;
264 	}
265 
266 	mem_regions_add_dt_regions();
267 	mem_regions_add_assumed();
268 	mem_init(PAGE_ALIGN((unsigned long)freemem));
269 
270 	psci_set_conduit();
271 	cpu_init();
272 
273 	/* cpu_init must be called before thread_info_init */
274 	thread_info_init(current_thread_info(), 0);
275 
276 	/* mem_init must be called before io_init */
277 	io_init();
278 
279 	timer_save_state();
280 
281 	ret = dt_get_bootargs(&bootargs);
282 	assert(ret == 0 || ret == -FDT_ERR_NOTFOUND);
283 	setup_args_progname(bootargs);
284 
285 	if (initrd) {
286 		/* environ is currently the only file in the initrd */
287 		char *env = malloc(initrd_size);
288 		memcpy(env, initrd, initrd_size);
289 		setup_env(env, initrd_size);
290 	}
291 
292 	if (!(auxinfo.flags & AUXINFO_MMU_OFF))
293 		setup_vm();
294 }
295 
296 #ifdef CONFIG_EFI
297 
298 #include <efi.h>
299 
300 static efi_status_t setup_rsdp(efi_bootinfo_t *efi_bootinfo)
301 {
302 	efi_status_t status;
303 	struct acpi_table_rsdp *rsdp;
304 
305 	/*
306 	 * RSDP resides in an EFI_ACPI_RECLAIM_MEMORY region, which is not used
307 	 * by kvm-unit-tests arm64 memory allocator. So it is not necessary to
308 	 * copy the data structure to another memory region to prevent
309 	 * unintentional overwrite.
310 	 */
311 	status = efi_get_system_config_table(ACPI_20_TABLE_GUID, (void **)&rsdp);
312 	if (status != EFI_SUCCESS)
313 		return status;
314 
315 	set_efi_rsdp(rsdp);
316 
317 	return EFI_SUCCESS;
318 }
319 
320 static efi_status_t efi_mem_init(efi_bootinfo_t *efi_bootinfo)
321 {
322 	int i;
323 	unsigned long free_mem_pages = 0;
324 	unsigned long free_mem_start = 0;
325 	struct efi_boot_memmap *map = &(efi_bootinfo->mem_map);
326 	efi_memory_desc_t *buffer = *map->map;
327 	efi_memory_desc_t *d = NULL;
328 	phys_addr_t base, top;
329 	struct mem_region r;
330 	uintptr_t text = (uintptr_t)&_text, etext = ALIGN((uintptr_t)&_etext, 4096);
331 	uintptr_t data = (uintptr_t)&_data, edata = ALIGN((uintptr_t)&_edata, 4096);
332 	const void *fdt = efi_bootinfo->fdt;
333 	int fdt_size, ret;
334 
335 	/*
336 	 * Record the largest free EFI_CONVENTIONAL_MEMORY region
337 	 * which will be used to set up the memory allocator, so that
338 	 * the memory allocator can work in the largest free
339 	 * continuous memory region.
340 	 */
341 	for (i = 0; i < *(map->map_size); i += *(map->desc_size)) {
342 		d = (efi_memory_desc_t *)(&((u8 *)buffer)[i]);
343 
344 		r.start = d->phys_addr;
345 		r.end = d->phys_addr + d->num_pages * EFI_PAGE_SIZE;
346 		r.flags = 0;
347 
348 		switch (d->type) {
349 		case EFI_RESERVED_TYPE:
350 		case EFI_LOADER_DATA:
351 		case EFI_BOOT_SERVICES_CODE:
352 		case EFI_BOOT_SERVICES_DATA:
353 		case EFI_RUNTIME_SERVICES_CODE:
354 		case EFI_RUNTIME_SERVICES_DATA:
355 		case EFI_UNUSABLE_MEMORY:
356 		case EFI_ACPI_RECLAIM_MEMORY:
357 		case EFI_ACPI_MEMORY_NVS:
358 		case EFI_PAL_CODE:
359 			r.flags = MR_F_RESERVED;
360 			break;
361 		case EFI_MEMORY_MAPPED_IO:
362 		case EFI_MEMORY_MAPPED_IO_PORT_SPACE:
363 			r.flags = MR_F_IO;
364 			break;
365 		case EFI_LOADER_CODE:
366 			if (r.start <= text && r.end > text) {
367 				/* This is the unit test region. Flag the code separately. */
368 				phys_addr_t tmp = r.end;
369 
370 				assert(etext <= data);
371 				assert(edata <= r.end);
372 				r.flags = MR_F_CODE;
373 				r.end = data;
374 				mem_region_add(&r);
375 				r.start = data;
376 				r.end = tmp;
377 				r.flags = 0;
378 			} else {
379 				r.flags = MR_F_RESERVED;
380 			}
381 			break;
382 		case EFI_CONVENTIONAL_MEMORY:
383 			if (free_mem_pages < d->num_pages) {
384 				free_mem_pages = d->num_pages;
385 				free_mem_start = d->phys_addr;
386 			}
387 			break;
388 		}
389 
390 		if (!(r.flags & MR_F_IO)) {
391 			if (r.start < __phys_offset)
392 				__phys_offset = r.start;
393 			if (r.end > __phys_end)
394 				__phys_end = r.end;
395 		}
396 		mem_region_add(&r);
397 	}
398 	if (fdt) {
399 		/* Move the FDT to the base of free memory */
400 		fdt_size = fdt_totalsize(fdt);
401 		ret = fdt_move(fdt, (void *)free_mem_start, fdt_size);
402 		assert(ret == 0);
403 		ret = dt_init((void *)free_mem_start);
404 		assert(ret == 0);
405 		free_mem_start += ALIGN(fdt_size, EFI_PAGE_SIZE);
406 		free_mem_pages -= ALIGN(fdt_size, EFI_PAGE_SIZE) >> EFI_PAGE_SHIFT;
407 	}
408 
409 	__phys_end &= PHYS_MASK;
410 	asm_mmu_disable();
411 
412 	if (free_mem_pages == 0)
413 		return EFI_OUT_OF_RESOURCES;
414 
415 	assert(sizeof(long) == 8 || free_mem_start < (3ul << 30));
416 
417 	phys_alloc_init(free_mem_start, free_mem_pages << EFI_PAGE_SHIFT);
418 	phys_alloc_set_minimum_alignment(SMP_CACHE_BYTES);
419 
420 	phys_alloc_get_unused(&base, &top);
421 	base = PAGE_ALIGN(base);
422 	top = top & PAGE_MASK;
423 	assert(sizeof(long) == 8 || !(base >> 32));
424 	if (sizeof(long) != 8 && (top >> 32) != 0)
425 		top = ((uint64_t)1 << 32);
426 	page_alloc_init_area(0, base >> PAGE_SHIFT, top >> PAGE_SHIFT);
427 	page_alloc_ops_enable();
428 
429 	return EFI_SUCCESS;
430 }
431 
432 efi_status_t setup_efi(efi_bootinfo_t *efi_bootinfo)
433 {
434 	efi_status_t status;
435 
436 	struct thread_info *ti = current_thread_info();
437 
438 	memset(ti, 0, sizeof(*ti));
439 
440 	exceptions_init();
441 
442 	status = efi_mem_init(efi_bootinfo);
443 	if (status != EFI_SUCCESS) {
444 		printf("Failed to initialize memory: ");
445 		switch (status) {
446 		case EFI_OUT_OF_RESOURCES:
447 			printf("No free memory region\n");
448 			break;
449 		default:
450 			printf("Unknown error\n");
451 			break;
452 		}
453 		return status;
454 	}
455 
456 	if (!dt_available()) {
457 		status = setup_rsdp(efi_bootinfo);
458 		if (status != EFI_SUCCESS) {
459 			printf("Cannot find RSDP in EFI system table\n");
460 			return status;
461 		}
462 	}
463 
464 	psci_set_conduit();
465 	cpu_init();
466 	/* cpu_init must be called before thread_info_init */
467 	thread_info_init(current_thread_info(), 0);
468 	/* mem_init must be called before io_init */
469 	io_init();
470 
471 	timer_save_state();
472 	if (initrd) {
473 		/* environ is currently the only file in the initrd */
474 		char *env = malloc(initrd_size);
475 
476 		memcpy(env, initrd, initrd_size);
477 		setup_env(env, initrd_size);
478 	}
479 
480 	if (!(auxinfo.flags & AUXINFO_MMU_OFF))
481 		setup_vm();
482 
483 	return EFI_SUCCESS;
484 }
485 
486 #endif
487