Upstream/CloverBootloader
1
0
Fork 0
mirror of https://github.com/CloverHackyColor/CloverBootloader.git synced 2024-12-18 15:27:48 +01:00
Code Issues Packages Projects Releases Wiki Activity
160b9231d7
CloverBootloader/rEFIt_UEFI/Platform/LegacyBoot.cpp

1149 lines
34 KiB
C++
Raw Normal View History

initial commit Clover sources 5061 and modules from EDK2 latest with legacy codes from UDK2018 Signed-off-by: Sergey Isakov <isakov-sl@bk.ru>
2019-09-03 11:58:42 +02:00
/*++
Slice 2011
LegacyBoot.c - support for boot legacy OS such as WindowsXP and Linux
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
Portion from XOM project
Copyright (c) 2006 JLA
*/
#include "Platform.h"
#include "LegacyBiosThunk.h"
#include <Protocol/Bds.h>
#ifndef DEBUG_ALL
#define DEBUG_LBOOT 1
#else
#define DEBUG_LBOOT DEBUG_ALL
#endif
#if DEBUG_LBOOT == 0
#define DBG(...)
#else
#define DBG(...) DebugLog(0, __VA_ARGS__) // until a better solution is found, force DebugLog(0, ...) to prevent saving to DebugLog, which may cause legacy boot to fail
#endif
#pragma pack(push)
#pragma pack(1)
//template
//CONST MBR_PARTITION_INFO tMBR = {0x80, {0xFE, 0xFF, 0xFF}, 0x06, {0xFE, 0xFF, 0xFF}, 0, 0};
CONST MBR_PARTITION_INFO tMBR = {0x80, {0xFE, 0xFF, 0xFF}, 0xEE, {0xFE, 0xFF, 0xFF}, 0, 0};
typedef struct {
UINT8 loader[0x1BE];
MBR_PARTITION_INFO p[4];
UINT16 signature;
} MBR;
typedef struct {
UINT64 signature;
UINT32 revision;
UINT32 headerSize;
UINT32 headerCRC;
UINT32 reserved;
UINT64 myLBA;
UINT64 alternateLBA;
UINT64 firstUsableLBA;
UINT64 lastUsableLBA;
EFI_GUID diskGUID;
UINT64 partitionEntryLBA;
UINT32 numberOfPartitionEntries;
UINT32 sizeOfPartitionEntry;
UINT32 partitionEntryArrayCRC32;
UINT8 filler[4]; //alignment
} GPT_HEADER;
typedef struct {
EFI_GUID partitionType;
EFI_GUID partitionGuid;
UINT64 startingLBA;
UINT64 endingLBA;
UINT64 attributes;
CHAR16 partitionName[72 / 2];
} GPT_ENTRY;
typedef struct Address_t {
UINT32 offset;
UINT16 segment;
UINT8 type;
} Address;
// for BIOS INT 13h AH=42h: Extended Read Sectors From Drive
typedef struct {
UINT8 size; // size of struct = 0x10
UINT8 unused; // should be 0
UINT16 numSectors; // number of sectors
UINT16 buffOffset; // segment and offset to the buffer
UINT16 buffSegment;
UINT64 lba; // LBA of starting sector
} BIOS_DISK_ADDRESS_PACKET;
//located at 0x7F00
CONST UINT8 VideoTest[] = {
0xb8, 0x02, 0x00, //mov ax,2
0xcd, 0x10, //int 0x10
0x66, 0xbb, 0x0f, 0x00, 0x00, 0x00, //mov ebx, 0x0f
0x66, 0xb8, 0x38, 0x0e, 0x00, 0x00, //mov eax, 0x0e38
0x66, 0xb9, 0x10, 0x00, 0x00, 0x00, //mov ecx, 0x10
0xcd, 0x10, //int 0x10
0xed, 0xe4, 0xfc //jmp near 0x7c00
}; //28bytes
#pragma pack(pop)
#define ADDRT_REAL 0 // Segment:Offset (16:16)
#define ADDRT_FLAT 1 // Segment is 0, Offset is 32 bit flat address
EFI_CPU_ARCH_PROTOCOL *mCpu;
EFI_LEGACY_8259_PROTOCOL *gLegacy8259;
THUNK_CONTEXT *mThunkContext = NULL;
UINT8* floppyImage;
EFI_BLOCK_IO* hd82 = NULL;
EFI_BLOCK_IO* hd80 = NULL;
EFI_BLOCK_IO* pCDROMBlockIO = NULL;
EFI_HANDLE hCDROM = NULL;
Address addrRealFromSegOfs(UINT16 segment, UINT16 offset) {
Address address;
address.segment = segment;
address.offset = offset;
address.type = ADDRT_REAL;
return address;
}
Address addrFlatFromOffset(UINT32 offset) {
Address address;
address.segment = 0;
address.offset = offset;
address.type = ADDRT_FLAT;
return address;
}
Address addrNull() {
Address address;
address.type = 0xff;
address.segment = 0;
address.offset = 0;
return address;
}
static UINTN addrPagingEnable;
UINTN addrIsPagingEnabled() {
return addrPagingEnable;
}
void addrEnablePaging(UINTN f) {
addrPagingEnable = f;
}
#define ADDR_FLAT_MAX addrFlatFromOffset(0xFFFFFFFF)
#define ADDR_FLAT_MIN addrFlatFromOffset(0x00000000)
#define ADDR_REAL_MAX addrRealFromSegOfs(0xFFFF, 0xFFFF)
#define ADDR_REAL_MIN addrRealFromSegOfs(0x0000, 0x0000)
#define ADDR_NULL addrNull()
UINT32 addrToOffset(Address address) {
if (address.type == ADDRT_REAL)
return (address.segment << 4) + address.offset;
if (address.type == ADDRT_FLAT)
return addrIsPagingEnabled() ? address.offset & 0x7FFFFFFF : address.offset;
return 0;
}
void* addrToPointer(Address address) {
return (UINT8*)(UINTN)addrToOffset(address);
}
static UINTN addrLT (Address a1, Address a2) { return addrToOffset(a1) < addrToOffset(a2); }
//static UINTN addrLTE(Address a1, Address a2) { return addrToOffset(a1) <= addrToOffset(a2); }
//static UINTN addrGT (Address a1, Address a2) { return addrToOffset(a1) > addrToOffset(a2); }
static UINTN addrGTE(Address a1, Address a2) { return addrToOffset(a1) >= addrToOffset(a2); }
//static UINTN addrEQ (Address a1, Address a2) { return addrToOffset(a1) == addrToOffset(a2); }
Address krnMemoryTop;
/** Reads sectors from given DriveNum with bios into Buffer.
* Requires Dap and Buffer to be allocated in legacy memory region.
*/
EFI_STATUS BiosReadSectorsFromDrive(UINT8 DriveNum, UINT64 Lba, UINTN NumSectors, BIOS_DISK_ADDRESS_PACKET *Dap, void *Buffer)
{
EFI_STATUS Status;
IA32_REGISTER_SET Regs;
// init disk access packet
Dap->size = sizeof(BIOS_DISK_ADDRESS_PACKET);
Dap->unused = 0;
Dap->numSectors = (UINT16)NumSectors;
Dap->buffSegment = (UINT16) (((UINTN) Buffer >> 16) << 12);
Dap->buffOffset = (UINT16) (UINTN) Buffer;
Dap->lba = Lba;
// set registers
use own implementation for CopyMem and SetMem instead of BIOS Signed-off-by: Sergey Isakov <isakov-sl@bk.ru>
2020-02-14 05:15:10 +01:00
SetMem (&Regs, sizeof (Regs), 0);
initial commit Clover sources 5061 and modules from EDK2 latest with legacy codes from UDK2018 Signed-off-by: Sergey Isakov <isakov-sl@bk.ru>
2019-09-03 11:58:42 +02:00
// first reset disk controller as the controller seems to be in an undefined state sometimes
DBG("Reset disk controller: %x\n", DriveNum);
Regs.H.AH = 0x00; // INT 13h AH=00h: Reset disk controller
Regs.H.DL = DriveNum;
Status = EFI_SUCCESS;
if (LegacyBiosInt86(0x13, &Regs)) {
// TRUE = error
DBG("Reset 0 disk controller: %x\n", DriveNum);
Regs.H.AH = 0x0D; // INT 13h AH=00h: Reset disk controller
Regs.H.DL = DriveNum;
if (LegacyBiosInt86(0x13, &Regs)) {
Status = EFI_NOT_FOUND;
DBG("reset controller error\n");
return Status;
}
}
// next, read sector
Regs.H.AH = 0x42; // INT 13h AH=42h: Extended Read Sectors From Drive
Regs.H.DL = DriveNum;
Regs.E.DS = (UINT16) (((UINTN) Dap >> 16) << 12);
Regs.X.SI = (UINT16) (UINTN) Dap;
// DBG("Drive: %x, Dap=%p, Buffer=%p, d.size=%X, d.nsect=%d, d.buff=[%X:%X]\n",
// DriveNum, Dap, Buffer, Dap->size, Dap->numSectors, Dap->buffSegment, Dap->buffOffset);
// DBG("Dap: Reg.DS:SI = [%X:%X]\n", Regs.E.DS, Regs.X.SI);
Status = EFI_SUCCESS;
if (LegacyBiosInt86(0x13, &Regs)) {
// TRUE = error
Regs.H.AH = 0x01; // INT 13h AH=01h: Get Status of Last Drive Operation
LegacyBiosInt86(0x13, &Regs);
Status = EFI_NOT_FOUND;
}
DBG("LegacyBiosInt86 status=%r, AH=%x\n", Status, Regs.H.AH);
return Status;
}
/** Reads first 2 sectors from given DriveNum with bios and calculates DriveCRC32.
* Requires Dap and Buffer to be allocated in legacy memory region.
*/
EFI_STATUS GetBiosDriveCRC32(UINT8 DriveNum,
UINT32 *DriveCRC32,
BIOS_DISK_ADDRESS_PACKET *Dap,
VOID *Buffer)
{
EFI_STATUS Status;
// read first 2 sectors
Status = BiosReadSectorsFromDrive(DriveNum, 0, 2, Dap, Buffer);
if (!EFI_ERROR(Status)) {
Fix void* cast and enum cast (prepa C++)
2019-12-27 18:01:40 +01:00
*DriveCRC32 = GetCrc32((UINT8*)Buffer, 2 * 512);
initial commit Clover sources 5061 and modules from EDK2 latest with legacy codes from UDK2018 Signed-off-by: Sergey Isakov <isakov-sl@bk.ru>
2019-09-03 11:58:42 +02:00
//gBS->CalculateCrc32(Buffer, 2 * 512, DriveCRC32);
DBG("Bios drive CRC32 = 0x%x\n", *DriveCRC32);
}
return Status;
}
/** Scans bios drives 0x80 and up, calculates CRC32 of first 2 sectors and compares it with Volume->DriveCRC32.
* First 2 sectors whould be enough - covers MBR and GPT header with signatures.
* Requires mThunkContext to be initialiyzed already with InitializeBiosIntCaller().
*/
UINT8 GetBiosDriveNumForVolume(REFIT_VOLUME *Volume)
{
EFI_STATUS Status;
UINT8 DriveNum, BestNum;
UINT32 DriveCRC32;
UINT8 *Buffer;
BIOS_DISK_ADDRESS_PACKET *Dap;
UINTN LegacyRegionPages;
EFI_PHYSICAL_ADDRESS LegacyRegion;
// DBG("Expected volume CRC32 = %X\n", Volume->DriveCRC32);
LegacyRegion = 0x0C0000;
LegacyRegionPages = EFI_SIZE_TO_PAGES(sizeof(BIOS_DISK_ADDRESS_PACKET) + 2 * 512)+1 /* dap + 2 sectors */;
Status = gBS->AllocatePages(AllocateMaxAddress,
EfiBootServicesData,
LegacyRegionPages,
&LegacyRegion
);
if (EFI_ERROR(Status)) {
return 0;
}
Dap = (BIOS_DISK_ADDRESS_PACKET *)(UINTN)LegacyRegion;
Buffer = (UINT8 *)(UINTN)(LegacyRegion + 0x200);
//Slice - some CD has BIOS driveNum = 0
// scan drives from 0x80
BestNum = 0;
for (DriveNum = 0x80; DriveNum < 0x88; DriveNum++) {
DriveCRC32 = 0;
Status = GetBiosDriveCRC32(DriveNum, &DriveCRC32, Dap, Buffer);
if (EFI_ERROR(Status)) {
// error or no more disks
//DriveNum = 0;
DBG("Can't get drive 0x%x CRC32\n", DriveNum);
continue;
}
BestNum = DriveNum;
DBG("Calculated CRC=%X at drive 0x%x\n", Volume->DriveCRC32, BestNum);
if (Volume->DriveCRC32 == DriveCRC32) {
break;
}
}
gBS->FreePages(LegacyRegion, LegacyRegionPages);
DBG("Returning Bios drive %X\n", BestNum);
return BestNum;
}
EFI_STATUS bootElTorito(REFIT_VOLUME* volume)
{
EFI_BLOCK_IO* pBlockIO = volume->BlockIO;
Address bootAddress = addrRealFromSegOfs(0x0000, 0x7C00);
UINT8 *sectorBuffer; //[2048];
EFI_STATUS Status = EFI_NOT_FOUND;
UINT64 lba;
UINT16 bootLoadSegment;
Address bootLoadAddress;
UINT32 bootSize;
UINT32 bootSectors;
IA32_REGISTER_SET Regs;
//UINTN LogSize;
Add cast to return value of memory allocation functions (prepa c++)
2019-12-21 01:31:49 +01:00
sectorBuffer = (__typeof__(sectorBuffer))AllocateAlignedPages (EFI_SIZE_TO_PAGES (2048), 64);
initial commit Clover sources 5061 and modules from EDK2 latest with legacy codes from UDK2018 Signed-off-by: Sergey Isakov <isakov-sl@bk.ru>
2019-09-03 11:58:42 +02:00
krnMemoryTop = addrRealFromSegOfs(0xA000, 0x0000);
addrEnablePaging(0);
// No device, no game
if (!pBlockIO) {
DBG("CDROMBoot: No CDROM to boot from\n");
if (sectorBuffer) {
FreePages(sectorBuffer, EFI_SIZE_TO_PAGES (2048));
}
return Status;
}
// Load El Torito boot record volume descriptor
Status = pBlockIO->ReadBlocks(pBlockIO, pBlockIO->Media->MediaId, 0x11, 2048, sectorBuffer);
if (EFI_ERROR(Status)) {
// Retry in case the CD was swapped out
Status = gBS->HandleProtocol(volume->DeviceHandle, &gEfiBlockIoProtocolGuid, (VOID **) &pBlockIO);
if (!EFI_ERROR(Status)) {
// pCDROMBlockIO = pBlockIO;
Status = pBlockIO->ReadBlocks(pBlockIO, pBlockIO->Media->MediaId, 0x11, 2048, sectorBuffer);
}
if (EFI_ERROR(Status)) {
DBG("CDROMBoot: Unable to read block %X: %r\n", 0x11, Status);
return Status;
}
}
if (AsciiStrCmp((CHAR8*)(sectorBuffer + 0x7), "EL TORITO SPECIFICATION")) {
DBG("CDROMBoot: Not an El Torito Specification disk\n");
return Status;
}
// Find the boot catalog
lba = sectorBuffer[0x47] + sectorBuffer[0x48] * 256 + sectorBuffer[0x49] * 65536 + sectorBuffer[0x4A] * 16777216;
Status = pBlockIO->ReadBlocks(pBlockIO, pBlockIO->Media->MediaId, lba, 2048, sectorBuffer);
if (EFI_ERROR(Status)) {
DBG("CDROMBoot: Unable to read block %X: %r\n", lba, Status);
return Status;
}
if (sectorBuffer[0x00] != 1 || sectorBuffer[0x1E] != 0x55 || sectorBuffer[0x1F] != 0xAA) {
DBG("CDROMBoot: Invalid El Torito validation entry in boot catalog LBA %X\n", lba);
// DumpHex(0, 0, 64, sectorBuffer);
return Status;
}
if (sectorBuffer[0x01] != 0) {
DBG("CDROMBoot: Platform mismatch: %d\n", sectorBuffer[0x01]);
return Status;
}
if (sectorBuffer[0x20] != 0x88) {
DBG("CDROMBoot: CD-ROM is not bootable\n");
return Status;
}
if (sectorBuffer[0x21] != 0) {
DBG("CDROMBoot: Currently only non-emulated CDROMs are supported");
return Status;
}
bootLoadSegment = sectorBuffer[0x22] + sectorBuffer[0x23] * 256;
if (!bootLoadSegment)
bootLoadSegment = 0x7C0;
bootSectors = sectorBuffer[0x26] + sectorBuffer[0x27] * 256;
bootSize = bootSectors * pBlockIO->Media->BlockSize;
bootLoadAddress = addrRealFromSegOfs(bootLoadSegment, 0);
if (addrLT(bootLoadAddress, bootAddress) || addrGTE(bootLoadAddress, krnMemoryTop)) {
DBG("CDROMBoot: Illegal boot load address %xL%x\n", addrToOffset(bootLoadAddress), bootSize);
return Status;
}
lba = sectorBuffer[0x28] + sectorBuffer[0x29] * 256 + sectorBuffer[0x2A] * 65536 + sectorBuffer[0x2B] * 16777216;
DBG("CDROMBoot: Booting LBA %ld @%x L%x\n", lba, addrToOffset(bootLoadAddress), bootSize);
gBS->FreePages((EFI_PHYSICAL_ADDRESS)(UINTN)sectorBuffer, 1);
// Read the boot sectors into the boot load address
Status = pBlockIO->ReadBlocks(pBlockIO, pBlockIO->Media->MediaId, lba, bootSize, addrToPointer(bootLoadAddress));
if (EFI_ERROR(Status)) {
DBG("CDROMBoot: Unable to read block %ld: %r\n", lba, Status);
return Status;
}
Status = SaveBooterLog(SelfRootDir, LEGBOOT_LOG);
if (EFI_ERROR(Status)) {
DBG("can't save legacy-boot.log\n");
Status = SaveBooterLog(NULL, LEGBOOT_LOG);
}
/*LogSize = msgCursor - msgbuf;
Status = egSaveFile(SelfRootDir, LEGBOOT_LOG, (UINT8*)msgbuf, LogSize);
if (EFI_ERROR(Status)) {
DBG("can't save legacy-boot.log\n");
Status = egSaveFile(NULL, LEGBOOT_LOG, (UINT8*)msgbuf, LogSize);
}
*/
// Configure drive
// hd82 = pBlockIO;
// Initialize Registers
// CONTEXT->edx = 0x82;
// Boot it
// dbgStart(bootLoadAddress, enableDebugger);
Status = gBS->LocateProtocol(&gEfiLegacy8259ProtocolGuid, NULL, (VOID**)&gLegacy8259);
if (EFI_ERROR(Status)) {
return Status;
}
/* mCpu = NULL;
Status = gBS->LocateProtocol (&gEfiCpuArchProtocolGuid, NULL, (VOID **) &mCpu);
if (EFI_ERROR(Status)) {
return Status;
}
*/
Status = gBS->AllocatePool (EfiBootServicesData,sizeof(THUNK_CONTEXT),(VOID **)&mThunkContext);
if (EFI_ERROR (Status)) {
return Status;
}
Status = InitializeBiosIntCaller(); //mThunkContext);
if (EFI_ERROR (Status)) {
return Status;
}
// InitializeInterruptRedirection(); //gLegacy8259);
// Status = mCpu->EnableInterrupt(mCpu);
Regs.X.DX = 0; //0x82;
// Regs.X.SI = (UINT16)activePartition;
//Regs.X.ES = EFI_SEGMENT((UINT32) pBootSector);
//Regs.X.BX = EFI_OFFSET ((UINT32) pBootSector);
// LegacyBiosFarCall86(0, 0x7c00, &Regs);
LegacyBiosFarCall86(
EFI_SEGMENT((UINT32) addrToOffset(bootLoadAddress)),
EFI_OFFSET ((UINT32) addrToOffset(bootLoadAddress)),
&Regs
);
// Success - Should never get here unless debugger aborts
return Status;
}
EFI_STATUS bootMBR(REFIT_VOLUME* volume)
{
EFI_STATUS Status;
EFI_BLOCK_IO* pDisk = volume->BlockIO;
//UINT8* pMBR = (void*)0x600;
UINT8* pMBR = (UINT8*)(UINTN)0x7C00;
//UINT8* pBootSector = (void*)0x7C00;
//MBR_PARTITION_INFO* activePartition = NULL;
//UINTN partitionIndex;
IA32_REGISTER_SET Regs;
UINTN i, j;
UINT8 BiosDriveNum;
//UINTN LogSize;
use own implementation for CopyMem and SetMem instead of BIOS Signed-off-by: Sergey Isakov <isakov-sl@bk.ru>
2020-02-14 05:15:10 +01:00
SetMem (&Regs, sizeof (Regs), 0);
initial commit Clover sources 5061 and modules from EDK2 latest with legacy codes from UDK2018 Signed-off-by: Sergey Isakov <isakov-sl@bk.ru>
2019-09-03 11:58:42 +02:00
addrEnablePaging(0);
Status = gBS->LocateProtocol(&gEfiLegacy8259ProtocolGuid, NULL, (VOID**)&gLegacy8259);
if (EFI_ERROR(Status)) {
return Status;
}
mCpu = NULL;
Status = gBS->LocateProtocol (&gEfiCpuArchProtocolGuid, NULL, (VOID **) &mCpu);
if (EFI_ERROR(Status)) {
return Status;
}
Status = gBS->AllocatePool (EfiBootServicesData,sizeof(THUNK_CONTEXT),(VOID **)&mThunkContext);
if (EFI_ERROR (Status)) {
return Status;
}
DBG("boot from partition %s\n", FileDevicePathToStr(volume->DevicePath));
Status = InitializeBiosIntCaller(); //mThunkContext);
if (EFI_ERROR (Status)) {
return Status;
}
//InitializeInterruptRedirection(); //gLegacy8259);
//Status = mCpu->EnableInterrupt(mCpu);
// Read the MBR
Status = pDisk->ReadBlocks(pDisk, pDisk->Media->MediaId, 0, 512, pMBR);
if (EFI_ERROR(Status)) {
DBG("HDBoot: Unable to read MBR: %r\n", Status);
return Status;
}
for (i=0; i<16; i++) {
DBG("%04x: ", i*16);
for (j=0; j<16; j++) {
DBG("%02x ", pMBR[i*16+j]);
}
DBG("\n");
}
Status = SaveBooterLog(SelfRootDir, LEGBOOT_LOG);
if (EFI_ERROR(Status)) {
Status = SaveBooterLog(NULL, LEGBOOT_LOG);
}
/*
LogSize = msgCursor - msgbuf;
Status = egSaveFile(SelfRootDir, LEGBOOT_LOG, (UINT8*)msgbuf, LogSize);
if (EFI_ERROR(Status)) {
Status = egSaveFile(NULL, LEGBOOT_LOG, (UINT8*)msgbuf, LogSize);
}
*/
// Check validity of MBR
if (pMBR[510] != 0x55 || pMBR[511] != 0xAA) {
DBG("HDBoot: Invalid MBR signature 0x%02X%02X (not 0xAA55)\n", pMBR[511], pMBR[510]);
Status = EFI_NOT_FOUND;
return Status;
}
BiosDriveNum = GetBiosDriveNumForVolume(volume);
if (BiosDriveNum == 0) {
// not found
DBG("HDBoot: BIOS drive number not found\n");
return EFI_NOT_FOUND;
}
/*
// Traverse partitions
for (partitionIndex = 0; partitionIndex < 4; ++partitionIndex) {
MBR_PARTITION_INFO* partition = (MBR_PARTITION_INFO*)(pMBR + 0x1BE + sizeof(MBR_PARTITION_INFO) * partitionIndex);
// Not the active partition?
if (partition->Flags != 0x80)
continue;
// Is the partition valid?
if (partition->StartLBA == 0 || partition->Size == 0) {
DBG("HDBoot: Invalid active partition %d: (%08X L %08X)\n", partition->StartLBA, partition->Size);
return Status;
}
activePartition = partition;
break;
}
// No active partitions found?
if (!activePartition) {
DBG("HDBoot: No active partitions found.\n");
Status = EFI_NOT_FOUND;
return Status;
}
DBG("HDBoot: Found active partition #%d.\n", partitionIndex);
// Read the boot sector
Status = pDisk->ReadBlocks(pDisk, pDisk->Media->MediaId, activePartition->StartLBA, 512, pBootSector);
if (EFI_ERROR(Status)) {
DBG("HDBoot: Unable to read partition %d's boot sector: %r\n", partitionIndex, Status);
Status = EFI_NOT_FOUND;
return Status;
}
// Check boot sector
if (pBootSector[0x1FE] != 0x55 || pBootSector[0x1FF] != 0xAA) {
DBG("HDBoot: Invalid Boot Sector signature 0x%02X%02X (not 0xAA55)\n", pBootSector[0x1FF], pBootSector[0x1FE]);
Status = EFI_NOT_FOUND;
return Status;
}
DBG("HDBoot: Found valid boot sector on partition #%d. Booting...\n", partitionIndex);
*/
DBG("HDBoot: Booting...\n");
Regs.X.DX = BiosDriveNum;
//Regs.X.SI = (UINT16)(UINTN)activePartition;
LegacyBiosFarCall86(0, 0x7c00, &Regs);
// Success - Should never get here
return EFI_SUCCESS;
}
EFI_STATUS bootPBRtest(REFIT_VOLUME* volume)
{
EFI_STATUS Status = EFI_NOT_FOUND;
EFI_BLOCK_IO* pDisk = volume->BlockIO;
UINT8* pBootSector = (UINT8*)(UINTN)0x7C00;
UINT8* mBootSector;
MBR_PARTITION_INFO* pMBR = (MBR_PARTITION_INFO*)(UINTN)0x7BE;
UINT32 LbaOffset = 0;
UINT32 LbaSize = 0;
HARDDRIVE_DEVICE_PATH *HdPath = NULL;
EFI_DEVICE_PATH_PROTOCOL *DevicePath = volume->DevicePath;
UINT8 BiosDriveNum;
// UINT16 OldMask;
// UINT16 NewMask;
UINTN i, j; //for debug dump
UINT8 *ptr;
// UINT32 MBRCRC32;
//UINTN LogSize;
EFI_ACPI_2_0_FIXED_ACPI_DESCRIPTION_TABLE *FadtPointer = NULL;
EFI_ACPI_4_0_FIRMWARE_ACPI_CONTROL_STRUCTURE *Facs = NULL;
IA32_REGISTER_SET Regs;
use own implementation for CopyMem and SetMem instead of BIOS Signed-off-by: Sergey Isakov <isakov-sl@bk.ru>
2020-02-14 05:15:10 +01:00
SetMem (&Regs, sizeof (Regs), 0);
initial commit Clover sources 5061 and modules from EDK2 latest with legacy codes from UDK2018 Signed-off-by: Sergey Isakov <isakov-sl@bk.ru>
2019-09-03 11:58:42 +02:00
addrEnablePaging(0);
//
// find the partition device path node
//
while (!IsDevicePathEnd (DevicePath)) {
if ((DevicePathType (DevicePath) == MEDIA_DEVICE_PATH) &&
(DevicePathSubType (DevicePath) == MEDIA_HARDDRIVE_DP)) {
HdPath = (HARDDRIVE_DEVICE_PATH *)DevicePath;
break;
}
DevicePath = NextDevicePathNode (DevicePath);
}
if (HdPath != NULL) {
DBG("boot from partition %s\n", FileDevicePathToStr((EFI_DEVICE_PATH *)HdPath));
LbaOffset = (UINT32)HdPath->PartitionStart;
LbaSize = (UINT32)HdPath->PartitionSize;
DBG("starting from 0x%x LBA \n", LbaOffset);
} else {
return Status;
}
Status = gBS->LocateProtocol(&gEfiLegacy8259ProtocolGuid, NULL, (VOID**)&gLegacy8259);
if (EFI_ERROR(Status)) {
return Status;
}
DBG("gEfiLegacy8259ProtocolGuid found\n");
Status = gBS->AllocatePool (EfiBootServicesData,sizeof(THUNK_CONTEXT),(VOID **)&mThunkContext);
if (EFI_ERROR (Status)) {
return Status;
}
Status = InitializeBiosIntCaller(); //mThunkContext);
if (EFI_ERROR (Status)) {
return Status;
}
Add cast to return value of memory allocation functions (prepa c++)
2019-12-21 01:31:49 +01:00
mBootSector = (__typeof__(mBootSector))AllocateAlignedPages(1, 16);
initial commit Clover sources 5061 and modules from EDK2 latest with legacy codes from UDK2018 Signed-off-by: Sergey Isakov <isakov-sl@bk.ru>
2019-09-03 11:58:42 +02:00
Status = pDisk->ReadBlocks(pDisk, pDisk->Media->MediaId, 0, 2*512, mBootSector);
CopyMem(pBootSector, mBootSector, 1024);
DBG("PBR after readDisk:\n");
for (i=0; i<4; i++) {
DBG("%04x: ", i*16);
for (j=0; j<16; j++) {
DBG("%02x ", pBootSector[i*16+j]);
}
DBG("\n");
}
DBG("Reset disk controller 0x80\n");
Status = SaveBooterLog(SelfRootDir, LEGBOOT_LOG);
if (EFI_ERROR(Status)) {
DBG("can't save legacy-boot.log\n");
Status = SaveBooterLog(NULL, LEGBOOT_LOG);
}
//after reset we can't save boot log
Regs.H.AH = 0x0D; // INT 13h AH=00h: Reset floppy disk controller; 0x0D - reset hard disk controller
Regs.H.DL = 0x80;
Status = EFI_SUCCESS;
if (LegacyBiosInt86(0x13, &Regs)) {
// TRUE = error
Status = EFI_NOT_FOUND;
DBG("reset controller 0x80 error\n");
// return Status;
}
BiosDriveNum = GetBiosDriveNumForVolume(volume);
if (BiosDriveNum == 0) {
// not found
DBG("HDBoot: BIOS drive number not found\n");
// BiosDriveNum = 0x80;
// return EFI_NOT_FOUND;
}
//Now I want to start from VideoTest
ptr = (UINT8*)(UINTN)0x7F00;
CopyMem(ptr, &VideoTest[0], 30);
CopyMem(pMBR, &tMBR, 16);
pMBR->StartLBA = LbaOffset;
pMBR->Size = LbaSize;
FadtPointer = GetFadt();
if (FadtPointer == NULL) {
return EFI_NOT_FOUND;
}
Facs = (EFI_ACPI_4_0_FIRMWARE_ACPI_CONTROL_STRUCTURE*)(UINTN)(FadtPointer->FirmwareCtrl);
Facs->FirmwareWakingVector = 0x7F00;
use RT instead of RS Signed-off-by: Sergey Isakov <isakov-sl@bk.ru>
2020-02-16 13:00:20 +01:00
gRT->ResetSystem(EfiResetWarm, EFI_SUCCESS, 0, NULL);
initial commit Clover sources 5061 and modules from EDK2 latest with legacy codes from UDK2018 Signed-off-by: Sergey Isakov <isakov-sl@bk.ru>
2019-09-03 11:58:42 +02:00
/*
Regs.X.DX = BiosDriveNum;
Regs.X.SI = 0x07BE;
//Regs.X.ES = EFI_SEGMENT((UINT32) pBootSector);
//Regs.X.BX = EFI_OFFSET ((UINT32) pBootSector);
LegacyBiosFarCall86(0, 0x7F00, &Regs); //0x7c00
*/
//if not success then save legacyboot.log
Status = SaveBooterLog(SelfRootDir, LEGBOOT_LOG);
if (EFI_ERROR(Status)) {
DBG("can't save legacy-boot.log\n");
/*Status = */SaveBooterLog(NULL, LEGBOOT_LOG);
}
return EFI_SUCCESS;
}
/*
EFI_ACPI_2_0_FIXED_ACPI_DESCRIPTION_TABLE *FadtPointer = GetFadt();
if (FadtPointer == NULL) {
return;
}
Facs = (EFI_ACPI_4_0_FIRMWARE_ACPI_CONTROL_STRUCTURE*)(UINTN)(FadtPointer->FirmwareCtrl);
Facs->FirmwareWakingVector = 0x7F00;
use RT instead of RS Signed-off-by: Sergey Isakov <isakov-sl@bk.ru>
2020-02-16 13:00:20 +01:00
gRT->ResetSystem(EfiResetWarm, EFI_SUCCESS, 0, NULL);
initial commit Clover sources 5061 and modules from EDK2 latest with legacy codes from UDK2018 Signed-off-by: Sergey Isakov <isakov-sl@bk.ru>
2019-09-03 11:58:42 +02:00
*/
#define EFI_CPU_EFLAGS_IF 0x200
/** For BIOS and some UEFI boots.
* Loads partition boot record (PBR) and starts it.
*/
EFI_STATUS bootPBR(REFIT_VOLUME* volume, BOOLEAN SataReset)
{
EFI_STATUS Status;
EFI_BLOCK_IO *pDisk = volume->BlockIO;
UINT8 *pBootSector = (UINT8*)(UINTN)0x7C00;
UINT8 *mBootSector;
UINT32 LbaOffset = 0;
UINT32 LbaSize = 0;
HARDDRIVE_DEVICE_PATH *HdPath = NULL;
EFI_DEVICE_PATH_PROTOCOL *DevicePath = volume->DevicePath;
UINT8 BiosDriveNum;
//UINT16 OldMask;
//UINT16 NewMask;
UINTN i, j; //for debug dump
IA32_REGISTER_SET Regs;
//UINTN LogSize;
EFI_LEGACY_BIOS_PROTOCOL *LegacyBios;
//UINT16 HddCount;
//HDD_INFO *HddInfo = NULL;
UINT16 BbsCount;
BBS_TABLE *BbsTable = NULL;
BBS_TABLE *BbsTableIt = NULL;
Final switch to C++ compiler
2020-02-17 21:41:09 +01:00
CONST CHAR16 *BbsPriorityTxt;
CONST CHAR16 *BbsDevTypeTxt;
initial commit Clover sources 5061 and modules from EDK2 latest with legacy codes from UDK2018 Signed-off-by: Sergey Isakov <isakov-sl@bk.ru>
2019-09-03 11:58:42 +02:00
MBR_PARTITION_INFO *pMBR = (MBR_PARTITION_INFO*)(UINTN)0x11BE; // typical location boot0 installs it, should be unused otherwise...
//
// get EfiLegacy8259Protocol - mandatory
//
Status = gBS->LocateProtocol(&gEfiLegacy8259ProtocolGuid, NULL, (VOID**)&gLegacy8259);
DBG("EfiLegacy8259ProtocolGuid: %r\n", Status);
if (EFI_ERROR(Status)) {
return Status;
}
if (SataReset) {
IoWrite8(0x3F2, 0x0C);
}
//
// get EfiLegacyBiosProtocol - optional
//
Status = gBS->LocateProtocol(&gEfiLegacyBiosProtocolGuid, NULL, (VOID**)&LegacyBios);
DBG("EfiLegacyBiosProtocolGuid: %r\n", Status);
if (!EFI_ERROR(Status)) {
//
// call PrepareToBootEfi() to init BIOS drives
//
//Status = LegacyBios->GetBbsInfo(LegacyBios, &HddCount, &HddInfo, &BbsCount, &BbsTable);
//DBG("GetBbsInfo = %r, HddCnt=%d, HddInfo=%p, BbsCount=%d, BbsTabl%p\n", Status, HddCount, HddInfo, BbsCount, BbsTable);
Status = LegacyBios->PrepareToBootEfi(LegacyBios, &BbsCount, &BbsTable);
DBG("PrepareToBootEfi = %r, BbsCount=%d, BbsTabl%p\n", Status, BbsCount, BbsTable);
//PauseForKey(L"continue ...\n");
//
// debug: dump BbsTable
//
BbsTableIt = BbsTable;
for (i=0; i<BbsCount; i++, BbsTableIt++) {
BbsPriorityTxt = L"";
switch (BbsTableIt->BootPriority) {
case BBS_DO_NOT_BOOT_FROM:
BbsPriorityTxt = L"NOT";
break;
case BBS_LOWEST_PRIORITY:
BbsPriorityTxt = L"LOW";
break;
case BBS_UNPRIORITIZED_ENTRY:
BbsPriorityTxt = L"UNP";
break;
case BBS_IGNORE_ENTRY:
BbsPriorityTxt = L"IGN";
break;
}
BbsDevTypeTxt = L"-";
switch (BbsTableIt->DeviceType) {
case BBS_FLOPPY:
BbsDevTypeTxt = L"FLP";
break;
case BBS_HARDDISK:
BbsDevTypeTxt = L"HDD";
break;
case BBS_CDROM:
BbsDevTypeTxt = L"CDR";
break;
case BBS_PCMCIA:
BbsDevTypeTxt = L"PCM";
break;
case BBS_USB:
BbsDevTypeTxt = L"USB";
break;
case BBS_EMBED_NETWORK:
BbsDevTypeTxt = L"NET";
break;
case BBS_BEV_DEVICE:
BbsDevTypeTxt = L"BEV";
break;
}
DBG("%d: Drv: %x P: %x %s PCI(%x,%x,%x), DT: %x %s SF: %x Txt: '%a'\n",
i, BbsTableIt->AssignedDriveNumber, BbsTableIt->BootPriority, BbsPriorityTxt,
BbsTableIt->Bus, BbsTableIt->Device, BbsTableIt->Function,
BbsTableIt->DeviceType, BbsDevTypeTxt, BbsTableIt->StatusFlags,
(CHAR8*)(UINTN)((BbsTableIt->DescStringSegment << 4) + BbsTableIt->DescStringOffset)
);
}
//PauseForKey(L"continue ...\n");
}
//
// find the partition device path node
//
while (!IsDevicePathEnd (DevicePath)) {
if ((DevicePathType (DevicePath) == MEDIA_DEVICE_PATH) &&
(DevicePathSubType (DevicePath) == MEDIA_HARDDRIVE_DP)) {
HdPath = (HARDDRIVE_DEVICE_PATH *)DevicePath;
break;
}
DevicePath = NextDevicePathNode (DevicePath);
}
if (HdPath != NULL) {
DBG("boot from partition %s\n", FileDevicePathToStr((EFI_DEVICE_PATH *)HdPath));
LbaOffset = (UINT32)HdPath->PartitionStart;
LbaSize = (UINT32)HdPath->PartitionSize;
DBG("starting from 0x%x LBA \n", LbaOffset);
} else {
return Status;
}
//
// prepare ThunkContext for 16bit BIOS calls
//
if (mThunkContext == NULL) {
Status = gBS->AllocatePool (EfiBootServicesData, sizeof(THUNK_CONTEXT), (VOID **)&mThunkContext);
if (EFI_ERROR (Status)) {
return Status;
}
DBG("Thunk allocated\n");
Status = InitializeBiosIntCaller(); //mThunkContext);
if (EFI_ERROR (Status)) {
return Status;
}
}
//
// read partition boot record and copy it to BIOS boot area 0000:07C00
//
Add cast to return value of memory allocation functions (prepa c++)
2019-12-21 01:31:49 +01:00
mBootSector = (__typeof__(mBootSector))AllocatePages(1);
initial commit Clover sources 5061 and modules from EDK2 latest with legacy codes from UDK2018 Signed-off-by: Sergey Isakov <isakov-sl@bk.ru>
2019-09-03 11:58:42 +02:00
Status = pDisk->ReadBlocks(pDisk, pDisk->Media->MediaId, 0, 1*512, mBootSector);
CopyMem(pBootSector, mBootSector, 1*512);
DBG("PBR:\n");
for (i=0; i<4; i++) {
DBG("%04x: ", i*16);
for (j=0; j<16; j++) {
DBG("%02x ", pBootSector[i*16+j]);
}
DBG("\n");
}
//
// find parent disk volume and it's BIOS drive num
// todo: if we managed to get BbsTable, then we may find
// BIOS drive from there, by matching PCI bus, device, function
//
DBG("Looking for parent disk of %s\n", FileDevicePathToStr(volume->DevicePath));
BiosDriveNum = 0;
for (i = 0; i < VolumesCount; i++) {
if (Volumes[i] != volume && Volumes[i]->BlockIO == volume->WholeDiskBlockIO)
{
BiosDriveNum = GetBiosDriveNumForVolume(Volumes[i]);
break;
}
}
if (BiosDriveNum == 0) {
// not found
DBG("HDBoot: BIOS drive number not found, using default 0x80\n");
BiosDriveNum = 0x80;
}
//
// prepare 16bit regs:
// DX = BIOS drive num
//
use own implementation for CopyMem and SetMem instead of BIOS Signed-off-by: Sergey Isakov <isakov-sl@bk.ru>
2020-02-14 05:15:10 +01:00
SetMem (&Regs, sizeof (Regs), 0);
initial commit Clover sources 5061 and modules from EDK2 latest with legacy codes from UDK2018 Signed-off-by: Sergey Isakov <isakov-sl@bk.ru>
2019-09-03 11:58:42 +02:00
Regs.X.DX = BiosDriveNum;
// set up SI to partition table entry, some boot1 boot code (such a boot1f32 and boot1h) depend on it
if (volume->IsMbrPartition) {
CopyMem(pMBR, volume->MbrPartitionTable, 4*16); // copy to lower memory, same location as boot0
Regs.X.SI = (UINT16)(UINTN)&pMBR[volume->MbrPartitionIndex];
}
// apparently gpt without mbr, should this be legacy bootable?
// boot0.s fakes an partition entry, so lets do the same...
else {
CopyMem(pMBR, &tMBR, 16);
pMBR->StartLBA = LbaOffset;
pMBR->Size = LbaSize;
Regs.X.SI = (UINT16)(UINTN)pMBR;
}
DBG("mbr: %x index: %x pointer: %x dx: %x si: %x\n", volume->IsMbrPartition, volume->MbrPartitionIndex, volume->MbrPartitionTable, Regs.X.DX, Regs.X.SI);
DBG("pmbr: %x start: %x size: %x\n", pMBR[volume->MbrPartitionIndex], pMBR[volume->MbrPartitionIndex].StartLBA, pMBR[volume->MbrPartitionIndex].Size);
//
// call 16bit partition boot code
//
//PauseForKey(L"Doing LegacyBiosFarCall86 ...\n");
LegacyBiosFarCall86(0, 0x7c00, &Regs);
//Status = gLegacy8259->SetMask(gLegacy8259, &OldMask, NULL, NULL, NULL);
PauseForKey(L"save legacy-boot.log ...\n");
Status = SaveBooterLog(SelfRootDir, LEGBOOT_LOG);
if (EFI_ERROR(Status)) {
DBG("can't save legacy-boot.log\n");
/*Status = */SaveBooterLog(NULL, LEGBOOT_LOG);
}
return EFI_SUCCESS;
}
/** For DefaultLegacyBios (UEFI)
* Patch BBS Table priorities to allow booting not only from first partition.
*/
static VOID PatchBbsTable(EFI_LEGACY_BIOS_PROTOCOL *LegacyBios, UINT16 BootEntry)
{
UINT16 Idx;
UINT16 IdxCount = 0;
UINT16 Priority = 1;
UINT16 OldPriority;
UINT16 HddCount;
UINT16 BbsCount;
HDD_INFO *LocalHddInfo;
BBS_TABLE *LocalBbsTable;
LegacyBios->GetBbsInfo (
LegacyBios,
&HddCount,
&LocalHddInfo,
&BbsCount,
&LocalBbsTable
);
DBG ("BBS Table of size %d, patching priorities Pold->Pnew:\n", BbsCount);
DBG (" NO: BBS# Pold Pnew bb/dd/ff cl/sc Type Stat segm:offs\n");
DBG (" =====================================================\n");
for (Idx = 0; Idx < BbsCount; Idx++) {
if ((LocalBbsTable[Idx].BootPriority == BBS_IGNORE_ENTRY) ||
(LocalBbsTable[Idx].BootPriority == BBS_DO_NOT_BOOT_FROM) ||
(LocalBbsTable[Idx].BootPriority == BBS_LOWEST_PRIORITY)
) {
continue;
}
OldPriority = LocalBbsTable[Idx].BootPriority;
if (++IdxCount==BootEntry) {
LocalBbsTable[Idx].BootPriority = 0;
} else {
LocalBbsTable[Idx].BootPriority = Priority++;
}
DBG (" %02d: 0x%02x %04x %04x %02x/%02x/%02x %02x/%02x %04x %04x %04x:%04x\n",
(UINTN) IdxCount,
(UINTN) Idx,
(UINTN) OldPriority,
(UINTN) LocalBbsTable[Idx].BootPriority,
(UINTN) LocalBbsTable[Idx].Bus,
(UINTN) LocalBbsTable[Idx].Device,
(UINTN) LocalBbsTable[Idx].Function,
(UINTN) LocalBbsTable[Idx].Class,
(UINTN) LocalBbsTable[Idx].SubClass,
(UINTN) LocalBbsTable[Idx].DeviceType,
(UINTN) * (UINT16 *) &LocalBbsTable[Idx].StatusFlags,
(UINTN) LocalBbsTable[Idx].BootHandlerSegment,
(UINTN) LocalBbsTable[Idx].BootHandlerOffset,
(UINTN) ((LocalBbsTable[Idx].MfgStringSegment << 4) + LocalBbsTable[Idx].MfgStringOffset),
(UINTN) ((LocalBbsTable[Idx].DescStringSegment << 4) + LocalBbsTable[Idx].DescStringOffset)
);
}
}
/** For some UEFI boots that have EfiLegacyBiosProtocol.
* Starts legacy boot from the first BIOS drive.
*/
EFI_STATUS bootLegacyBiosDefault(IN UINT16 LegacyBiosDefaultEntry)
{
EFI_STATUS Status;
EFI_LEGACY_BIOS_PROTOCOL *LegacyBios;
//BBS_BBS_DEVICE_PATH *BbsDPN;
BBS_BBS_DEVICE_PATH *BbsDP = NULL;
//
// get EfiLegacyBiosProtocol - optional
//
Status = gBS->LocateProtocol(&gEfiLegacyBiosProtocolGuid, NULL, (VOID**)&LegacyBios);
DBG("EfiLegacyBiosProtocolGuid: %r\n", Status);
if (EFI_ERROR(Status)) {
return Status;
}
// Patch BBS Table
if (LegacyBiosDefaultEntry > 0) {
PatchBbsTable(LegacyBios, LegacyBiosDefaultEntry);
/*Status = SaveBooterLog(SelfRootDir, LEGBOOT_LOG);
if (EFI_ERROR(Status)) {
DBG("can't save legacy-boot.log\n");
Status = SaveBooterLog(NULL, LEGBOOT_LOG);
}*/
}
/* commented out - it seems it does not have any effect
//
// create BBS device path for HDD
//
// size - size of struct, no additional String
BbsDPN = (BBS_BBS_DEVICE_PATH *) CreateDeviceNode(BBS_DEVICE_PATH, BBS_BBS_DP, sizeof(BBS_BBS_DEVICE_PATH));
BbsDPN->DeviceType = BBS_TYPE_HARDDRIVE; // BBS_TYPE_CDROM;
BbsDPN->StatusFlag = 0;
BbsDPN->String[0] = '\0';
// appends end-of-device-path node and returns complete DP
BbsDP = (BBS_BBS_DEVICE_PATH *) AppendDevicePathNode(NULL, (EFI_DEVICE_PATH_PROTOCOL *) BbsDPN);
FreePool(BbsDPN);
*/
//
// do boot from default MBR hard disk
//
Status = LegacyBios->LegacyBoot(LegacyBios, BbsDP, 0, NULL);
DBG("LegacyBios->LegacyBoot(): %r\n", Status);
return Status;
}
VOID DumpBiosMemoryMap()
{
EFI_STATUS Status;
INT32 i, Length; //for debug dump
UINT64 Start, Size;
IA32_REGISTER_SET Regs;
UINT8* BiosMap = (UINT8*)(UINTN)0x7C00;
use own implementation for CopyMem and SetMem instead of BIOS Signed-off-by: Sergey Isakov <isakov-sl@bk.ru>
2020-02-14 05:15:10 +01:00
SetMem (&Regs, sizeof (Regs), 0);
initial commit Clover sources 5061 and modules from EDK2 latest with legacy codes from UDK2018 Signed-off-by: Sergey Isakov <isakov-sl@bk.ru>
2019-09-03 11:58:42 +02:00
addrEnablePaging(0);
Status = gBS->LocateProtocol(&gEfiLegacy8259ProtocolGuid, NULL, (VOID**)&gLegacy8259);
if (EFI_ERROR(Status)) {
return;
}
DBG("gEfiLegacy8259ProtocolGuid found\n");
Status = gBS->AllocatePool (EfiBootServicesData,sizeof(THUNK_CONTEXT),(VOID **)&mThunkContext);
if (EFI_ERROR (Status)) {
return;
}
Status = InitializeBiosIntCaller(); //mThunkContext);
if (EFI_ERROR (Status)) {
return;
}
Regs.E.EBX = 0;
Regs.E.EDI = 0x7C00;
do {
Regs.X.AX = 0xE820;
Regs.E.EDX = 0x534d4150;
Regs.X.CX = 24;
if (LegacyBiosInt86(0x15, &Regs)) {
DBG("finished by bit C\n");
break;
}
if (Regs.E.EBX == 0) {
DBG("finished by ebx=0\n");
break;
}
Regs.E.EDI += 24;
} while (Regs.E.EDI < 0x8000);
Length = ((INT32)(Regs.E.EDI - 0x7c00)) / 24 + 1;
DBG("BiosMemoryMap length=%d:\n Start End Type Ext\n", Length);
for (i = 0; i < Length; i++) {
Start = *(UINT64*)BiosMap;
Size = *((UINT64*)BiosMap + 1);
DBG(" %08lx %08lx %x %08x\n", Start, Start + Size - 1, *(UINT32*)(BiosMap + 16), *(UINT32*)(BiosMap + 20));
BiosMap += 24;
}
}
Reference in New Issue Copy Permalink