ArmPlatformPkg/Bds: Remove any use of the "Fdt" UEFI variable
[mirror_edk2.git] / ArmPkg / Library / BdsLib / AArch64 / BdsLinuxLoader.c
1 /** @file
2 *
3 * Copyright (c) 2011-2014, ARM Limited. All rights reserved.
4 *
5 * This program and the accompanying materials
6 * are licensed and made available under the terms and conditions of the BSD License
7 * which accompanies this distribution. The full text of the license may be found at
8 * http://opensource.org/licenses/bsd-license.php
9 *
10 * THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
12 *
13 **/
14 #include <Library/ArmGicLib.h>
15 #include <Ppi/ArmMpCoreInfo.h>
16 #include <Library/IoLib.h>
17 #include <Guid/Fdt.h>
18 #include <libfdt.h>
19
20 #include "BdsInternal.h"
21 #include "BdsLinuxLoader.h"
22
23 /*
24 Linux kernel booting: Look at the doc in the Kernel source :
25 Documentation/arm64/booting.txt
26 The kernel image must be placed at the start of the memory to be used by the
27 kernel (2MB aligned) + 0x80000.
28
29 The Device tree blob is expected to be under 2MB and be within the first 512MB
30 of kernel memory and be 2MB aligned.
31
32 A Flattened Device Tree (FDT) used to boot linux needs to be updated before
33 the kernel is started. It needs to indicate how secondary cores are brought up
34 and where they are waiting before loading Linux. The FDT also needs to hold
35 the correct kernel command line and filesystem RAM-disk information.
36 At the moment we do not fully support generating this FDT information at
37 runtime. A prepared FDT should be provided at boot. FDT is the only supported
38 method for booting the AArch64 Linux kernel.
39
40 Linux does not use any runtime services at this time, so we can let it
41 overwrite UEFI.
42 */
43
44
45 #define LINUX_ALIGN_VAL (0x080000) // 2MB + 0x80000 mask
46 #define LINUX_ALIGN_MASK (0x1FFFFF) // Bottom 21bits
47 #define ALIGN_2MB(addr) ALIGN_POINTER(addr , (2*1024*1024))
48
49 /* ARM32 and AArch64 kernel handover differ.
50 * x0 is set to FDT base.
51 * x1-x3 are reserved for future use and should be set to zero.
52 */
53 typedef VOID (*LINUX_KERNEL64)(UINTN ParametersBase, UINTN Reserved0,
54 UINTN Reserved1, UINTN Reserved2);
55
56 /* These externs are used to relocate some ASM code into Linux memory. */
57 extern VOID *SecondariesPenStart;
58 extern VOID *SecondariesPenEnd;
59 extern UINTN *AsmMailboxbase;
60
61
62 STATIC
63 EFI_STATUS
64 PreparePlatformHardware (
65 VOID
66 )
67 {
68 //Note: Interrupts will be disabled by the GIC driver when ExitBootServices() will be called.
69
70 // Clean before Disable else the Stack gets corrupted with old data.
71 ArmCleanDataCache ();
72 ArmDisableDataCache ();
73 // Invalidate all the entries that might have snuck in.
74 ArmInvalidateDataCache ();
75
76 // Disable and invalidate the instruction cache
77 ArmDisableInstructionCache ();
78 ArmInvalidateInstructionCache ();
79
80 // Turn off MMU
81 ArmDisableMmu();
82
83 return EFI_SUCCESS;
84 }
85
86 STATIC
87 EFI_STATUS
88 StartLinux (
89 IN EFI_PHYSICAL_ADDRESS LinuxImage,
90 IN UINTN LinuxImageSize,
91 IN EFI_PHYSICAL_ADDRESS FdtBlobBase,
92 IN UINTN FdtBlobSize
93 )
94 {
95 EFI_STATUS Status;
96 LINUX_KERNEL64 LinuxKernel = (LINUX_KERNEL64)LinuxImage;
97
98 // Send msg to secondary cores to go to the kernel pen.
99 ArmGicSendSgiTo (PcdGet32(PcdGicDistributorBase), ARM_GIC_ICDSGIR_FILTER_EVERYONEELSE, 0x0E, PcdGet32 (PcdGicSgiIntId));
100
101 // Shut down UEFI boot services. ExitBootServices() will notify every driver that created an event on
102 // ExitBootServices event. Example the Interrupt DXE driver will disable the interrupts on this event.
103 Status = ShutdownUefiBootServices ();
104 if(EFI_ERROR(Status)) {
105 DEBUG((EFI_D_ERROR,"ERROR: Can not shutdown UEFI boot services. Status=0x%X\n", Status));
106 goto Exit;
107 }
108
109 // Check if the Linux Image is a uImage
110 if (*(UINTN*)LinuxKernel == LINUX_UIMAGE_SIGNATURE) {
111 // Assume the Image Entry Point is just after the uImage header (64-byte size)
112 LinuxKernel = (LINUX_KERNEL64)((UINTN)LinuxKernel + 64);
113 LinuxImageSize -= 64;
114 }
115
116 //
117 // Switch off interrupts, caches, mmu, etc
118 //
119 Status = PreparePlatformHardware ();
120 ASSERT_EFI_ERROR(Status);
121
122 // Register and print out performance information
123 PERF_END (NULL, "BDS", NULL, 0);
124 if (PerformanceMeasurementEnabled ()) {
125 PrintPerformance ();
126 }
127
128 //
129 // Start the Linux Kernel
130 //
131
132 // x1-x3 are reserved (set to zero) for future use.
133 LinuxKernel ((UINTN)FdtBlobBase, 0, 0, 0);
134
135 // Kernel should never exit
136 // After Life services are not provided
137 ASSERT(FALSE);
138
139 Exit:
140 // Only be here if we fail to start Linux
141 Print (L"ERROR : Can not start the kernel. Status=0x%X\n", Status);
142
143 // Free Runtimee Memory (kernel and FDT)
144 return Status;
145 }
146
147
148 /**
149 Start a Linux kernel from a Device Path
150
151 @param LinuxKernel Device Path to the Linux Kernel
152 @param Parameters Linux kernel agruments
153 @param Fdt Device Path to the Flat Device Tree
154
155 @retval EFI_SUCCESS All drivers have been connected
156 @retval EFI_NOT_FOUND The Linux kernel Device Path has not been found
157 @retval EFI_OUT_OF_RESOURCES There is not enough resource memory to store the matching results.
158
159 **/
160 EFI_STATUS
161 BdsBootLinuxAtag (
162 IN EFI_DEVICE_PATH_PROTOCOL* LinuxKernelDevicePath,
163 IN EFI_DEVICE_PATH_PROTOCOL* InitrdDevicePath,
164 IN CONST CHAR8* Arguments
165 )
166 {
167 // NOTE : AArch64 Linux kernel does not support ATAG, FDT only.
168 ASSERT(0);
169
170 return RETURN_UNSUPPORTED;
171 }
172
173 /**
174 Start a Linux kernel from a Device Path
175
176 @param[in] LinuxKernelDevicePath Device Path to the Linux Kernel
177 @param[in] InitrdDevicePath Device Path to the Initrd
178 @param[in] Arguments Linux kernel arguments
179
180 @retval EFI_SUCCESS All drivers have been connected
181 @retval EFI_NOT_FOUND The Linux kernel Device Path has not been found
182 @retval EFI_OUT_OF_RESOURCES There is not enough resource memory to store the matching results.
183
184 **/
185 EFI_STATUS
186 BdsBootLinuxFdt (
187 IN EFI_DEVICE_PATH_PROTOCOL* LinuxKernelDevicePath,
188 IN EFI_DEVICE_PATH_PROTOCOL* InitrdDevicePath,
189 IN CONST CHAR8* Arguments
190 )
191 {
192 EFI_STATUS Status;
193 EFI_STATUS PenBaseStatus;
194 UINTN LinuxImageSize;
195 UINTN InitrdImageSize;
196 UINTN InitrdImageBaseSize;
197 VOID *InstalledFdtBase;
198 UINTN FdtBlobSize;
199 EFI_PHYSICAL_ADDRESS FdtBlobBase;
200 EFI_PHYSICAL_ADDRESS LinuxImage;
201 EFI_PHYSICAL_ADDRESS InitrdImage;
202 EFI_PHYSICAL_ADDRESS InitrdImageBase;
203 ARM_PROCESSOR_TABLE *ArmProcessorTable;
204 ARM_CORE_INFO *ArmCoreInfoTable;
205 UINTN Index;
206 EFI_PHYSICAL_ADDRESS PenBase;
207 UINTN PenSize;
208 UINTN MailBoxBase;
209
210 PenBaseStatus = EFI_UNSUPPORTED;
211 PenSize = 0;
212 InitrdImage = 0;
213 InitrdImageSize = 0;
214 InitrdImageBase = 0;
215 InitrdImageBaseSize = 0;
216
217 PERF_START (NULL, "BDS", NULL, 0);
218
219 //
220 // Load the Linux kernel from a device path
221 //
222
223 // Try to put the kernel at the start of RAM so as to give it access to all memory.
224 // If that fails fall back to try loading it within LINUX_KERNEL_MAX_OFFSET of memory start.
225 LinuxImage = PcdGet64 (PcdSystemMemoryBase) + 0x80000;
226 Status = BdsLoadImage (LinuxKernelDevicePath, AllocateAddress, &LinuxImage, &LinuxImageSize);
227 if (EFI_ERROR(Status)) {
228 // Try again but give the loader more freedom of where to put the image.
229 LinuxImage = LINUX_KERNEL_MAX_OFFSET;
230 Status = BdsLoadImage (LinuxKernelDevicePath, AllocateMaxAddress, &LinuxImage, &LinuxImageSize);
231 if (EFI_ERROR(Status)) {
232 Print (L"ERROR: Did not find Linux kernel (%r).\n", Status);
233 return Status;
234 }
235 }
236 // Adjust the kernel location slightly if required. The kernel needs to be placed at start
237 // of memory (2MB aligned) + 0x80000.
238 if ((LinuxImage & LINUX_ALIGN_MASK) != LINUX_ALIGN_VAL) {
239 LinuxImage = (EFI_PHYSICAL_ADDRESS)CopyMem (ALIGN_2MB(LinuxImage) + 0x80000, (VOID*)(UINTN)LinuxImage, LinuxImageSize);
240 }
241
242 if (InitrdDevicePath) {
243 InitrdImageBase = LINUX_KERNEL_MAX_OFFSET;
244 Status = BdsLoadImage (InitrdDevicePath, AllocateMaxAddress, &InitrdImageBase, &InitrdImageBaseSize);
245 if (Status == EFI_OUT_OF_RESOURCES) {
246 Status = BdsLoadImage (InitrdDevicePath, AllocateAnyPages, &InitrdImageBase, &InitrdImageBaseSize);
247 }
248 if (EFI_ERROR (Status)) {
249 Print (L"ERROR: Did not find initrd image (%r).\n", Status);
250 goto EXIT_FREE_LINUX;
251 }
252
253 // Check if the initrd is a uInitrd
254 if (*(UINTN*)((UINTN)InitrdImageBase) == LINUX_UIMAGE_SIGNATURE) {
255 // Skip the 64-byte image header
256 InitrdImage = (EFI_PHYSICAL_ADDRESS)((UINTN)InitrdImageBase + 64);
257 InitrdImageSize = InitrdImageBaseSize - 64;
258 } else {
259 InitrdImage = InitrdImageBase;
260 InitrdImageSize = InitrdImageBaseSize;
261 }
262 }
263
264 //
265 // Get the FDT from the Configuration Table.
266 // The FDT will be reloaded in PrepareFdt() to a more appropriate
267 // location for the Linux Kernel.
268 //
269 Status = EfiGetSystemConfigurationTable (&gFdtTableGuid, &InstalledFdtBase);
270 if (EFI_ERROR (Status)) {
271 Print (L"ERROR: Did not get the Device Tree blob (%r).\n", Status);
272 goto EXIT_FREE_INITRD;
273 }
274 FdtBlobBase = (EFI_PHYSICAL_ADDRESS)InstalledFdtBase;
275 FdtBlobSize = fdt_totalsize (InstalledFdtBase);
276
277 //
278 // Install secondary core pens if the Power State Coordination Interface is not supported
279 //
280 if (FeaturePcdGet (PcdArmLinuxSpinTable)) {
281 // Place Pen at the start of Linux memory. We can then tell Linux to not use this bit of memory
282 PenBase = LinuxImage - 0x80000;
283 PenSize = (UINTN)&SecondariesPenEnd - (UINTN)&SecondariesPenStart;
284
285 // Reserve the memory as RuntimeServices
286 PenBaseStatus = gBS->AllocatePages (AllocateAddress, EfiRuntimeServicesCode, EFI_SIZE_TO_PAGES (PenSize), &PenBase);
287 if (EFI_ERROR (PenBaseStatus)) {
288 Print (L"Warning: Failed to reserve the memory required for the secondary cores at 0x%lX, Status = %r\n", PenBase, PenBaseStatus);
289 // Even if there is a risk of memory corruption we carry on
290 }
291
292 // Put mailboxes below the pen code so we know where they are relative to code.
293 MailBoxBase = (UINTN)PenBase + ((UINTN)&SecondariesPenEnd - (UINTN)&SecondariesPenStart);
294 // Make sure this is 8 byte aligned.
295 if (MailBoxBase % sizeof(MailBoxBase) != 0) {
296 MailBoxBase += sizeof(MailBoxBase) - MailBoxBase % sizeof(MailBoxBase);
297 }
298
299 CopyMem ( (VOID*)(PenBase), (VOID*)&SecondariesPenStart, PenSize);
300
301 // Update the MailboxBase variable used in the pen code
302 *(UINTN*)(PenBase + ((UINTN)&AsmMailboxbase - (UINTN)&SecondariesPenStart)) = MailBoxBase;
303
304 for (Index=0; Index < gST->NumberOfTableEntries; Index++) {
305 // Check for correct GUID type
306 if (CompareGuid (&gArmMpCoreInfoGuid, &(gST->ConfigurationTable[Index].VendorGuid))) {
307 UINTN i;
308
309 // Get them under our control. Move from depending on 32bit reg(sys_flags) and SWI
310 // to 64 bit addr and WFE
311 ArmProcessorTable = (ARM_PROCESSOR_TABLE *)gST->ConfigurationTable[Index].VendorTable;
312 ArmCoreInfoTable = ArmProcessorTable->ArmCpus;
313
314 for (i = 0; i < ArmProcessorTable->NumberOfEntries; i++ ) {
315 // This goes into the SYSFLAGS register for the VE platform. We only have one 32bit reg to use
316 MmioWrite32(ArmCoreInfoTable[i].MailboxSetAddress, (UINTN)PenBase);
317
318 // So FDT can set the mailboxes correctly with the parser. These are 64bit Memory locations.
319 ArmCoreInfoTable[i].MailboxSetAddress = (UINTN)MailBoxBase + i*sizeof(MailBoxBase);
320
321 // Clear the mailboxes for the respective cores
322 *((UINTN*)(ArmCoreInfoTable[i].MailboxSetAddress)) = 0x0;
323 }
324 }
325 }
326 // Flush caches to make sure our pen gets to mem before we free the cores.
327 ArmCleanDataCache();
328 }
329
330 // By setting address=0 we leave the memory allocation to the function
331 Status = PrepareFdt (Arguments, InitrdImage, InitrdImageSize, &FdtBlobBase, &FdtBlobSize);
332 if (EFI_ERROR(Status)) {
333 Print(L"ERROR: Can not load Linux kernel with Device Tree. Status=0x%X\n", Status);
334 goto EXIT_FREE_FDT;
335 }
336
337 return StartLinux (LinuxImage, LinuxImageSize, FdtBlobBase, FdtBlobSize);
338
339 EXIT_FREE_FDT:
340 if (!EFI_ERROR (PenBaseStatus)) {
341 gBS->FreePages (PenBase, EFI_SIZE_TO_PAGES (PenSize));
342 }
343
344 gBS->FreePages (FdtBlobBase, EFI_SIZE_TO_PAGES (FdtBlobSize));
345
346 EXIT_FREE_INITRD:
347 if (InitrdDevicePath) {
348 gBS->FreePages (InitrdImageBase, EFI_SIZE_TO_PAGES (InitrdImageBaseSize));
349 }
350
351 EXIT_FREE_LINUX:
352 gBS->FreePages (LinuxImage, EFI_SIZE_TO_PAGES (LinuxImageSize));
353
354 return Status;
355 }