Upstream/CloverBootloader
1
0
Fork 0
mirror of https://github.com/CloverHackyColor/CloverBootloader.git synced 2024-12-02 13:03:28 +01:00
Code Issues Packages Projects Releases Wiki Activity
986c00552d
CloverBootloader/MdeModulePkg/Bus/Pci/IdeBusPei/AtapiPeim.c
SergeySlice 01f33f7552 detect unknown linux versions, 
stylish change: remove space between func and brace

Signed-off-by: SergeySlice <sergey.slice@gmail.com>
2020-04-23 12:08:10 +03:00

2495 lines
75 KiB
C
Raw Blame History

/** @file
PEIM to produce gEfiPeiVirtualBlockIoPpiGuid & gEfiPeiVirtualBlockIo2PpiGuid PPI for
ATA controllers in the platform.
This PPI can be consumed by PEIM which produce gEfiPeiDeviceRecoveryModulePpiGuid
for Atapi CD ROM device.
Copyright (c) 2006 - 2018, Intel Corporation. All rights reserved.<BR>
SPDX-License-Identifier: BSD-2-Clause-Patent
**/
#include "AtapiPeim.h"
/**
Initializes the Atapi Block Io PPI.
@param[in] FileHandle Handle of the file being invoked.
@param[in] PeiServices Describes the list of possible PEI Services.
@retval EFI_SUCCESS Operation performed successfully.
@retval EFI_OUT_OF_RESOURCES Not enough memory to allocate.
**/
EFI_STATUS
EFIAPI
AtapiPeimEntry (
IN EFI_PEI_FILE_HANDLE FileHandle,
IN CONST EFI_PEI_SERVICES **PeiServices
)
{
PEI_ATA_CONTROLLER_PPI *AtaControllerPpi;
EFI_STATUS Status;
ATAPI_BLK_IO_DEV *AtapiBlkIoDev;
Status = PeiServicesRegisterForShadow (FileHandle);
if (!EFI_ERROR(Status)) {
return Status;
}
Status = PeiServicesLocatePpi (
&gPeiAtaControllerPpiGuid,
0,
NULL,
(VOID **) &AtaControllerPpi
);
ASSERT_EFI_ERROR(Status);
AtapiBlkIoDev = AllocatePages (EFI_SIZE_TO_PAGES (sizeof (*AtapiBlkIoDev)));
if (AtapiBlkIoDev == NULL) {
return EFI_OUT_OF_RESOURCES;
}
AtapiBlkIoDev->Signature = ATAPI_BLK_IO_DEV_SIGNATURE;
AtapiBlkIoDev->AtaControllerPpi = AtaControllerPpi;
//
// atapi device enumeration and build private data
//
AtapiEnumerateDevices (AtapiBlkIoDev);
AtapiBlkIoDev->AtapiBlkIo.GetNumberOfBlockDevices = AtapiGetNumberOfBlockDevices;
AtapiBlkIoDev->AtapiBlkIo.GetBlockDeviceMediaInfo = AtapiGetBlockDeviceMediaInfo;
AtapiBlkIoDev->AtapiBlkIo.ReadBlocks = AtapiReadBlocks;
AtapiBlkIoDev->AtapiBlkIo2.Revision = EFI_PEI_RECOVERY_BLOCK_IO2_PPI_REVISION;
AtapiBlkIoDev->AtapiBlkIo2.GetNumberOfBlockDevices = AtapiGetNumberOfBlockDevices2;
AtapiBlkIoDev->AtapiBlkIo2.GetBlockDeviceMediaInfo = AtapiGetBlockDeviceMediaInfo2;
AtapiBlkIoDev->AtapiBlkIo2.ReadBlocks = AtapiReadBlocks2;
AtapiBlkIoDev->PpiDescriptor.Flags = EFI_PEI_PPI_DESCRIPTOR_PPI;
AtapiBlkIoDev->PpiDescriptor.Guid = &gEfiPeiVirtualBlockIoPpiGuid;
AtapiBlkIoDev->PpiDescriptor.Ppi = &AtapiBlkIoDev->AtapiBlkIo;
AtapiBlkIoDev->PpiDescriptor2.Flags = (EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST);
AtapiBlkIoDev->PpiDescriptor2.Guid = &gEfiPeiVirtualBlockIo2PpiGuid;
AtapiBlkIoDev->PpiDescriptor2.Ppi = &AtapiBlkIoDev->AtapiBlkIo2;
DEBUG ((EFI_D_INFO, "Atatpi Device Count is %d\n", AtapiBlkIoDev->DeviceCount));
if (AtapiBlkIoDev->DeviceCount != 0) {
Status = PeiServicesInstallPpi (&AtapiBlkIoDev->PpiDescriptor);
if (EFI_ERROR(Status)) {
return EFI_OUT_OF_RESOURCES;
}
}
return EFI_SUCCESS;
}
/**
Gets the count of block I/O devices that one specific block driver detects.
This function is used for getting the count of block I/O devices that one
specific block driver detects. To the PEI ATAPI driver, it returns the number
of all the detected ATAPI devices it detects during the enumeration process.
To the PEI legacy floppy driver, it returns the number of all the legacy
devices it finds during its enumeration process. If no device is detected,
then the function will return zero.
@param[in] PeiServices General-purpose services that are available
to every PEIM.
@param[in] This Indicates the EFI_PEI_RECOVERY_BLOCK_IO_PPI
instance.
@param[out] NumberBlockDevices The number of block I/O devices discovered.
@retval EFI_SUCCESS Operation performed successfully.
**/
EFI_STATUS
EFIAPI
AtapiGetNumberOfBlockDevices (
IN EFI_PEI_SERVICES **PeiServices,
IN EFI_PEI_RECOVERY_BLOCK_IO_PPI *This,
OUT UINTN *NumberBlockDevices
)
{
ATAPI_BLK_IO_DEV *AtapiBlkIoDev;
AtapiBlkIoDev = NULL;
AtapiBlkIoDev = PEI_RECOVERY_ATAPI_FROM_BLKIO_THIS (This);
*NumberBlockDevices = AtapiBlkIoDev->DeviceCount;
return EFI_SUCCESS;
}
/**
Gets a block device's media information.
This function will provide the caller with the specified block device's media
information. If the media changes, calling this function will update the media
information accordingly.
@param[in] PeiServices General-purpose services that are available to every
PEIM
@param[in] This Indicates the EFI_PEI_RECOVERY_BLOCK_IO_PPI instance.
@param[in] DeviceIndex Specifies the block device to which the function wants
to talk. Because the driver that implements Block I/O
PPIs will manage multiple block devices, the PPIs that
want to talk to a single device must specify the
device index that was assigned during the enumeration
process. This index is a number from one to
NumberBlockDevices.
@param[out] MediaInfo The media information of the specified block media.
The caller is responsible for the ownership of this
data structure.
@retval EFI_SUCCESS Media information about the specified block device
was obtained successfully.
@retval EFI_DEVICE_ERROR Cannot get the media information due to a hardware
error.
@retval Others Other failure occurs.
**/
EFI_STATUS
EFIAPI
AtapiGetBlockDeviceMediaInfo (
IN EFI_PEI_SERVICES **PeiServices,
IN EFI_PEI_RECOVERY_BLOCK_IO_PPI *This,
IN UINTN DeviceIndex,
OUT EFI_PEI_BLOCK_IO_MEDIA *MediaInfo
)
{
UINTN DeviceCount;
ATAPI_BLK_IO_DEV *AtapiBlkIoDev;
EFI_STATUS Status;
UINTN Index;
AtapiBlkIoDev = NULL;
if (This == NULL || MediaInfo == NULL) {
return EFI_INVALID_PARAMETER;
}
AtapiBlkIoDev = PEI_RECOVERY_ATAPI_FROM_BLKIO_THIS (This);
DeviceCount = AtapiBlkIoDev->DeviceCount;
//
// DeviceIndex is a value from 1 to NumberBlockDevices.
//
if ((DeviceIndex < 1) || (DeviceIndex > DeviceCount) || (DeviceIndex > MAX_IDE_DEVICES)) {
return EFI_INVALID_PARAMETER;
}
Index = DeviceIndex - 1;
//
// probe media and retrieve latest media information
//
DEBUG ((EFI_D_INFO, "Atatpi GetInfo DevicePosition is %d\n", AtapiBlkIoDev->DeviceInfo[Index].DevicePosition));
DEBUG ((EFI_D_INFO, "Atatpi GetInfo DeviceType is %d\n", AtapiBlkIoDev->DeviceInfo[Index].MediaInfo.DeviceType));
DEBUG ((EFI_D_INFO, "Atatpi GetInfo MediaPresent is %d\n", AtapiBlkIoDev->DeviceInfo[Index].MediaInfo.MediaPresent));
DEBUG ((EFI_D_INFO, "Atatpi GetInfo BlockSize is 0x%x\n", AtapiBlkIoDev->DeviceInfo[Index].MediaInfo.BlockSize));
DEBUG ((EFI_D_INFO, "Atatpi GetInfo LastBlock is 0x%x\n", AtapiBlkIoDev->DeviceInfo[Index].MediaInfo.LastBlock));
Status = DetectMedia (
AtapiBlkIoDev,
AtapiBlkIoDev->DeviceInfo[Index].DevicePosition,
&AtapiBlkIoDev->DeviceInfo[Index].MediaInfo,
&AtapiBlkIoDev->DeviceInfo[Index].MediaInfo2
);
if (Status != EFI_SUCCESS) {
return EFI_DEVICE_ERROR;
}
DEBUG ((EFI_D_INFO, "Atatpi GetInfo DevicePosition is %d\n", AtapiBlkIoDev->DeviceInfo[Index].DevicePosition));
DEBUG ((EFI_D_INFO, "Atatpi GetInfo DeviceType is %d\n", AtapiBlkIoDev->DeviceInfo[Index].MediaInfo.DeviceType));
DEBUG ((EFI_D_INFO, "Atatpi GetInfo MediaPresent is %d\n", AtapiBlkIoDev->DeviceInfo[Index].MediaInfo.MediaPresent));
DEBUG ((EFI_D_INFO, "Atatpi GetInfo BlockSize is 0x%x\n", AtapiBlkIoDev->DeviceInfo[Index].MediaInfo.BlockSize));
DEBUG ((EFI_D_INFO, "Atatpi GetInfo LastBlock is 0x%x\n", AtapiBlkIoDev->DeviceInfo[Index].MediaInfo.LastBlock));
//
// Get media info from AtapiBlkIoDev
//
CopyMem (MediaInfo, &AtapiBlkIoDev->DeviceInfo[Index].MediaInfo, sizeof(EFI_PEI_BLOCK_IO_MEDIA));
return EFI_SUCCESS;
}
/**
Reads the requested number of blocks from the specified block device.
The function reads the requested number of blocks from the device. All the
blocks are read, or an error is returned. If there is no media in the device,
the function returns EFI_NO_MEDIA.
@param[in] PeiServices General-purpose services that are available to
every PEIM.
@param[in] This Indicates the EFI_PEI_RECOVERY_BLOCK_IO_PPI instance.
@param[in] DeviceIndex Specifies the block device to which the function wants
to talk. Because the driver that implements Block I/O
PPIs will manage multiple block devices, the PPIs that
want to talk to a single device must specify the device
index that was assigned during the enumeration process.
This index is a number from one to NumberBlockDevices.
@param[in] StartLBA The starting logical block address (LBA) to read from
on the device
@param[in] BufferSize The size of the Buffer in bytes. This number must be
a multiple of the intrinsic block size of the device.
@param[out] Buffer A pointer to the destination buffer for the data.
The caller is responsible for the 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 attempting
to perform the read operation.
@retval EFI_INVALID_PARAMETER The read request contains LBAs that are not
valid, or the buffer is not properly aligned.
@retval EFI_NO_MEDIA There is no media in the device.
@retval EFI_BAD_BUFFER_SIZE The BufferSize parameter is not a multiple of
the intrinsic block size of the device.
**/
EFI_STATUS
EFIAPI
AtapiReadBlocks (
IN EFI_PEI_SERVICES **PeiServices,
IN EFI_PEI_RECOVERY_BLOCK_IO_PPI *This,
IN UINTN DeviceIndex,
IN EFI_PEI_LBA StartLBA,
IN UINTN BufferSize,
OUT VOID *Buffer
)
{
EFI_PEI_BLOCK_IO_MEDIA MediaInfo;
EFI_STATUS Status;
UINTN NumberOfBlocks;
UINTN BlockSize;
ATAPI_BLK_IO_DEV *AtapiBlkIoDev;
AtapiBlkIoDev = NULL;
if (This == NULL) {
return EFI_INVALID_PARAMETER;
}
AtapiBlkIoDev = PEI_RECOVERY_ATAPI_FROM_BLKIO_THIS (This);
if (Buffer == NULL) {
return EFI_INVALID_PARAMETER;
}
if (BufferSize == 0) {
return EFI_SUCCESS;
}
Status = AtapiGetBlockDeviceMediaInfo (
PeiServices,
This,
DeviceIndex,
&MediaInfo
);
if (Status != EFI_SUCCESS) {
return EFI_DEVICE_ERROR;
}
if (!MediaInfo.MediaPresent) {
return EFI_NO_MEDIA;
}
BlockSize = MediaInfo.BlockSize;
if (BufferSize % BlockSize != 0) {
return EFI_BAD_BUFFER_SIZE;
}
NumberOfBlocks = BufferSize / BlockSize;
if ((StartLBA + NumberOfBlocks - 1) > AtapiBlkIoDev->DeviceInfo[DeviceIndex - 1].MediaInfo2.LastBlock) {
return EFI_INVALID_PARAMETER;
}
Status = ReadSectors (
AtapiBlkIoDev,
AtapiBlkIoDev->DeviceInfo[DeviceIndex - 1].DevicePosition,
Buffer,
StartLBA,
NumberOfBlocks,
BlockSize
);
if (EFI_ERROR(Status)) {
return EFI_DEVICE_ERROR;
}
return EFI_SUCCESS;
}
/**
Gets the count of block I/O devices that one specific block driver detects.
This function is used for getting the count of block I/O devices that one
specific block driver detects. To the PEI ATAPI driver, it returns the number
of all the detected ATAPI devices it detects during the enumeration process.
To the PEI legacy floppy driver, it returns the number of all the legacy
devices it finds during its enumeration process. If no device is detected,
then the function will return zero.
@param[in] PeiServices General-purpose services that are available
to every PEIM.
@param[in] This Indicates the EFI_PEI_RECOVERY_BLOCK_IO2_PPI
instance.
@param[out] NumberBlockDevices The number of block I/O devices discovered.
@retval EFI_SUCCESS Operation performed successfully.
**/
EFI_STATUS
EFIAPI
AtapiGetNumberOfBlockDevices2 (
IN EFI_PEI_SERVICES **PeiServices,
IN EFI_PEI_RECOVERY_BLOCK_IO2_PPI *This,
OUT UINTN *NumberBlockDevices
)
{
EFI_STATUS Status;
ATAPI_BLK_IO_DEV *AtapiBlkIoDev;
AtapiBlkIoDev = PEI_RECOVERY_ATAPI_FROM_BLKIO2_THIS (This);
Status = AtapiGetNumberOfBlockDevices (
PeiServices,
&AtapiBlkIoDev->AtapiBlkIo,
NumberBlockDevices
);
return Status;
}
/**
Gets a block device's media information.
This function will provide the caller with the specified block device's media
information. If the media changes, calling this function will update the media
information accordingly.
@param[in] PeiServices General-purpose services that are available to every
PEIM
@param[in] This Indicates the EFI_PEI_RECOVERY_BLOCK_IO2_PPI instance.
@param[in] DeviceIndex Specifies the block device to which the function wants
to talk. Because the driver that implements Block I/O
PPIs will manage multiple block devices, the PPIs that
want to talk to a single device must specify the
device index that was assigned during the enumeration
process. This index is a number from one to
NumberBlockDevices.
@param[out] MediaInfo The media information of the specified block media.
The caller is responsible for the ownership of this
data structure.
@retval EFI_SUCCESS Media information about the specified block device
was obtained successfully.
@retval EFI_DEVICE_ERROR Cannot get the media information due to a hardware
error.
@retval Others Other failure occurs.
**/
EFI_STATUS
EFIAPI
AtapiGetBlockDeviceMediaInfo2 (
IN EFI_PEI_SERVICES **PeiServices,
IN EFI_PEI_RECOVERY_BLOCK_IO2_PPI *This,
IN UINTN DeviceIndex,
OUT EFI_PEI_BLOCK_IO2_MEDIA *MediaInfo
)
{
ATAPI_BLK_IO_DEV *AtapiBlkIoDev;
EFI_STATUS Status;
EFI_PEI_BLOCK_IO_MEDIA Media;
AtapiBlkIoDev = NULL;
if (This == NULL || MediaInfo == NULL) {
return EFI_INVALID_PARAMETER;
}
AtapiBlkIoDev = PEI_RECOVERY_ATAPI_FROM_BLKIO2_THIS (This);
Status = AtapiGetBlockDeviceMediaInfo (
PeiServices,
&AtapiBlkIoDev->AtapiBlkIo,
DeviceIndex,
&Media
);
if (EFI_ERROR(Status)) {
return Status;
}
//
// Get media info from AtapiBlkIoDev
//
CopyMem (MediaInfo, &AtapiBlkIoDev->DeviceInfo[DeviceIndex - 1].MediaInfo2, sizeof(EFI_PEI_BLOCK_IO2_MEDIA));
return EFI_SUCCESS;
}
/**
Reads the requested number of blocks from the specified block device.
The function reads the requested number of blocks from the device. All the
blocks are read, or an error is returned. If there is no media in the device,
the function returns EFI_NO_MEDIA.
@param[in] PeiServices General-purpose services that are available to
every PEIM.
@param[in] This Indicates the EFI_PEI_RECOVERY_BLOCK_IO2_PPI instance.
@param[in] DeviceIndex Specifies the block device to which the function wants
to talk. Because the driver that implements Block I/O
PPIs will manage multiple block devices, the PPIs that
want to talk to a single device must specify the device
index that was assigned during the enumeration process.
This index is a number from one to NumberBlockDevices.
@param[in] StartLBA The starting logical block address (LBA) to read from
on the device
@param[in] BufferSize The size of the Buffer in bytes. This number must be
a multiple of the intrinsic block size of the device.
@param[out] Buffer A pointer to the destination buffer for the data.
The caller is responsible for the 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 attempting
to perform the read operation.
@retval EFI_INVALID_PARAMETER The read request contains LBAs that are not
valid, or the buffer is not properly aligned.
@retval EFI_NO_MEDIA There is no media in the device.
@retval EFI_BAD_BUFFER_SIZE The BufferSize parameter is not a multiple of
the intrinsic block size of the device.
**/
EFI_STATUS
EFIAPI
AtapiReadBlocks2 (
IN EFI_PEI_SERVICES **PeiServices,
IN EFI_PEI_RECOVERY_BLOCK_IO2_PPI *This,
IN UINTN DeviceIndex,
IN EFI_PEI_LBA StartLBA,
IN UINTN BufferSize,
OUT VOID *Buffer
)
{
EFI_STATUS Status;
ATAPI_BLK_IO_DEV *AtapiBlkIoDev;
AtapiBlkIoDev = NULL;
if (This == NULL) {
return EFI_INVALID_PARAMETER;
}
AtapiBlkIoDev = PEI_RECOVERY_ATAPI_FROM_BLKIO2_THIS (This);
Status = AtapiReadBlocks (
PeiServices,
&AtapiBlkIoDev->AtapiBlkIo,
DeviceIndex,
StartLBA,
BufferSize,
Buffer
);
return Status;
}
/**
Enumerate Atapi devices.
This function is used to enumerate Atatpi device in Ide channel.
@param[in] AtapiBlkIoDev A pointer to atapi block IO device
**/
VOID
AtapiEnumerateDevices (
IN ATAPI_BLK_IO_DEV *AtapiBlkIoDev
)
{
UINT8 Index1;
UINT8 Index2;
UINTN DevicePosition;
EFI_PEI_BLOCK_IO_MEDIA MediaInfo;
EFI_PEI_BLOCK_IO2_MEDIA MediaInfo2;
EFI_STATUS Status;
UINTN DeviceCount;
UINT16 CommandBlockBaseAddr;
UINT16 ControlBlockBaseAddr;
UINT32 IdeEnabledNumber;
IDE_REGS_BASE_ADDR IdeRegsBaseAddr[MAX_IDE_CHANNELS];
DeviceCount = 0;
DevicePosition = 0;
//
// Scan IDE bus for ATAPI devices
//
//
// Enable Sata and IDE controller.
//
AtapiBlkIoDev->AtaControllerPpi->EnableAtaChannel (
(EFI_PEI_SERVICES **) GetPeiServicesTablePointer(),
AtapiBlkIoDev->AtaControllerPpi,
PEI_ICH_IDE_PRIMARY | PEI_ICH_IDE_SECONDARY
);
//
// Allow SATA Devices to spin-up. This is needed if
// SEC and PEI phase is too short, for example Release Build.
//
DEBUG ((EFI_D_INFO, "Delay for %d seconds for SATA devices to spin-up\n", PcdGet16 (PcdSataSpinUpDelayInSecForRecoveryPath)));
MicroSecondDelay (PcdGet16 (PcdSataSpinUpDelayInSecForRecoveryPath) * 1000 * 1000); //
//
// Get four channels (primary or secondary Pata, Sata Channel) Command and Control Regs Base address.
//
IdeEnabledNumber = AtapiBlkIoDev->AtaControllerPpi->GetIdeRegsBaseAddr (
(EFI_PEI_SERVICES **) GetPeiServicesTablePointer(),
AtapiBlkIoDev->AtaControllerPpi,
IdeRegsBaseAddr
);
//
// Using Command and Control Regs Base Address to fill other registers.
//
for (Index1 = 0; Index1 < IdeEnabledNumber; Index1 ++) {
CommandBlockBaseAddr = IdeRegsBaseAddr[Index1].CommandBlockBaseAddr;
AtapiBlkIoDev->IdeIoPortReg[Index1].Data = CommandBlockBaseAddr;
AtapiBlkIoDev->IdeIoPortReg[Index1].Reg1.Feature = (UINT16) (CommandBlockBaseAddr + 0x1);
AtapiBlkIoDev->IdeIoPortReg[Index1].SectorCount = (UINT16) (CommandBlockBaseAddr + 0x2);
AtapiBlkIoDev->IdeIoPortReg[Index1].SectorNumber = (UINT16) (CommandBlockBaseAddr + 0x3);
AtapiBlkIoDev->IdeIoPortReg[Index1].CylinderLsb = (UINT16) (CommandBlockBaseAddr + 0x4);
AtapiBlkIoDev->IdeIoPortReg[Index1].CylinderMsb = (UINT16) (CommandBlockBaseAddr + 0x5);
AtapiBlkIoDev->IdeIoPortReg[Index1].Head = (UINT16) (CommandBlockBaseAddr + 0x6);
AtapiBlkIoDev->IdeIoPortReg[Index1].Reg.Command = (UINT16) (CommandBlockBaseAddr + 0x7);
ControlBlockBaseAddr = IdeRegsBaseAddr[Index1].ControlBlockBaseAddr;
AtapiBlkIoDev->IdeIoPortReg[Index1].Alt.DeviceControl = ControlBlockBaseAddr;
AtapiBlkIoDev->IdeIoPortReg[Index1].DriveAddress = (UINT16) (ControlBlockBaseAddr + 0x1);
//
// Scan IDE bus for ATAPI devices IDE or Sata device
//
for (Index2 = IdeMaster; Index2 < IdeMaxDevice; Index2++) {
//
// Pata & Sata, Primary & Secondary channel, Master & Slave device
//
DevicePosition = Index1 * 2 + Index2;
if (DiscoverAtapiDevice (AtapiBlkIoDev, DevicePosition, &MediaInfo, &MediaInfo2)) {
//
// ATAPI Device at DevicePosition is found.
//
AtapiBlkIoDev->DeviceInfo[DeviceCount].DevicePosition = DevicePosition;
//
// Retrieve Media Info
//
Status = DetectMedia (AtapiBlkIoDev, DevicePosition, &MediaInfo, &MediaInfo2);
CopyMem (&(AtapiBlkIoDev->DeviceInfo[DeviceCount].MediaInfo), &MediaInfo, sizeof (MediaInfo));
CopyMem (&(AtapiBlkIoDev->DeviceInfo[DeviceCount].MediaInfo2), &MediaInfo2, sizeof (MediaInfo2));
DEBUG ((EFI_D_INFO, "Atatpi Device Position is %d\n", DevicePosition));
DEBUG ((EFI_D_INFO, "Atatpi DeviceType is %d\n", MediaInfo.DeviceType));
DEBUG ((EFI_D_INFO, "Atatpi MediaPresent is %d\n", MediaInfo.MediaPresent));
DEBUG ((EFI_D_INFO, "Atatpi BlockSize is 0x%x\n", MediaInfo.BlockSize));
if (EFI_ERROR(Status)) {
AtapiBlkIoDev->DeviceInfo[DeviceCount].MediaInfo.MediaPresent = FALSE;
AtapiBlkIoDev->DeviceInfo[DeviceCount].MediaInfo.LastBlock = 0;
AtapiBlkIoDev->DeviceInfo[DeviceCount].MediaInfo2.MediaPresent = FALSE;
AtapiBlkIoDev->DeviceInfo[DeviceCount].MediaInfo2.LastBlock = 0;
}
DeviceCount += 1;
}
}
}
AtapiBlkIoDev->DeviceCount = DeviceCount;
}
/**
Detect Atapi devices.
@param[in] AtapiBlkIoDev A pointer to atapi block IO device.
@param[in] DevicePosition An integer to signify device position.
@param[out] MediaInfo The media information of the specified block media.
@param[out] MediaInfo2 The media information 2 of the specified block media.
@retval TRUE Atapi device exists in specified position.
@retval FALSE Atapi device does not exist in specified position.
**/
BOOLEAN
DiscoverAtapiDevice (
IN ATAPI_BLK_IO_DEV *AtapiBlkIoDev,
IN UINTN DevicePosition,
OUT EFI_PEI_BLOCK_IO_MEDIA *MediaInfo,
OUT EFI_PEI_BLOCK_IO2_MEDIA *MediaInfo2
)
{
EFI_STATUS Status;
if (!DetectIDEController (AtapiBlkIoDev, DevicePosition)) {
return FALSE;
}
//
// test if it is an ATAPI device (only supported device)
//
if (ATAPIIdentify (AtapiBlkIoDev, DevicePosition) == EFI_SUCCESS) {
Status = Inquiry (AtapiBlkIoDev, DevicePosition, MediaInfo, MediaInfo2);
if (!EFI_ERROR(Status)) {
return TRUE;
}
}
return FALSE;
}
/**
Check power mode of Atapi devices.
@param[in] AtapiBlkIoDev A pointer to atapi block IO device.
@param[in] DevicePosition An integer to signify device position.
@param[in] AtaCommand The Ata Command passed in.
@retval EFI_SUCCESS The Atapi device support power mode.
@retval EFI_NOT_FOUND The Atapi device not found.
@retval EFI_TIMEOUT Atapi command transaction is time out.
@retval EFI_ABORTED Atapi command abort.
**/
EFI_STATUS
CheckPowerMode (
IN ATAPI_BLK_IO_DEV *AtapiBlkIoDev,
IN UINTN DevicePosition,
IN UINT8 AtaCommand
)
{
UINT8 Channel;
UINT8 Device;
UINT16 StatusRegister;
UINT16 HeadRegister;
UINT16 CommandRegister;
UINT16 ErrorRegister;
UINT16 SectorCountRegister;
EFI_STATUS Status;
UINT8 StatusValue;
UINT8 ErrorValue;
UINT8 SectorCountValue;
Channel = (UINT8) (DevicePosition / 2);
Device = (UINT8) (DevicePosition % 2);
ASSERT (Channel < MAX_IDE_CHANNELS);
StatusRegister = AtapiBlkIoDev->IdeIoPortReg[Channel].Reg.Status;
HeadRegister = AtapiBlkIoDev->IdeIoPortReg[Channel].Head;
CommandRegister = AtapiBlkIoDev->IdeIoPortReg[Channel].Reg.Command;
ErrorRegister = AtapiBlkIoDev->IdeIoPortReg[Channel].Reg1.Error;
SectorCountRegister = AtapiBlkIoDev->IdeIoPortReg[Channel].SectorCount;
//
// select device
//
IoWrite8 (HeadRegister, (UINT8) ((Device << 4) | 0xe0));
//
// refresh the SectorCount register
//
SectorCountValue = 0x55;
IoWrite8 (SectorCountRegister, SectorCountValue);
//
// select device
//
IoWrite8 (HeadRegister, (UINT8) ((Device << 4) | 0xe0));
Status = DRDYReady (AtapiBlkIoDev, &(AtapiBlkIoDev->IdeIoPortReg[Channel]), 100);
//
// select device
//
IoWrite8 (HeadRegister, (UINT8) ((Device << 4) | 0xe0));
//
// send 'check power' commandd via Command Register
//
IoWrite8 (CommandRegister, AtaCommand);
Status = WaitForBSYClear (AtapiBlkIoDev, &(AtapiBlkIoDev->IdeIoPortReg[Channel]), 3000);
if (EFI_ERROR(Status)) {
return EFI_TIMEOUT;
}
StatusValue = IoRead8 (StatusRegister);
//
// command returned status is DRDY, indicating device supports the command,
// so device is present.
//
if ((StatusValue & ATA_STSREG_DRDY) == ATA_STSREG_DRDY) {
return EFI_SUCCESS;
}
SectorCountValue = IoRead8 (SectorCountRegister);
//
// command returned status is ERR & ABRT_ERR, indicating device does not support
// the command, so device is present.
//
if ((StatusValue & ATA_STSREG_ERR) == ATA_STSREG_ERR) {
ErrorValue = IoRead8 (ErrorRegister);
if ((ErrorValue & ATA_ERRREG_ABRT) == ATA_ERRREG_ABRT) {
return EFI_ABORTED;
} else {
//
// According to spec, no other error code is valid
//
return EFI_NOT_FOUND;
}
}
if ((SectorCountValue == 0x00) || (SectorCountValue == 0x80) || (SectorCountValue == 0xff)) {
//
// Write SectorCount 0x55 but return valid state value. Maybe no device
// exists or some slow kind of ATAPI device exists.
//
IoWrite8 (HeadRegister, (UINT8) ((Device << 4) | 0xe0));
//
// write 0x55 and 0xaa to SectorCounter register,
// if the data could be written into the register,
// indicating the device is present, otherwise the device is not present.
//
SectorCountValue = 0x55;
IoWrite8 (SectorCountRegister, SectorCountValue);
MicroSecondDelay (10000);
SectorCountValue = IoRead8 (SectorCountRegister);
if (SectorCountValue != 0x55) {
return EFI_NOT_FOUND;
}
//
// Send a "ATAPI TEST UNIT READY" command ... slow but accurate
//
Status = TestUnitReady (AtapiBlkIoDev, DevicePosition);
return Status;
}
return EFI_NOT_FOUND;
}
/**
Detect if an IDE controller exists in specified position.
@param[in] AtapiBlkIoDev A pointer to atapi block IO device.
@param[in] DevicePosition An integer to signify device position.
@retval TRUE The Atapi device exists.
@retval FALSE The Atapi device does not present.
**/
BOOLEAN
DetectIDEController (
IN ATAPI_BLK_IO_DEV *AtapiBlkIoDev,
IN UINTN DevicePosition
)
{
UINT8 Channel;
EFI_STATUS Status;
UINT8 AtaCommand;
Channel = (UINT8) (DevicePosition / 2);
ASSERT (Channel < MAX_IDE_CHANNELS);
//
// Wait 31 seconds for BSY clear
//
Status = WaitForBSYClear (AtapiBlkIoDev, &(AtapiBlkIoDev->IdeIoPortReg[Channel]), 31000);
if (EFI_ERROR(Status)) {
return FALSE;
}
//
// Send 'check power' command for IDE device
//
AtaCommand = 0xE5;
Status = CheckPowerMode (AtapiBlkIoDev, DevicePosition, AtaCommand);
if ((Status == EFI_ABORTED) || (Status == EFI_SUCCESS)) {
return TRUE;
}
return FALSE;
}
/**
Wait specified time interval to poll for BSY bit clear in the Status Register.
@param[in] AtapiBlkIoDev A pointer to atapi block IO device.
@param[in] IdeIoRegisters A pointer to IDE IO registers.
@param[in] TimeoutInMilliSeconds Time specified in milliseconds.
@retval EFI_SUCCESS BSY bit is cleared in the specified time interval.
@retval EFI_TIMEOUT BSY bit is not cleared in the specified time interval.
**/
EFI_STATUS
WaitForBSYClear (
IN ATAPI_BLK_IO_DEV *AtapiBlkIoDev,
IN IDE_BASE_REGISTERS *IdeIoRegisters,
IN UINTN TimeoutInMilliSeconds
)
{
UINTN Delay;
UINT16 StatusRegister;
UINT8 StatusValue;
StatusValue = 0;
StatusRegister = IdeIoRegisters->Reg.Status;
Delay = ((TimeoutInMilliSeconds * STALL_1_MILLI_SECOND) / 250) + 1;
do {
StatusValue = IoRead8 (StatusRegister);
if ((StatusValue & ATA_STSREG_BSY) == 0x00) {
break;
}
MicroSecondDelay (250);
Delay--;
} while (Delay != 0);
if (Delay == 0) {
return EFI_TIMEOUT;
}
return EFI_SUCCESS;
}
/**
Wait specified time interval to poll for DRDY bit set in the Status register.
@param[in] AtapiBlkIoDev A pointer to atapi block IO device.
@param[in] IdeIoRegisters A pointer to IDE IO registers.
@param[in] TimeoutInMilliSeconds Time specified in milliseconds.
@retval EFI_SUCCESS DRDY bit is set in the specified time interval.
@retval EFI_TIMEOUT DRDY bit is not set in the specified time interval.
**/
EFI_STATUS
DRDYReady (
IN ATAPI_BLK_IO_DEV *AtapiBlkIoDev,
IN IDE_BASE_REGISTERS *IdeIoRegisters,
IN UINTN TimeoutInMilliSeconds
)
{
UINTN Delay;
UINT16 StatusRegister;
UINT8 StatusValue;
UINT8 ErrValue;
StatusValue = 0;
StatusRegister = IdeIoRegisters->Reg.Status;
Delay = ((TimeoutInMilliSeconds * STALL_1_MILLI_SECOND) / 250) + 1;
do {
StatusValue = IoRead8 (StatusRegister);
//
// BSY == 0 , DRDY == 1
//
if ((StatusValue & (ATA_STSREG_DRDY | ATA_STSREG_BSY)) == ATA_STSREG_DRDY) {
break;
}
if ((StatusValue & (ATA_STSREG_ERR | ATA_STSREG_BSY)) == ATA_STSREG_ERR) {
ErrValue = IoRead8 (IdeIoRegisters->Reg1.Error);
if ((ErrValue & ATA_ERRREG_ABRT) == ATA_ERRREG_ABRT) {
return EFI_ABORTED;
}
}
MicroSecondDelay (250);
Delay--;
} while (Delay != 0);
if (Delay == 0) {
return EFI_TIMEOUT;
}
return EFI_SUCCESS;
}
/**
Wait specified time interval to poll for DRQ bit clear in the Status Register.
@param[in] AtapiBlkIoDev A pointer to atapi block IO device.
@param[in] IdeIoRegisters A pointer to IDE IO registers.
@param[in] TimeoutInMilliSeconds Time specified in milliseconds.
@retval EFI_SUCCESS DRQ bit is cleared in the specified time interval.
@retval EFI_TIMEOUT DRQ bit is not cleared in the specified time interval.
**/
EFI_STATUS
DRQClear (
IN ATAPI_BLK_IO_DEV *AtapiBlkIoDev,
IN IDE_BASE_REGISTERS *IdeIoRegisters,
IN UINTN TimeoutInMilliSeconds
)
{
UINTN Delay;
UINT16 StatusRegister;
UINT8 StatusValue;
UINT8 ErrValue;
StatusValue = 0;
StatusRegister = IdeIoRegisters->Reg.Status;
Delay = ((TimeoutInMilliSeconds * STALL_1_MILLI_SECOND) / 250) + 1;
do {
StatusValue = IoRead8 (StatusRegister);
//
// wait for BSY == 0 and DRQ == 0
//
if ((StatusValue & (ATA_STSREG_DRQ | ATA_STSREG_BSY)) == 0) {
break;
}
if ((StatusValue & (ATA_STSREG_BSY | ATA_STSREG_ERR)) == ATA_STSREG_ERR) {
ErrValue = IoRead8 (IdeIoRegisters->Reg1.Error);
if ((ErrValue & ATA_ERRREG_ABRT) == ATA_ERRREG_ABRT) {
return EFI_ABORTED;
}
}
MicroSecondDelay (250);
Delay--;
} while (Delay != 0);
if (Delay == 0) {
return EFI_TIMEOUT;
}
return EFI_SUCCESS;
}
/**
Wait specified time interval to poll for DRQ bit clear in the Alternate Status Register.
@param[in] AtapiBlkIoDev A pointer to atapi block IO device.
@param[in] IdeIoRegisters A pointer to IDE IO registers.
@param[in] TimeoutInMilliSeconds Time specified in milliseconds.
@retval EFI_SUCCESS DRQ bit is cleared in the specified time interval.
@retval EFI_TIMEOUT DRQ bit is not cleared in the specified time interval.
**/
EFI_STATUS
DRQClear2 (
IN ATAPI_BLK_IO_DEV *AtapiBlkIoDev,
IN IDE_BASE_REGISTERS *IdeIoRegisters,
IN UINTN TimeoutInMilliSeconds
)
{
UINTN Delay;
UINT16 AltStatusRegister;
UINT8 AltStatusValue;
UINT8 ErrValue;
AltStatusValue = 0;
AltStatusRegister = IdeIoRegisters->Alt.AltStatus;
Delay = ((TimeoutInMilliSeconds * STALL_1_MILLI_SECOND) / 250) + 1;
do {
AltStatusValue = IoRead8 (AltStatusRegister);
//
// wait for BSY == 0 and DRQ == 0
//
if ((AltStatusValue & (ATA_STSREG_DRQ | ATA_STSREG_BSY)) == 0) {
break;
}
if ((AltStatusValue & (ATA_STSREG_BSY | ATA_STSREG_ERR)) == ATA_STSREG_ERR) {
ErrValue = IoRead8 (IdeIoRegisters->Reg1.Error);
if ((ErrValue & ATA_ERRREG_ABRT) == ATA_ERRREG_ABRT) {
return EFI_ABORTED;
}
}
MicroSecondDelay (250);
Delay--;
} while (Delay != 0);
if (Delay == 0) {
return EFI_TIMEOUT;
}
return EFI_SUCCESS;
}
/**
Wait specified time interval to poll for DRQ bit set in the Status Register.
@param[in] AtapiBlkIoDev A pointer to atapi block IO device.
@param[in] IdeIoRegisters A pointer to IDE IO registers.
@param[in] TimeoutInMilliSeconds Time specified in milliseconds.
@retval EFI_SUCCESS DRQ bit is set in the specified time interval.
@retval EFI_TIMEOUT DRQ bit is not set in the specified time interval.
@retval EFI_ABORTED Operation Aborted.
**/
EFI_STATUS
DRQReady (
IN ATAPI_BLK_IO_DEV *AtapiBlkIoDev,
IN IDE_BASE_REGISTERS *IdeIoRegisters,
IN UINTN TimeoutInMilliSeconds
)
{
UINTN Delay;
UINT16 StatusRegister;
UINT8 StatusValue;
UINT8 ErrValue;
StatusValue = 0;
ErrValue = 0;
StatusRegister = IdeIoRegisters->Reg.Status;
Delay = ((TimeoutInMilliSeconds * STALL_1_MILLI_SECOND) / 250) + 1;
do {
//
// read Status Register will clear interrupt
//
StatusValue = IoRead8 (StatusRegister);
//
// BSY==0,DRQ==1
//
if ((StatusValue & (ATA_STSREG_BSY | ATA_STSREG_DRQ)) == ATA_STSREG_DRQ) {
break;
}
if ((StatusValue & (ATA_STSREG_BSY | ATA_STSREG_ERR)) == ATA_STSREG_ERR) {
ErrValue = IoRead8 (IdeIoRegisters->Reg1.Error);
if ((ErrValue & ATA_ERRREG_ABRT) == ATA_ERRREG_ABRT) {
return EFI_ABORTED;
}
}
MicroSecondDelay (250);
Delay--;
} while (Delay != 0);
if (Delay == 0) {
return EFI_TIMEOUT;
}
return EFI_SUCCESS;
}
/**
Wait specified time interval to poll for DRQ bit set in the Alternate Status Register.
@param[in] AtapiBlkIoDev A pointer to atapi block IO device.
@param[in] IdeIoRegisters A pointer to IDE IO registers.
@param[in] TimeoutInMilliSeconds Time specified in milliseconds.
@retval EFI_SUCCESS DRQ bit is set in the specified time interval.
@retval EFI_TIMEOUT DRQ bit is not set in the specified time interval.
@retval EFI_ABORTED Operation Aborted.
**/
EFI_STATUS
DRQReady2 (
IN ATAPI_BLK_IO_DEV *AtapiBlkIoDev,
IN IDE_BASE_REGISTERS *IdeIoRegisters,
IN UINTN TimeoutInMilliSeconds
)
{
UINTN Delay;
UINT16 AltStatusRegister;
UINT8 AltStatusValue;
UINT8 ErrValue;
AltStatusValue = 0;
AltStatusRegister = IdeIoRegisters->Alt.AltStatus;
Delay = ((TimeoutInMilliSeconds * STALL_1_MILLI_SECOND) / 250) + 1;
do {
AltStatusValue = IoRead8 (AltStatusRegister);
//
// BSY==0,DRQ==1
//
if ((AltStatusValue & (ATA_STSREG_BSY | ATA_STSREG_DRQ)) == ATA_STSREG_DRQ) {
break;
}
if ((AltStatusValue & (ATA_STSREG_BSY | ATA_STSREG_ERR)) == ATA_STSREG_ERR) {
ErrValue = IoRead8 (IdeIoRegisters->Reg1.Error);
if ((ErrValue & ATA_ERRREG_ABRT) == ATA_ERRREG_ABRT) {
return EFI_ABORTED;
}
}
MicroSecondDelay (250);
Delay--;
} while (Delay != 0);
if (Delay == 0) {
return EFI_TIMEOUT;
}
return EFI_SUCCESS;
}
/**
Check if there is an error in Status Register.
@param[in] AtapiBlkIoDev A pointer to atapi block IO device.
@param[in] StatusReg The address to IDE IO registers.
@retval EFI_SUCCESS Operation success.
@retval EFI_DEVICE_ERROR Device error.
**/
EFI_STATUS
CheckErrorStatus (
IN ATAPI_BLK_IO_DEV *AtapiBlkIoDev,
IN UINT16 StatusReg
)
{
UINT8 StatusValue;
StatusValue = IoRead8 (StatusReg);
if ((StatusValue & (ATA_STSREG_ERR | ATA_STSREG_DWF | ATA_STSREG_CORR)) == 0) {
return EFI_SUCCESS;
}
return EFI_DEVICE_ERROR;
}
/**
Idendify Atapi devices.
@param[in] AtapiBlkIoDev A pointer to atapi block IO device.
@param[in] DevicePosition An integer to signify device position.
@retval EFI_SUCCESS Identify successfully.
@retval EFI_DEVICE_ERROR Device cannot be identified successfully.
**/
EFI_STATUS
ATAPIIdentify (
IN ATAPI_BLK_IO_DEV *AtapiBlkIoDev,
IN UINTN DevicePosition
)
{
ATAPI_IDENTIFY_DATA AtapiIdentifyData;
UINT8 Channel;
UINT8 Device;
UINT16 StatusReg;
UINT16 HeadReg;
UINT16 CommandReg;
UINT16 DataReg;
UINT16 SectorCountReg;
UINT16 SectorNumberReg;
UINT16 CylinderLsbReg;
UINT16 CylinderMsbReg;
UINT32 WordCount;
UINT32 Increment;
UINT32 Index;
UINT32 ByteCount;
UINT16 *Buffer16;
EFI_STATUS Status;
ByteCount = sizeof (AtapiIdentifyData);
Buffer16 = (UINT16 *) &AtapiIdentifyData;
Channel = (UINT8) (DevicePosition / 2);
Device = (UINT8) (DevicePosition % 2);
ASSERT (Channel < MAX_IDE_CHANNELS);
StatusReg = AtapiBlkIoDev->IdeIoPortReg[Channel].Reg.Status;
HeadReg = AtapiBlkIoDev->IdeIoPortReg[Channel].Head;
CommandReg = AtapiBlkIoDev->IdeIoPortReg[Channel].Reg.Command;
DataReg = AtapiBlkIoDev->IdeIoPortReg[Channel].Data;
SectorCountReg = AtapiBlkIoDev->IdeIoPortReg[Channel].SectorCount;
SectorNumberReg = AtapiBlkIoDev->IdeIoPortReg[Channel].SectorNumber;
CylinderLsbReg = AtapiBlkIoDev->IdeIoPortReg[Channel].CylinderLsb;
CylinderMsbReg = AtapiBlkIoDev->IdeIoPortReg[Channel].CylinderMsb;
//
// Send ATAPI Identify Command to get IDENTIFY data.
//
if (WaitForBSYClear (
AtapiBlkIoDev,
&(AtapiBlkIoDev->IdeIoPortReg[Channel]),
ATATIMEOUT
) != EFI_SUCCESS) {
return EFI_DEVICE_ERROR;
}
//
// select device via Head/Device register.
// Before write Head/Device register, BSY and DRQ must be 0.
//
if (DRQClear2 (AtapiBlkIoDev, &(AtapiBlkIoDev->IdeIoPortReg[Channel]), ATATIMEOUT) != EFI_SUCCESS) {
return EFI_DEVICE_ERROR;
}
//
// e0:1110,0000-- bit7 and bit5 are reserved bits.
// bit6 set means LBA mode
//
IoWrite8 (HeadReg, (UINT8) ((Device << 4) | 0xe0));
//
// set all the command parameters
// Before write to all the following registers, BSY and DRQ must be 0.
//
if (DRQClear2 (
AtapiBlkIoDev,
&(AtapiBlkIoDev->IdeIoPortReg[Channel]),
ATATIMEOUT
) != EFI_SUCCESS) {
return EFI_DEVICE_ERROR;
}
IoWrite8 (SectorCountReg, 0);
IoWrite8 (SectorNumberReg, 0);
IoWrite8 (CylinderLsbReg, 0);
IoWrite8 (CylinderMsbReg, 0);
//
// send command via Command Register
//
IoWrite8 (CommandReg, ATA_CMD_IDENTIFY_DEVICE);
//
// According to PIO data in protocol, host can perform a series of reads to the
// data register after each time device set DRQ ready;
// The data size of "a series of read" is command specific.
// For most ATA command, data size received from device will not exceed 1 sector,
// hense the data size for "a series of read" can be the whole data size of one command request.
// For ATA command such as Read Sector command, whole data size of one ATA command request is often larger
// than 1 sector, according to the Read Sector command, the data size of "a series of read" is exactly
// 1 sector.
// Here for simplification reason, we specify the data size for "a series of read" to
// 1 sector (256 words) if whole data size of one ATA commmand request is larger than 256 words.
//
Increment = 256;
//
// 256 words
//
WordCount = 0;
//
// WordCount is used to record bytes of currently transfered data
//
while (WordCount < ByteCount / 2) {
//
// Poll DRQ bit set, data transfer can be performed only when DRQ is ready.
//
Status = DRQReady2 (AtapiBlkIoDev, &(AtapiBlkIoDev->IdeIoPortReg[Channel]), ATATIMEOUT);
if (Status != EFI_SUCCESS) {
return Status;
}
if (CheckErrorStatus (AtapiBlkIoDev, StatusReg) != EFI_SUCCESS) {
return EFI_DEVICE_ERROR;
}
//
// Get the byte count for one series of read
//
if ((WordCount + Increment) > ByteCount / 2) {
Increment = ByteCount / 2 - WordCount;
}
//
// perform a series of read without check DRQ ready
//
for (Index = 0; Index < Increment; Index++) {
*Buffer16++ = IoRead16 (DataReg);
}
WordCount += Increment;
}
//
// while
//
if (DRQClear (
AtapiBlkIoDev,
&(AtapiBlkIoDev->IdeIoPortReg[Channel]),
ATATIMEOUT
) != EFI_SUCCESS) {
return CheckErrorStatus (AtapiBlkIoDev, StatusReg);
}
return EFI_SUCCESS;
}
/**
Sends out ATAPI Test Unit Ready Packet Command to the specified device
to find out whether device is accessible.
@param[in] AtapiBlkIoDev A pointer to atapi block IO device.
@param[in] DevicePosition An integer to signify device position.
@retval EFI_SUCCESS TestUnit command executed successfully.
@retval EFI_DEVICE_ERROR Device cannot be executed TestUnit command successfully.
**/
EFI_STATUS
TestUnitReady (
IN ATAPI_BLK_IO_DEV *AtapiBlkIoDev,
IN UINTN DevicePosition
)
{
ATAPI_PACKET_COMMAND Packet;
EFI_STATUS Status;
//
// fill command packet
//
ZeroMem (&Packet, sizeof (ATAPI_PACKET_COMMAND));
Packet.TestUnitReady.opcode = ATA_CMD_TEST_UNIT_READY;
//
// send command packet
//
Status = AtapiPacketCommandIn (AtapiBlkIoDev, DevicePosition, &Packet, NULL, 0, ATAPITIMEOUT);
return Status;
}
/**
Send out ATAPI commands conforms to the Packet Command with PIO Data In Protocol.
@param[in] AtapiBlkIoDev A pointer to atapi block IO device.
@param[in] DevicePosition An integer to signify device position.
@param[in] Packet A pointer to ATAPI command packet.
@param[in] Buffer Buffer to contain requested transfer data from device.
@param[in] ByteCount Requested transfer data length.
@param[in] TimeoutInMilliSeconds Time out value, in unit of milliseconds.
@retval EFI_SUCCESS Command executed successfully.
@retval EFI_DEVICE_ERROR Device cannot be executed command successfully.
**/
EFI_STATUS
AtapiPacketCommandIn (
IN ATAPI_BLK_IO_DEV *AtapiBlkIoDev,
IN UINTN DevicePosition,
IN ATAPI_PACKET_COMMAND *Packet,
IN UINT16 *Buffer,
IN UINT32 ByteCount,
IN UINTN TimeoutInMilliSeconds
)
{
UINT8 Channel;
UINT8 Device;
UINT16 StatusReg;
UINT16 HeadReg;
UINT16 CommandReg;
UINT16 FeatureReg;
UINT16 CylinderLsbReg;
UINT16 CylinderMsbReg;
UINT16 DeviceControlReg;
UINT16 DataReg;
EFI_STATUS Status;
UINT32 Count;
UINT16 *CommandIndex;
UINT16 *PtrBuffer;
UINT32 Index;
UINT8 StatusValue;
UINT32 WordCount;
//
// required transfer data in word unit.
//
UINT32 RequiredWordCount;
//
// actual transfer data in word unit.
//
UINT32 ActualWordCount;
Channel = (UINT8) (DevicePosition / 2);
Device = (UINT8) (DevicePosition % 2);
ASSERT (Channel < MAX_IDE_CHANNELS);
StatusReg = AtapiBlkIoDev->IdeIoPortReg[Channel].Reg.Status;
HeadReg = AtapiBlkIoDev->IdeIoPortReg[Channel].Head;
CommandReg = AtapiBlkIoDev->IdeIoPortReg[Channel].Reg.Command;
FeatureReg = AtapiBlkIoDev->IdeIoPortReg[Channel].Reg1.Feature;
CylinderLsbReg = AtapiBlkIoDev->IdeIoPortReg[Channel].CylinderLsb;
CylinderMsbReg = AtapiBlkIoDev->IdeIoPortReg[Channel].CylinderMsb;
DeviceControlReg = AtapiBlkIoDev->IdeIoPortReg[Channel].Alt.DeviceControl;
DataReg = AtapiBlkIoDev->IdeIoPortReg[Channel].Data;
//
// Set all the command parameters by fill related registers.
// Before write to all the following registers, BSY and DRQ must be 0.
//
if (DRQClear2 (
AtapiBlkIoDev,
&(AtapiBlkIoDev->IdeIoPortReg[Channel]),
ATATIMEOUT
) != EFI_SUCCESS) {
return EFI_DEVICE_ERROR;
}
//
// Select device via Device/Head Register.
// DEFAULT_CMD: 0xa0 (1010,0000)
//
IoWrite8 (HeadReg, (UINT8) ((Device << 4) | ATA_DEFAULT_CMD));
//
// No OVL; No DMA
//
IoWrite8 (FeatureReg, 0x00);
//
// set the transfersize to MAX_ATAPI_BYTE_COUNT to let the device
// determine how many data should be transfered.
//
IoWrite8 (CylinderLsbReg, (UINT8) (ATAPI_MAX_BYTE_COUNT & 0x00ff));
IoWrite8 (CylinderMsbReg, (UINT8) (ATAPI_MAX_BYTE_COUNT >> 8));
//
// DEFAULT_CTL:0x0a (0000,1010)
// Disable interrupt
//
IoWrite8 (DeviceControlReg, ATA_DEFAULT_CTL);
//
// Send Packet command to inform device
// that the following data bytes are command packet.
//
IoWrite8 (CommandReg, ATA_CMD_PACKET);
Status = DRQReady (AtapiBlkIoDev, &(AtapiBlkIoDev->IdeIoPortReg[Channel]), TimeoutInMilliSeconds);
if (Status != EFI_SUCCESS) {
return Status;
}
//
// Send out command packet
//
CommandIndex = Packet->Data16;
for (Count = 0; Count < 6; Count++, CommandIndex++) {
IoWrite16 (DataReg, *CommandIndex);
MicroSecondDelay (10);
}
StatusValue = IoRead8 (StatusReg);
if ((StatusValue & ATA_STSREG_ERR) == ATA_STSREG_ERR) {
//
// Trouble! Something's wrong here... Wait some time and return. 3 second is
// supposed to be long enough for a device reset latency or error recovery
//
MicroSecondDelay (3000000);
return EFI_DEVICE_ERROR;
}
if (Buffer == NULL || ByteCount == 0) {
return EFI_SUCCESS;
}
//
// call PioReadWriteData() function to get
// requested transfer data form device.
//
PtrBuffer = Buffer;
RequiredWordCount = ByteCount / 2;
//
// ActuralWordCount means the word count of data really transfered.
//
ActualWordCount = 0;
Status = EFI_SUCCESS;
while ((Status == EFI_SUCCESS) && (ActualWordCount < RequiredWordCount)) {
//
// before each data transfer stream, the host should poll DRQ bit ready,
// which informs device is ready to transfer data.
//
if (DRQReady2 (
AtapiBlkIoDev,
&(AtapiBlkIoDev->IdeIoPortReg[Channel]),
TimeoutInMilliSeconds
) != EFI_SUCCESS) {
return CheckErrorStatus (AtapiBlkIoDev, StatusReg);
}
//
// read Status Register will clear interrupt
//
StatusValue = IoRead8 (StatusReg);
//
// get current data transfer size from Cylinder Registers.
//
WordCount = IoRead8 (CylinderMsbReg) << 8;
WordCount = WordCount | IoRead8 (CylinderLsbReg);
WordCount = WordCount & 0xffff;
WordCount /= 2;
//
// perform a series data In/Out.
//
for (Index = 0; (Index < WordCount) && (ActualWordCount < RequiredWordCount); Index++, ActualWordCount++) {
*PtrBuffer = IoRead16 (DataReg);
PtrBuffer++;
}
if (((ATAPI_REQUEST_SENSE_CMD *) Packet)->opcode == ATA_CMD_REQUEST_SENSE && ActualWordCount >= 4) {
RequiredWordCount = MIN (
RequiredWordCount,
(UINT32) (4 + (((ATAPI_REQUEST_SENSE_DATA *) Buffer)->addnl_sense_length / 2))
);
}
}
//
// After data transfer is completed, normally, DRQ bit should clear.
//
Status = DRQClear2 (AtapiBlkIoDev, &(AtapiBlkIoDev->IdeIoPortReg[Channel]), TimeoutInMilliSeconds);
if (Status != EFI_SUCCESS) {
return EFI_DEVICE_ERROR;
}
//
// read status register to check whether error happens.
//
Status = CheckErrorStatus (AtapiBlkIoDev, StatusReg);
return Status;
}
/**
Sends out ATAPI Inquiry Packet Command to the specified device.
This command will return INQUIRY data of the device.
@param[in] AtapiBlkIoDev A pointer to atapi block IO device.
@param[in] DevicePosition An integer to signify device position.
@param[out] MediaInfo The media information of the specified block media.
@param[out] MediaInfo2 The media information 2 of the specified block media.
@retval EFI_SUCCESS Command executed successfully.
@retval EFI_DEVICE_ERROR Device cannot be executed command successfully.
@retval EFI_UNSUPPORTED Unsupported device type.
**/
EFI_STATUS
Inquiry (
IN ATAPI_BLK_IO_DEV *AtapiBlkIoDev,
IN UINTN DevicePosition,
OUT EFI_PEI_BLOCK_IO_MEDIA *MediaInfo,
OUT EFI_PEI_BLOCK_IO2_MEDIA *MediaInfo2
)
{
ATAPI_PACKET_COMMAND Packet;
EFI_STATUS Status;
ATAPI_INQUIRY_DATA Idata;
//
// prepare command packet for the ATAPI Inquiry Packet Command.
//
ZeroMem (&Packet, sizeof (ATAPI_PACKET_COMMAND));
ZeroMem (&Idata, sizeof (ATAPI_INQUIRY_DATA));
Packet.Inquiry.opcode = ATA_CMD_INQUIRY;
Packet.Inquiry.page_code = 0;
Packet.Inquiry.allocation_length = (UINT8) sizeof (ATAPI_INQUIRY_DATA);
//
// Send command packet and get requested Inquiry data.
//
Status = AtapiPacketCommandIn (
AtapiBlkIoDev,
DevicePosition,
&Packet,
(UINT16 *) (&Idata),
sizeof (ATAPI_INQUIRY_DATA),
ATAPITIMEOUT
//50
);
if (Status != EFI_SUCCESS) {
return EFI_DEVICE_ERROR;
}
//
// Identify device type via INQUIRY data.
//
switch (Idata.peripheral_type & 0x1f) {
case 0x00:
//
// Magnetic Disk
//
MediaInfo->DeviceType = IdeLS120;
MediaInfo->MediaPresent = FALSE;
MediaInfo->LastBlock = 0;
MediaInfo->BlockSize = 0x200;
MediaInfo2->InterfaceType = MSG_ATAPI_DP;
MediaInfo2->RemovableMedia = TRUE;
MediaInfo2->MediaPresent = FALSE;
MediaInfo2->ReadOnly = FALSE;
MediaInfo2->BlockSize = 0x200;
MediaInfo2->LastBlock = 0;
break;
case 0x05:
//
// CD-ROM
//
MediaInfo->DeviceType = IdeCDROM;
MediaInfo->MediaPresent = FALSE;
MediaInfo->LastBlock = 0;
MediaInfo->BlockSize = 0x800;
MediaInfo2->InterfaceType = MSG_ATAPI_DP;
MediaInfo2->RemovableMedia = TRUE;
MediaInfo2->MediaPresent = FALSE;
MediaInfo2->ReadOnly = TRUE;
MediaInfo2->BlockSize = 0x200;
MediaInfo2->LastBlock = 0;
break;
default:
return EFI_UNSUPPORTED;
}
return EFI_SUCCESS;
}
/**
Used before read/write blocks from/to ATAPI device media.
Since ATAPI device media is removable, it is necessary to detect
whether media is present and get current present media's information.
@param[in] AtapiBlkIoDev A pointer to atapi block IO device.
@param[in] DevicePosition An integer to signify device position.
@param[in, out] MediaInfo The media information of the specified block media.
@param[in, out] MediaInfo2 The media information 2 of the specified block media.
@retval EFI_SUCCESS Command executed successfully.
@retval EFI_DEVICE_ERROR Some device errors happen.
@retval EFI_OUT_OF_RESOURCES Can not allocate required resources.
**/
EFI_STATUS
DetectMedia (
IN ATAPI_BLK_IO_DEV *AtapiBlkIoDev,
IN UINTN DevicePosition,
IN OUT EFI_PEI_BLOCK_IO_MEDIA *MediaInfo,
IN OUT EFI_PEI_BLOCK_IO2_MEDIA *MediaInfo2
)
{
UINTN Index;
UINTN RetryNum;
UINTN MaxRetryNum;
ATAPI_REQUEST_SENSE_DATA *SenseBuffers;
BOOLEAN NeedReadCapacity;
BOOLEAN NeedRetry;
EFI_STATUS Status;
UINT8 SenseCounts;
SenseBuffers = AllocatePages (EFI_SIZE_TO_PAGES (sizeof (*SenseBuffers)));
if (SenseBuffers == NULL) {
return EFI_OUT_OF_RESOURCES;
}
//
// Test Unit Ready command is used to detect whether device is accessible,
// the device will produce corresponding Sense data.
//
for (Index = 0; Index < 2; Index++) {
Status = TestUnitReady (AtapiBlkIoDev, DevicePosition);
if (Status != EFI_SUCCESS) {
Status = ResetDevice (AtapiBlkIoDev, DevicePosition, FALSE);
if (Status != EFI_SUCCESS) {
ResetDevice (AtapiBlkIoDev, DevicePosition, TRUE);
}
} else {
break;
}
}
SenseCounts = MAX_SENSE_KEY_COUNT;
Status = EFI_SUCCESS;
NeedReadCapacity = TRUE;
for (Index = 0; Index < 5; Index++) {
SenseCounts = MAX_SENSE_KEY_COUNT;
Status = RequestSense (
AtapiBlkIoDev,
DevicePosition,
SenseBuffers,
&SenseCounts
);
DEBUG ((EFI_D_INFO, "Atapi Request Sense Count is %d\n", SenseCounts));
if (IsDeviceStateUnclear (SenseBuffers, SenseCounts) || IsNoMedia (SenseBuffers, SenseCounts)) {
//
// We are not sure whether the media is present or not, try again
//
TestUnitReady (AtapiBlkIoDev, DevicePosition);
} else {
break;
}
}
if (Status == EFI_SUCCESS) {
if (IsNoMedia (SenseBuffers, SenseCounts)) {
NeedReadCapacity = FALSE;
MediaInfo->MediaPresent = FALSE;
MediaInfo->LastBlock = 0;
MediaInfo2->MediaPresent = FALSE;
MediaInfo2->LastBlock = 0;
}
if (IsMediaError (SenseBuffers, SenseCounts)) {
return EFI_DEVICE_ERROR;
}
}
if (NeedReadCapacity) {
//
// at most retry 5 times
//
MaxRetryNum = 5;
RetryNum = 1;
//
// initial retry once
//
for (Index = 0; (Index < RetryNum) && (Index < MaxRetryNum); Index++) {
Status = ReadCapacity (AtapiBlkIoDev, DevicePosition, MediaInfo, MediaInfo2);
MicroSecondDelay (200000);
SenseCounts = MAX_SENSE_KEY_COUNT;
if (Status != EFI_SUCCESS) {
Status = RequestSense (AtapiBlkIoDev, DevicePosition, SenseBuffers, &SenseCounts);
//
// If Request Sense data failed, reset the device and retry.
//
if (Status != EFI_SUCCESS) {
Status = ResetDevice (AtapiBlkIoDev, DevicePosition, FALSE);
//
// if ATAPI soft reset fail,
// use stronger reset mechanism -- ATA soft reset.
//
if (Status != EFI_SUCCESS) {
ResetDevice (AtapiBlkIoDev, DevicePosition, TRUE);
}
RetryNum++;
//
// retry once more
//
continue;
}
//
// No Media
//
if (IsNoMedia (SenseBuffers, SenseCounts)) {
MediaInfo->MediaPresent = FALSE;
MediaInfo->LastBlock = 0;
MediaInfo2->MediaPresent = FALSE;
MediaInfo2->LastBlock = 0;
break;
}
if (IsMediaError (SenseBuffers, SenseCounts)) {
return EFI_DEVICE_ERROR;
}
if (!IsDriveReady (SenseBuffers, SenseCounts, &NeedRetry)) {
//
// Drive not ready: if NeedRetry, then retry once more;
// else return error
//
if (NeedRetry) {
RetryNum++;
continue;
} else {
return EFI_DEVICE_ERROR;
}
}
//
// if read capacity fail not for above reasons, retry once more
//
RetryNum++;
}
}
}
return EFI_SUCCESS;
}
/**
Reset specified Atapi device.
@param[in] AtapiBlkIoDev A pointer to atapi block IO device.
@param[in] DevicePosition An integer to signify device position.
@param[in] Extensive If TRUE, use ATA soft reset, otherwise use Atapi soft reset.
@retval EFI_SUCCESS Command executed successfully.
@retval EFI_DEVICE_ERROR Some device errors happen.
**/
EFI_STATUS
ResetDevice (
IN ATAPI_BLK_IO_DEV *AtapiBlkIoDev,
IN UINTN DevicePosition,
IN BOOLEAN Extensive
)
{
UINT8 DevControl;
UINT8 Command;
UINT8 DeviceSelect;
UINT16 DeviceControlReg;
UINT16 CommandReg;
UINT16 HeadReg;
UINT8 Channel;
UINT8 Device;
Channel = (UINT8) (DevicePosition / 2);
Device = (UINT8) (DevicePosition % 2);
ASSERT (Channel < MAX_IDE_CHANNELS);
DeviceControlReg = AtapiBlkIoDev->IdeIoPortReg[Channel].Alt.DeviceControl;
CommandReg = AtapiBlkIoDev->IdeIoPortReg[Channel].Reg.Command;
HeadReg = AtapiBlkIoDev->IdeIoPortReg[Channel].Head;
if (Extensive) {
DevControl = 0;
DevControl |= ATA_CTLREG_SRST;
//
// set SRST bit to initiate soft reset
//
DevControl |= BIT1;
//
// disable Interrupt
//
IoWrite8 (DeviceControlReg, DevControl);
//
// Wait 10us
//
MicroSecondDelay (10);
//
// Clear SRST bit
//
DevControl &= 0xfb;
//
// 0xfb:1111,1011
//
IoWrite8 (DeviceControlReg, DevControl);
//
// slave device needs at most 31s to clear BSY
//
if (WaitForBSYClear (AtapiBlkIoDev, &(AtapiBlkIoDev->IdeIoPortReg[Channel]), 31000) == EFI_TIMEOUT) {
return EFI_DEVICE_ERROR;
}
} else {
//
// for ATAPI device, no need to wait DRDY ready after device selecting.
// bit7 and bit5 are both set to 1 for backward compatibility
//
DeviceSelect = (UINT8) (((BIT7 | BIT5) | (Device << 4)));
IoWrite8 (HeadReg, DeviceSelect);
Command = ATA_CMD_SOFT_RESET;
IoWrite8 (CommandReg, Command);
//
// BSY cleared is the only status return to the host by the device when reset is completed
// slave device needs at most 31s to clear BSY
//
if (WaitForBSYClear (AtapiBlkIoDev, &(AtapiBlkIoDev->IdeIoPortReg[Channel]), 31000) != EFI_SUCCESS) {
return EFI_DEVICE_ERROR;
}
//
// stall 5 seconds to make the device status stable
//
MicroSecondDelay (STALL_1_SECONDS * 5);
}
return EFI_SUCCESS;
}
/**
Sends out ATAPI Request Sense Packet Command to the specified device.
@param[in] AtapiBlkIoDev A pointer to atapi block IO device.
@param[in] DevicePosition An integer to signify device position.
@param[in] SenseBuffers Pointer to sense buffer.
@param[in, out] SenseCounts Length of sense buffer.
@retval EFI_SUCCESS Command executed successfully.
@retval EFI_DEVICE_ERROR Some device errors happen.
**/
EFI_STATUS
RequestSense (
IN ATAPI_BLK_IO_DEV *AtapiBlkIoDev,
IN UINTN DevicePosition,
IN ATAPI_REQUEST_SENSE_DATA *SenseBuffers,
IN OUT UINT8 *SenseCounts
)
{
EFI_STATUS Status;
ATAPI_REQUEST_SENSE_DATA *Sense;
UINT16 *Ptr;
BOOLEAN SenseReq;
ATAPI_PACKET_COMMAND Packet;
ZeroMem (SenseBuffers, sizeof (ATAPI_REQUEST_SENSE_DATA) * (*SenseCounts));
//
// fill command packet for Request Sense Packet Command
//
ZeroMem (&Packet, sizeof (ATAPI_PACKET_COMMAND));
Packet.RequestSence.opcode = ATA_CMD_REQUEST_SENSE;
Packet.RequestSence.allocation_length = (UINT8) sizeof (ATAPI_REQUEST_SENSE_DATA);
Ptr = (UINT16 *) SenseBuffers;
//
// initialize pointer
//
*SenseCounts = 0;
//
// request sense data from device continiously until no sense data exists in the device.
//
for (SenseReq = TRUE; SenseReq;) {
Sense = (ATAPI_REQUEST_SENSE_DATA *) Ptr;
//
// send out Request Sense Packet Command and get one Sense data form device
//
Status = AtapiPacketCommandIn (
AtapiBlkIoDev,
DevicePosition,
&Packet,
Ptr,
sizeof (ATAPI_REQUEST_SENSE_DATA),
ATAPITIMEOUT
);
//
// failed to get Sense data
//
if (Status != EFI_SUCCESS) {
if (*SenseCounts == 0) {
return EFI_DEVICE_ERROR;
} else {
return EFI_SUCCESS;
}
}
(*SenseCounts)++;
if (*SenseCounts > MAX_SENSE_KEY_COUNT) {
return EFI_SUCCESS;
}
//
// We limit MAX sense data count to 20 in order to avoid dead loop. Some
// incompatible ATAPI devices don't retrive NO_SENSE when there is no media.
// In this case, dead loop occurs if we don't have a gatekeeper. 20 is
// supposed to be large enough for any ATAPI device.
//
if ((Sense->sense_key != ATA_SK_NO_SENSE) && ((*SenseCounts) < 20)) {
Ptr += sizeof (ATAPI_REQUEST_SENSE_DATA) / 2;
//
// Ptr is word based pointer
//
} else {
//
// when no sense key, skip out the loop
//
SenseReq = FALSE;
}
}
return EFI_SUCCESS;
}
/**
Sends out ATAPI Read Capacity Packet Command to the specified device.
This command will return the information regarding the capacity of the
media in the device.
@param[in] AtapiBlkIoDev A pointer to atapi block IO device.
@param[in] DevicePosition An integer to signify device position.
@param[in, out] MediaInfo The media information of the specified block media.
@param[in, out] MediaInfo2 The media information 2 of the specified block media.
@retval EFI_SUCCESS Command executed successfully.
@retval EFI_DEVICE_ERROR Some device errors happen.
**/
EFI_STATUS
ReadCapacity (
IN ATAPI_BLK_IO_DEV *AtapiBlkIoDev,
IN UINTN DevicePosition,
IN OUT EFI_PEI_BLOCK_IO_MEDIA *MediaInfo,
IN OUT EFI_PEI_BLOCK_IO2_MEDIA *MediaInfo2
)
{
EFI_STATUS Status;
ATAPI_PACKET_COMMAND Packet;
//
// used for capacity data returned from ATAPI device
//
ATAPI_READ_CAPACITY_DATA Data;
ATAPI_READ_FORMAT_CAPACITY_DATA FormatData;
ZeroMem (&Data, sizeof (Data));
ZeroMem (&FormatData, sizeof (FormatData));
if (MediaInfo->DeviceType == IdeCDROM) {
ZeroMem (&Packet, sizeof (ATAPI_PACKET_COMMAND));
Packet.Inquiry.opcode = ATA_CMD_READ_CAPACITY;
Status = AtapiPacketCommandIn (
AtapiBlkIoDev,
DevicePosition,
&Packet,
(UINT16 *) (&Data),
sizeof (ATAPI_READ_CAPACITY_DATA),
ATAPITIMEOUT
);
} else {
//
// DeviceType == IdeLS120
//
ZeroMem (&Packet, sizeof (ATAPI_PACKET_COMMAND));
Packet.ReadFormatCapacity.opcode = ATA_CMD_READ_FORMAT_CAPACITY;
Packet.ReadFormatCapacity.allocation_length_lo = 12;
Status = AtapiPacketCommandIn (
AtapiBlkIoDev,
DevicePosition,
&Packet,
(UINT16 *) (&FormatData),
sizeof (ATAPI_READ_FORMAT_CAPACITY_DATA),
ATAPITIMEOUT*10
);
}
if (Status == EFI_SUCCESS) {
if (MediaInfo->DeviceType == IdeCDROM) {
MediaInfo->LastBlock = ((UINT32) Data.LastLba3 << 24) | (Data.LastLba2 << 16) | (Data.LastLba1 << 8) | Data.LastLba0;
MediaInfo->MediaPresent = TRUE;
//
// Because the user data portion in the sector of the Data CD supported
// is always 800h
//
MediaInfo->BlockSize = 0x800;
MediaInfo2->LastBlock = MediaInfo->LastBlock;
MediaInfo2->MediaPresent = MediaInfo->MediaPresent;
MediaInfo2->BlockSize = (UINT32)MediaInfo->BlockSize;
}
if (MediaInfo->DeviceType == IdeLS120) {
if (FormatData.DesCode == 3) {
MediaInfo->MediaPresent = FALSE;
MediaInfo->LastBlock = 0;
MediaInfo2->MediaPresent = FALSE;
MediaInfo2->LastBlock = 0;
} else {
MediaInfo->LastBlock = ((UINT32) FormatData.LastLba3 << 24) |
(FormatData.LastLba2 << 16) |
(FormatData.LastLba1 << 8) |
FormatData.LastLba0;
MediaInfo->LastBlock--;
MediaInfo->MediaPresent = TRUE;
MediaInfo->BlockSize = 0x200;
MediaInfo2->LastBlock = MediaInfo->LastBlock;
MediaInfo2->MediaPresent = MediaInfo->MediaPresent;
MediaInfo2->BlockSize = (UINT32)MediaInfo->BlockSize;
}
}
return EFI_SUCCESS;
} else {
return EFI_DEVICE_ERROR;
}
}
/**
Perform read from disk in block unit.
@param[in] AtapiBlkIoDev A pointer to atapi block IO device.
@param[in] DevicePosition An integer to signify device position.
@param[in] Buffer Buffer to contain read data.
@param[in] StartLba Starting LBA address.
@param[in] NumberOfBlocks Number of blocks to read.
@param[in] BlockSize Size of each block.
@retval EFI_SUCCESS Command executed successfully.
@retval EFI_DEVICE_ERROR Some device errors happen.
**/
EFI_STATUS
ReadSectors (
IN ATAPI_BLK_IO_DEV *AtapiBlkIoDev,
IN UINTN DevicePosition,
IN VOID *Buffer,
IN EFI_PEI_LBA StartLba,
IN UINTN NumberOfBlocks,
IN UINTN BlockSize
)
{
ATAPI_PACKET_COMMAND Packet;
ATAPI_READ10_CMD *Read10Packet;
EFI_STATUS Status;
UINTN BlocksRemaining;
UINT32 Lba32;
UINT32 ByteCount;
UINT16 SectorCount;
VOID *PtrBuffer;
UINT16 MaxBlock;
//
// fill command packet for Read(10) command
//
ZeroMem (&Packet, sizeof (ATAPI_PACKET_COMMAND));
Read10Packet = &Packet.Read10;
Lba32 = (UINT32) StartLba;
PtrBuffer = Buffer;
//
// limit the data bytes that can be transfered by one Read(10) Command
//
MaxBlock = (UINT16) (0x10000 / BlockSize);
//
// (64k bytes)
//
BlocksRemaining = NumberOfBlocks;
Status = EFI_SUCCESS;
while (BlocksRemaining > 0) {
if (BlocksRemaining <= MaxBlock) {
SectorCount = (UINT16) BlocksRemaining;
} else {
SectorCount = MaxBlock;
}
//
// fill the Packet data sturcture
//
Read10Packet->opcode = ATA_CMD_READ_10;
//
// Lba0 ~ Lba3 specify the start logical block address of the data transfer.
// Lba0 is MSB, Lba3 is LSB
//
Read10Packet->Lba3 = (UINT8) (Lba32 & 0xff);
Read10Packet->Lba2 = (UINT8) (Lba32 >> 8);
Read10Packet->Lba1 = (UINT8) (Lba32 >> 16);
Read10Packet->Lba0 = (UINT8) (Lba32 >> 24);
//
// TranLen0 ~ TranLen1 specify the transfer length in block unit.
// TranLen0 is MSB, TranLen is LSB
//
Read10Packet->TranLen1 = (UINT8) (SectorCount & 0xff);
Read10Packet->TranLen0 = (UINT8) (SectorCount >> 8);
ByteCount = (UINT32) (SectorCount * BlockSize);
Status = AtapiPacketCommandIn (
AtapiBlkIoDev,
DevicePosition,
&Packet,
(UINT16 *) PtrBuffer,
ByteCount,
ATAPILONGTIMEOUT
);
if (Status != EFI_SUCCESS) {
return Status;
}
Lba32 += SectorCount;
PtrBuffer = (UINT8 *) PtrBuffer + SectorCount * BlockSize;
BlocksRemaining -= SectorCount;
}
return Status;
}
/**
Check if there is media according to sense data.
@param[in] SenseData Pointer to sense data.
@param[in] SenseCounts Count of sense data.
@retval TRUE No media
@retval FALSE Media exists
**/
BOOLEAN
IsNoMedia (
IN ATAPI_REQUEST_SENSE_DATA *SenseData,
IN UINTN SenseCounts
)
{
ATAPI_REQUEST_SENSE_DATA *SensePtr;
UINTN Index;
BOOLEAN IsNoMedia;
IsNoMedia = FALSE;
SensePtr = SenseData;
for (Index = 0; Index < SenseCounts; Index++) {
if ((SensePtr->sense_key == ATA_SK_NOT_READY) && (SensePtr->addnl_sense_code == ATA_ASC_NO_MEDIA)) {
IsNoMedia = TRUE;
}
SensePtr++;
}
return IsNoMedia;
}
/**
Check if device state is unclear according to sense data.
@param[in] SenseData Pointer to sense data.
@param[in] SenseCounts Count of sense data.
@retval TRUE Device state is unclear
@retval FALSE Device state is clear
**/
BOOLEAN
IsDeviceStateUnclear (
IN ATAPI_REQUEST_SENSE_DATA *SenseData,
IN UINTN SenseCounts
)
{
ATAPI_REQUEST_SENSE_DATA *SensePtr;
UINTN Index;
BOOLEAN Unclear;
Unclear = FALSE;
SensePtr = SenseData;
for (Index = 0; Index < SenseCounts; Index++) {
if (SensePtr->sense_key == 0x06) {
//
// Sense key is 0x06 means the device is just be reset or media just
// changed. The current state of the device is unclear.
//
Unclear = TRUE;
break;
}
SensePtr++;
}
return Unclear;
}
/**
Check if there is media error according to sense data.
@param[in] SenseData Pointer to sense data.
@param[in] SenseCounts Count of sense data.
@retval TRUE Media error
@retval FALSE No media error
**/
BOOLEAN
IsMediaError (
IN ATAPI_REQUEST_SENSE_DATA *SenseData,
IN UINTN SenseCounts
)
{
ATAPI_REQUEST_SENSE_DATA *SensePtr;
UINTN Index;
BOOLEAN IsError;
IsError = FALSE;
SensePtr = SenseData;
for (Index = 0; Index < SenseCounts; Index++) {
switch (SensePtr->sense_key) {
case ATA_SK_MEDIUM_ERROR:
switch (SensePtr->addnl_sense_code) {
case ATA_ASC_MEDIA_ERR1:
//
// fall through
//
case ATA_ASC_MEDIA_ERR2:
//
// fall through
//
case ATA_ASC_MEDIA_ERR3:
//
// fall through
//
case ATA_ASC_MEDIA_ERR4:
IsError = TRUE;
break;
default:
break;
}
break;
case ATA_SK_NOT_READY:
switch (SensePtr->addnl_sense_code) {
case ATA_ASC_MEDIA_UPSIDE_DOWN:
IsError = TRUE;
break;
default:
break;
}
break;
default:
break;
}
SensePtr++;
}
return IsError;
}
/**
Check if drive is ready according to sense data.
@param[in] SenseData Pointer to sense data.
@param[in] SenseCounts Count of sense data.
@param[out] NeedRetry Indicate if retry is needed.
@retval TRUE Drive ready
@retval FALSE Drive not ready
**/
BOOLEAN
IsDriveReady (
IN ATAPI_REQUEST_SENSE_DATA *SenseData,
IN UINTN SenseCounts,
OUT BOOLEAN *NeedRetry
)
{
ATAPI_REQUEST_SENSE_DATA *SensePtr;
UINTN Index;
BOOLEAN IsReady;
IsReady = TRUE;
*NeedRetry = FALSE;
SensePtr = SenseData;
for (Index = 0; Index < SenseCounts; Index++) {
switch (SensePtr->sense_key) {
case ATA_SK_NOT_READY:
switch (SensePtr->addnl_sense_code) {
case ATA_ASC_NOT_READY:
switch (SensePtr->addnl_sense_code_qualifier) {
case ATA_ASCQ_IN_PROGRESS:
IsReady = FALSE;
*NeedRetry = TRUE;
break;
default:
IsReady = FALSE;
*NeedRetry = FALSE;
break;
}
break;
default:
break;
}
break;
default:
break;
}
SensePtr++;
}
return IsReady;
}
Reference in New Issue View Git Blame Copy Permalink