Upstream/CloverBootloader
1
0
Fork 0
mirror of https://github.com/CloverHackyColor/CloverBootloader.git synced 2024-12-27 16:58:09 +01:00
Code Issues Packages Projects Releases Wiki Activity
09bf1901e4
CloverBootloader/LegacyBios/BlockIoDxe/BiosInt13.c
Sergey Isakov 7c0aa811ec 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 12:58:42 +03:00

2553 lines
82 KiB
C
Raw Blame History

/** @file
Routines that use BIOS to support INT 13 devices.
Copyright (c) 1999 - 2010, 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 "BiosBlkIo.h"
#ifndef DEBUG_ALL
#define DEBUG_BI 1
#else
#define DEBUG_BI DEBUG_ALL
#endif
#if DEBUG_BI==0
#define DBG(...)
#elif DEBUG_BI == 1
#define DBG(...) MemLog(TRUE, 1, __VA_ARGS__)
#else
#define DBG(...) MemLog(TRUE, 0, __VA_ARGS__)
#endif
//
// Module global variables
//
//
// Address packet is a buffer under 1 MB for all version EDD calls
//
extern EDD_DEVICE_ADDRESS_PACKET *mEddBufferUnder1Mb;
//
// This is a buffer for INT 13h func 48 information
//
extern BIOS_LEGACY_DRIVE *mLegacyDriverUnder1Mb;
//
// Buffer of 0xFE00 bytes for EDD 1.1 transfer must be under 1 MB
// 0xFE00 bytes is the max transfer size supported.
//
extern VOID *mEdd11Buffer;
/**
Initialize block I/O device instance
@param Dev Instance of block I/O device instance
@retval TRUE Initialization succeeds.
@retval FALSE Initialization fails.
**/
BOOLEAN
BiosInitBlockIo (
IN BIOS_BLOCK_IO_DEV *Dev
)
{
EFI_BLOCK_IO_PROTOCOL *BlockIo;
EFI_BLOCK_IO2_PROTOCOL *BlockIo2;
EFI_BLOCK_IO_MEDIA *BlockMedia;
BIOS_LEGACY_DRIVE *Bios;
BlockIo = &Dev->BlockIo;
BlockIo2 = &Dev->BlockIo2;
BlockIo2->Media = &Dev->BlockMedia;
BlockIo->Media = &Dev->BlockMedia;
BlockMedia = BlockIo->Media;
Bios = &Dev->Bios;
if (Int13GetDeviceParameters (Dev, Bios) != 0) {
if (Int13Extensions (Dev, Bios) != 0) {
BlockMedia->LastBlock = (EFI_LBA) Bios->Parameters.PhysicalSectors - 1;
BlockMedia->BlockSize = (UINT32) Bios->Parameters.BytesPerSector;
if ((Bios->Parameters.Flags & EDD_DEVICE_REMOVABLE) == EDD_DEVICE_REMOVABLE) {
BlockMedia->RemovableMedia = TRUE;
}
} else {
//
// Legacy Interfaces
//
BlockMedia->BlockSize = 512;
BlockMedia->LastBlock = (Bios->MaxHead + 1) * Bios->MaxSector * (Bios->MaxCylinder + 1) - 1;
}
DBG("BlockSize = %d LastBlock = %d\n", BlockMedia->BlockSize, BlockMedia->LastBlock);
BlockMedia->LogicalPartition = FALSE;
BlockMedia->WriteCaching = FALSE;
//
// BugBug: Need to set this for removable media devices if they do not
// have media present
//
BlockMedia->ReadOnly = FALSE;
BlockMedia->MediaPresent = TRUE;
BlockIo->Reset = BiosBlockIoReset;
BlockIo->FlushBlocks = BiosBlockIoFlushBlocks;
BlockIo2->Reset = BiosBlockIoReset2;
BlockIo2->FlushBlocksEx = BiosBlockIoFlushBlocksEx;
if (!Bios->ExtendedInt13) {
//
// Legacy interfaces
//
BlockIo->ReadBlocks = BiosReadLegacyDrive;
BlockIo->WriteBlocks = BiosWriteLegacyDrive;
BlockIo2->ReadBlocksEx = BiosReadLegacyDriveEx;
BlockIo2->WriteBlocksEx = BiosWriteLegacyDriveEx;
} else if ((Bios->EddVersion == EDD_VERSION_30) && (Bios->Extensions64Bit)) {
//
// EDD 3.0 Required for Device path, but extended reads are not required.
//
BlockIo->ReadBlocks = Edd30BiosReadBlocks;
BlockIo->WriteBlocks = Edd30BiosWriteBlocks;
BlockIo2->ReadBlocksEx = Edd30BiosReadBlocksEx;
BlockIo2->WriteBlocksEx = Edd30BiosWriteBlocksEx;
} else {
//
// Assume EDD 1.1 - Read and Write functions.
// This could be EDD 3.0 without Extensions64Bit being set.
// If it's EDD 1.1 this will work, but the device path will not
// be correct. This will cause confusion to EFI OS installation.
//
BlockIo->ReadBlocks = Edd11BiosReadBlocks;
BlockIo->WriteBlocks = Edd11BiosWriteBlocks;
BlockIo2->ReadBlocksEx = Edd11BiosReadBlocksEx;
BlockIo2->WriteBlocksEx = Edd11BiosWriteBlocksEx;
}
BlockMedia->LogicalPartition = FALSE;
BlockMedia->WriteCaching = FALSE;
return TRUE;
}
return FALSE;
}
/**
Gets parameters of block I/O device.
@param BiosBlockIoDev Instance of block I/O device.
@param Drive Legacy drive.
@return Result of device parameter retrieval.
**/
UINTN
Int13GetDeviceParameters (
IN BIOS_BLOCK_IO_DEV *BiosBlockIoDev,
IN BIOS_LEGACY_DRIVE *Drive
)
{
UINTN CarryFlag;
UINT16 Cylinder;
IA32_REGISTER_SET Regs;
ZeroMem (&Regs, sizeof (IA32_REGISTER_SET));
Regs.H.AH = 0x08;
Regs.H.DL = Drive->Number;
// CarryFlag = BiosBlockIoDev->LegacyBios->Int86 (BiosBlockIoDev->LegacyBios, 0x13, &Regs);
CarryFlag = LegacyBiosInt86 (BiosBlockIoDev, 0x13, &Regs);
// DBG("Int13GetDeviceParameters: INT 13 08 DL=%02x : CF=%d AH=%02x\n", Drive->Number, CarryFlag, Regs.H.AH);
if (CarryFlag != 0 || Regs.H.AH != 0x00) {
Drive->ErrorCode = Regs.H.AH;
return FALSE;
}
if (Drive->Floppy) {
if (Regs.H.BL == 0x10) {
Drive->AtapiFloppy = TRUE;
} else {
Drive->MaxHead = Regs.H.DH;
Drive->MaxSector = Regs.H.CL;
Drive->MaxCylinder = Regs.H.CH;
if (Drive->MaxSector == 0) {
//
// BugBug: You can not trust the Carry flag.
//
return FALSE;
}
}
} else {
Drive->MaxHead = (UINT8) (Regs.H.DH & 0x3f);
Cylinder = (UINT16) (((UINT16) Regs.H.DH & 0xc0) << 4);
Cylinder = (UINT16) (Cylinder | ((UINT16) Regs.H.CL & 0xc0) << 2);
Drive->MaxCylinder = (UINT16) (Cylinder + Regs.H.CH);
Drive->MaxSector = (UINT8) (Regs.H.CL & 0x3f);
}
return TRUE;
}
/**
Extension of INT13 call.
@param BiosBlockIoDev Instance of block I/O device.
@param Drive Legacy drive.
@return Result of this extension.
**/
UINTN
Int13Extensions (
IN BIOS_BLOCK_IO_DEV *BiosBlockIoDev,
IN BIOS_LEGACY_DRIVE *Drive
)
{
INTN CarryFlag;
IA32_REGISTER_SET Regs;
ZeroMem (&Regs, sizeof (IA32_REGISTER_SET));
Regs.H.AH = 0x41;
Regs.X.BX = 0x55aa;
Regs.H.DL = Drive->Number;
// CarryFlag = BiosBlockIoDev->LegacyBios->Int86 (BiosBlockIoDev->LegacyBios, 0x13, &Regs);
CarryFlag = LegacyBiosInt86 (BiosBlockIoDev, 0x13, &Regs);
DBG( "Int13Extensions: INT 13 41 DL=%02x : CF=%d BX=%04x CX=%04x\n",
Drive->Number, CarryFlag, Regs.X.BX, Regs.X.CX);
if (CarryFlag != 0 || Regs.X.BX != 0xaa55) {
Drive->ExtendedInt13 = FALSE;
Drive->DriveLockingAndEjecting = FALSE;
Drive->Edd = FALSE;
return FALSE;
}
Drive->EddVersion = Regs.H.AH;
Drive->ExtendedInt13 = (BOOLEAN) ((Regs.X.CX & 0x01) == 0x01);
Drive->DriveLockingAndEjecting = (BOOLEAN) ((Regs.X.CX & 0x02) == 0x02);
Drive->Edd = (BOOLEAN) ((Regs.X.CX & 0x04) == 0x04);
Drive->Extensions64Bit = (BOOLEAN) (Regs.X.CX & 0x08);
Drive->ParametersValid = (UINT8) GetDriveParameters (BiosBlockIoDev, Drive);
return TRUE;
}
/**
Gets parameters of legacy drive.
@param BiosBlockIoDev Instance of block I/O device.
@param Drive Legacy drive.
@return Result of drive parameter retrieval.
**/
UINTN
GetDriveParameters (
IN BIOS_BLOCK_IO_DEV *BiosBlockIoDev,
IN BIOS_LEGACY_DRIVE *Drive
)
{
INTN CarryFlag;
IA32_REGISTER_SET Regs;
UINTN PointerMath;
ZeroMem (&Regs, sizeof (IA32_REGISTER_SET));
Regs.H.AH = 0x48;
Regs.H.DL = Drive->Number;
//
// EDD Buffer must be passed in with max buffer size as first entry in the buffer
//
mLegacyDriverUnder1Mb->Parameters.StructureSize = (UINT16) sizeof (EDD_DRIVE_PARAMETERS);
Regs.E.DS = EFI_SEGMENT ((UINTN)(&mLegacyDriverUnder1Mb->Parameters));
Regs.X.SI = EFI_OFFSET ((UINTN)(&mLegacyDriverUnder1Mb->Parameters));
// CarryFlag = BiosBlockIoDev->LegacyBios->Int86 (BiosBlockIoDev->LegacyBios, 0x13, &Regs);
CarryFlag = LegacyBiosInt86 (BiosBlockIoDev, 0x13, &Regs);
DBG( "GetDriveParameters: INT 13 48 DL=%02x : CF=%d AH=%02x\n", Drive->Number, CarryFlag, Regs.H.AH);
if (CarryFlag != 0 || Regs.H.AH != 0x00) {
Drive->ErrorCode = Regs.H.AH;
SetMem (&Drive->Parameters, sizeof (Drive->Parameters), 0xaf);
return FALSE;
}
//
// We only have one buffer < 1MB, so copy into our instance data
//
CopyMem (
&Drive->Parameters,
&mLegacyDriverUnder1Mb->Parameters,
sizeof (Drive->Parameters)
);
if (Drive->AtapiFloppy) {
//
// Sense Media Type
//
Regs.H.AH = 0x20;
Regs.H.DL = Drive->Number;
// CarryFlag = BiosBlockIoDev->LegacyBios->Int86 (BiosBlockIoDev->LegacyBios, 0x13, &Regs);
CarryFlag = LegacyBiosInt86 (BiosBlockIoDev, 0x13, &Regs);
DBG( "GetDriveParameters: INT 13 20 DL=%02x : CF=%d AL=%02x\n", Drive->Number, CarryFlag, Regs.H.AL);
if (CarryFlag != 0) {
//
// Media not present or unknown media present
//
if ((Drive->Parameters.Flags & EDD_GEOMETRY_VALID) == EDD_GEOMETRY_VALID) {
Drive->MaxHead = (UINT8) (Drive->Parameters.MaxHeads - 1);
Drive->MaxSector = (UINT8) Drive->Parameters.SectorsPerTrack;
ASSERT (Drive->MaxSector != 0);
Drive->MaxCylinder = (UINT16) (Drive->Parameters.MaxCylinders - 1);
} else {
Drive->MaxHead = 0;
Drive->MaxSector = 1;
Drive->MaxCylinder = 0;
}
} else {
//
// Media Present
//
switch (Regs.H.AL) {
case 0x03:
//
// 720 KB
//
Drive->MaxHead = 1;
Drive->MaxSector = 9;
Drive->MaxCylinder = 79;
break;
case 0x04:
//
// 1.44MB
//
Drive->MaxHead = 1;
Drive->MaxSector = 18;
Drive->MaxCylinder = 79;
break;
case 0x06:
//
// 2.88MB
//
Drive->MaxHead = 1;
Drive->MaxSector = 36;
Drive->MaxCylinder = 79;
break;
case 0x0C:
//
// 360 KB
//
Drive->MaxHead = 1;
Drive->MaxSector = 9;
Drive->MaxCylinder = 39;
break;
case 0x0D:
//
// 1.2 MB
//
Drive->MaxHead = 1;
Drive->MaxSector = 15;
Drive->MaxCylinder = 79;
break;
case 0x0E:
//
// Toshiba 3 mode
//
case 0x0F:
//
// NEC 3 mode
//
case 0x10:
//
// Default Media
//
if ((Drive->Parameters.Flags & EDD_GEOMETRY_VALID) == EDD_GEOMETRY_VALID) {
Drive->MaxHead = (UINT8) (Drive->Parameters.MaxHeads - 1);
Drive->MaxSector = (UINT8) Drive->Parameters.SectorsPerTrack;
ASSERT (Drive->MaxSector != 0);
Drive->MaxCylinder = (UINT16) (Drive->Parameters.MaxCylinders - 1);
} else {
Drive->MaxHead = 0;
Drive->MaxSector = 1;
Drive->MaxCylinder = 0;
}
break;
default:
//
// Unknown media type.
//
Drive->MaxHead = 0;
Drive->MaxSector = 1;
Drive->MaxCylinder = 0;
break;
}
}
Drive->Parameters.PhysicalSectors = (Drive->MaxHead + 1) * Drive->MaxSector * (Drive->MaxCylinder + 1);
Drive->Parameters.BytesPerSector = 512;
}
//
// This data comes from the BIOS so it may not allways be valid
// since the BIOS may reuse this buffer for future accesses
//
PointerMath = EFI_SEGMENT (Drive->Parameters.Fdpt) << 4;
PointerMath += EFI_OFFSET (Drive->Parameters.Fdpt);
Drive->FdptPointer = (VOID *) PointerMath;
return TRUE;
}
//
// Block IO Routines
//
/**
Read BufferSize bytes from Lba into Buffer.
@param This Indicates a pointer to the calling context.
@param MediaId Id of the media, changes every time the media is replaced.
@param Lba The starting Logical Block Address to read from
@param BufferSize Size of Buffer, must be a multiple of device block size.
@param Buffer A pointer to the destination buffer for the data. The caller is
responsible for either having implicit or explicit ownership of the buffer.
@retval EFI_SUCCESS The data was read correctly from the device.
@retval EFI_DEVICE_ERROR The device reported an error while performing the read.
@retval EFI_NO_MEDIA There is no media in the device.
@retval EFI_MEDIA_CHANGED The MediaId does not matched the current device.
@retval EFI_BAD_BUFFER_SIZE The Buffer was not a multiple of the block size of the device.
@retval EFI_INVALID_PARAMETER The read request contains LBAs that are not valid,
or the buffer is not on proper alignment.
**/
EFI_STATUS
EFIAPI
Edd30BiosReadBlocks (
IN EFI_BLOCK_IO_PROTOCOL *This,
IN UINT32 MediaId,
IN EFI_LBA Lba,
IN UINTN BufferSize,
OUT VOID *Buffer
)
{
EFI_BLOCK_IO_MEDIA *Media;
BIOS_BLOCK_IO_DEV *BiosBlockIoDev;
EDD_DEVICE_ADDRESS_PACKET *AddressPacket;
//
// I exist only for readability
//
IA32_REGISTER_SET Regs;
UINT64 TransferBuffer;
UINTN NumberOfBlocks;
UINTN TransferByteSize;
UINTN BlockSize;
BIOS_LEGACY_DRIVE *Bios;
UINTN CarryFlag;
UINTN MaxTransferBlocks;
EFI_BLOCK_IO_PROTOCOL *BlockIo;
Media = This->Media;
BlockSize = Media->BlockSize;
if (!BlockSize) {
return EFI_NO_MEDIA;
}
ZeroMem (&Regs, sizeof (IA32_REGISTER_SET));
if (MediaId != Media->MediaId) {
return EFI_MEDIA_CHANGED;
}
if (Lba > Media->LastBlock) {
return EFI_INVALID_PARAMETER;
}
if ((Lba + (BufferSize / BlockSize) - 1) > Media->LastBlock) {
return EFI_INVALID_PARAMETER;
}
if (BufferSize % BlockSize != 0) {
return EFI_BAD_BUFFER_SIZE;
}
if (Buffer == NULL) {
return EFI_INVALID_PARAMETER;
}
if (BufferSize == 0) {
return EFI_SUCCESS;
}
BiosBlockIoDev = BIOS_BLOCK_IO_FROM_THIS (This);
if (BiosBlockIoDev->Bios.ErrorCode == BIOS_SECTOR_NOT_FOUND || BiosBlockIoDev->Bios.ErrorCode == BIOS_DRIVE_DOES_NOT_EXIST) {
return EFI_DEVICE_ERROR;
}
AddressPacket = mEddBufferUnder1Mb;
MaxTransferBlocks = MAX_EDD11_XFER / BlockSize;
TransferBuffer = (UINT64)(UINTN) Buffer;
for (; BufferSize > 0;) {
NumberOfBlocks = BufferSize / BlockSize;
NumberOfBlocks = NumberOfBlocks > MaxTransferBlocks ? MaxTransferBlocks : NumberOfBlocks;
//
// Max transfer MaxTransferBlocks
//
AddressPacket->PacketSizeInBytes = (UINT8) sizeof (EDD_DEVICE_ADDRESS_PACKET);
AddressPacket->Zero = 0;
AddressPacket->NumberOfBlocks = (UINT8) NumberOfBlocks;
AddressPacket->Zero2 = 0;
AddressPacket->SegOffset = 0xffffffff;
AddressPacket->Lba = (UINT64) Lba;
AddressPacket->TransferBuffer = TransferBuffer;
Regs.H.AH = 0x42;
Regs.H.DL = BiosBlockIoDev->Bios.Number;
Regs.X.SI = EFI_OFFSET (AddressPacket);
Regs.E.DS = EFI_SEGMENT (AddressPacket);
// CarryFlag = BiosBlockIoDev->LegacyBios->Int86 (BiosBlockIoDev->LegacyBios, 0x13, &Regs);
CarryFlag = LegacyBiosInt86 (BiosBlockIoDev, 0x13, &Regs);
// DBG( "Edd30BiosReadBlocks: INT 13 42 DL=%02x : CF=%d AH=%02x\n",
// BiosBlockIoDev->Bios.Number, CarryFlag, Regs.H.AH);
Media->MediaPresent = TRUE;
if (CarryFlag != 0) {
//
// Return Error Status
//
BiosBlockIoDev->Bios.ErrorCode = Regs.H.AH;
if (BiosBlockIoDev->Bios.ErrorCode == BIOS_DISK_CHANGED) {
Media->MediaId++;
Bios = &BiosBlockIoDev->Bios;
if (Int13GetDeviceParameters (BiosBlockIoDev, Bios) != 0) {
if (Int13Extensions (BiosBlockIoDev, Bios) != 0) {
Media->LastBlock = (EFI_LBA) Bios->Parameters.PhysicalSectors - 1;
Media->BlockSize = (UINT32) Bios->Parameters.BytesPerSector;
}
/*else {
ASSERT (FALSE);
} */
Media->ReadOnly = FALSE;
gBS->HandleProtocol (BiosBlockIoDev->Handle, &gEfiBlockIoProtocolGuid, (VOID **) &BlockIo);
gBS->ReinstallProtocolInterface (BiosBlockIoDev->Handle, &gEfiBlockIoProtocolGuid, BlockIo, BlockIo);
return EFI_MEDIA_CHANGED;
}
}
if (Media->RemovableMedia) {
Media->MediaPresent = FALSE;
}
return EFI_DEVICE_ERROR;
}
TransferByteSize = NumberOfBlocks * BlockSize;
BufferSize = BufferSize - TransferByteSize;
TransferBuffer += TransferByteSize;
Lba += NumberOfBlocks;
}
return EFI_SUCCESS;
}
EFI_STATUS
EFIAPI
Edd30BiosReadBlocksEx (
IN EFI_BLOCK_IO2_PROTOCOL *This,
IN UINT32 MediaId,
IN EFI_LBA Lba,
IN OUT EFI_BLOCK_IO2_TOKEN *Token,
IN UINTN BufferSize,
OUT VOID *Buffer
)
{
EFI_BLOCK_IO_MEDIA *Media;
BIOS_BLOCK_IO_DEV *BiosBlockIoDev;
EDD_DEVICE_ADDRESS_PACKET *AddressPacket;
//
// I exist only for readability
//
IA32_REGISTER_SET Regs;
UINT64 TransferBuffer;
UINTN NumberOfBlocks;
UINTN TransferByteSize;
UINTN BlockSize;
BIOS_LEGACY_DRIVE *Bios;
UINTN CarryFlag;
UINTN MaxTransferBlocks;
EFI_BLOCK_IO2_PROTOCOL *BlockIo2;
Media = This->Media;
BlockSize = Media->BlockSize;
if (!BlockSize) {
return EFI_NO_MEDIA;
}
ZeroMem (&Regs, sizeof (IA32_REGISTER_SET));
if (MediaId != Media->MediaId) {
return EFI_MEDIA_CHANGED;
}
if (Lba > Media->LastBlock) {
return EFI_INVALID_PARAMETER;
}
if ((Lba + (BufferSize / BlockSize) - 1) > Media->LastBlock) {
return EFI_INVALID_PARAMETER;
}
if (BufferSize % BlockSize != 0) {
return EFI_BAD_BUFFER_SIZE;
}
if (Buffer == NULL) {
return EFI_INVALID_PARAMETER;
}
if (BufferSize == 0) {
return EFI_SUCCESS;
}
BiosBlockIoDev = BIOS_BLOCK_IO2_FROM_THIS (This);
if (BiosBlockIoDev->Bios.ErrorCode == BIOS_SECTOR_NOT_FOUND || BiosBlockIoDev->Bios.ErrorCode == BIOS_DRIVE_DOES_NOT_EXIST) {
return EFI_DEVICE_ERROR;
}
AddressPacket = mEddBufferUnder1Mb;
MaxTransferBlocks = MAX_EDD11_XFER / BlockSize;
TransferBuffer = (UINT64)(UINTN) Buffer;
for (; BufferSize > 0;) {
NumberOfBlocks = BufferSize / BlockSize;
NumberOfBlocks = NumberOfBlocks > MaxTransferBlocks ? MaxTransferBlocks : NumberOfBlocks;
//
// Max transfer MaxTransferBlocks
//
AddressPacket->PacketSizeInBytes = (UINT8) sizeof (EDD_DEVICE_ADDRESS_PACKET);
AddressPacket->Zero = 0;
AddressPacket->NumberOfBlocks = (UINT8) NumberOfBlocks;
AddressPacket->Zero2 = 0;
AddressPacket->SegOffset = 0xffffffff;
AddressPacket->Lba = (UINT64) Lba;
AddressPacket->TransferBuffer = TransferBuffer;
Regs.H.AH = 0x42;
Regs.H.DL = BiosBlockIoDev->Bios.Number;
Regs.X.SI = EFI_OFFSET (AddressPacket);
Regs.E.DS = EFI_SEGMENT (AddressPacket);
// CarryFlag = BiosBlockIoDev->LegacyBios->Int86 (BiosBlockIoDev->LegacyBios, 0x13, &Regs);
CarryFlag = LegacyBiosInt86 (BiosBlockIoDev, 0x13, &Regs);
// DBG( "Edd30BiosReadBlocks: INT 13 42 DL=%02x : CF=%d AH=%02x\n",
// BiosBlockIoDev->Bios.Number, CarryFlag, Regs.H.AH);
Media->MediaPresent = TRUE;
if (CarryFlag != 0) {
//
// Return Error Status
//
BiosBlockIoDev->Bios.ErrorCode = Regs.H.AH;
if (BiosBlockIoDev->Bios.ErrorCode == BIOS_DISK_CHANGED) {
Media->MediaId++;
Bios = &BiosBlockIoDev->Bios;
if (Int13GetDeviceParameters (BiosBlockIoDev, Bios) != 0) {
if (Int13Extensions (BiosBlockIoDev, Bios) != 0) {
Media->LastBlock = (EFI_LBA) Bios->Parameters.PhysicalSectors - 1;
Media->BlockSize = (UINT32) Bios->Parameters.BytesPerSector;
}
/*else {
ASSERT (FALSE);
} */
Media->ReadOnly = FALSE;
gBS->HandleProtocol (BiosBlockIoDev->Handle, &gEfiBlockIo2ProtocolGuid, (VOID **) &BlockIo2);
gBS->ReinstallProtocolInterface (BiosBlockIoDev->Handle, &gEfiBlockIo2ProtocolGuid, BlockIo2, BlockIo2);
return EFI_MEDIA_CHANGED;
}
}
if (Media->RemovableMedia) {
Media->MediaPresent = FALSE;
}
return EFI_DEVICE_ERROR;
}
TransferByteSize = NumberOfBlocks * BlockSize;
BufferSize = BufferSize - TransferByteSize;
TransferBuffer += TransferByteSize;
Lba += NumberOfBlocks;
}
return EFI_SUCCESS;
}
/**
Write BufferSize bytes from Lba into Buffer.
@param This Indicates a pointer to the calling context.
@param MediaId The media ID that the write request is for.
@param Lba The starting logical block address to be written. The caller is
responsible for writing to only legitimate locations.
@param BufferSize Size of Buffer, must be a multiple of device block size.
@param Buffer A pointer to the source buffer for the data.
@retval EFI_SUCCESS The data was written correctly to the device.
@retval EFI_WRITE_PROTECTED The device can not be written to.
@retval EFI_DEVICE_ERROR The device reported an error while performing the write.
@retval EFI_NO_MEDIA There is no media in the device.
@retval EFI_MEDIA_CHNAGED The MediaId does not matched the current device.
@retval EFI_BAD_BUFFER_SIZE The Buffer was not a multiple of the block size of the device.
@retval EFI_INVALID_PARAMETER The write request contains LBAs that are not valid,
or the buffer is not on proper alignment.
**/
EFI_STATUS
EFIAPI
Edd30BiosWriteBlocks (
IN EFI_BLOCK_IO_PROTOCOL *This,
IN UINT32 MediaId,
IN EFI_LBA Lba,
IN UINTN BufferSize,
OUT VOID *Buffer
)
{
EFI_BLOCK_IO_MEDIA *Media;
BIOS_BLOCK_IO_DEV *BiosBlockIoDev;
EDD_DEVICE_ADDRESS_PACKET *AddressPacket;
//
// I exist only for readability
//
IA32_REGISTER_SET Regs;
UINT64 TransferBuffer;
UINTN NumberOfBlocks;
UINTN TransferByteSize;
UINTN BlockSize;
BIOS_LEGACY_DRIVE *Bios;
UINTN CarryFlag;
UINTN MaxTransferBlocks;
EFI_BLOCK_IO_PROTOCOL *BlockIo;
Media = This->Media;
BlockSize = Media->BlockSize;
if (!BlockSize) {
return EFI_NO_MEDIA;
}
ZeroMem (&Regs, sizeof (IA32_REGISTER_SET));
if (MediaId != Media->MediaId) {
return EFI_MEDIA_CHANGED;
}
if (Lba > Media->LastBlock) {
return EFI_DEVICE_ERROR;
}
if ((Lba + (BufferSize / BlockSize) - 1) > Media->LastBlock) {
return EFI_INVALID_PARAMETER;
}
if (BufferSize % BlockSize != 0) {
return EFI_BAD_BUFFER_SIZE;
}
if (Buffer == NULL) {
return EFI_INVALID_PARAMETER;
}
if (BufferSize == 0) {
return EFI_SUCCESS;
}
BiosBlockIoDev = BIOS_BLOCK_IO_FROM_THIS (This);
if (BiosBlockIoDev->Bios.ErrorCode == BIOS_SECTOR_NOT_FOUND || BiosBlockIoDev->Bios.ErrorCode == BIOS_DRIVE_DOES_NOT_EXIST) {
return EFI_DEVICE_ERROR;
}
AddressPacket = mEddBufferUnder1Mb;
MaxTransferBlocks = MAX_EDD11_XFER / BlockSize;
TransferBuffer = (UINT64)(UINTN) Buffer;
for (; BufferSize > 0;) {
NumberOfBlocks = BufferSize / BlockSize;
NumberOfBlocks = NumberOfBlocks > MaxTransferBlocks ? MaxTransferBlocks : NumberOfBlocks;
//
// Max transfer MaxTransferBlocks
//
AddressPacket->PacketSizeInBytes = (UINT8) sizeof (EDD_DEVICE_ADDRESS_PACKET);
AddressPacket->Zero = 0;
AddressPacket->NumberOfBlocks = (UINT8) NumberOfBlocks;
AddressPacket->Zero2 = 0;
AddressPacket->SegOffset = 0xffffffff;
AddressPacket->Lba = (UINT64) Lba;
AddressPacket->TransferBuffer = TransferBuffer;
Regs.H.AH = 0x43;
Regs.H.AL = 0x00;
//
// Write Verify Off
//
Regs.H.DL = (UINT8) (BiosBlockIoDev->Bios.Number);
Regs.X.SI = EFI_OFFSET (AddressPacket);
Regs.E.DS = EFI_SEGMENT (AddressPacket);
// CarryFlag = BiosBlockIoDev->LegacyBios->Int86 (BiosBlockIoDev->LegacyBios, 0x13, &Regs);
CarryFlag = LegacyBiosInt86 (BiosBlockIoDev, 0x13, &Regs);
// DBG( "Edd30BiosWriteBlocks: INT 13 43 DL=%02x : CF=%d AH=%02x\n",
// BiosBlockIoDev->Bios.Number, CarryFlag, Regs.H.AH);
Media->MediaPresent = TRUE;
if (CarryFlag != 0) {
//
// Return Error Status
//
BiosBlockIoDev->Bios.ErrorCode = Regs.H.AH;
if (BiosBlockIoDev->Bios.ErrorCode == BIOS_DISK_CHANGED) {
Media->MediaId++;
Bios = &BiosBlockIoDev->Bios;
if (Int13GetDeviceParameters (BiosBlockIoDev, Bios) != 0) {
if (Int13Extensions (BiosBlockIoDev, Bios) != 0) {
Media->LastBlock = (EFI_LBA) Bios->Parameters.PhysicalSectors - 1;
Media->BlockSize = (UINT32) Bios->Parameters.BytesPerSector;
} /* else {
ASSERT (FALSE);
} */
Media->ReadOnly = FALSE;
gBS->HandleProtocol (BiosBlockIoDev->Handle, &gEfiBlockIoProtocolGuid, (VOID **) &BlockIo);
gBS->ReinstallProtocolInterface (BiosBlockIoDev->Handle, &gEfiBlockIoProtocolGuid, BlockIo, BlockIo);
return EFI_MEDIA_CHANGED;
}
} else if (BiosBlockIoDev->Bios.ErrorCode == BIOS_WRITE_PROTECTED) {
Media->ReadOnly = TRUE;
return EFI_WRITE_PROTECTED;
}
if (Media->RemovableMedia) {
Media->MediaPresent = FALSE;
}
return EFI_DEVICE_ERROR;
}
Media->ReadOnly = FALSE;
TransferByteSize = NumberOfBlocks * BlockSize;
BufferSize = BufferSize - TransferByteSize;
TransferBuffer += TransferByteSize;
Lba += NumberOfBlocks;
}
return EFI_SUCCESS;
}
EFI_STATUS
EFIAPI
Edd30BiosWriteBlocksEx (
IN EFI_BLOCK_IO2_PROTOCOL *This,
IN UINT32 MediaId,
IN EFI_LBA Lba,
IN OUT EFI_BLOCK_IO2_TOKEN *Token,
IN UINTN BufferSize,
OUT VOID *Buffer
)
{
EFI_BLOCK_IO_MEDIA *Media;
BIOS_BLOCK_IO_DEV *BiosBlockIoDev;
EDD_DEVICE_ADDRESS_PACKET *AddressPacket;
//
// I exist only for readability
//
IA32_REGISTER_SET Regs;
UINT64 TransferBuffer;
UINTN NumberOfBlocks;
UINTN TransferByteSize;
UINTN BlockSize;
BIOS_LEGACY_DRIVE *Bios;
UINTN CarryFlag;
UINTN MaxTransferBlocks;
EFI_BLOCK_IO2_PROTOCOL *BlockIo2;
Media = This->Media;
BlockSize = Media->BlockSize;
if (!BlockSize) {
return EFI_NO_MEDIA;
}
ZeroMem (&Regs, sizeof (IA32_REGISTER_SET));
if (MediaId != Media->MediaId) {
return EFI_MEDIA_CHANGED;
}
if (Lba > Media->LastBlock) {
return EFI_DEVICE_ERROR;
}
if ((Lba + (BufferSize / BlockSize) - 1) > Media->LastBlock) {
return EFI_INVALID_PARAMETER;
}
if (BufferSize % BlockSize != 0) {
return EFI_BAD_BUFFER_SIZE;
}
if (Buffer == NULL) {
return EFI_INVALID_PARAMETER;
}
if (BufferSize == 0) {
return EFI_SUCCESS;
}
BiosBlockIoDev = BIOS_BLOCK_IO2_FROM_THIS (This);
if (BiosBlockIoDev->Bios.ErrorCode == BIOS_SECTOR_NOT_FOUND || BiosBlockIoDev->Bios.ErrorCode == BIOS_DRIVE_DOES_NOT_EXIST) {
return EFI_DEVICE_ERROR;
}
AddressPacket = mEddBufferUnder1Mb;
MaxTransferBlocks = MAX_EDD11_XFER / BlockSize;
TransferBuffer = (UINT64)(UINTN) Buffer;
for (; BufferSize > 0;) {
NumberOfBlocks = BufferSize / BlockSize;
NumberOfBlocks = NumberOfBlocks > MaxTransferBlocks ? MaxTransferBlocks : NumberOfBlocks;
//
// Max transfer MaxTransferBlocks
//
AddressPacket->PacketSizeInBytes = (UINT8) sizeof (EDD_DEVICE_ADDRESS_PACKET);
AddressPacket->Zero = 0;
AddressPacket->NumberOfBlocks = (UINT8) NumberOfBlocks;
AddressPacket->Zero2 = 0;
AddressPacket->SegOffset = 0xffffffff;
AddressPacket->Lba = (UINT64) Lba;
AddressPacket->TransferBuffer = TransferBuffer;
Regs.H.AH = 0x43;
Regs.H.AL = 0x00;
//
// Write Verify Off
//
Regs.H.DL = (UINT8) (BiosBlockIoDev->Bios.Number);
Regs.X.SI = EFI_OFFSET (AddressPacket);
Regs.E.DS = EFI_SEGMENT (AddressPacket);
// CarryFlag = BiosBlockIoDev->LegacyBios->Int86 (BiosBlockIoDev->LegacyBios, 0x13, &Regs);
CarryFlag = LegacyBiosInt86 (BiosBlockIoDev, 0x13, &Regs);
// DBG( "Edd30BiosWriteBlocks: INT 13 43 DL=%02x : CF=%d AH=%02x\n",
// BiosBlockIoDev->Bios.Number, CarryFlag, Regs.H.AH);
Media->MediaPresent = TRUE;
if (CarryFlag != 0) {
//
// Return Error Status
//
BiosBlockIoDev->Bios.ErrorCode = Regs.H.AH;
if (BiosBlockIoDev->Bios.ErrorCode == BIOS_DISK_CHANGED) {
Media->MediaId++;
Bios = &BiosBlockIoDev->Bios;
if (Int13GetDeviceParameters (BiosBlockIoDev, Bios) != 0) {
if (Int13Extensions (BiosBlockIoDev, Bios) != 0) {
Media->LastBlock = (EFI_LBA) Bios->Parameters.PhysicalSectors - 1;
Media->BlockSize = (UINT32) Bios->Parameters.BytesPerSector;
} /* else {
ASSERT (FALSE);
} */
Media->ReadOnly = FALSE;
gBS->HandleProtocol (BiosBlockIoDev->Handle, &gEfiBlockIo2ProtocolGuid, (VOID **) &BlockIo2);
gBS->ReinstallProtocolInterface (BiosBlockIoDev->Handle, &gEfiBlockIo2ProtocolGuid, BlockIo2, BlockIo2);
return EFI_MEDIA_CHANGED;
}
} else if (BiosBlockIoDev->Bios.ErrorCode == BIOS_WRITE_PROTECTED) {
Media->ReadOnly = TRUE;
return EFI_WRITE_PROTECTED;
}
if (Media->RemovableMedia) {
Media->MediaPresent = FALSE;
}
return EFI_DEVICE_ERROR;
}
Media->ReadOnly = FALSE;
TransferByteSize = NumberOfBlocks * BlockSize;
BufferSize = BufferSize - TransferByteSize;
TransferBuffer += TransferByteSize;
Lba += NumberOfBlocks;
}
return EFI_SUCCESS;
}
/**
Flush the Block Device.
@param This Indicates a pointer to the calling context.
@retval EFI_SUCCESS All outstanding data was written to the device
@retval EFI_DEVICE_ERROR The device reported an error while writting back the data
@retval EFI_NO_MEDIA There is no media in the device.
**/
EFI_STATUS
EFIAPI
BiosBlockIoFlushBlocks (
IN EFI_BLOCK_IO_PROTOCOL *This
)
{
return EFI_SUCCESS;
}
EFI_STATUS
EFIAPI
BiosBlockIoFlushBlocksEx (
IN EFI_BLOCK_IO2_PROTOCOL *This,
IN OUT EFI_BLOCK_IO2_TOKEN *Token
)
{
return EFI_SUCCESS;
}
/**
Reset the Block Device.
@param This Indicates a pointer to the calling context.
@param ExtendedVerification Driver may perform diagnostics on reset.
@retval EFI_SUCCESS The device was reset.
@retval EFI_DEVICE_ERROR The device is not functioning properly and could
not be reset.
**/
EFI_STATUS
EFIAPI
BiosBlockIoReset2 (
IN EFI_BLOCK_IO2_PROTOCOL *This,
IN BOOLEAN ExtendedVerification
)
{
BIOS_BLOCK_IO_DEV *BiosBlockIoDev;
IA32_REGISTER_SET Regs;
UINTN CarryFlag;
BiosBlockIoDev = BIOS_BLOCK_IO2_FROM_THIS (This);
ZeroMem (&Regs, sizeof (IA32_REGISTER_SET));
Regs.H.AH = 0x00;
Regs.H.DL = BiosBlockIoDev->Bios.Number;
// CarryFlag = BiosBlockIoDev->LegacyBios->Int86 (BiosBlockIoDev->LegacyBios, 0x13, &Regs);
CarryFlag = LegacyBiosInt86 (BiosBlockIoDev, 0x13, &Regs);
// DBG("BiosBlockIoReset: INT 13 00 DL=%02x : CF=%d AH=%02x\n",
// BiosBlockIoDev->Bios.Number, CarryFlag, Regs.H.AH );
if (CarryFlag != 0) {
if (Regs.H.AL == BIOS_RESET_FAILED) {
Regs.H.AH = 0x00;
Regs.H.DL = BiosBlockIoDev->Bios.Number;
// CarryFlag = BiosBlockIoDev->LegacyBios->Int86 (BiosBlockIoDev->LegacyBios, 0x13, &Regs);
CarryFlag = LegacyBiosInt86 (BiosBlockIoDev, 0x13, &Regs);
// DBG("BiosBlockIoReset: INT 13 00 DL=%02x : CF=%d AH=%02x\n", BiosBlockIoDev->Bios.Number, CarryFlag, Regs.H.AH );
if (CarryFlag != 0) {
BiosBlockIoDev->Bios.ErrorCode = Regs.H.AH;
return EFI_DEVICE_ERROR;
}
}
}
return EFI_SUCCESS;
}
EFI_STATUS
EFIAPI
BiosBlockIoReset (
IN EFI_BLOCK_IO_PROTOCOL *This,
IN BOOLEAN ExtendedVerification
)
{
BIOS_BLOCK_IO_DEV *BiosBlockIoDev;
IA32_REGISTER_SET Regs;
UINTN CarryFlag;
BiosBlockIoDev = BIOS_BLOCK_IO_FROM_THIS (This);
ZeroMem (&Regs, sizeof (IA32_REGISTER_SET));
Regs.H.AH = 0x00;
Regs.H.DL = BiosBlockIoDev->Bios.Number;
// CarryFlag = BiosBlockIoDev->LegacyBios->Int86 (BiosBlockIoDev->LegacyBios, 0x13, &Regs);
CarryFlag = LegacyBiosInt86 (BiosBlockIoDev, 0x13, &Regs);
// DBG("BiosBlockIoReset: INT 13 00 DL=%02x : CF=%d AH=%02x\n",
// BiosBlockIoDev->Bios.Number, CarryFlag, Regs.H.AH );
if (CarryFlag != 0) {
if (Regs.H.AL == BIOS_RESET_FAILED) {
Regs.H.AH = 0x00;
Regs.H.DL = BiosBlockIoDev->Bios.Number;
// CarryFlag = BiosBlockIoDev->LegacyBios->Int86 (BiosBlockIoDev->LegacyBios, 0x13, &Regs);
CarryFlag = LegacyBiosInt86 (BiosBlockIoDev, 0x13, &Regs);
// DBG("BiosBlockIoReset: INT 13 00 DL=%02x : CF=%d AH=%02x\n", BiosBlockIoDev->Bios.Number, CarryFlag, Regs.H.AH );
if (CarryFlag != 0) {
BiosBlockIoDev->Bios.ErrorCode = Regs.H.AH;
return EFI_DEVICE_ERROR;
}
}
}
return EFI_SUCCESS;
}
//
//
// These functions need to double buffer all data under 1MB!
//
//
/**
Read BufferSize bytes from Lba into Buffer.
@param This Indicates a pointer to the calling context.
@param MediaId Id of the media, changes every time the media is replaced.
@param Lba The starting Logical Block Address to read from
@param BufferSize Size of Buffer, must be a multiple of device block size.
@param Buffer A pointer to the destination buffer for the data. The caller is
responsible for either having implicit or explicit ownership of the buffer.
@retval EFI_SUCCESS The data was read correctly from the device.
@retval EFI_DEVICE_ERROR The device reported an error while performing the read.
@retval EFI_NO_MEDIA There is no media in the device.
@retval EFI_MEDIA_CHANGED The MediaId does not matched the current device.
@retval EFI_BAD_BUFFER_SIZE The Buffer was not a multiple of the block size of the device.
@retval EFI_INVALID_PARAMETER The read request contains LBAs that are not valid,
or the buffer is not on proper alignment.
**/
EFI_STATUS
EFIAPI
Edd11BiosReadBlocks (
IN EFI_BLOCK_IO_PROTOCOL *This,
IN UINT32 MediaId,
IN EFI_LBA Lba,
IN UINTN BufferSize,
OUT VOID *Buffer
)
{
EFI_BLOCK_IO_MEDIA *Media;
BIOS_BLOCK_IO_DEV *BiosBlockIoDev;
EDD_DEVICE_ADDRESS_PACKET *AddressPacket;
//
// I exist only for readability
//
IA32_REGISTER_SET Regs;
UINT64 TransferBuffer;
UINTN NumberOfBlocks;
UINTN TransferByteSize;
UINTN BlockSize;
BIOS_LEGACY_DRIVE *Bios;
UINTN CarryFlag;
UINTN MaxTransferBlocks;
EFI_BLOCK_IO_PROTOCOL *BlockIo;
Media = This->Media;
BlockSize = Media->BlockSize;
if (!BlockSize) {
return EFI_NO_MEDIA;
}
ZeroMem (&Regs, sizeof (IA32_REGISTER_SET));
if (MediaId != Media->MediaId) {
return EFI_MEDIA_CHANGED;
}
if (Lba > Media->LastBlock) {
return EFI_INVALID_PARAMETER;
}
if ((Lba + (BufferSize / BlockSize) - 1) > Media->LastBlock) {
return EFI_INVALID_PARAMETER;
}
if (BufferSize % BlockSize != 0) {
return EFI_BAD_BUFFER_SIZE;
}
if (Buffer == NULL) {
return EFI_INVALID_PARAMETER;
}
if (BufferSize == 0) {
return EFI_SUCCESS;
}
BiosBlockIoDev = BIOS_BLOCK_IO_FROM_THIS (This);
if (BiosBlockIoDev->Bios.ErrorCode == BIOS_SECTOR_NOT_FOUND || BiosBlockIoDev->Bios.ErrorCode == BIOS_DRIVE_DOES_NOT_EXIST) {
return EFI_DEVICE_ERROR;
}
AddressPacket = mEddBufferUnder1Mb;
MaxTransferBlocks = MAX_EDD11_XFER / BlockSize;
TransferBuffer = (UINT64)(UINTN) mEdd11Buffer;
for (; BufferSize > 0;) {
NumberOfBlocks = BufferSize / BlockSize;
NumberOfBlocks = NumberOfBlocks > MaxTransferBlocks ? MaxTransferBlocks : NumberOfBlocks;
//
// Max transfer MaxTransferBlocks
//
AddressPacket->PacketSizeInBytes = (UINT8) sizeof (EDD_DEVICE_ADDRESS_PACKET);
AddressPacket->Zero = 0;
AddressPacket->NumberOfBlocks = (UINT8) NumberOfBlocks;
AddressPacket->Zero2 = 0;
//
// TransferBuffer has been 4KB alignment. Normalize TransferBuffer to make offset as 0 in seg:offset
// format to transfer maximum 127 blocks of data.
// Otherwise when offset adding data size exceeds 0xFFFF, if OpROM does not normalize TransferBuffer,
// INT13 function 42H will return data boundary error 09H.
//
AddressPacket->SegOffset = (UINT32) LShiftU64(RShiftU64(TransferBuffer, 4), 16);
AddressPacket->Lba = (UINT64) Lba;
Regs.H.AH = 0x42;
Regs.H.DL = BiosBlockIoDev->Bios.Number;
Regs.X.SI = EFI_OFFSET (AddressPacket);
Regs.E.DS = EFI_SEGMENT (AddressPacket);
// CarryFlag = BiosBlockIoDev->LegacyBios->Int86 (BiosBlockIoDev->LegacyBios, 0x13, &Regs);
CarryFlag = LegacyBiosInt86 (BiosBlockIoDev, 0x13, &Regs);
// DBG("Edd11BiosReadBlocks: INT 13 42 DL=%02x : CF=%d AH=%02x : LBA 0x%lx Block(s) %0d \n",
// BiosBlockIoDev->Bios.Number, CarryFlag, Regs.H.AH, Lba, NumberOfBlocks);
Media->MediaPresent = TRUE;
if (CarryFlag != 0) {
//
// Return Error Status
//
BiosBlockIoDev->Bios.ErrorCode = Regs.H.AH;
if (BiosBlockIoDev->Bios.ErrorCode == BIOS_DISK_CHANGED) {
Media->MediaId++;
Bios = &BiosBlockIoDev->Bios;
if (Int13GetDeviceParameters (BiosBlockIoDev, Bios) != 0) {
if (Int13Extensions (BiosBlockIoDev, Bios) != 0) {
Media->LastBlock = (EFI_LBA) Bios->Parameters.PhysicalSectors - 1;
Media->BlockSize = (UINT32) Bios->Parameters.BytesPerSector;
}
/*else {
ASSERT (FALSE);
}*/
Media->ReadOnly = FALSE;
gBS->HandleProtocol (BiosBlockIoDev->Handle, &gEfiBlockIoProtocolGuid, (VOID **) &BlockIo);
gBS->ReinstallProtocolInterface (BiosBlockIoDev->Handle, &gEfiBlockIoProtocolGuid, BlockIo, BlockIo);
return EFI_MEDIA_CHANGED;
}
}
if (Media->RemovableMedia) {
Media->MediaPresent = FALSE;
}
return EFI_DEVICE_ERROR;
}
TransferByteSize = NumberOfBlocks * BlockSize;
CopyMem (Buffer, (VOID *) (UINTN) TransferBuffer, TransferByteSize);
BufferSize = BufferSize - TransferByteSize;
Buffer = (VOID *) ((UINT8 *) Buffer + TransferByteSize);
Lba += NumberOfBlocks;
}
return EFI_SUCCESS;
}
EFI_STATUS
EFIAPI
Edd11BiosReadBlocksEx (
IN EFI_BLOCK_IO2_PROTOCOL *This,
IN UINT32 MediaId,
IN EFI_LBA Lba,
IN OUT EFI_BLOCK_IO2_TOKEN *Token,
IN UINTN BufferSize,
OUT VOID *Buffer
)
{
EFI_BLOCK_IO_MEDIA *Media;
BIOS_BLOCK_IO_DEV *BiosBlockIoDev;
EDD_DEVICE_ADDRESS_PACKET *AddressPacket;
//
// I exist only for readability
//
IA32_REGISTER_SET Regs;
UINT64 TransferBuffer;
UINTN NumberOfBlocks;
UINTN TransferByteSize;
UINTN BlockSize;
BIOS_LEGACY_DRIVE *Bios;
UINTN CarryFlag;
UINTN MaxTransferBlocks;
EFI_BLOCK_IO2_PROTOCOL *BlockIo2;
Media = This->Media;
BlockSize = Media->BlockSize;
if (!BlockSize) {
return EFI_NO_MEDIA;
}
ZeroMem (&Regs, sizeof (IA32_REGISTER_SET));
if (MediaId != Media->MediaId) {
return EFI_MEDIA_CHANGED;
}
if (Lba > Media->LastBlock) {
return EFI_INVALID_PARAMETER;
}
if ((Lba + (BufferSize / BlockSize) - 1) > Media->LastBlock) {
return EFI_INVALID_PARAMETER;
}
if (BufferSize % BlockSize != 0) {
return EFI_BAD_BUFFER_SIZE;
}
if (Buffer == NULL) {
return EFI_INVALID_PARAMETER;
}
if (BufferSize == 0) {
return EFI_SUCCESS;
}
BiosBlockIoDev = BIOS_BLOCK_IO2_FROM_THIS (This);
if (BiosBlockIoDev->Bios.ErrorCode == BIOS_SECTOR_NOT_FOUND || BiosBlockIoDev->Bios.ErrorCode == BIOS_DRIVE_DOES_NOT_EXIST) {
return EFI_DEVICE_ERROR;
}
AddressPacket = mEddBufferUnder1Mb;
MaxTransferBlocks = MAX_EDD11_XFER / BlockSize;
TransferBuffer = (UINT64)(UINTN) mEdd11Buffer;
for (; BufferSize > 0;) {
NumberOfBlocks = BufferSize / BlockSize;
NumberOfBlocks = NumberOfBlocks > MaxTransferBlocks ? MaxTransferBlocks : NumberOfBlocks;
//
// Max transfer MaxTransferBlocks
//
AddressPacket->PacketSizeInBytes = (UINT8) sizeof (EDD_DEVICE_ADDRESS_PACKET);
AddressPacket->Zero = 0;
AddressPacket->NumberOfBlocks = (UINT8) NumberOfBlocks;
AddressPacket->Zero2 = 0;
//
// TransferBuffer has been 4KB alignment. Normalize TransferBuffer to make offset as 0 in seg:offset
// format to transfer maximum 127 blocks of data.
// Otherwise when offset adding data size exceeds 0xFFFF, if OpROM does not normalize TransferBuffer,
// INT13 function 42H will return data boundary error 09H.
//
AddressPacket->SegOffset = (UINT32) LShiftU64(RShiftU64(TransferBuffer, 4), 16);
AddressPacket->Lba = (UINT64) Lba;
Regs.H.AH = 0x42;
Regs.H.DL = BiosBlockIoDev->Bios.Number;
Regs.X.SI = EFI_OFFSET (AddressPacket);
Regs.E.DS = EFI_SEGMENT (AddressPacket);
// CarryFlag = BiosBlockIoDev->LegacyBios->Int86 (BiosBlockIoDev->LegacyBios, 0x13, &Regs);
CarryFlag = LegacyBiosInt86 (BiosBlockIoDev, 0x13, &Regs);
// DBG("Edd11BiosReadBlocks: INT 13 42 DL=%02x : CF=%d AH=%02x : LBA 0x%lx Block(s) %0d \n",
// BiosBlockIoDev->Bios.Number, CarryFlag, Regs.H.AH, Lba, NumberOfBlocks);
Media->MediaPresent = TRUE;
if (CarryFlag != 0) {
//
// Return Error Status
//
BiosBlockIoDev->Bios.ErrorCode = Regs.H.AH;
if (BiosBlockIoDev->Bios.ErrorCode == BIOS_DISK_CHANGED) {
Media->MediaId++;
Bios = &BiosBlockIoDev->Bios;
if (Int13GetDeviceParameters (BiosBlockIoDev, Bios) != 0) {
if (Int13Extensions (BiosBlockIoDev, Bios) != 0) {
Media->LastBlock = (EFI_LBA) Bios->Parameters.PhysicalSectors - 1;
Media->BlockSize = (UINT32) Bios->Parameters.BytesPerSector;
}
/*else {
ASSERT (FALSE);
}*/
Media->ReadOnly = FALSE;
gBS->HandleProtocol (BiosBlockIoDev->Handle, &gEfiBlockIo2ProtocolGuid, (VOID **) &BlockIo2);
gBS->ReinstallProtocolInterface (BiosBlockIoDev->Handle, &gEfiBlockIo2ProtocolGuid, BlockIo2, BlockIo2);
return EFI_MEDIA_CHANGED;
}
}
if (Media->RemovableMedia) {
Media->MediaPresent = FALSE;
}
return EFI_DEVICE_ERROR;
}
TransferByteSize = NumberOfBlocks * BlockSize;
CopyMem (Buffer, (VOID *) (UINTN) TransferBuffer, TransferByteSize);
BufferSize = BufferSize - TransferByteSize;
Buffer = (VOID *) ((UINT8 *) Buffer + TransferByteSize);
Lba += NumberOfBlocks;
}
return EFI_SUCCESS;
}
/**
Write BufferSize bytes from Lba into Buffer.
@param This Indicates a pointer to the calling context.
@param MediaId The media ID that the write request is for.
@param Lba The starting logical block address to be written. The caller is
responsible for writing to only legitimate locations.
@param BufferSize Size of Buffer, must be a multiple of device block size.
@param Buffer A pointer to the source buffer for the data.
@retval EFI_SUCCESS The data was written correctly to the device.
@retval EFI_WRITE_PROTECTED The device can not be written to.
@retval EFI_DEVICE_ERROR The device reported an error while performing the write.
@retval EFI_NO_MEDIA There is no media in the device.
@retval EFI_MEDIA_CHNAGED The MediaId does not matched the current device.
@retval EFI_BAD_BUFFER_SIZE The Buffer was not a multiple of the block size of the device.
@retval EFI_INVALID_PARAMETER The write request contains LBAs that are not valid,
or the buffer is not on proper alignment.
**/
EFI_STATUS
EFIAPI
Edd11BiosWriteBlocks (
IN EFI_BLOCK_IO_PROTOCOL *This,
IN UINT32 MediaId,
IN EFI_LBA Lba,
IN UINTN BufferSize,
OUT VOID *Buffer
)
{
EFI_BLOCK_IO_MEDIA *Media;
BIOS_BLOCK_IO_DEV *BiosBlockIoDev;
EDD_DEVICE_ADDRESS_PACKET *AddressPacket;
//
// I exist only for readability
//
IA32_REGISTER_SET Regs;
UINT64 TransferBuffer;
UINTN NumberOfBlocks;
UINTN TransferByteSize;
UINTN BlockSize;
BIOS_LEGACY_DRIVE *Bios;
UINTN CarryFlag;
UINTN MaxTransferBlocks;
EFI_BLOCK_IO_PROTOCOL *BlockIo;
Media = This->Media;
BlockSize = Media->BlockSize;
if (!BlockSize) {
return EFI_NO_MEDIA;
}
ZeroMem (&Regs, sizeof (IA32_REGISTER_SET));
if (MediaId != Media->MediaId) {
return EFI_MEDIA_CHANGED;
}
if (Lba > Media->LastBlock) {
return EFI_INVALID_PARAMETER;
}
if ((Lba + (BufferSize / BlockSize) - 1) > Media->LastBlock) {
return EFI_INVALID_PARAMETER;
}
if (BufferSize % BlockSize != 0) {
return EFI_BAD_BUFFER_SIZE;
}
if (Buffer == NULL) {
return EFI_INVALID_PARAMETER;
}
if (BufferSize == 0) {
return EFI_SUCCESS;
}
BiosBlockIoDev = BIOS_BLOCK_IO_FROM_THIS (This);
if (BiosBlockIoDev->Bios.ErrorCode == BIOS_SECTOR_NOT_FOUND || BiosBlockIoDev->Bios.ErrorCode == BIOS_DRIVE_DOES_NOT_EXIST) {
return EFI_DEVICE_ERROR;
}
AddressPacket = mEddBufferUnder1Mb;
MaxTransferBlocks = MAX_EDD11_XFER / BlockSize;
TransferBuffer = (UINT64)(UINTN) mEdd11Buffer;
for (; BufferSize > 0;) {
NumberOfBlocks = BufferSize / BlockSize;
NumberOfBlocks = NumberOfBlocks > MaxTransferBlocks ? MaxTransferBlocks : NumberOfBlocks;
//
// Max transfer MaxTransferBlocks
//
AddressPacket->PacketSizeInBytes = (UINT8) sizeof (EDD_DEVICE_ADDRESS_PACKET);
AddressPacket->Zero = 0;
AddressPacket->NumberOfBlocks = (UINT8) NumberOfBlocks;
AddressPacket->Zero2 = 0;
//
// TransferBuffer has been 4KB alignment. Normalize TransferBuffer to make offset as 0 in seg:offset
// format to transfer maximum 127 blocks of data.
// Otherwise when offset adding data size exceeds 0xFFFF, if OpROM does not normalize TransferBuffer,
// INT13 function 42H will return data boundary error 09H.
//
AddressPacket->SegOffset = (UINT32) LShiftU64(RShiftU64(TransferBuffer, 4), 16);
AddressPacket->Lba = (UINT64) Lba;
Regs.H.AH = 0x43;
Regs.H.AL = 0x00;
//
// Write Verify disable
//
Regs.H.DL = BiosBlockIoDev->Bios.Number;
Regs.X.SI = EFI_OFFSET (AddressPacket);
Regs.E.DS = EFI_SEGMENT (AddressPacket);
TransferByteSize = NumberOfBlocks * BlockSize;
CopyMem ((VOID *) (UINTN) TransferBuffer, Buffer, TransferByteSize);
// CarryFlag = BiosBlockIoDev->LegacyBios->Int86 (BiosBlockIoDev->LegacyBios, 0x13, &Regs);
CarryFlag = LegacyBiosInt86 (BiosBlockIoDev, 0x13, &Regs);
// DBG("Edd11BiosWriteBlocks: INT 13 43 DL=%02x : CF=%d AH=%02x\n: LBA 0x%lx Block(s) %0d \n",
// BiosBlockIoDev->Bios.Number, CarryFlag, Regs.H.AH, Lba, NumberOfBlocks);
Media->MediaPresent = TRUE;
if (CarryFlag != 0) {
//
// Return Error Status
//
BiosBlockIoDev->Bios.ErrorCode = Regs.H.AH;
if (BiosBlockIoDev->Bios.ErrorCode == BIOS_DISK_CHANGED) {
Media->MediaId++;
Bios = &BiosBlockIoDev->Bios;
if (Int13GetDeviceParameters (BiosBlockIoDev, Bios) != 0) {
if (Int13Extensions (BiosBlockIoDev, Bios) != 0) {
Media->LastBlock = (EFI_LBA) Bios->Parameters.PhysicalSectors - 1;
Media->BlockSize = (UINT32) Bios->Parameters.BytesPerSector;
}
/*else {
ASSERT (FALSE);
}*/
Media->ReadOnly = FALSE;
gBS->HandleProtocol (BiosBlockIoDev->Handle, &gEfiBlockIoProtocolGuid, (VOID **) &BlockIo);
gBS->ReinstallProtocolInterface (BiosBlockIoDev->Handle, &gEfiBlockIoProtocolGuid, BlockIo, BlockIo);
return EFI_MEDIA_CHANGED;
}
} else if (BiosBlockIoDev->Bios.ErrorCode == BIOS_WRITE_PROTECTED) {
Media->ReadOnly = TRUE;
return EFI_WRITE_PROTECTED;
}
if (Media->RemovableMedia) {
Media->MediaPresent = FALSE;
}
return EFI_DEVICE_ERROR;
}
Media->ReadOnly = FALSE;
BufferSize = BufferSize - TransferByteSize;
Buffer = (VOID *) ((UINT8 *) Buffer + TransferByteSize);
Lba += NumberOfBlocks;
}
return EFI_SUCCESS;
}
EFI_STATUS
EFIAPI
Edd11BiosWriteBlocksEx (
IN EFI_BLOCK_IO2_PROTOCOL *This,
IN UINT32 MediaId,
IN EFI_LBA Lba,
IN OUT EFI_BLOCK_IO2_TOKEN *Token,
IN UINTN BufferSize,
OUT VOID *Buffer
)
{
EFI_BLOCK_IO_MEDIA *Media;
BIOS_BLOCK_IO_DEV *BiosBlockIoDev;
EDD_DEVICE_ADDRESS_PACKET *AddressPacket;
//
// I exist only for readability
//
IA32_REGISTER_SET Regs;
UINT64 TransferBuffer;
UINTN NumberOfBlocks;
UINTN TransferByteSize;
UINTN BlockSize;
BIOS_LEGACY_DRIVE *Bios;
UINTN CarryFlag;
UINTN MaxTransferBlocks;
EFI_BLOCK_IO2_PROTOCOL *BlockIo2;
Media = This->Media;
BlockSize = Media->BlockSize;
if (!BlockSize) {
return EFI_NO_MEDIA;
}
ZeroMem (&Regs, sizeof (IA32_REGISTER_SET));
if (MediaId != Media->MediaId) {
return EFI_MEDIA_CHANGED;
}
if (Lba > Media->LastBlock) {
return EFI_INVALID_PARAMETER;
}
if ((Lba + (BufferSize / BlockSize) - 1) > Media->LastBlock) {
return EFI_INVALID_PARAMETER;
}
if (BufferSize % BlockSize != 0) {
return EFI_BAD_BUFFER_SIZE;
}
if (Buffer == NULL) {
return EFI_INVALID_PARAMETER;
}
if (BufferSize == 0) {
return EFI_SUCCESS;
}
BiosBlockIoDev = BIOS_BLOCK_IO2_FROM_THIS (This);
if (BiosBlockIoDev->Bios.ErrorCode == BIOS_SECTOR_NOT_FOUND || BiosBlockIoDev->Bios.ErrorCode == BIOS_DRIVE_DOES_NOT_EXIST) {
return EFI_DEVICE_ERROR;
}
AddressPacket = mEddBufferUnder1Mb;
MaxTransferBlocks = MAX_EDD11_XFER / BlockSize;
TransferBuffer = (UINT64)(UINTN) mEdd11Buffer;
for (; BufferSize > 0;) {
NumberOfBlocks = BufferSize / BlockSize;
NumberOfBlocks = NumberOfBlocks > MaxTransferBlocks ? MaxTransferBlocks : NumberOfBlocks;
//
// Max transfer MaxTransferBlocks
//
AddressPacket->PacketSizeInBytes = (UINT8) sizeof (EDD_DEVICE_ADDRESS_PACKET);
AddressPacket->Zero = 0;
AddressPacket->NumberOfBlocks = (UINT8) NumberOfBlocks;
AddressPacket->Zero2 = 0;
//
// TransferBuffer has been 4KB alignment. Normalize TransferBuffer to make offset as 0 in seg:offset
// format to transfer maximum 127 blocks of data.
// Otherwise when offset adding data size exceeds 0xFFFF, if OpROM does not normalize TransferBuffer,
// INT13 function 42H will return data boundary error 09H.
//
AddressPacket->SegOffset = (UINT32) LShiftU64(RShiftU64(TransferBuffer, 4), 16);
AddressPacket->Lba = (UINT64) Lba;
Regs.H.AH = 0x43;
Regs.H.AL = 0x00;
//
// Write Verify disable
//
Regs.H.DL = BiosBlockIoDev->Bios.Number;
Regs.X.SI = EFI_OFFSET (AddressPacket);
Regs.E.DS = EFI_SEGMENT (AddressPacket);
TransferByteSize = NumberOfBlocks * BlockSize;
CopyMem ((VOID *) (UINTN) TransferBuffer, Buffer, TransferByteSize);
// CarryFlag = BiosBlockIoDev->LegacyBios->Int86 (BiosBlockIoDev->LegacyBios, 0x13, &Regs);
CarryFlag = LegacyBiosInt86 (BiosBlockIoDev, 0x13, &Regs);
// DBG("Edd11BiosWriteBlocks: INT 13 43 DL=%02x : CF=%d AH=%02x\n: LBA 0x%lx Block(s) %0d \n",
// BiosBlockIoDev->Bios.Number, CarryFlag, Regs.H.AH, Lba, NumberOfBlocks);
Media->MediaPresent = TRUE;
if (CarryFlag != 0) {
//
// Return Error Status
//
BiosBlockIoDev->Bios.ErrorCode = Regs.H.AH;
if (BiosBlockIoDev->Bios.ErrorCode == BIOS_DISK_CHANGED) {
Media->MediaId++;
Bios = &BiosBlockIoDev->Bios;
if (Int13GetDeviceParameters (BiosBlockIoDev, Bios) != 0) {
if (Int13Extensions (BiosBlockIoDev, Bios) != 0) {
Media->LastBlock = (EFI_LBA) Bios->Parameters.PhysicalSectors - 1;
Media->BlockSize = (UINT32) Bios->Parameters.BytesPerSector;
}
/*else {
ASSERT (FALSE);
}*/
Media->ReadOnly = FALSE;
gBS->HandleProtocol (BiosBlockIoDev->Handle, &gEfiBlockIo2ProtocolGuid, (VOID **) &BlockIo2);
gBS->ReinstallProtocolInterface (BiosBlockIoDev->Handle, &gEfiBlockIo2ProtocolGuid, BlockIo2, BlockIo2);
return EFI_MEDIA_CHANGED;
}
} else if (BiosBlockIoDev->Bios.ErrorCode == BIOS_WRITE_PROTECTED) {
Media->ReadOnly = TRUE;
return EFI_WRITE_PROTECTED;
}
if (Media->RemovableMedia) {
Media->MediaPresent = FALSE;
}
return EFI_DEVICE_ERROR;
}
Media->ReadOnly = FALSE;
BufferSize = BufferSize - TransferByteSize;
Buffer = (VOID *) ((UINT8 *) Buffer + TransferByteSize);
Lba += NumberOfBlocks;
}
return EFI_SUCCESS;
}
/**
Read BufferSize bytes from Lba into Buffer.
@param This Indicates a pointer to the calling context.
@param MediaId Id of the media, changes every time the media is replaced.
@param Lba The starting Logical Block Address to read from
@param BufferSize Size of Buffer, must be a multiple of device block size.
@param Buffer A pointer to the destination buffer for the data. The caller is
responsible for either having implicit or explicit ownership of the buffer.
@retval EFI_SUCCESS The data was read correctly from the device.
@retval EFI_DEVICE_ERROR The device reported an error while performing the read.
@retval EFI_NO_MEDIA There is no media in the device.
@retval EFI_MEDIA_CHANGED The MediaId does not matched the current device.
@retval EFI_BAD_BUFFER_SIZE The Buffer was not a multiple of the block size of the device.
@retval EFI_INVALID_PARAMETER The read request contains LBAs that are not valid,
or the buffer is not on proper alignment.
**/
EFI_STATUS
EFIAPI
BiosReadLegacyDrive (
IN EFI_BLOCK_IO_PROTOCOL *This,
IN UINT32 MediaId,
IN EFI_LBA Lba,
IN UINTN BufferSize,
OUT VOID *Buffer
)
{
EFI_BLOCK_IO_MEDIA *Media;
BIOS_BLOCK_IO_DEV *BiosBlockIoDev;
IA32_REGISTER_SET Regs;
UINTN UpperCylinder;
UINTN Temp;
UINTN Cylinder;
UINTN Head;
UINTN Sector;
UINTN NumberOfBlocks;
UINTN TransferByteSize;
UINTN ShortLba;
UINTN CheckLba;
UINTN BlockSize;
BIOS_LEGACY_DRIVE *Bios;
UINTN CarryFlag;
UINTN Retry;
EFI_BLOCK_IO_PROTOCOL *BlockIo;
Media = This->Media;
BlockSize = Media->BlockSize;
if (!BlockSize) {
return EFI_NO_MEDIA;
}
ZeroMem (&Regs, sizeof (IA32_REGISTER_SET));
if (MediaId != Media->MediaId) {
return EFI_MEDIA_CHANGED;
}
if (Lba > Media->LastBlock) {
return EFI_INVALID_PARAMETER;
}
if ((Lba + (BufferSize / BlockSize) - 1) > Media->LastBlock) {
return EFI_INVALID_PARAMETER;
}
if (BufferSize % BlockSize != 0) {
return EFI_BAD_BUFFER_SIZE;
}
if (Buffer == NULL) {
return EFI_INVALID_PARAMETER;
}
if (BufferSize == 0) {
return EFI_SUCCESS;
}
BiosBlockIoDev = BIOS_BLOCK_IO_FROM_THIS (This);
if (BiosBlockIoDev->Bios.ErrorCode == BIOS_SECTOR_NOT_FOUND || BiosBlockIoDev->Bios.ErrorCode == BIOS_DRIVE_DOES_NOT_EXIST) {
return EFI_DEVICE_ERROR;
}
ShortLba = (UINTN) Lba;
while (BufferSize != 0) {
//
// Compute I/O location in Sector, Head, Cylinder format
//
Sector = (ShortLba % BiosBlockIoDev->Bios.MaxSector) + 1;
Temp = ShortLba / BiosBlockIoDev->Bios.MaxSector;
Head = Temp % (BiosBlockIoDev->Bios.MaxHead + 1);
Cylinder = Temp / (BiosBlockIoDev->Bios.MaxHead + 1);
//
// Limit transfer to this Head & Cylinder
//
NumberOfBlocks = BufferSize / BlockSize;
Temp = BiosBlockIoDev->Bios.MaxSector - Sector + 1;
NumberOfBlocks = NumberOfBlocks > Temp ? Temp : NumberOfBlocks;
Retry = 3;
do {
//
// Perform the IO
//
Regs.H.AH = 2;
Regs.H.AL = (UINT8) NumberOfBlocks;
Regs.H.DL = BiosBlockIoDev->Bios.Number;
UpperCylinder = (Cylinder & 0x0f00) >> 2;
CheckLba = Cylinder * (BiosBlockIoDev->Bios.MaxHead + 1) + Head;
CheckLba = CheckLba * BiosBlockIoDev->Bios.MaxSector + Sector - 1;
/* DBG("RLD: LBA %x (%x), Sector %x (%x), Head %x (%x), Cyl %x, UCyl %x\n",
ShortLba,
CheckLba,
Sector,
BiosBlockIoDev->Bios.MaxSector,
Head,
BiosBlockIoDev->Bios.MaxHead,
Cylinder,
UpperCylinder
); */
// ASSERT (CheckLba == ShortLba);
if (CheckLba != ShortLba) {
DBG("CheckLba != ShortLba");
return EFI_DEVICE_ERROR;
}
Regs.H.CL = (UINT8) ((Sector & 0x3f) + (UpperCylinder & 0xff));
Regs.H.DH = (UINT8) (Head & 0x3f);
Regs.H.CH = (UINT8) (Cylinder & 0xff);
Regs.X.BX = EFI_OFFSET (mEdd11Buffer);
Regs.E.ES = EFI_SEGMENT (mEdd11Buffer);
/* DBG("INT 13h: AX:(02%02x) DX:(%02x%02x) CX:(%02x%02x) BX:(%04x) ES:(%04x)\n",
Regs.H.AL,
(UINT8) (Head & 0x3f),
Regs.H.DL,
(UINT8) (Cylinder & 0xff),
(UINT8) ((Sector & 0x3f) + (UpperCylinder & 0xff)),
EFI_OFFSET (mEdd11Buffer),
EFI_SEGMENT (mEdd11Buffer)
);
*/
// CarryFlag = BiosBlockIoDev->LegacyBios->Int86 (BiosBlockIoDev->LegacyBios, 0x13, &Regs);
CarryFlag = LegacyBiosInt86 (BiosBlockIoDev, 0x13, &Regs);
// DBG("BiosReadLegacyDrive: INT 13 02 DL=%02x : CF=%d AH=%02x\n",
// BiosBlockIoDev->Bios.Number, CarryFlag, Regs.H.AH);
Retry--;
} while (CarryFlag != 0 && Retry != 0 && Regs.H.AH != BIOS_DISK_CHANGED);
Media->MediaPresent = TRUE;
if (CarryFlag != 0) {
//
// Return Error Status
//
BiosBlockIoDev->Bios.ErrorCode = Regs.H.AH;
if (BiosBlockIoDev->Bios.ErrorCode == BIOS_DISK_CHANGED) {
Media->MediaId++;
Bios = &BiosBlockIoDev->Bios;
if (Int13GetDeviceParameters (BiosBlockIoDev, Bios) != 0) {
//
// If the size of the media changed we need to reset the disk geometry
//
if (Int13Extensions (BiosBlockIoDev, Bios) != 0) {
Media->LastBlock = (EFI_LBA) Bios->Parameters.PhysicalSectors - 1;
Media->BlockSize = (UINT32) Bios->Parameters.BytesPerSector;
} else {
//
// Legacy Interfaces
//
Media->LastBlock = (Bios->MaxHead + 1) * Bios->MaxSector * (Bios->MaxCylinder + 1) - 1;
Media->BlockSize = 512;
}
Media->ReadOnly = FALSE;
gBS->HandleProtocol (BiosBlockIoDev->Handle, &gEfiBlockIoProtocolGuid, (VOID **) &BlockIo);
gBS->ReinstallProtocolInterface (BiosBlockIoDev->Handle, &gEfiBlockIoProtocolGuid, BlockIo, BlockIo);
return EFI_MEDIA_CHANGED;
}
}
if (Media->RemovableMedia) {
Media->MediaPresent = FALSE;
}
return EFI_DEVICE_ERROR;
}
TransferByteSize = NumberOfBlocks * BlockSize;
CopyMem (Buffer, mEdd11Buffer, TransferByteSize);
ShortLba = ShortLba + NumberOfBlocks;
BufferSize = BufferSize - TransferByteSize;
Buffer = (VOID *) ((UINT8 *) Buffer + TransferByteSize);
}
return EFI_SUCCESS;
}
EFI_STATUS
EFIAPI
BiosReadLegacyDriveEx (
IN EFI_BLOCK_IO2_PROTOCOL *This,
IN UINT32 MediaId,
IN EFI_LBA Lba,
IN OUT EFI_BLOCK_IO2_TOKEN *Token,
IN UINTN BufferSize,
OUT VOID *Buffer
)
{
EFI_BLOCK_IO_MEDIA *Media;
BIOS_BLOCK_IO_DEV *BiosBlockIoDev;
IA32_REGISTER_SET Regs;
UINTN UpperCylinder;
UINTN Temp;
UINTN Cylinder;
UINTN Head;
UINTN Sector;
UINTN NumberOfBlocks;
UINTN TransferByteSize;
UINTN ShortLba;
UINTN CheckLba;
UINTN BlockSize;
BIOS_LEGACY_DRIVE *Bios;
UINTN CarryFlag;
UINTN Retry;
EFI_BLOCK_IO2_PROTOCOL *BlockIo2;
Media = This->Media;
BlockSize = Media->BlockSize;
if (!BlockSize) {
return EFI_NO_MEDIA;
}
ZeroMem (&Regs, sizeof (IA32_REGISTER_SET));
if (MediaId != Media->MediaId) {
return EFI_MEDIA_CHANGED;
}
if (Lba > Media->LastBlock) {
return EFI_INVALID_PARAMETER;
}
if ((Lba + (BufferSize / BlockSize) - 1) > Media->LastBlock) {
return EFI_INVALID_PARAMETER;
}
if (BufferSize % BlockSize != 0) {
return EFI_BAD_BUFFER_SIZE;
}
if (Buffer == NULL) {
return EFI_INVALID_PARAMETER;
}
if (BufferSize == 0) {
return EFI_SUCCESS;
}
BiosBlockIoDev = BIOS_BLOCK_IO2_FROM_THIS (This);
if (BiosBlockIoDev->Bios.ErrorCode == BIOS_SECTOR_NOT_FOUND || BiosBlockIoDev->Bios.ErrorCode == BIOS_DRIVE_DOES_NOT_EXIST) {
return EFI_DEVICE_ERROR;
}
ShortLba = (UINTN) Lba;
while (BufferSize != 0) {
//
// Compute I/O location in Sector, Head, Cylinder format
//
Sector = (ShortLba % BiosBlockIoDev->Bios.MaxSector) + 1;
Temp = ShortLba / BiosBlockIoDev->Bios.MaxSector;
Head = Temp % (BiosBlockIoDev->Bios.MaxHead + 1);
Cylinder = Temp / (BiosBlockIoDev->Bios.MaxHead + 1);
//
// Limit transfer to this Head & Cylinder
//
NumberOfBlocks = BufferSize / BlockSize;
Temp = BiosBlockIoDev->Bios.MaxSector - Sector + 1;
NumberOfBlocks = NumberOfBlocks > Temp ? Temp : NumberOfBlocks;
Retry = 3;
do {
//
// Perform the IO
//
Regs.H.AH = 2;
Regs.H.AL = (UINT8) NumberOfBlocks;
Regs.H.DL = BiosBlockIoDev->Bios.Number;
UpperCylinder = (Cylinder & 0x0f00) >> 2;
CheckLba = Cylinder * (BiosBlockIoDev->Bios.MaxHead + 1) + Head;
CheckLba = CheckLba * BiosBlockIoDev->Bios.MaxSector + Sector - 1;
/* DBG("RLD: LBA %x (%x), Sector %x (%x), Head %x (%x), Cyl %x, UCyl %x\n",
ShortLba,
CheckLba,
Sector,
BiosBlockIoDev->Bios.MaxSector,
Head,
BiosBlockIoDev->Bios.MaxHead,
Cylinder,
UpperCylinder
); */
// ASSERT (CheckLba == ShortLba);
if (CheckLba != ShortLba) {
DBG("CheckLba != ShortLba");
return EFI_DEVICE_ERROR;
}
Regs.H.CL = (UINT8) ((Sector & 0x3f) + (UpperCylinder & 0xff));
Regs.H.DH = (UINT8) (Head & 0x3f);
Regs.H.CH = (UINT8) (Cylinder & 0xff);
Regs.X.BX = EFI_OFFSET (mEdd11Buffer);
Regs.E.ES = EFI_SEGMENT (mEdd11Buffer);
/* DBG("INT 13h: AX:(02%02x) DX:(%02x%02x) CX:(%02x%02x) BX:(%04x) ES:(%04x)\n",
Regs.H.AL,
(UINT8) (Head & 0x3f),
Regs.H.DL,
(UINT8) (Cylinder & 0xff),
(UINT8) ((Sector & 0x3f) + (UpperCylinder & 0xff)),
EFI_OFFSET (mEdd11Buffer),
EFI_SEGMENT (mEdd11Buffer)
);
*/
// CarryFlag = BiosBlockIoDev->LegacyBios->Int86 (BiosBlockIoDev->LegacyBios, 0x13, &Regs);
CarryFlag = LegacyBiosInt86 (BiosBlockIoDev, 0x13, &Regs);
// DBG("BiosReadLegacyDrive: INT 13 02 DL=%02x : CF=%d AH=%02x\n",
// BiosBlockIoDev->Bios.Number, CarryFlag, Regs.H.AH);
Retry--;
} while (CarryFlag != 0 && Retry != 0 && Regs.H.AH != BIOS_DISK_CHANGED);
Media->MediaPresent = TRUE;
if (CarryFlag != 0) {
//
// Return Error Status
//
BiosBlockIoDev->Bios.ErrorCode = Regs.H.AH;
if (BiosBlockIoDev->Bios.ErrorCode == BIOS_DISK_CHANGED) {
Media->MediaId++;
Bios = &BiosBlockIoDev->Bios;
if (Int13GetDeviceParameters (BiosBlockIoDev, Bios) != 0) {
//
// If the size of the media changed we need to reset the disk geometry
//
if (Int13Extensions (BiosBlockIoDev, Bios) != 0) {
Media->LastBlock = (EFI_LBA) Bios->Parameters.PhysicalSectors - 1;
Media->BlockSize = (UINT32) Bios->Parameters.BytesPerSector;
} else {
//
// Legacy Interfaces
//
Media->LastBlock = (Bios->MaxHead + 1) * Bios->MaxSector * (Bios->MaxCylinder + 1) - 1;
Media->BlockSize = 512;
}
Media->ReadOnly = FALSE;
gBS->HandleProtocol (BiosBlockIoDev->Handle, &gEfiBlockIo2ProtocolGuid, (VOID **) &BlockIo2);
gBS->ReinstallProtocolInterface (BiosBlockIoDev->Handle, &gEfiBlockIo2ProtocolGuid, BlockIo2, BlockIo2);
return EFI_MEDIA_CHANGED;
}
}
if (Media->RemovableMedia) {
Media->MediaPresent = FALSE;
}
return EFI_DEVICE_ERROR;
}
TransferByteSize = NumberOfBlocks * BlockSize;
CopyMem (Buffer, mEdd11Buffer, TransferByteSize);
ShortLba = ShortLba + NumberOfBlocks;
BufferSize = BufferSize - TransferByteSize;
Buffer = (VOID *) ((UINT8 *) Buffer + TransferByteSize);
}
return EFI_SUCCESS;
}
/**
Write BufferSize bytes from Lba into Buffer.
@param This Indicates a pointer to the calling context.
@param MediaId The media ID that the write request is for.
@param Lba The starting logical block address to be written. The caller is
responsible for writing to only legitimate locations.
@param BufferSize Size of Buffer, must be a multiple of device block size.
@param Buffer A pointer to the source buffer for the data.
@retval EFI_SUCCESS The data was written correctly to the device.
@retval EFI_WRITE_PROTECTED The device can not be written to.
@retval EFI_DEVICE_ERROR The device reported an error while performing the write.
@retval EFI_NO_MEDIA There is no media in the device.
@retval EFI_MEDIA_CHNAGED The MediaId does not matched the current device.
@retval EFI_BAD_BUFFER_SIZE The Buffer was not a multiple of the block size of the device.
@retval EFI_INVALID_PARAMETER The write request contains LBAs that are not valid,
or the buffer is not on proper alignment.
**/
EFI_STATUS
EFIAPI
BiosWriteLegacyDrive (
IN EFI_BLOCK_IO_PROTOCOL *This,
IN UINT32 MediaId,
IN EFI_LBA Lba,
IN UINTN BufferSize,
OUT VOID *Buffer
)
{
EFI_BLOCK_IO_MEDIA *Media;
BIOS_BLOCK_IO_DEV *BiosBlockIoDev;
IA32_REGISTER_SET Regs;
UINTN UpperCylinder;
UINTN Temp;
UINTN Cylinder;
UINTN Head;
UINTN Sector;
UINTN NumberOfBlocks;
UINTN TransferByteSize;
UINTN ShortLba;
UINTN CheckLba;
UINTN BlockSize;
BIOS_LEGACY_DRIVE *Bios;
UINTN CarryFlag;
UINTN Retry;
EFI_BLOCK_IO_PROTOCOL *BlockIo;
Media = This->Media;
BlockSize = Media->BlockSize;
if (!BlockSize) {
return EFI_NO_MEDIA;
}
ZeroMem (&Regs, sizeof (IA32_REGISTER_SET));
if (MediaId != Media->MediaId) {
return EFI_MEDIA_CHANGED;
}
if (Lba > Media->LastBlock) {
return EFI_INVALID_PARAMETER;
}
if ((Lba + (BufferSize / BlockSize) - 1) > Media->LastBlock) {
return EFI_INVALID_PARAMETER;
}
if (BufferSize % BlockSize != 0) {
return EFI_BAD_BUFFER_SIZE;
}
if (Buffer == NULL) {
return EFI_INVALID_PARAMETER;
}
if (BufferSize == 0) {
return EFI_SUCCESS;
}
BiosBlockIoDev = BIOS_BLOCK_IO_FROM_THIS (This);
if (BiosBlockIoDev->Bios.ErrorCode == BIOS_SECTOR_NOT_FOUND || BiosBlockIoDev->Bios.ErrorCode == BIOS_DRIVE_DOES_NOT_EXIST) {
return EFI_DEVICE_ERROR;
}
ShortLba = (UINTN) Lba;
while (BufferSize != 0) {
//
// Compute I/O location in Sector, Head, Cylinder format
//
Sector = (ShortLba % BiosBlockIoDev->Bios.MaxSector) + 1;
Temp = ShortLba / BiosBlockIoDev->Bios.MaxSector;
Head = Temp % (BiosBlockIoDev->Bios.MaxHead + 1);
Cylinder = Temp / (BiosBlockIoDev->Bios.MaxHead + 1);
//
// Limit transfer to this Head & Cylinder
//
NumberOfBlocks = BufferSize / BlockSize;
Temp = BiosBlockIoDev->Bios.MaxSector - Sector + 1;
NumberOfBlocks = NumberOfBlocks > Temp ? Temp : NumberOfBlocks;
Retry = 3;
do {
//
// Perform the IO
//
Regs.H.AH = 3;
Regs.H.AL = (UINT8) NumberOfBlocks;
Regs.H.DL = BiosBlockIoDev->Bios.Number;
UpperCylinder = (Cylinder & 0x0f00) >> 2;
CheckLba = Cylinder * (BiosBlockIoDev->Bios.MaxHead + 1) + Head;
CheckLba = CheckLba * BiosBlockIoDev->Bios.MaxSector + Sector - 1;
/* DBG("RLD: LBA %x (%x), Sector %x (%x), Head %x (%x), Cyl %x, UCyl %x\n",
ShortLba,
CheckLba,
Sector,
BiosBlockIoDev->Bios.MaxSector,
Head,
BiosBlockIoDev->Bios.MaxHead,
Cylinder,
UpperCylinder
);
*/
// ASSERT (CheckLba == ShortLba);
if (CheckLba != ShortLba) {
DBG("CheckLba != ShortLba");
return EFI_DEVICE_ERROR;
}
Regs.H.CL = (UINT8) ((Sector & 0x3f) + (UpperCylinder & 0xff));
Regs.H.DH = (UINT8) (Head & 0x3f);
Regs.H.CH = (UINT8) (Cylinder & 0xff);
Regs.X.BX = EFI_OFFSET (mEdd11Buffer);
Regs.E.ES = EFI_SEGMENT (mEdd11Buffer);
TransferByteSize = NumberOfBlocks * BlockSize;
CopyMem (mEdd11Buffer, Buffer, TransferByteSize);
/* DBG("INT 13h: AX:(03%02x) DX:(%02x%02x) CX:(%02x%02x) BX:(%04x) ES:(%04x)\n",
Regs.H.AL,
(UINT8) (Head & 0x3f),
Regs.H.DL,
(UINT8) (Cylinder & 0xff),
(UINT8) ((Sector & 0x3f) + (UpperCylinder & 0xff)),
EFI_OFFSET (mEdd11Buffer),
EFI_SEGMENT (mEdd11Buffer)
);
*/
// CarryFlag = BiosBlockIoDev->LegacyBios->Int86 (BiosBlockIoDev->LegacyBios, 0x13, &Regs);
CarryFlag = LegacyBiosInt86 (BiosBlockIoDev, 0x13, &Regs);
// DBG("BiosWriteLegacyDrive: INT 13 03 DL=%02x : CF=%d AH=%02x\n",
// BiosBlockIoDev->Bios.Number, CarryFlag, Regs.H.AH);
Retry--;
} while (CarryFlag != 0 && Retry != 0 && Regs.H.AH != BIOS_DISK_CHANGED);
Media->MediaPresent = TRUE;
if (CarryFlag != 0) {
//
// Return Error Status
//
BiosBlockIoDev->Bios.ErrorCode = Regs.H.AH;
if (BiosBlockIoDev->Bios.ErrorCode == BIOS_DISK_CHANGED) {
Media->MediaId++;
Bios = &BiosBlockIoDev->Bios;
if (Int13GetDeviceParameters (BiosBlockIoDev, Bios) != 0) {
if (Int13Extensions (BiosBlockIoDev, Bios) != 0) {
Media->LastBlock = (EFI_LBA) Bios->Parameters.PhysicalSectors - 1;
Media->BlockSize = (UINT32) Bios->Parameters.BytesPerSector;
} else {
//
// Legacy Interfaces
//
Media->LastBlock = (Bios->MaxHead + 1) * Bios->MaxSector * (Bios->MaxCylinder + 1) - 1;
Media->BlockSize = 512;
}
//
// If the size of the media changed we need to reset the disk geometry
//
Media->ReadOnly = FALSE;
gBS->HandleProtocol (BiosBlockIoDev->Handle, &gEfiBlockIoProtocolGuid, (VOID **) &BlockIo);
gBS->ReinstallProtocolInterface (BiosBlockIoDev->Handle, &gEfiBlockIoProtocolGuid, BlockIo, BlockIo);
return EFI_MEDIA_CHANGED;
}
} else if (BiosBlockIoDev->Bios.ErrorCode == BIOS_WRITE_PROTECTED) {
Media->ReadOnly = TRUE;
return EFI_WRITE_PROTECTED;
}
if (Media->RemovableMedia) {
Media->MediaPresent = FALSE;
}
return EFI_DEVICE_ERROR;
}
Media->ReadOnly = FALSE;
ShortLba = ShortLba + NumberOfBlocks;
BufferSize = BufferSize - TransferByteSize;
Buffer = (VOID *) ((UINT8 *) Buffer + TransferByteSize);
}
return EFI_SUCCESS;
}
EFI_STATUS
EFIAPI
BiosWriteLegacyDriveEx (
IN EFI_BLOCK_IO2_PROTOCOL *This,
IN UINT32 MediaId,
IN EFI_LBA Lba,
IN OUT EFI_BLOCK_IO2_TOKEN *Token,
IN UINTN BufferSize,
OUT VOID *Buffer
)
{
EFI_BLOCK_IO_MEDIA *Media;
BIOS_BLOCK_IO_DEV *BiosBlockIoDev;
IA32_REGISTER_SET Regs;
UINTN UpperCylinder;
UINTN Temp;
UINTN Cylinder;
UINTN Head;
UINTN Sector;
UINTN NumberOfBlocks;
UINTN TransferByteSize;
UINTN ShortLba;
UINTN CheckLba;
UINTN BlockSize;
BIOS_LEGACY_DRIVE *Bios;
UINTN CarryFlag;
UINTN Retry;
EFI_BLOCK_IO2_PROTOCOL *BlockIo2;
Media = This->Media;
BlockSize = Media->BlockSize;
if (!BlockSize) {
return EFI_NO_MEDIA;
}
ZeroMem (&Regs, sizeof (IA32_REGISTER_SET));
if (MediaId != Media->MediaId) {
return EFI_MEDIA_CHANGED;
}
if (Lba > Media->LastBlock) {
return EFI_INVALID_PARAMETER;
}
if ((Lba + (BufferSize / BlockSize) - 1) > Media->LastBlock) {
return EFI_INVALID_PARAMETER;
}
if (BufferSize % BlockSize != 0) {
return EFI_BAD_BUFFER_SIZE;
}
if (Buffer == NULL) {
return EFI_INVALID_PARAMETER;
}
if (BufferSize == 0) {
return EFI_SUCCESS;
}
BiosBlockIoDev = BIOS_BLOCK_IO2_FROM_THIS (This);
if (BiosBlockIoDev->Bios.ErrorCode == BIOS_SECTOR_NOT_FOUND || BiosBlockIoDev->Bios.ErrorCode == BIOS_DRIVE_DOES_NOT_EXIST) {
return EFI_DEVICE_ERROR;
}
ShortLba = (UINTN) Lba;
while (BufferSize != 0) {
//
// Compute I/O location in Sector, Head, Cylinder format
//
Sector = (ShortLba % BiosBlockIoDev->Bios.MaxSector) + 1;
Temp = ShortLba / BiosBlockIoDev->Bios.MaxSector;
Head = Temp % (BiosBlockIoDev->Bios.MaxHead + 1);
Cylinder = Temp / (BiosBlockIoDev->Bios.MaxHead + 1);
//
// Limit transfer to this Head & Cylinder
//
NumberOfBlocks = BufferSize / BlockSize;
Temp = BiosBlockIoDev->Bios.MaxSector - Sector + 1;
NumberOfBlocks = NumberOfBlocks > Temp ? Temp : NumberOfBlocks;
Retry = 3;
do {
//
// Perform the IO
//
Regs.H.AH = 3;
Regs.H.AL = (UINT8) NumberOfBlocks;
Regs.H.DL = BiosBlockIoDev->Bios.Number;
UpperCylinder = (Cylinder & 0x0f00) >> 2;
CheckLba = Cylinder * (BiosBlockIoDev->Bios.MaxHead + 1) + Head;
CheckLba = CheckLba * BiosBlockIoDev->Bios.MaxSector + Sector - 1;
/* DBG("RLD: LBA %x (%x), Sector %x (%x), Head %x (%x), Cyl %x, UCyl %x\n",
ShortLba,
CheckLba,
Sector,
BiosBlockIoDev->Bios.MaxSector,
Head,
BiosBlockIoDev->Bios.MaxHead,
Cylinder,
UpperCylinder
);
*/
// ASSERT (CheckLba == ShortLba);
if (CheckLba != ShortLba) {
DBG("CheckLba != ShortLba");
return EFI_DEVICE_ERROR;
}
Regs.H.CL = (UINT8) ((Sector & 0x3f) + (UpperCylinder & 0xff));
Regs.H.DH = (UINT8) (Head & 0x3f);
Regs.H.CH = (UINT8) (Cylinder & 0xff);
Regs.X.BX = EFI_OFFSET (mEdd11Buffer);
Regs.E.ES = EFI_SEGMENT (mEdd11Buffer);
TransferByteSize = NumberOfBlocks * BlockSize;
CopyMem (mEdd11Buffer, Buffer, TransferByteSize);
/* DBG("INT 13h: AX:(03%02x) DX:(%02x%02x) CX:(%02x%02x) BX:(%04x) ES:(%04x)\n",
Regs.H.AL,
(UINT8) (Head & 0x3f),
Regs.H.DL,
(UINT8) (Cylinder & 0xff),
(UINT8) ((Sector & 0x3f) + (UpperCylinder & 0xff)),
EFI_OFFSET (mEdd11Buffer),
EFI_SEGMENT (mEdd11Buffer)
);
*/
// CarryFlag = BiosBlockIoDev->LegacyBios->Int86 (BiosBlockIoDev->LegacyBios, 0x13, &Regs);
CarryFlag = LegacyBiosInt86 (BiosBlockIoDev, 0x13, &Regs);
// DBG("BiosWriteLegacyDrive: INT 13 03 DL=%02x : CF=%d AH=%02x\n",
// BiosBlockIoDev->Bios.Number, CarryFlag, Regs.H.AH);
Retry--;
} while (CarryFlag != 0 && Retry != 0 && Regs.H.AH != BIOS_DISK_CHANGED);
Media->MediaPresent = TRUE;
if (CarryFlag != 0) {
//
// Return Error Status
//
BiosBlockIoDev->Bios.ErrorCode = Regs.H.AH;
if (BiosBlockIoDev->Bios.ErrorCode == BIOS_DISK_CHANGED) {
Media->MediaId++;
Bios = &BiosBlockIoDev->Bios;
if (Int13GetDeviceParameters (BiosBlockIoDev, Bios) != 0) {
if (Int13Extensions (BiosBlockIoDev, Bios) != 0) {
Media->LastBlock = (EFI_LBA) Bios->Parameters.PhysicalSectors - 1;
Media->BlockSize = (UINT32) Bios->Parameters.BytesPerSector;
} else {
//
// Legacy Interfaces
//
Media->LastBlock = (Bios->MaxHead + 1) * Bios->MaxSector * (Bios->MaxCylinder + 1) - 1;
Media->BlockSize = 512;
}
//
// If the size of the media changed we need to reset the disk geometry
//
Media->ReadOnly = FALSE;
gBS->HandleProtocol (BiosBlockIoDev->Handle, &gEfiBlockIo2ProtocolGuid, (VOID **) &BlockIo2);
gBS->ReinstallProtocolInterface (BiosBlockIoDev->Handle, &gEfiBlockIo2ProtocolGuid, BlockIo2, BlockIo2);
return EFI_MEDIA_CHANGED;
}
} else if (BiosBlockIoDev->Bios.ErrorCode == BIOS_WRITE_PROTECTED) {
Media->ReadOnly = TRUE;
return EFI_WRITE_PROTECTED;
}
if (Media->RemovableMedia) {
Media->MediaPresent = FALSE;
}
return EFI_DEVICE_ERROR;
}
Media->ReadOnly = FALSE;
ShortLba = ShortLba + NumberOfBlocks;
BufferSize = BufferSize - TransferByteSize;
Buffer = (VOID *) ((UINT8 *) Buffer + TransferByteSize);
}
return EFI_SUCCESS;
}
Reference in New Issue View Git Blame Copy Permalink