xref: /haiku/src/system/boot/platform/efi/arch/arm64/arch_start.cpp (revision 688acf41a377f25d4048dc6092edb86ac9179677)
1 /*
2  * Copyright 2019-2022 Haiku, Inc. All rights reserved.
3  * Released under the terms of the MIT License.
4  */
5 
6 
7 #include <boot/platform.h>
8 #include <boot/stage2.h>
9 #include <boot/stdio.h>
10 
11 #include "efi_platform.h"
12 #include "mmu.h"
13 #include "serial.h"
14 
15 #include "aarch64.h"
16 
17 extern "C" void arch_enter_kernel(
18 	struct kernel_args* kernelArgs, addr_t kernelEntry, addr_t kernelStackTop);
19 
20 extern void arch_mmu_dump_present_tables();
21 extern const char* granule_type_str(int tg);
22 
23 extern uint32_t arch_mmu_generate_post_efi_page_tables(size_t memory_map_size,
24 	efi_memory_descriptor* memory_map, size_t descriptor_size, uint32_t descriptor_version);
25 
26 extern void arch_mmu_post_efi_setup(size_t memory_map_size, efi_memory_descriptor* memory_map,
27 	size_t descriptor_size, uint32_t descriptor_version);
28 
29 extern void arch_mmu_setup_EL1(uint64 tcr);
30 
31 
32 static const char*
33 memory_region_type_str(int type)
34 {
35 	switch (type) {
36 		case EfiReservedMemoryType:
37 			return "ReservedMemoryType";
38 		case EfiLoaderCode:
39 			return "LoaderCode";
40 		case EfiLoaderData:
41 			return "LoaderData";
42 		case EfiBootServicesCode:
43 			return "BootServicesCode";
44 		case EfiBootServicesData:
45 			return "BootServicesData";
46 		case EfiRuntimeServicesCode:
47 			return "RuntimeServicesCode";
48 		case EfiRuntimeServicesData:
49 			return "RuntimeServicesData";
50 		case EfiConventionalMemory:
51 			return "ConventionalMemory";
52 		case EfiUnusableMemory:
53 			return "UnusableMemory";
54 		case EfiACPIReclaimMemory:
55 			return "ACPIReclaimMemory";
56 		case EfiACPIMemoryNVS:
57 			return "ACPIMemoryNVS";
58 		case EfiMemoryMappedIO:
59 			return "MMIO";
60 		case EfiMemoryMappedIOPortSpace:
61 			return "MMIOPortSpace";
62 		case EfiPalCode:
63 			return "PalCode";
64 		case EfiPersistentMemory:
65 			return "PersistentMemory";
66 		default:
67 			return "unknown";
68 	}
69 }
70 
71 
72 void
73 arch_convert_kernel_args(void)
74 {
75 	fix_address(gKernelArgs.arch_args.fdt);
76 }
77 
78 
79 void
80 arch_start_kernel(addr_t kernelEntry)
81 {
82 	// Prepare to exit EFI boot services.
83 	// Read the memory map.
84 	// First call is to determine the buffer size.
85 	size_t memory_map_size = 0;
86 	efi_memory_descriptor dummy;
87 	efi_memory_descriptor* memory_map;
88 	size_t map_key;
89 	size_t descriptor_size;
90 	uint32_t descriptor_version;
91 	if (kBootServices->GetMemoryMap(
92 			&memory_map_size, &dummy, &map_key, &descriptor_size, &descriptor_version)
93 		!= EFI_BUFFER_TOO_SMALL) {
94 		panic("Unable to determine size of system memory map");
95 	}
96 
97 	// Allocate a buffer twice as large as needed just in case it gets bigger
98 	// between calls to ExitBootServices.
99 	size_t actual_memory_map_size = memory_map_size * 2;
100 	memory_map = (efi_memory_descriptor*) kernel_args_malloc(actual_memory_map_size);
101 
102 	if (memory_map == NULL)
103 		panic("Unable to allocate memory map.");
104 
105 	// Read (and print) the memory map.
106 	memory_map_size = actual_memory_map_size;
107 	if (kBootServices->GetMemoryMap(
108 			&memory_map_size, memory_map, &map_key, &descriptor_size, &descriptor_version)
109 		!= EFI_SUCCESS) {
110 		panic("Unable to fetch system memory map.");
111 	}
112 
113 	addr_t addr = (addr_t) memory_map;
114 	efi_physical_addr loaderCode = 0LL;
115 	dprintf("System provided memory map:\n");
116 	for (size_t i = 0; i < memory_map_size / descriptor_size; ++i) {
117 		efi_memory_descriptor* entry = (efi_memory_descriptor*) (addr + i * descriptor_size);
118 		dprintf("  phys: 0x%0lx-0x%0lx, virt: 0x%0lx-0x%0lx, size = 0x%0lx, type: %s (%#x), attr: "
119 				"%#lx\n",
120 			entry->PhysicalStart, entry->PhysicalStart + entry->NumberOfPages * B_PAGE_SIZE,
121 			entry->VirtualStart, entry->VirtualStart + entry->NumberOfPages * B_PAGE_SIZE,
122 			entry->NumberOfPages * B_PAGE_SIZE, memory_region_type_str(entry->Type), entry->Type,
123 			entry->Attribute);
124 		if (entry->Type == EfiLoaderCode)
125 			loaderCode = entry->PhysicalStart;
126 	}
127 	// This is where our efi loader got relocated, therefore we need to use this
128 	// offset for properly align symbols
129 	dprintf("Efi loader symbols offset: 0x%0lx:\n", loaderCode);
130 
131 	/*
132 	*   "The AArch64 exception model is made up of a number of exception levels
133 	*    (EL0 - EL3), with EL0 and EL1 having a secure and a non-secure
134 	*    counterpart.  EL2 is the hypervisor level and exists only in non-secure
135 	*    mode. EL3 is the highest priority level and exists only in secure mode."
136 	*
137 	*	"2.3 UEFI System Environment and Configuration
138 	*    The resident UEFI boot-time environment shall use the highest non-secure
139 	*    privilege level available. The exact meaning of this is architecture
140 	*    dependent, as detailed below."
141 
142 	*	"2.3.1 AArch64 Exception Levels
143 	*    On AArch64 UEFI shall execute as 64-bit code at either EL1 or EL2,
144 	*    depending on whether or not virtualization is available at OS load time."
145 	*/
146 	uint64 el = arch_exception_level();
147 	dprintf("Current Exception Level EL%1lx\n", el);
148 	dprintf("TTBR0: %" B_PRIx64 " TTBRx: %" B_PRIx64 " SCTLR: %" B_PRIx64 " TCR: %" B_PRIx64 "\n",
149 		arch_mmu_base_register(), arch_mmu_base_register(true), _arch_mmu_get_sctlr(),
150 		_arch_mmu_get_tcr());
151 
152 	if (arch_mmu_enabled()) {
153 		dprintf("MMU Enabled, Granularity %s, bits %d\n", granule_type_str(arch_mmu_user_granule()),
154 			arch_mmu_user_address_bits());
155 
156 		dprintf("Kernel entry accessibility W: %x R: %x\n", arch_mmu_write_access(kernelEntry),
157 			arch_mmu_read_access(kernelEntry));
158 
159 		arch_mmu_dump_present_tables();
160 
161 		if (el == 1) {
162 			// Disable CACHE & MMU before dealing with TTBRx
163 			arch_cache_disable();
164 		}
165 	}
166 
167 	// Generate page tables for use after ExitBootServices.
168 	arch_mmu_generate_post_efi_page_tables(
169 		memory_map_size, memory_map, descriptor_size, descriptor_version);
170 
171 	// Attempt to fetch the memory map and exit boot services.
172 	// This needs to be done in a loop, as ExitBootServices can change the
173 	// memory map.
174 	// Even better: Only GetMemoryMap and ExitBootServices can be called after
175 	// the first call to ExitBootServices, as the firmware is permitted to
176 	// partially exit. This is why twice as much space was allocated for the
177 	// memory map, as it's impossible to allocate more now.
178 	// A changing memory map shouldn't affect the generated page tables, as
179 	// they only needed to know about the maximum address, not any specific
180 	// entry.
181 	dprintf("Calling ExitBootServices. So long, EFI!\n");
182 	while (true) {
183 		if (kBootServices->ExitBootServices(kImage, map_key) == EFI_SUCCESS) {
184 			// The console was provided by boot services, disable it.
185 			stdout = NULL;
186 			stderr = NULL;
187 			// Can we adjust gKernelArgs.platform_args.serial_base_ports[0]
188 			// to something fixed in qemu for debugging?
189 			serial_switch_to_legacy();
190 			dprintf("Switched to legacy serial output\n");
191 			break;
192 		}
193 
194 		memory_map_size = actual_memory_map_size;
195 		if (kBootServices->GetMemoryMap(
196 				&memory_map_size, memory_map, &map_key, &descriptor_size, &descriptor_version)
197 			!= EFI_SUCCESS) {
198 			panic("Unable to fetch system memory map.");
199 		}
200 	}
201 
202 	// Update EFI, generate final kernel physical memory map, etc.
203 	arch_mmu_post_efi_setup(memory_map_size, memory_map, descriptor_size, descriptor_version);
204 
205 	switch (el) {
206 		case 1:
207 			arch_mmu_setup_EL1(READ_SPECIALREG(TCR_EL1));
208 			break;
209 		case 2:
210 			arch_mmu_setup_EL1(READ_SPECIALREG(TCR_EL2));
211 			arch_cache_disable();
212 			_arch_transition_EL2_EL1();
213 			break;
214 		default:
215 			panic("Unexpected Exception Level\n");
216 			break;
217 	}
218 
219 	arch_cache_enable();
220 
221 	// smp_boot_other_cpus(final_pml4, kernelEntry, (addr_t)&gKernelArgs);
222 
223 	if (arch_mmu_read_access(kernelEntry)
224 		&& arch_mmu_read_access(gKernelArgs.cpu_kstack[0].start)) {
225 		// Enter the kernel!
226 		arch_enter_kernel(&gKernelArgs, kernelEntry,
227 			gKernelArgs.cpu_kstack[0].start + gKernelArgs.cpu_kstack[0].size);
228 	} else {
229 		// _arch_exception_panic("Kernel or Stack memory not accessible\n", __LINE__);
230 		panic("Kernel or Stack memory not accessible\n");
231 	}
232 }
233