/** @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; }