1 /** @file
2 *
3 * Copyright (c) 2011-2015, 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
15 #include <Library/ArmLib.h>
16 #include <Library/PcdLib.h>
17
18 #include <Guid/Fdt.h>
19
20 #include "LinuxLoader.h"
21
22 #define ALIGN32_BELOW(addr) ALIGN_POINTER(addr - 32,32)
23
24 #define IS_ADDRESS_IN_REGION(RegionStart, RegionSize, Address) \
25 (((UINTN)(RegionStart) <= (UINTN)(Address)) && ((UINTN)(Address) <= ((UINTN)(RegionStart) + (UINTN)(RegionSize))))
26
27 EFI_STATUS
28 PrepareAtagList (
29 IN EFI_PHYSICAL_ADDRESS SystemMemoryBase,
30 IN CONST CHAR8* CommandLineString,
31 IN EFI_PHYSICAL_ADDRESS InitrdImage,
32 IN UINTN InitrdImageSize,
33 OUT EFI_PHYSICAL_ADDRESS *AtagBase,
34 OUT UINT32 *AtagSize
35 );
36
37 STATIC
38 VOID
PreparePlatformHardware(VOID)39 PreparePlatformHardware (
40 VOID
41 )
42 {
43 //Note: Interrupts will be disabled by the GIC driver when ExitBootServices() will be called.
44
45 // Clean before Disable else the Stack gets corrupted with old data.
46 ArmCleanDataCache ();
47 ArmDisableDataCache ();
48 // Invalidate all the entries that might have snuck in.
49 ArmInvalidateDataCache ();
50
51 // Invalidate and disable the Instruction cache
52 ArmDisableInstructionCache ();
53 ArmInvalidateInstructionCache ();
54
55 // Turn off MMU
56 ArmDisableMmu ();
57 }
58
59 STATIC
60 EFI_STATUS
StartLinux(IN EFI_PHYSICAL_ADDRESS SystemMemoryBase,IN EFI_PHYSICAL_ADDRESS LinuxImage,IN UINTN LinuxImageSize,IN EFI_PHYSICAL_ADDRESS KernelParamsAddress,IN UINTN KernelParamsSize,IN UINT32 MachineType)61 StartLinux (
62 IN EFI_PHYSICAL_ADDRESS SystemMemoryBase,
63 IN EFI_PHYSICAL_ADDRESS LinuxImage,
64 IN UINTN LinuxImageSize,
65 IN EFI_PHYSICAL_ADDRESS KernelParamsAddress,
66 IN UINTN KernelParamsSize,
67 IN UINT32 MachineType
68 )
69 {
70 EFI_STATUS Status;
71 LINUX_KERNEL LinuxKernel;
72
73 // Shut down UEFI boot services. ExitBootServices() will notify every driver that created an event on
74 // ExitBootServices event. Example the Interrupt DXE driver will disable the interrupts on this event.
75 Status = ShutdownUefiBootServices ();
76 if (EFI_ERROR (Status)) {
77 DEBUG ((EFI_D_ERROR, "ERROR: Can not shutdown UEFI boot services. Status=0x%X\n", Status));
78 return Status;
79 }
80
81 // Move the kernel parameters to any address inside the first 1MB.
82 // This is necessary because the ARM Linux kernel requires
83 // the FTD / ATAG List to reside entirely inside the first 1MB of
84 // physical memory.
85 //Note: There is no requirement on the alignment
86 if (MachineType != ARM_FDT_MACHINE_TYPE) {
87 if (((UINTN)KernelParamsAddress > LINUX_ATAG_MAX_OFFSET) && (KernelParamsSize < PcdGet32 (PcdArmLinuxAtagMaxOffset))) {
88 KernelParamsAddress = (EFI_PHYSICAL_ADDRESS)(UINTN)CopyMem (ALIGN32_BELOW (LINUX_ATAG_MAX_OFFSET - KernelParamsSize), (VOID*)(UINTN)KernelParamsAddress, KernelParamsSize);
89 }
90 } else {
91 if (((UINTN)KernelParamsAddress > LINUX_FDT_MAX_OFFSET) && (KernelParamsSize < PcdGet32 (PcdArmLinuxFdtMaxOffset))) {
92 KernelParamsAddress = (EFI_PHYSICAL_ADDRESS)(UINTN)CopyMem (ALIGN32_BELOW (LINUX_FDT_MAX_OFFSET - KernelParamsSize), (VOID*)(UINTN)KernelParamsAddress, KernelParamsSize);
93 }
94 }
95
96 if ((UINTN)LinuxImage > LINUX_KERNEL_MAX_OFFSET) {
97 //Note: There is no requirement on the alignment
98 LinuxKernel = (LINUX_KERNEL)CopyMem (ALIGN32_BELOW (LINUX_KERNEL_MAX_OFFSET - LinuxImageSize), (VOID*)(UINTN)LinuxImage, LinuxImageSize);
99 } else {
100 LinuxKernel = (LINUX_KERNEL)(UINTN)LinuxImage;
101 }
102
103 // Check if the Linux Image is a uImage
104 if (*(UINT32*)LinuxKernel == LINUX_UIMAGE_SIGNATURE) {
105 // Assume the Image Entry Point is just after the uImage header (64-byte size)
106 LinuxKernel = (LINUX_KERNEL)((UINTN)LinuxKernel + 64);
107 LinuxImageSize -= 64;
108 }
109
110 // Check there is no overlapping between kernel and its parameters
111 // We can only assert because it is too late to fallback to UEFI (ExitBootServices has been called).
112 ASSERT (!IS_ADDRESS_IN_REGION (LinuxKernel, LinuxImageSize, KernelParamsAddress) &&
113 !IS_ADDRESS_IN_REGION (LinuxKernel, LinuxImageSize, KernelParamsAddress + KernelParamsSize));
114
115 //
116 // Switch off interrupts, caches, mmu, etc
117 //
118 PreparePlatformHardware ();
119
120 // Register and print out performance information
121 PERF_END (NULL, "BDS", NULL, 0);
122 if (PerformanceMeasurementEnabled ()) {
123 PrintPerformance ();
124 }
125
126 //
127 // Start the Linux Kernel
128 //
129
130 // Outside BootServices, so can't use Print();
131 DEBUG ((EFI_D_ERROR, "\nStarting the kernel:\n\n"));
132
133 // Jump to kernel with register set
134 LinuxKernel ((UINTN)0, MachineType, (UINTN)KernelParamsAddress);
135
136 // Kernel should never exit
137 // After Life services are not provided
138 ASSERT (FALSE);
139 // We cannot recover the execution at this stage
140 while (1);
141 }
142
143 /**
144 Start a Linux kernel from a Device Path
145
146 @param SystemMemoryBase Base of the system memory
147 @param LinuxKernel Device Path to the Linux Kernel
148 @param Parameters Linux kernel arguments
149 @param Fdt Device Path to the Flat Device Tree
150 @param MachineType ARM machine type value
151
152 @retval EFI_SUCCESS All drivers have been connected
153 @retval EFI_NOT_FOUND The Linux kernel Device Path has not been found
154 @retval EFI_OUT_OF_RESOURCES There is not enough resource memory to store the matching results.
155 @retval RETURN_UNSUPPORTED ATAG is not support by this architecture
156
157 **/
158 EFI_STATUS
BootLinuxAtag(IN EFI_PHYSICAL_ADDRESS SystemMemoryBase,IN EFI_DEVICE_PATH_PROTOCOL * LinuxKernelDevicePath,IN EFI_DEVICE_PATH_PROTOCOL * InitrdDevicePath,IN CONST CHAR8 * CommandLineArguments,IN UINTN MachineType)159 BootLinuxAtag (
160 IN EFI_PHYSICAL_ADDRESS SystemMemoryBase,
161 IN EFI_DEVICE_PATH_PROTOCOL* LinuxKernelDevicePath,
162 IN EFI_DEVICE_PATH_PROTOCOL* InitrdDevicePath,
163 IN CONST CHAR8* CommandLineArguments,
164 IN UINTN MachineType
165 )
166 {
167 EFI_STATUS Status;
168 UINT32 LinuxImageSize;
169 UINT32 InitrdImageBaseSize = 0;
170 UINT32 InitrdImageSize = 0;
171 UINT32 AtagSize;
172 EFI_PHYSICAL_ADDRESS AtagBase;
173 EFI_PHYSICAL_ADDRESS LinuxImage;
174 EFI_PHYSICAL_ADDRESS InitrdImageBase = 0;
175 EFI_PHYSICAL_ADDRESS InitrdImage = 0;
176
177 PERF_START (NULL, "BDS", NULL, 0);
178
179 // Load the Linux kernel from a device path
180 LinuxImage = LINUX_KERNEL_MAX_OFFSET;
181 Status = BdsLoadImage (LinuxKernelDevicePath, AllocateMaxAddress, &LinuxImage, &LinuxImageSize);
182 if (EFI_ERROR (Status)) {
183 Print (L"ERROR: Did not find Linux kernel.\n");
184 return Status;
185 }
186
187 if (InitrdDevicePath) {
188 // Load the initrd near to the Linux kernel
189 InitrdImageBase = LINUX_KERNEL_MAX_OFFSET;
190 Status = BdsLoadImage (InitrdDevicePath, AllocateMaxAddress, &InitrdImageBase, &InitrdImageBaseSize);
191 if (Status == EFI_OUT_OF_RESOURCES) {
192 Status = BdsLoadImage (InitrdDevicePath, AllocateAnyPages, &InitrdImageBase, &InitrdImageBaseSize);
193 }
194 if (EFI_ERROR (Status)) {
195 Print (L"ERROR: Did not find initrd image.\n");
196 goto EXIT_FREE_LINUX;
197 }
198
199 // Check if the initrd is a uInitrd
200 if (*(UINT32*)((UINTN)InitrdImageBase) == LINUX_UIMAGE_SIGNATURE) {
201 // Skip the 64-byte image header
202 InitrdImage = (EFI_PHYSICAL_ADDRESS)((UINTN)InitrdImageBase + 64);
203 InitrdImageSize = InitrdImageBaseSize - 64;
204 } else {
205 InitrdImage = InitrdImageBase;
206 InitrdImageSize = InitrdImageBaseSize;
207 }
208 }
209
210 //
211 // Setup the Linux Kernel Parameters
212 //
213
214 // By setting address=0 we leave the memory allocation to the function
215 Status = PrepareAtagList (SystemMemoryBase, CommandLineArguments, InitrdImage, InitrdImageSize, &AtagBase, &AtagSize);
216 if (EFI_ERROR (Status)) {
217 Print (L"ERROR: Can not prepare ATAG list. Status=0x%X\n", Status);
218 goto EXIT_FREE_INITRD;
219 }
220
221 return StartLinux (SystemMemoryBase, LinuxImage, LinuxImageSize, AtagBase, AtagSize, MachineType);
222
223 EXIT_FREE_INITRD:
224 if (InitrdDevicePath) {
225 gBS->FreePages (InitrdImageBase, EFI_SIZE_TO_PAGES (InitrdImageBaseSize));
226 }
227
228 EXIT_FREE_LINUX:
229 gBS->FreePages (LinuxImage, EFI_SIZE_TO_PAGES (LinuxImageSize));
230
231 return Status;
232 }
233
234 /**
235 Start a Linux kernel from a Device Path
236
237 @param LinuxKernelDevicePath Device Path to the Linux Kernel
238 @param InitrdDevicePath Device Path to the Initrd
239 @param CommandLineArguments Linux command line
240
241 @retval EFI_SUCCESS All drivers have been connected
242 @retval EFI_NOT_FOUND The Linux kernel Device Path has not been found
243 @retval EFI_OUT_OF_RESOURCES There is not enough resource memory to store the matching results.
244
245 **/
246 EFI_STATUS
BootLinuxFdt(IN EFI_PHYSICAL_ADDRESS SystemMemoryBase,IN EFI_DEVICE_PATH_PROTOCOL * LinuxKernelDevicePath,IN EFI_DEVICE_PATH_PROTOCOL * InitrdDevicePath,IN EFI_DEVICE_PATH_PROTOCOL * FdtDevicePath,IN CONST CHAR8 * CommandLineArguments)247 BootLinuxFdt (
248 IN EFI_PHYSICAL_ADDRESS SystemMemoryBase,
249 IN EFI_DEVICE_PATH_PROTOCOL* LinuxKernelDevicePath,
250 IN EFI_DEVICE_PATH_PROTOCOL* InitrdDevicePath,
251 IN EFI_DEVICE_PATH_PROTOCOL* FdtDevicePath,
252 IN CONST CHAR8* CommandLineArguments
253 )
254 {
255 EFI_STATUS Status;
256 UINT32 LinuxImageSize;
257 UINT32 InitrdImageBaseSize = 0;
258 UINT32 InitrdImageSize = 0;
259 VOID *InstalledFdtBase;
260 UINT32 FdtBlobSize;
261 EFI_PHYSICAL_ADDRESS FdtBlobBase;
262 EFI_PHYSICAL_ADDRESS LinuxImage;
263 EFI_PHYSICAL_ADDRESS InitrdImageBase = 0;
264 EFI_PHYSICAL_ADDRESS InitrdImage = 0;
265
266 PERF_START (NULL, "BDS", NULL, 0);
267
268 // Load the Linux kernel from a device path
269 LinuxImage = LINUX_KERNEL_MAX_OFFSET;
270 Status = BdsLoadImage (LinuxKernelDevicePath, AllocateMaxAddress, &LinuxImage, &LinuxImageSize);
271 if (EFI_ERROR (Status)) {
272 Print (L"ERROR: Did not find Linux kernel.\n");
273 return Status;
274 }
275
276 if (InitrdDevicePath) {
277 InitrdImageBase = LINUX_KERNEL_MAX_OFFSET;
278 Status = BdsLoadImage (InitrdDevicePath, AllocateMaxAddress, &InitrdImageBase, &InitrdImageBaseSize);
279 if (Status == EFI_OUT_OF_RESOURCES) {
280 Status = BdsLoadImage (InitrdDevicePath, AllocateAnyPages, &InitrdImageBase, &InitrdImageBaseSize);
281 }
282 if (EFI_ERROR (Status)) {
283 Print (L"ERROR: Did not find initrd image.\n");
284 goto EXIT_FREE_LINUX;
285 }
286
287 // Check if the initrd is a uInitrd
288 if (*(UINT32*)((UINTN)InitrdImageBase) == LINUX_UIMAGE_SIGNATURE) {
289 // Skip the 64-byte image header
290 InitrdImage = (EFI_PHYSICAL_ADDRESS)((UINTN)InitrdImageBase + 64);
291 InitrdImageSize = InitrdImageBaseSize - 64;
292 } else {
293 InitrdImage = InitrdImageBase;
294 InitrdImageSize = InitrdImageBaseSize;
295 }
296 }
297
298 if (FdtDevicePath == NULL) {
299 //
300 // Get the FDT from the Configuration Table.
301 // The FDT will be reloaded in PrepareFdt() to a more appropriate
302 // location for the Linux Kernel.
303 //
304 Status = EfiGetSystemConfigurationTable (&gFdtTableGuid, &InstalledFdtBase);
305 if (EFI_ERROR (Status)) {
306 Print (L"ERROR: Did not get the Device Tree blob (%r).\n", Status);
307 goto EXIT_FREE_INITRD;
308 }
309 FdtBlobBase = (EFI_PHYSICAL_ADDRESS)(UINTN)InstalledFdtBase;
310 FdtBlobSize = fdt_totalsize (InstalledFdtBase);
311 } else {
312 //
313 // FDT device path explicitly defined. The FDT is relocated later to a
314 // more appropriate location for the Linux kernel.
315 //
316 FdtBlobBase = LINUX_KERNEL_MAX_OFFSET;
317 Status = BdsLoadImage (FdtDevicePath, AllocateMaxAddress, &FdtBlobBase, &FdtBlobSize);
318 if (EFI_ERROR (Status)) {
319 Print (L"ERROR: Did not find Device Tree blob (%r).\n", Status);
320 goto EXIT_FREE_INITRD;
321 }
322 }
323
324 // Update the Fdt with the Initrd information. The FDT will increase in size.
325 // By setting address=0 we leave the memory allocation to the function
326 Status = PrepareFdt (SystemMemoryBase, CommandLineArguments, InitrdImage, InitrdImageSize, &FdtBlobBase, &FdtBlobSize);
327 if (EFI_ERROR (Status)) {
328 Print (L"ERROR: Can not load kernel with FDT. Status=%r\n", Status);
329 goto EXIT_FREE_FDT;
330 }
331
332 return StartLinux (SystemMemoryBase, LinuxImage, LinuxImageSize, FdtBlobBase, FdtBlobSize, ARM_FDT_MACHINE_TYPE);
333
334 EXIT_FREE_FDT:
335 gBS->FreePages (FdtBlobBase, EFI_SIZE_TO_PAGES (FdtBlobSize));
336
337 EXIT_FREE_INITRD:
338 if (InitrdDevicePath) {
339 gBS->FreePages (InitrdImageBase, EFI_SIZE_TO_PAGES (InitrdImageBaseSize));
340 }
341
342 EXIT_FREE_LINUX:
343 gBS->FreePages (LinuxImage, EFI_SIZE_TO_PAGES (LinuxImageSize));
344
345 return Status;
346 }
347