/** @file
Copyright (c) 2011 - 2014, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
#include "LoadLinuxLib.h"
/**
A simple check of the kernel setup image
An assumption is made that the size of the data is at least the
size of struct boot_params.
@param[in] KernelSetup - The kernel setup image
@retval EFI_SUCCESS - The kernel setup looks valid and supported
@retval EFI_INVALID_PARAMETER - KernelSetup was NULL
@retval EFI_UNSUPPORTED - The kernel setup is not valid or supported
**/
STATIC
EFI_STATUS
EFIAPI
BasicKernelSetupCheck (
IN VOID *KernelSetup
)
{
return LoadLinuxCheckKernelSetup(KernelSetup, sizeof (struct boot_params));
}
EFI_STATUS
EFIAPI
LoadLinuxCheckKernelSetup (
IN VOID *KernelSetup,
IN UINTN KernelSetupSize
)
{
struct boot_params *Bp;
if (KernelSetup == NULL) {
return EFI_INVALID_PARAMETER;
}
if (KernelSetupSize < sizeof (*Bp)) {
return EFI_UNSUPPORTED;
}
Bp = (struct boot_params*) KernelSetup;
if ((Bp->hdr.signature != 0xAA55) || // Check boot sector signature
(Bp->hdr.header != SETUP_HDR) ||
(Bp->hdr.version < 0x205) || // We only support relocatable kernels
(!Bp->hdr.relocatable_kernel)
) {
return EFI_UNSUPPORTED;
} else {
return EFI_SUCCESS;
}
}
UINTN
EFIAPI
LoadLinuxGetKernelSize (
IN VOID *KernelSetup,
IN UINTN KernelSize
)
{
struct boot_params *Bp;
if (EFI_ERROR (BasicKernelSetupCheck (KernelSetup))) {
return 0;
}
Bp = (struct boot_params*) KernelSetup;
if (Bp->hdr.version > 0x20a) {
return Bp->hdr.init_size;
} else {
//
// Add extra size for kernel decompression
//
return 3 * KernelSize;
}
}
VOID*
EFIAPI
LoadLinuxAllocateKernelSetupPages (
IN UINTN Pages
)
{
EFI_STATUS Status;
EFI_PHYSICAL_ADDRESS Address;
Address = BASE_1GB;
Status = gBS->AllocatePages (
AllocateMaxAddress,
EfiLoaderData,
Pages,
&Address
);
if (!EFI_ERROR (Status)) {
return (VOID*)(UINTN) Address;
} else {
return NULL;
}
}
EFI_STATUS
EFIAPI
LoadLinuxInitializeKernelSetup (
IN VOID *KernelSetup
)
{
EFI_STATUS Status;
UINTN SetupEnd;
struct boot_params *Bp;
Status = BasicKernelSetupCheck (KernelSetup);
if (EFI_ERROR (Status)) {
return Status;
}
Bp = (struct boot_params*) KernelSetup;
SetupEnd = 0x202 + (Bp->hdr.jump & 0xff);
//
// Clear all but the setup_header
//
ZeroMem (KernelSetup, 0x1f1);
ZeroMem (((UINT8 *)KernelSetup) + SetupEnd, 4096 - SetupEnd);
DEBUG ((EFI_D_INFO, "Cleared kernel setup 0-0x1f1, 0x%Lx-0x1000\n",
(UINT64)SetupEnd));
return EFI_SUCCESS;
}
VOID*
EFIAPI
LoadLinuxAllocateKernelPages (
IN VOID *KernelSetup,
IN UINTN Pages
)
{
EFI_STATUS Status;
EFI_PHYSICAL_ADDRESS KernelAddress;
UINT32 Loop;
struct boot_params *Bp;
if (EFI_ERROR (BasicKernelSetupCheck (KernelSetup))) {
return NULL;
}
Bp = (struct boot_params*) KernelSetup;
for (Loop = 1; Loop < 512; Loop++) {
KernelAddress = MultU64x32 (
2 * Bp->hdr.kernel_alignment,
Loop
);
Status = gBS->AllocatePages (
AllocateAddress,
EfiLoaderData,
Pages,
&KernelAddress
);
if (!EFI_ERROR (Status)) {
return (VOID*)(UINTN) KernelAddress;
}
}
return NULL;
}
VOID*
EFIAPI
LoadLinuxAllocateCommandLinePages (
IN UINTN Pages
)
{
EFI_STATUS Status;
EFI_PHYSICAL_ADDRESS Address;
Address = 0xa0000;
Status = gBS->AllocatePages (
AllocateMaxAddress,
EfiLoaderData,
Pages,
&Address
);
if (!EFI_ERROR (Status)) {
return (VOID*)(UINTN) Address;
} else {
return NULL;
}
}
VOID*
EFIAPI
LoadLinuxAllocateInitrdPages (
IN VOID *KernelSetup,
IN UINTN Pages
)
{
EFI_STATUS Status;
EFI_PHYSICAL_ADDRESS Address;
struct boot_params *Bp;
if (EFI_ERROR (BasicKernelSetupCheck (KernelSetup))) {
return NULL;
}
Bp = (struct boot_params*) KernelSetup;
Address = (EFI_PHYSICAL_ADDRESS)(UINTN) Bp->hdr.ramdisk_max;
Status = gBS->AllocatePages (
AllocateMaxAddress,
EfiLoaderData,
Pages,
&Address
);
if (!EFI_ERROR (Status)) {
return (VOID*)(UINTN) Address;
} else {
return NULL;
}
}
STATIC
VOID
SetupLinuxMemmap (
IN OUT struct boot_params *Bp
)
{
EFI_STATUS Status;
UINT8 TmpMemoryMap[1];
UINTN MapKey;
UINTN DescriptorSize;
UINT32 DescriptorVersion;
UINTN MemoryMapSize;
EFI_MEMORY_DESCRIPTOR *MemoryMap;
EFI_MEMORY_DESCRIPTOR *MemoryMapPtr;
UINTN Index;
struct efi_info *Efi;
struct e820_entry *LastE820;
struct e820_entry *E820;
UINTN E820EntryCount;
EFI_PHYSICAL_ADDRESS LastEndAddr;
//
// Get System MemoryMapSize
//
MemoryMapSize = sizeof (TmpMemoryMap);
Status = gBS->GetMemoryMap (
&MemoryMapSize,
(EFI_MEMORY_DESCRIPTOR *)TmpMemoryMap,
&MapKey,
&DescriptorSize,
&DescriptorVersion
);
ASSERT (Status == EFI_BUFFER_TOO_SMALL);
//
// Enlarge space here, because we will allocate pool now.
//
MemoryMapSize += EFI_PAGE_SIZE;
Status = gBS->AllocatePool (
EfiLoaderData,
MemoryMapSize,
(VOID **) &MemoryMap
);
ASSERT_EFI_ERROR (Status);
//
// Get System MemoryMap
//
Status = gBS->GetMemoryMap (
&MemoryMapSize,
MemoryMap,
&MapKey,
&DescriptorSize,
&DescriptorVersion
);
ASSERT_EFI_ERROR (Status);
LastE820 = NULL;
E820 = &Bp->e820_map[0];
E820EntryCount = 0;
LastEndAddr = 0;
MemoryMapPtr = MemoryMap;
for (Index = 0; Index < (MemoryMapSize / DescriptorSize); Index++) {
UINTN E820Type = 0;
if (MemoryMap->NumberOfPages == 0) {
continue;
}
switch(MemoryMap->Type) {
case EfiReservedMemoryType:
case EfiRuntimeServicesCode:
case EfiRuntimeServicesData:
case EfiMemoryMappedIO:
case EfiMemoryMappedIOPortSpace:
case EfiPalCode:
E820Type = E820_RESERVED;
break;
case EfiUnusableMemory:
E820Type = E820_UNUSABLE;
break;
case EfiACPIReclaimMemory:
E820Type = E820_ACPI;
break;
case EfiLoaderCode:
case EfiLoaderData:
case EfiBootServicesCode:
case EfiBootServicesData:
case EfiConventionalMemory:
E820Type = E820_RAM;
break;
case EfiACPIMemoryNVS:
E820Type = E820_NVS;
break;
default:
DEBUG ((
EFI_D_ERROR,
"Invalid EFI memory descriptor type (0x%x)!\n",
MemoryMap->Type
));
continue;
}
if ((LastE820 != NULL) &&
(LastE820->type == (UINT32) E820Type) &&
(MemoryMap->PhysicalStart == LastEndAddr)) {
LastE820->size += EFI_PAGES_TO_SIZE ((UINTN) MemoryMap->NumberOfPages);
LastEndAddr += EFI_PAGES_TO_SIZE ((UINTN) MemoryMap->NumberOfPages);
} else {
if (E820EntryCount >= ARRAY_SIZE (Bp->e820_map)) {
break;
}
E820->type = (UINT32) E820Type;
E820->addr = MemoryMap->PhysicalStart;
E820->size = EFI_PAGES_TO_SIZE ((UINTN) MemoryMap->NumberOfPages);
LastE820 = E820;
LastEndAddr = E820->addr + E820->size;
E820++;
E820EntryCount++;
}
//
// Get next item
//
MemoryMap = (EFI_MEMORY_DESCRIPTOR *)((UINTN)MemoryMap + DescriptorSize);
}
Bp->e820_entries = (UINT8) E820EntryCount;
Efi = &Bp->efi_info;
Efi->efi_systab = (UINT32)(UINTN) gST;
Efi->efi_memdesc_size = (UINT32) DescriptorSize;
Efi->efi_memdesc_version = DescriptorVersion;
Efi->efi_memmap = (UINT32)(UINTN) MemoryMapPtr;
Efi->efi_memmap_size = (UINT32) MemoryMapSize;
#ifdef MDE_CPU_IA32
Efi->efi_loader_signature = SIGNATURE_32 ('E', 'L', '3', '2');
#else
Efi->efi_systab_hi = (UINT32) (((UINT64)(UINTN) gST) >> 32);
Efi->efi_memmap_hi = (UINT32) (((UINT64)(UINTN) MemoryMapPtr) >> 32);
Efi->efi_loader_signature = SIGNATURE_32 ('E', 'L', '6', '4');
#endif
gBS->ExitBootServices (gImageHandle, MapKey);
}
EFI_STATUS
EFIAPI
LoadLinuxSetCommandLine (
IN OUT VOID *KernelSetup,
IN CHAR8 *CommandLine
)
{
EFI_STATUS Status;
struct boot_params *Bp;
Status = BasicKernelSetupCheck (KernelSetup);
if (EFI_ERROR (Status)) {
return Status;
}
Bp = (struct boot_params*) KernelSetup;
Bp->hdr.cmd_line_ptr = (UINT32)(UINTN) CommandLine;
return EFI_SUCCESS;
}
EFI_STATUS
EFIAPI
LoadLinuxSetInitrd (
IN OUT VOID *KernelSetup,
IN VOID *Initrd,
IN UINTN InitrdSize
)
{
EFI_STATUS Status;
struct boot_params *Bp;
Status = BasicKernelSetupCheck (KernelSetup);
if (EFI_ERROR (Status)) {
return Status;
}
Bp = (struct boot_params*) KernelSetup;
Bp->hdr.ramdisk_start = (UINT32)(UINTN) Initrd;
Bp->hdr.ramdisk_len = (UINT32) InitrdSize;
return EFI_SUCCESS;
}
STATIC VOID
FindBits (
unsigned long Mask,
UINT8 *Pos,
UINT8 *Size
)
{
UINT8 First, Len;
First = 0;
Len = 0;
if (Mask) {
while (!(Mask & 0x1)) {
Mask = Mask >> 1;
First++;
}
while (Mask & 0x1) {
Mask = Mask >> 1;
Len++;
}
}
*Pos = First;
*Size = Len;
}
STATIC
EFI_STATUS
SetupGraphicsFromGop (
struct screen_info *Si,
EFI_GRAPHICS_OUTPUT_PROTOCOL *Gop
)
{
EFI_GRAPHICS_OUTPUT_MODE_INFORMATION *Info;
EFI_STATUS Status;
UINTN Size;
Status = Gop->QueryMode(Gop, Gop->Mode->Mode, &Size, &Info);
if (EFI_ERROR (Status)) {
return Status;
}
/* We found a GOP */
/* EFI framebuffer */
Si->orig_video_isVGA = 0x70;
Si->orig_x = 0;
Si->orig_y = 0;
Si->orig_video_page = 0;
Si->orig_video_mode = 0;
Si->orig_video_cols = 0;
Si->orig_video_lines = 0;
Si->orig_video_ega_bx = 0;
Si->orig_video_points = 0;
Si->lfb_base = (UINT32) Gop->Mode->FrameBufferBase;
Si->lfb_size = (UINT32) Gop->Mode->FrameBufferSize;
Si->lfb_width = (UINT16) Info->HorizontalResolution;
Si->lfb_height = (UINT16) Info->VerticalResolution;
Si->pages = 1;
Si->vesapm_seg = 0;
Si->vesapm_off = 0;
if (Info->PixelFormat == PixelRedGreenBlueReserved8BitPerColor) {
Si->lfb_depth = 32;
Si->red_size = 8;
Si->red_pos = 0;
Si->green_size = 8;
Si->green_pos = 8;
Si->blue_size = 8;
Si->blue_pos = 16;
Si->rsvd_size = 8;
Si->rsvd_pos = 24;
Si->lfb_linelength = (UINT16) (Info->PixelsPerScanLine * 4);
} else if (Info->PixelFormat == PixelBlueGreenRedReserved8BitPerColor) {
Si->lfb_depth = 32;
Si->red_size = 8;
Si->red_pos = 16;
Si->green_size = 8;
Si->green_pos = 8;
Si->blue_size = 8;
Si->blue_pos = 0;
Si->rsvd_size = 8;
Si->rsvd_pos = 24;
Si->lfb_linelength = (UINT16) (Info->PixelsPerScanLine * 4);
} else if (Info->PixelFormat == PixelBitMask) {
FindBits(Info->PixelInformation.RedMask,
&Si->red_pos, &Si->red_size);
FindBits(Info->PixelInformation.GreenMask,
&Si->green_pos, &Si->green_size);
FindBits(Info->PixelInformation.BlueMask,
&Si->blue_pos, &Si->blue_size);
FindBits(Info->PixelInformation.ReservedMask,
&Si->rsvd_pos, &Si->rsvd_size);
Si->lfb_depth = Si->red_size + Si->green_size +
Si->blue_size + Si->rsvd_size;
Si->lfb_linelength = (UINT16) ((Info->PixelsPerScanLine * Si->lfb_depth) / 8);
} else {
Si->lfb_depth = 4;
Si->red_size = 0;
Si->red_pos = 0;
Si->green_size = 0;
Si->green_pos = 0;
Si->blue_size = 0;
Si->blue_pos = 0;
Si->rsvd_size = 0;
Si->rsvd_pos = 0;
Si->lfb_linelength = Si->lfb_width / 2;
}
return Status;
}
STATIC
EFI_STATUS
SetupGraphics (
IN OUT struct boot_params *Bp
)
{
EFI_STATUS Status;
EFI_HANDLE *HandleBuffer;
UINTN HandleCount;
UINTN Index;
EFI_GRAPHICS_OUTPUT_PROTOCOL *Gop;
ZeroMem ((VOID*)&Bp->screen_info, sizeof(Bp->screen_info));
Status = gBS->LocateHandleBuffer (
ByProtocol,
&gEfiGraphicsOutputProtocolGuid,
NULL,
&HandleCount,
&HandleBuffer
);
if (!EFI_ERROR (Status)) {
for (Index = 0; Index < HandleCount; Index++) {
Status = gBS->HandleProtocol (
HandleBuffer[Index],
&gEfiGraphicsOutputProtocolGuid,
(VOID*) &Gop
);
if (EFI_ERROR (Status)) {
continue;
}
Status = SetupGraphicsFromGop (&Bp->screen_info, Gop);
if (!EFI_ERROR (Status)) {
FreePool (HandleBuffer);
return EFI_SUCCESS;
}
}
FreePool (HandleBuffer);
}
return EFI_NOT_FOUND;
}
STATIC
EFI_STATUS
SetupLinuxBootParams (
IN OUT struct boot_params *Bp
)
{
SetupGraphics (Bp);
SetupLinuxMemmap (Bp);
return EFI_SUCCESS;
}
EFI_STATUS
EFIAPI
LoadLinux (
IN VOID *Kernel,
IN OUT VOID *KernelSetup
)
{
EFI_STATUS Status;
struct boot_params *Bp;
Status = BasicKernelSetupCheck (KernelSetup);
if (EFI_ERROR (Status)) {
return Status;
}
Bp = (struct boot_params *) KernelSetup;
if (Bp->hdr.version < 0x205 || !Bp->hdr.relocatable_kernel) {
//
// We only support relocatable kernels
//
return EFI_UNSUPPORTED;
}
InitLinuxDescriptorTables ();
Bp->hdr.code32_start = (UINT32)(UINTN) Kernel;
if (Bp->hdr.version >= 0x20c && Bp->hdr.handover_offset &&
(Bp->hdr.xloadflags & (sizeof (UINTN) == 4 ? BIT2 : BIT3))) {
DEBUG ((EFI_D_INFO, "Jumping to kernel EFI handover point at ofs %x\n", Bp->hdr.handover_offset));
DisableInterrupts ();
JumpToUefiKernel ((VOID*) gImageHandle, (VOID*) gST, KernelSetup, Kernel);
}
//
// Old kernels without EFI handover protocol
//
SetupLinuxBootParams (KernelSetup);
DEBUG ((EFI_D_INFO, "Jumping to kernel\n"));
DisableInterrupts ();
SetLinuxDescriptorTables ();
JumpToKernel (Kernel, (VOID*) KernelSetup);
return EFI_SUCCESS;
}