MdeModulePkg/AtaAtapiPassThru: Revert patch to disable Bus Master

[mirror_edk2.git] / MdeModulePkg / Bus / Ata / AtaAtapiPassThru / IdeMode.c

/** @file\r
  Header file for AHCI mode of ATA host controller.\r
\r
  Copyright (c) 2010 - 2015, Intel Corporation. All rights reserved.<BR>\r
  This program and the accompanying materials\r
  are licensed and made available under the terms and conditions of the BSD License\r
  which accompanies this distribution.  The full text of the license may be found at\r
  http://opensource.org/licenses/bsd-license.php\r
\r
  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
\r
**/\r
\r
#include "AtaAtapiPassThru.h"\r
\r
/**\r
  read a one-byte data from a IDE port.\r
\r
  @param  PciIo  A pointer to EFI_PCI_IO_PROTOCOL data structure\r
  @param  Port   The IDE Port number\r
\r
  @return  the one-byte data read from IDE port\r
**/\r
UINT8\r
EFIAPI\r
IdeReadPortB (\r
  IN  EFI_PCI_IO_PROTOCOL   *PciIo,\r
  IN  UINT16                Port\r
  )\r
{\r
  UINT8 Data;\r
\r
  ASSERT (PciIo != NULL);\r
\r
  Data = 0;\r
  //\r
  // perform 1-byte data read from register\r
  //\r
  PciIo->Io.Read (\r
              PciIo,\r
              EfiPciIoWidthUint8,\r
              EFI_PCI_IO_PASS_THROUGH_BAR,\r
              (UINT64) Port,\r
              1,\r
              &Data\r
              );\r
  return Data;\r
}\r
\r
/**\r
  write a 1-byte data to a specific IDE port.\r
\r
  @param  PciIo  A pointer to EFI_PCI_IO_PROTOCOL data structure\r
  @param  Port   The IDE port to be writen\r
  @param  Data   The data to write to the port\r
**/\r
VOID\r
EFIAPI\r
IdeWritePortB (\r
  IN  EFI_PCI_IO_PROTOCOL   *PciIo,\r
  IN  UINT16                Port,\r
  IN  UINT8                 Data\r
  )\r
{\r
  ASSERT (PciIo != NULL);\r
\r
  //\r
  // perform 1-byte data write to register\r
  //\r
  PciIo->Io.Write (\r
              PciIo,\r
              EfiPciIoWidthUint8,\r
              EFI_PCI_IO_PASS_THROUGH_BAR,\r
              (UINT64) Port,\r
              1,\r
              &Data\r
              );\r
}\r
\r
/**\r
  write a 1-word data to a specific IDE port.\r
\r
  @param  PciIo  A pointer to EFI_PCI_IO_PROTOCOL data structure\r
  @param  Port   The IDE port to be writen\r
  @param  Data   The data to write to the port\r
**/\r
VOID\r
EFIAPI\r
IdeWritePortW (\r
  IN  EFI_PCI_IO_PROTOCOL   *PciIo,\r
  IN  UINT16                Port,\r
  IN  UINT16                Data\r
  )\r
{\r
  ASSERT (PciIo != NULL);\r
\r
  //\r
  // perform 1-word data write to register\r
  //\r
  PciIo->Io.Write (\r
              PciIo,\r
              EfiPciIoWidthUint16,\r
              EFI_PCI_IO_PASS_THROUGH_BAR,\r
              (UINT64) Port,\r
              1,\r
              &Data\r
              );\r
}\r
\r
/**\r
  write a 2-word data to a specific IDE port.\r
\r
  @param  PciIo  A pointer to EFI_PCI_IO_PROTOCOL data structure\r
  @param  Port   The IDE port to be writen\r
  @param  Data   The data to write to the port\r
**/\r
VOID\r
EFIAPI\r
IdeWritePortDW (\r
  IN  EFI_PCI_IO_PROTOCOL   *PciIo,\r
  IN  UINT16                Port,\r
  IN  UINT32                Data\r
  )\r
{\r
  ASSERT (PciIo != NULL);\r
\r
  //\r
  // perform 2-word data write to register\r
  //\r
  PciIo->Io.Write (\r
              PciIo,\r
              EfiPciIoWidthUint32,\r
              EFI_PCI_IO_PASS_THROUGH_BAR,\r
              (UINT64) Port,\r
              1,\r
              &Data\r
              );\r
}\r
\r
/**\r
  Write multiple words of data to the IDE data port.\r
  Call the IO abstraction once to do the complete read,\r
  not one word at a time\r
\r
  @param  PciIo      A pointer to EFI_PCI_IO_PROTOCOL data structure\r
  @param  Port       IO port to read\r
  @param  Count      No. of UINT16's to read\r
  @param  Buffer     Pointer to the data buffer for read\r
\r
**/\r
VOID\r
EFIAPI\r
IdeWritePortWMultiple (\r
  IN  EFI_PCI_IO_PROTOCOL   *PciIo,\r
  IN  UINT16                Port,\r
  IN  UINTN                 Count,\r
  IN  VOID                  *Buffer\r
  )\r
{\r
  ASSERT (PciIo  != NULL);\r
  ASSERT (Buffer != NULL);\r
\r
  //\r
  // perform UINT16 data write to the FIFO\r
  //\r
  PciIo->Io.Write (\r
              PciIo,\r
              EfiPciIoWidthFifoUint16,\r
              EFI_PCI_IO_PASS_THROUGH_BAR,\r
              (UINT64) Port,\r
              Count,\r
              (UINT16 *) Buffer\r
              );\r
\r
}\r
\r
/**\r
  Reads multiple words of data from the IDE data port.\r
  Call the IO abstraction once to do the complete read,\r
  not one word at a time\r
\r
  @param  PciIo    A pointer to EFI_PCI_IO_PROTOCOL data structure\r
  @param  Port     IO port to read\r
  @param  Count    Number of UINT16's to read\r
  @param  Buffer   Pointer to the data buffer for read\r
\r
**/\r
VOID\r
EFIAPI\r
IdeReadPortWMultiple (\r
  IN  EFI_PCI_IO_PROTOCOL   *PciIo,\r
  IN  UINT16                Port,\r
  IN  UINTN                 Count,\r
  IN  VOID                  *Buffer\r
  )\r
{\r
  ASSERT (PciIo  != NULL);\r
  ASSERT (Buffer != NULL);\r
\r
  //\r
  // Perform UINT16 data read from FIFO\r
  //\r
  PciIo->Io.Read (\r
              PciIo,\r
              EfiPciIoWidthFifoUint16,\r
              EFI_PCI_IO_PASS_THROUGH_BAR,\r
              (UINT64) Port,\r
              Count,\r
              (UINT16 *) Buffer\r
              );\r
\r
}\r
\r
/**\r
  This function is used to analyze the Status Register and print out\r
  some debug information and if there is ERR bit set in the Status\r
  Register, the Error Register's value is also be parsed and print out.\r
\r
  @param PciIo            A pointer to EFI_PCI_IO_PROTOCOL data structure.\r
  @param IdeRegisters     A pointer to EFI_IDE_REGISTERS data structure.\r
  @param AtaStatusBlock   A pointer to EFI_ATA_STATUS_BLOCK data structure.\r
\r
**/\r
VOID\r
EFIAPI\r
DumpAllIdeRegisters (\r
  IN     EFI_PCI_IO_PROTOCOL      *PciIo,\r
  IN     EFI_IDE_REGISTERS        *IdeRegisters,\r
  IN OUT EFI_ATA_STATUS_BLOCK     *AtaStatusBlock\r
  )\r
{\r
  EFI_ATA_STATUS_BLOCK StatusBlock;\r
\r
  ASSERT (PciIo != NULL);\r
  ASSERT (IdeRegisters != NULL);\r
\r
  ZeroMem (&StatusBlock, sizeof (EFI_ATA_STATUS_BLOCK));\r
\r
  StatusBlock.AtaStatus          = IdeReadPortB (PciIo, IdeRegisters->CmdOrStatus);\r
  StatusBlock.AtaError           = IdeReadPortB (PciIo, IdeRegisters->ErrOrFeature);\r
  StatusBlock.AtaSectorCount     = IdeReadPortB (PciIo, IdeRegisters->SectorCount);\r
  StatusBlock.AtaSectorCountExp  = IdeReadPortB (PciIo, IdeRegisters->SectorCount);\r
  StatusBlock.AtaSectorNumber    = IdeReadPortB (PciIo, IdeRegisters->SectorNumber);\r
  StatusBlock.AtaSectorNumberExp = IdeReadPortB (PciIo, IdeRegisters->SectorNumber);\r
  StatusBlock.AtaCylinderLow     = IdeReadPortB (PciIo, IdeRegisters->CylinderLsb);\r
  StatusBlock.AtaCylinderLowExp  = IdeReadPortB (PciIo, IdeRegisters->CylinderLsb);\r
  StatusBlock.AtaCylinderHigh    = IdeReadPortB (PciIo, IdeRegisters->CylinderMsb);\r
  StatusBlock.AtaCylinderHighExp = IdeReadPortB (PciIo, IdeRegisters->CylinderMsb);\r
  StatusBlock.AtaDeviceHead      = IdeReadPortB (PciIo, IdeRegisters->Head);\r
\r
  if (AtaStatusBlock != NULL) {\r
    //\r
    // Dump the content of all ATA registers.\r
    //\r
    CopyMem (AtaStatusBlock, &StatusBlock, sizeof (EFI_ATA_STATUS_BLOCK));\r
  }\r
\r
  DEBUG_CODE_BEGIN ();\r
  if ((StatusBlock.AtaStatus & ATA_STSREG_DWF) != 0) {\r
    DEBUG ((EFI_D_ERROR, "CheckRegisterStatus()-- %02x : Error : Write Fault\n", StatusBlock.AtaStatus));\r
  }\r
\r
  if ((StatusBlock.AtaStatus & ATA_STSREG_CORR) != 0) {\r
    DEBUG ((EFI_D_ERROR, "CheckRegisterStatus()-- %02x : Error : Corrected Data\n", StatusBlock.AtaStatus));\r
  }\r
\r
  if ((StatusBlock.AtaStatus & ATA_STSREG_ERR) != 0) {\r
    if ((StatusBlock.AtaError & ATA_ERRREG_BBK) != 0) {\r
      DEBUG ((EFI_D_ERROR, "CheckRegisterStatus()-- %02x : Error : Bad Block Detected\n", StatusBlock.AtaError));\r
    }\r
\r
    if ((StatusBlock.AtaError & ATA_ERRREG_UNC) != 0) {\r
      DEBUG ((EFI_D_ERROR, "CheckRegisterStatus()-- %02x : Error : Uncorrectable Data\n", StatusBlock.AtaError));\r
    }\r
\r
    if ((StatusBlock.AtaError & ATA_ERRREG_MC) != 0) {\r
      DEBUG ((EFI_D_ERROR, "CheckRegisterStatus()-- %02x : Error : Media Change\n", StatusBlock.AtaError));\r
    }\r
\r
    if ((StatusBlock.AtaError & ATA_ERRREG_ABRT) != 0) {\r
      DEBUG ((EFI_D_ERROR, "CheckRegisterStatus()-- %02x : Error : Abort\n", StatusBlock.AtaError));\r
    }\r
\r
    if ((StatusBlock.AtaError & ATA_ERRREG_TK0NF) != 0) {\r
      DEBUG ((EFI_D_ERROR, "CheckRegisterStatus()-- %02x : Error : Track 0 Not Found\n", StatusBlock.AtaError));\r
    }\r
\r
    if ((StatusBlock.AtaError & ATA_ERRREG_AMNF) != 0) {\r
      DEBUG ((EFI_D_ERROR, "CheckRegisterStatus()-- %02x : Error : Address Mark Not Found\n", StatusBlock.AtaError));\r
    }\r
  }\r
  DEBUG_CODE_END ();\r
}\r
\r
/**\r
  This function is used to analyze the Status Register at the condition that BSY is zero.\r
  if there is ERR bit set in the Status Register, then return error.\r
\r
  @param PciIo            A pointer to EFI_PCI_IO_PROTOCOL data structure.\r
  @param IdeRegisters     A pointer to EFI_IDE_REGISTERS data structure.\r
\r
  @retval EFI_SUCCESS       No err information in the Status Register.\r
  @retval EFI_DEVICE_ERROR  Any err information in the Status Register.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
CheckStatusRegister (\r
  IN  EFI_PCI_IO_PROTOCOL      *PciIo,\r
  IN  EFI_IDE_REGISTERS        *IdeRegisters\r
  )\r
{\r
  UINT8           StatusRegister;\r
\r
  ASSERT (PciIo != NULL);\r
  ASSERT (IdeRegisters != NULL);\r
\r
  StatusRegister = IdeReadPortB (PciIo, IdeRegisters->CmdOrStatus);\r
\r
  if ((StatusRegister & ATA_STSREG_BSY) == 0) {\r
    if ((StatusRegister & (ATA_STSREG_ERR | ATA_STSREG_DWF | ATA_STSREG_CORR)) == 0) {\r
      return EFI_SUCCESS;\r
    } else {\r
      return EFI_DEVICE_ERROR;\r
    }\r
  }\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  This function is used to poll for the DRQ bit clear in the Status\r
  Register. DRQ is cleared when the device is finished transferring data.\r
  So this function is called after data transfer is finished.\r
\r
  @param PciIo            A pointer to EFI_PCI_IO_PROTOCOL data structure.\r
  @param IdeRegisters     A pointer to EFI_IDE_REGISTERS data structure.\r
  @param Timeout          The time to complete the command, uses 100ns as a unit.\r
\r
  @retval EFI_SUCCESS     DRQ bit clear within the time out.\r
\r
  @retval EFI_TIMEOUT     DRQ bit not clear within the time out.\r
\r
  @note\r
  Read Status Register will clear interrupt status.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
DRQClear (\r
  IN  EFI_PCI_IO_PROTOCOL       *PciIo,\r
  IN  EFI_IDE_REGISTERS         *IdeRegisters,\r
  IN  UINT64                    Timeout\r
  )\r
{\r
  UINT64  Delay;\r
  UINT8   StatusRegister;\r
  BOOLEAN InfiniteWait;\r
\r
  ASSERT (PciIo != NULL);\r
  ASSERT (IdeRegisters != NULL);\r
\r
  if (Timeout == 0) {\r
    InfiniteWait = TRUE;\r
  } else {\r
    InfiniteWait = FALSE;\r
  }\r
\r
  Delay = DivU64x32(Timeout, 1000) + 1;\r
  do {\r
    StatusRegister = IdeReadPortB (PciIo, IdeRegisters->CmdOrStatus);\r
\r
    //\r
    // Wait for BSY == 0, then judge if DRQ is clear\r
    //\r
    if ((StatusRegister & ATA_STSREG_BSY) == 0) {\r
      if ((StatusRegister & ATA_STSREG_DRQ) == ATA_STSREG_DRQ) {\r
        return EFI_DEVICE_ERROR;\r
      } else {\r
        return EFI_SUCCESS;\r
      }\r
    }\r
\r
    //\r
    // Stall for 100 microseconds.\r
    //\r
    MicroSecondDelay (100);\r
\r
    Delay--;\r
\r
  } while (InfiniteWait || (Delay > 0));\r
\r
  return EFI_TIMEOUT;\r
}\r
/**\r
  This function is used to poll for the DRQ bit clear in the Alternate\r
  Status Register. DRQ is cleared when the device is finished\r
  transferring data. So this function is called after data transfer\r
  is finished.\r
\r
  @param PciIo            A pointer to EFI_PCI_IO_PROTOCOL data structure.\r
  @param IdeRegisters     A pointer to EFI_IDE_REGISTERS data structure.\r
  @param Timeout          The time to complete the command, uses 100ns as a unit.\r
\r
  @retval EFI_SUCCESS     DRQ bit clear within the time out.\r
\r
  @retval EFI_TIMEOUT     DRQ bit not clear within the time out.\r
  @note   Read Alternate Status Register will not clear interrupt status.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
DRQClear2 (\r
  IN  EFI_PCI_IO_PROTOCOL  *PciIo,\r
  IN  EFI_IDE_REGISTERS    *IdeRegisters,\r
  IN  UINT64               Timeout\r
  )\r
{\r
  UINT64  Delay;\r
  UINT8   AltRegister;\r
  BOOLEAN InfiniteWait;\r
\r
  ASSERT (PciIo != NULL);\r
  ASSERT (IdeRegisters != NULL);\r
\r
  if (Timeout == 0) {\r
    InfiniteWait = TRUE;\r
  } else {\r
    InfiniteWait = FALSE;\r
  }\r
\r
  Delay = DivU64x32(Timeout, 1000) + 1;\r
  do {\r
    AltRegister = IdeReadPortB (PciIo, IdeRegisters->AltOrDev);\r
\r
    //\r
    // Wait for BSY == 0, then judge if DRQ is clear\r
    //\r
    if ((AltRegister & ATA_STSREG_BSY) == 0) {\r
      if ((AltRegister & ATA_STSREG_DRQ) == ATA_STSREG_DRQ) {\r
        return EFI_DEVICE_ERROR;\r
      } else {\r
        return EFI_SUCCESS;\r
      }\r
    }\r
\r
    //\r
    // Stall for 100 microseconds.\r
    //\r
    MicroSecondDelay (100);\r
\r
    Delay--;\r
\r
  } while (InfiniteWait || (Delay > 0));\r
\r
  return EFI_TIMEOUT;\r
}\r
\r
/**\r
  This function is used to poll for the DRQ bit set in the\r
  Status Register.\r
  DRQ is set when the device is ready to transfer data. So this function\r
  is called after the command is sent to the device and before required\r
  data is transferred.\r
\r
  @param PciIo            A pointer to EFI_PCI_IO_PROTOCOL data structure.\r
  @param IdeRegisters     A pointer to EFI_IDE_REGISTERS data structure.\r
  @param Timeout          The time to complete the command, uses 100ns as a unit.\r
\r
  @retval EFI_SUCCESS           BSY bit cleared and DRQ bit set within the\r
                                timeout.\r
\r
  @retval EFI_TIMEOUT           BSY bit not cleared within the timeout.\r
\r
  @retval EFI_ABORTED           Polling abandoned due to command abort.\r
\r
  @retval EFI_DEVICE_ERROR      Polling abandoned due to a non-abort error.\r
\r
  @retval EFI_NOT_READY         BSY bit cleared within timeout, and device\r
                                reported "command complete" by clearing DRQ\r
                                bit.\r
\r
  @note  Read Status Register will clear interrupt status.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
DRQReady (\r
  IN  EFI_PCI_IO_PROTOCOL  *PciIo,\r
  IN  EFI_IDE_REGISTERS    *IdeRegisters,\r
  IN  UINT64               Timeout\r
  )\r
{\r
  UINT64  Delay;\r
  UINT8   StatusRegister;\r
  UINT8   ErrorRegister;\r
  BOOLEAN InfiniteWait;\r
\r
  ASSERT (PciIo != NULL);\r
  ASSERT (IdeRegisters != NULL);\r
\r
  if (Timeout == 0) {\r
    InfiniteWait = TRUE;\r
  } else {\r
    InfiniteWait = FALSE;\r
  }\r
\r
  Delay = DivU64x32(Timeout, 1000) + 1;\r
  do {\r
    //\r
    // Read Status Register will clear interrupt\r
    //\r
    StatusRegister = IdeReadPortB (PciIo, IdeRegisters->CmdOrStatus);\r
\r
    //\r
    // Wait for BSY == 0, then judge if DRQ is clear or ERR is set\r
    //\r
    if ((StatusRegister & ATA_STSREG_BSY) == 0) {\r
      if ((StatusRegister & ATA_STSREG_ERR) == ATA_STSREG_ERR) {\r
        ErrorRegister = IdeReadPortB (PciIo, IdeRegisters->ErrOrFeature);\r
\r
        if ((ErrorRegister & ATA_ERRREG_ABRT) == ATA_ERRREG_ABRT) {\r
          return EFI_ABORTED;\r
        }\r
        return EFI_DEVICE_ERROR;\r
      }\r
\r
      if ((StatusRegister & ATA_STSREG_DRQ) == ATA_STSREG_DRQ) {\r
        return EFI_SUCCESS;\r
      } else {\r
        return EFI_NOT_READY;\r
      }\r
    }\r
\r
    //\r
    // Stall for 100 microseconds.\r
    //\r
    MicroSecondDelay (100);\r
\r
    Delay--;\r
  } while (InfiniteWait || (Delay > 0));\r
\r
  return EFI_TIMEOUT;\r
}\r
/**\r
  This function is used to poll for the DRQ bit set in the Alternate Status Register.\r
  DRQ is set when the device is ready to transfer data. So this function is called after\r
  the command is sent to the device and before required data is transferred.\r
\r
  @param PciIo            A pointer to EFI_PCI_IO_PROTOCOL data structure.\r
  @param IdeRegisters     A pointer to EFI_IDE_REGISTERS data structure.\r
  @param Timeout          The time to complete the command, uses 100ns as a unit.\r
\r
  @retval EFI_SUCCESS           BSY bit cleared and DRQ bit set within the\r
                                timeout.\r
\r
  @retval EFI_TIMEOUT           BSY bit not cleared within the timeout.\r
\r
  @retval EFI_ABORTED           Polling abandoned due to command abort.\r
\r
  @retval EFI_DEVICE_ERROR      Polling abandoned due to a non-abort error.\r
\r
  @retval EFI_NOT_READY         BSY bit cleared within timeout, and device\r
                                reported "command complete" by clearing DRQ\r
                                bit.\r
\r
  @note  Read Alternate Status Register will not clear interrupt status.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
DRQReady2 (\r
  IN  EFI_PCI_IO_PROTOCOL  *PciIo,\r
  IN  EFI_IDE_REGISTERS    *IdeRegisters,\r
  IN  UINT64               Timeout\r
  )\r
{\r
  UINT64  Delay;\r
  UINT8   AltRegister;\r
  UINT8   ErrorRegister;\r
  BOOLEAN InfiniteWait;\r
\r
  ASSERT (PciIo != NULL);\r
  ASSERT (IdeRegisters != NULL);\r
\r
  if (Timeout == 0) {\r
    InfiniteWait = TRUE;\r
  } else {\r
    InfiniteWait = FALSE;\r
  }\r
\r
  Delay = DivU64x32(Timeout, 1000) + 1;\r
\r
  do {\r
    //\r
    // Read Alternate Status Register will not clear interrupt status\r
    //\r
    AltRegister = IdeReadPortB (PciIo, IdeRegisters->AltOrDev);\r
    //\r
    // Wait for BSY == 0, then judge if DRQ is clear or ERR is set\r
    //\r
    if ((AltRegister & ATA_STSREG_BSY) == 0) {\r
      if ((AltRegister & ATA_STSREG_ERR) == ATA_STSREG_ERR) {\r
        ErrorRegister = IdeReadPortB (PciIo, IdeRegisters->ErrOrFeature);\r
\r
        if ((ErrorRegister & ATA_ERRREG_ABRT) == ATA_ERRREG_ABRT) {\r
          return EFI_ABORTED;\r
        }\r
        return EFI_DEVICE_ERROR;\r
      }\r
\r
      if ((AltRegister & ATA_STSREG_DRQ) == ATA_STSREG_DRQ) {\r
        return EFI_SUCCESS;\r
      } else {\r
        return EFI_NOT_READY;\r
      }\r
    }\r
\r
    //\r
    // Stall for 100 microseconds.\r
    //\r
    MicroSecondDelay (100);\r
\r
    Delay--;\r
  } while (InfiniteWait || (Delay > 0));\r
\r
  return EFI_TIMEOUT;\r
}\r
\r
/**\r
  This function is used to poll for the DRDY bit set in the Status Register. DRDY\r
  bit is set when the device is ready to accept command. Most ATA commands must be\r
  sent after DRDY set except the ATAPI Packet Command.\r
\r
  @param PciIo            A pointer to EFI_PCI_IO_PROTOCOL data structure.\r
  @param IdeRegisters     A pointer to EFI_IDE_REGISTERS data structure.\r
  @param Timeout          The time to complete the command, uses 100ns as a unit.\r
\r
  @retval EFI_SUCCESS         DRDY bit set within the time out.\r
  @retval EFI_TIMEOUT         DRDY bit not set within the time out.\r
\r
  @note  Read Status Register will clear interrupt status.\r
**/\r
EFI_STATUS\r
EFIAPI\r
DRDYReady (\r
  IN  EFI_PCI_IO_PROTOCOL  *PciIo,\r
  IN  EFI_IDE_REGISTERS    *IdeRegisters,\r
  IN  UINT64               Timeout\r
  )\r
{\r
  UINT64  Delay;\r
  UINT8   StatusRegister;\r
  UINT8   ErrorRegister;\r
  BOOLEAN InfiniteWait;\r
\r
  ASSERT (PciIo != NULL);\r
  ASSERT (IdeRegisters != NULL);\r
\r
  if (Timeout == 0) {\r
    InfiniteWait = TRUE;\r
  } else {\r
    InfiniteWait = FALSE;\r
  }\r
\r
  Delay = DivU64x32(Timeout, 1000) + 1;\r
  do {\r
    StatusRegister = IdeReadPortB (PciIo, IdeRegisters->CmdOrStatus);\r
    //\r
    // Wait for BSY == 0, then judge if DRDY is set or ERR is set\r
    //\r
    if ((StatusRegister & ATA_STSREG_BSY) == 0) {\r
      if ((StatusRegister & ATA_STSREG_ERR) == ATA_STSREG_ERR) {\r
        ErrorRegister = IdeReadPortB (PciIo, IdeRegisters->ErrOrFeature);\r
\r
        if ((ErrorRegister & ATA_ERRREG_ABRT) == ATA_ERRREG_ABRT) {\r
          return EFI_ABORTED;\r
        }\r
        return EFI_DEVICE_ERROR;\r
      }\r
\r
      if ((StatusRegister & ATA_STSREG_DRDY) == ATA_STSREG_DRDY) {\r
        return EFI_SUCCESS;\r
      } else {\r
        return EFI_DEVICE_ERROR;\r
      }\r
    }\r
\r
    //\r
    // Stall for 100 microseconds.\r
    //\r
    MicroSecondDelay (100);\r
\r
    Delay--;\r
  } while (InfiniteWait || (Delay > 0));\r
\r
  return EFI_TIMEOUT;\r
}\r
\r
/**\r
  This function is used to poll for the DRDY bit set in the Alternate Status Register.\r
  DRDY bit is set when the device is ready to accept command. Most ATA commands must\r
  be sent after DRDY set except the ATAPI Packet Command.\r
\r
  @param PciIo            A pointer to EFI_PCI_IO_PROTOCOL data structure.\r
  @param IdeRegisters     A pointer to EFI_IDE_REGISTERS data structure.\r
  @param Timeout          The time to complete the command, uses 100ns as a unit.\r
\r
  @retval EFI_SUCCESS      DRDY bit set within the time out.\r
  @retval EFI_TIMEOUT      DRDY bit not set within the time out.\r
\r
  @note  Read Alternate Status Register will clear interrupt status.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
DRDYReady2 (\r
  IN  EFI_PCI_IO_PROTOCOL  *PciIo,\r
  IN  EFI_IDE_REGISTERS    *IdeRegisters,\r
  IN  UINT64               Timeout\r
  )\r
{\r
  UINT64  Delay;\r
  UINT8   AltRegister;\r
  UINT8   ErrorRegister;\r
  BOOLEAN InfiniteWait;\r
\r
  ASSERT (PciIo != NULL);\r
  ASSERT (IdeRegisters != NULL);\r
\r
  if (Timeout == 0) {\r
    InfiniteWait = TRUE;\r
  } else {\r
    InfiniteWait = FALSE;\r
  }\r
\r
  Delay = DivU64x32(Timeout, 1000) + 1;\r
  do {\r
    AltRegister = IdeReadPortB (PciIo, IdeRegisters->AltOrDev);\r
    //\r
    // Wait for BSY == 0, then judge if DRDY is set or ERR is set\r
    //\r
    if ((AltRegister & ATA_STSREG_BSY) == 0) {\r
      if ((AltRegister & ATA_STSREG_ERR) == ATA_STSREG_ERR) {\r
        ErrorRegister = IdeReadPortB (PciIo, IdeRegisters->ErrOrFeature);\r
\r
        if ((ErrorRegister & ATA_ERRREG_ABRT) == ATA_ERRREG_ABRT) {\r
          return EFI_ABORTED;\r
        }\r
        return EFI_DEVICE_ERROR;\r
      }\r
\r
      if ((AltRegister & ATA_STSREG_DRDY) == ATA_STSREG_DRDY) {\r
        return EFI_SUCCESS;\r
      } else {\r
        return EFI_DEVICE_ERROR;\r
      }\r
    }\r
\r
    //\r
    // Stall for 100 microseconds.\r
    //\r
    MicroSecondDelay (100);\r
\r
    Delay--;\r
  } while (InfiniteWait || (Delay > 0));\r
\r
  return EFI_TIMEOUT;\r
}\r
\r
/**\r
  This function is used to poll for the BSY bit clear in the Status Register. BSY\r
  is clear when the device is not busy. Every command must be sent after device is not busy.\r
\r
  @param PciIo            A pointer to ATA_ATAPI_PASS_THRU_INSTANCE data structure.\r
  @param IdeRegisters     A pointer to EFI_IDE_REGISTERS data structure.\r
  @param Timeout          The time to complete the command, uses 100ns as a unit.\r
\r
  @retval EFI_SUCCESS          BSY bit clear within the time out.\r
  @retval EFI_TIMEOUT          BSY bit not clear within the time out.\r
\r
  @note Read Status Register will clear interrupt status.\r
**/\r
EFI_STATUS\r
EFIAPI\r
WaitForBSYClear (\r
  IN  EFI_PCI_IO_PROTOCOL  *PciIo,\r
  IN  EFI_IDE_REGISTERS    *IdeRegisters,\r
  IN  UINT64               Timeout\r
  )\r
{\r
  UINT64  Delay;\r
  UINT8   StatusRegister;\r
  BOOLEAN InfiniteWait;\r
\r
  ASSERT (PciIo != NULL);\r
  ASSERT (IdeRegisters != NULL);\r
\r
  if (Timeout == 0) {\r
    InfiniteWait = TRUE;\r
  } else {\r
    InfiniteWait = FALSE;\r
  }\r
\r
  Delay = DivU64x32(Timeout, 1000) + 1;\r
  do {\r
    StatusRegister = IdeReadPortB (PciIo, IdeRegisters->CmdOrStatus);\r
\r
    if ((StatusRegister & ATA_STSREG_BSY) == 0x00) {\r
      return EFI_SUCCESS;\r
    }\r
\r
    //\r
    // Stall for 100 microseconds.\r
    //\r
    MicroSecondDelay (100);\r
\r
    Delay--;\r
\r
  } while (InfiniteWait || (Delay > 0));\r
\r
  return EFI_TIMEOUT;\r
}\r
\r
/**\r
  This function is used to poll for the BSY bit clear in the Status Register. BSY\r
  is clear when the device is not busy. Every command must be sent after device is not busy.\r
\r
  @param PciIo            A pointer to ATA_ATAPI_PASS_THRU_INSTANCE data structure.\r
  @param IdeRegisters     A pointer to EFI_IDE_REGISTERS data structure.\r
  @param Timeout          The time to complete the command, uses 100ns as a unit.\r
\r
  @retval EFI_SUCCESS          BSY bit clear within the time out.\r
  @retval EFI_TIMEOUT          BSY bit not clear within the time out.\r
\r
  @note Read Status Register will clear interrupt status.\r
**/\r
EFI_STATUS\r
EFIAPI\r
WaitForBSYClear2 (\r
  IN  EFI_PCI_IO_PROTOCOL  *PciIo,\r
  IN  EFI_IDE_REGISTERS    *IdeRegisters,\r
  IN  UINT64               Timeout\r
  )\r
{\r
  UINT64  Delay;\r
  UINT8   AltStatusRegister;\r
  BOOLEAN InfiniteWait;\r
\r
  ASSERT (PciIo != NULL);\r
  ASSERT (IdeRegisters != NULL);\r
\r
  if (Timeout == 0) {\r
    InfiniteWait = TRUE;\r
  } else {\r
    InfiniteWait = FALSE;\r
  }\r
\r
  Delay = DivU64x32(Timeout, 1000) + 1;\r
  do {\r
    AltStatusRegister = IdeReadPortB (PciIo, IdeRegisters->AltOrDev);\r
\r
    if ((AltStatusRegister & ATA_STSREG_BSY) == 0x00) {\r
      return EFI_SUCCESS;\r
    }\r
\r
    //\r
    // Stall for 100 microseconds.\r
    //\r
    MicroSecondDelay (100);\r
\r
    Delay--;\r
\r
  } while (InfiniteWait || (Delay > 0));\r
\r
  return EFI_TIMEOUT;\r
}\r
\r
/**\r
  Get IDE i/o port registers' base addresses by mode.\r
\r
  In 'Compatibility' mode, use fixed addresses.\r
  In Native-PCI mode, get base addresses from BARs in the PCI IDE controller's\r
  Configuration Space.\r
\r
  The steps to get IDE i/o port registers' base addresses for each channel\r
  as follows:\r
\r
  1. Examine the Programming Interface byte of the Class Code fields in PCI IDE\r
  controller's Configuration Space to determine the operating mode.\r
\r
  2. a) In 'Compatibility' mode, use fixed addresses shown in the Table 1 below.\r
   ___________________________________________\r
  |           | Command Block | Control Block |\r
  |  Channel  |   Registers   |   Registers   |\r
  |___________|_______________|_______________|\r
  |  Primary  |  1F0h - 1F7h  |  3F6h - 3F7h  |\r
  |___________|_______________|_______________|\r
  | Secondary |  170h - 177h  |  376h - 377h  |\r
  |___________|_______________|_______________|\r
\r
  Table 1. Compatibility resource mappings\r
\r
  b) In Native-PCI mode, IDE registers are mapped into IO space using the BARs\r
  in IDE controller's PCI Configuration Space, shown in the Table 2 below.\r
   ___________________________________________________\r
  |           |   Command Block   |   Control Block   |\r
  |  Channel  |     Registers     |     Registers     |\r
  |___________|___________________|___________________|\r
  |  Primary  | BAR at offset 0x10| BAR at offset 0x14|\r
  |___________|___________________|___________________|\r
  | Secondary | BAR at offset 0x18| BAR at offset 0x1C|\r
  |___________|___________________|___________________|\r
\r
  Table 2. BARs for Register Mapping\r
\r
  @param[in]      PciIo          Pointer to the EFI_PCI_IO_PROTOCOL instance\r
  @param[in, out] IdeRegisters    Pointer to EFI_IDE_REGISTERS which is used to\r
                                 store the IDE i/o port registers' base addresses\r
\r
  @retval EFI_UNSUPPORTED        Return this value when the BARs is not IO type\r
  @retval EFI_SUCCESS            Get the Base address successfully\r
  @retval Other                  Read the pci configureation data error\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
GetIdeRegisterIoAddr (\r
  IN     EFI_PCI_IO_PROTOCOL         *PciIo,\r
  IN OUT EFI_IDE_REGISTERS           *IdeRegisters\r
  )\r
{\r
  EFI_STATUS        Status;\r
  PCI_TYPE00        PciData;\r
  UINT16            CommandBlockBaseAddr;\r
  UINT16            ControlBlockBaseAddr;\r
  UINT16            BusMasterBaseAddr;\r
\r
  if ((PciIo == NULL) || (IdeRegisters == NULL)) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  Status = PciIo->Pci.Read (\r
                        PciIo,\r
                        EfiPciIoWidthUint8,\r
                        0,\r
                        sizeof (PciData),\r
                        &PciData\r
                        );\r
\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  BusMasterBaseAddr    = (UINT16) ((PciData.Device.Bar[4] & 0x0000fff0));\r
\r
  if ((PciData.Hdr.ClassCode[0] & IDE_PRIMARY_OPERATING_MODE) == 0) {\r
    CommandBlockBaseAddr = 0x1f0;\r
    ControlBlockBaseAddr = 0x3f6;\r
  } else {\r
    //\r
    // The BARs should be of IO type\r
    //\r
    if ((PciData.Device.Bar[0] & BIT0) == 0 ||\r
        (PciData.Device.Bar[1] & BIT0) == 0) {\r
      return EFI_UNSUPPORTED;\r
    }\r
\r
    CommandBlockBaseAddr = (UINT16) (PciData.Device.Bar[0] & 0x0000fff8);\r
    ControlBlockBaseAddr = (UINT16) ((PciData.Device.Bar[1] & 0x0000fffc) + 2);\r
  }\r
\r
  //\r
  // Calculate IDE primary channel I/O register base address.\r
  //\r
  IdeRegisters[EfiIdePrimary].Data              = CommandBlockBaseAddr;\r
  IdeRegisters[EfiIdePrimary].ErrOrFeature      = (UINT16) (CommandBlockBaseAddr + 0x01);\r
  IdeRegisters[EfiIdePrimary].SectorCount       = (UINT16) (CommandBlockBaseAddr + 0x02);\r
  IdeRegisters[EfiIdePrimary].SectorNumber      = (UINT16) (CommandBlockBaseAddr + 0x03);\r
  IdeRegisters[EfiIdePrimary].CylinderLsb       = (UINT16) (CommandBlockBaseAddr + 0x04);\r
  IdeRegisters[EfiIdePrimary].CylinderMsb       = (UINT16) (CommandBlockBaseAddr + 0x05);\r
  IdeRegisters[EfiIdePrimary].Head              = (UINT16) (CommandBlockBaseAddr + 0x06);\r
  IdeRegisters[EfiIdePrimary].CmdOrStatus       = (UINT16) (CommandBlockBaseAddr + 0x07);\r
  IdeRegisters[EfiIdePrimary].AltOrDev          = ControlBlockBaseAddr;\r
  IdeRegisters[EfiIdePrimary].BusMasterBaseAddr = BusMasterBaseAddr;\r
\r
  if ((PciData.Hdr.ClassCode[0] & IDE_SECONDARY_OPERATING_MODE) == 0) {\r
    CommandBlockBaseAddr = 0x170;\r
    ControlBlockBaseAddr = 0x376;\r
  } else {\r
    //\r
    // The BARs should be of IO type\r
    //\r
    if ((PciData.Device.Bar[2] & BIT0) == 0 ||\r
        (PciData.Device.Bar[3] & BIT0) == 0) {\r
      return EFI_UNSUPPORTED;\r
    }\r
\r
    CommandBlockBaseAddr = (UINT16) (PciData.Device.Bar[2] & 0x0000fff8);\r
    ControlBlockBaseAddr = (UINT16) ((PciData.Device.Bar[3] & 0x0000fffc) + 2);\r
  }\r
\r
  //\r
  // Calculate IDE secondary channel I/O register base address.\r
  //\r
  IdeRegisters[EfiIdeSecondary].Data              = CommandBlockBaseAddr;\r
  IdeRegisters[EfiIdeSecondary].ErrOrFeature      = (UINT16) (CommandBlockBaseAddr + 0x01);\r
  IdeRegisters[EfiIdeSecondary].SectorCount       = (UINT16) (CommandBlockBaseAddr + 0x02);\r
  IdeRegisters[EfiIdeSecondary].SectorNumber      = (UINT16) (CommandBlockBaseAddr + 0x03);\r
  IdeRegisters[EfiIdeSecondary].CylinderLsb       = (UINT16) (CommandBlockBaseAddr + 0x04);\r
  IdeRegisters[EfiIdeSecondary].CylinderMsb       = (UINT16) (CommandBlockBaseAddr + 0x05);\r
  IdeRegisters[EfiIdeSecondary].Head              = (UINT16) (CommandBlockBaseAddr + 0x06);\r
  IdeRegisters[EfiIdeSecondary].CmdOrStatus       = (UINT16) (CommandBlockBaseAddr + 0x07);\r
  IdeRegisters[EfiIdeSecondary].AltOrDev          = ControlBlockBaseAddr;\r
  IdeRegisters[EfiIdeSecondary].BusMasterBaseAddr = (UINT16) (BusMasterBaseAddr + 0x8);\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  This function is used to implement the Soft Reset on the specified device. But,\r
  the ATA Soft Reset mechanism is so strong a reset method that it will force\r
  resetting on both devices connected to the same cable.\r
\r
  It is called by IdeBlkIoReset(), a interface function of Block\r
  I/O protocol.\r
\r
  This function can also be used by the ATAPI device to perform reset when\r
  ATAPI Reset command is failed.\r
\r
  @param PciIo            A pointer to ATA_ATAPI_PASS_THRU_INSTANCE data structure.\r
  @param IdeRegisters     A pointer to EFI_IDE_REGISTERS data structure.\r
  @param Timeout          The time to complete the command, uses 100ns as a unit.\r
\r
  @retval EFI_SUCCESS       Soft reset completes successfully.\r
  @retval EFI_DEVICE_ERROR  Any step during the reset process is failed.\r
\r
  @note  The registers initial values after ATA soft reset are different\r
         to the ATA device and ATAPI device.\r
**/\r
EFI_STATUS\r
EFIAPI\r
AtaSoftReset (\r
  IN  EFI_PCI_IO_PROTOCOL  *PciIo,\r
  IN  EFI_IDE_REGISTERS    *IdeRegisters,\r
  IN  UINT64               Timeout\r
  )\r
{\r
  UINT8 DeviceControl;\r
\r
  DeviceControl = 0;\r
  //\r
  // disable Interrupt and set SRST bit to initiate soft reset\r
  //\r
  DeviceControl = ATA_CTLREG_SRST | ATA_CTLREG_IEN_L;\r
\r
  IdeWritePortB (PciIo, IdeRegisters->AltOrDev, DeviceControl);\r
\r
  //\r
  // SRST should assert for at least 5 us, we use 10 us for\r
  // better compatibility\r
  //\r
  MicroSecondDelay (10);\r
\r
  //\r
  // Enable interrupt to support UDMA, and clear SRST bit\r
  //\r
  DeviceControl = 0;\r
  IdeWritePortB (PciIo, IdeRegisters->AltOrDev, DeviceControl);\r
\r
  //\r
  // Wait for at least 10 ms to check BSY status, we use 10 ms\r
  // for better compatibility\r
  //\r
  MicroSecondDelay (10000);\r
\r
  //\r
  // slave device needs at most 31ms to clear BSY\r
  //\r
  if (WaitForBSYClear (PciIo, IdeRegisters, Timeout) == EFI_TIMEOUT) {\r
    return EFI_DEVICE_ERROR;\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Send ATA Ext command into device with NON_DATA protocol.\r
\r
  @param PciIo            A pointer to ATA_ATAPI_PASS_THRU_INSTANCE data structure.\r
  @param IdeRegisters     A pointer to EFI_IDE_REGISTERS data structure.\r
  @param AtaCommandBlock  A pointer to EFI_ATA_COMMAND_BLOCK data structure.\r
  @param Timeout          The time to complete the command, uses 100ns as a unit.\r
\r
  @retval  EFI_SUCCESS Reading succeed\r
  @retval  EFI_DEVICE_ERROR Error executing commands on this device.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
AtaIssueCommand (\r
  IN  EFI_PCI_IO_PROTOCOL       *PciIo,\r
  IN  EFI_IDE_REGISTERS         *IdeRegisters,\r
  IN  EFI_ATA_COMMAND_BLOCK     *AtaCommandBlock,\r
  IN  UINT64                    Timeout\r
  )\r
{\r
  EFI_STATUS  Status;\r
  UINT8       DeviceHead;\r
  UINT8       AtaCommand;\r
\r
  ASSERT (PciIo != NULL);\r
  ASSERT (IdeRegisters != NULL);\r
  ASSERT (AtaCommandBlock != NULL);\r
\r
  DeviceHead = AtaCommandBlock->AtaDeviceHead;\r
  AtaCommand = AtaCommandBlock->AtaCommand;\r
\r
  Status = WaitForBSYClear (PciIo, IdeRegisters, Timeout);\r
  if (EFI_ERROR (Status)) {\r
    return EFI_DEVICE_ERROR;\r
  }\r
\r
  //\r
  // Select device (bit4), set LBA mode(bit6) (use 0xe0 for compatibility)\r
  //\r
  IdeWritePortB (PciIo, IdeRegisters->Head, (UINT8) (0xe0 | DeviceHead));\r
\r
  //\r
  // set all the command parameters\r
  // Before write to all the following registers, BSY and DRQ must be 0.\r
  //\r
  Status = DRQClear2 (PciIo, IdeRegisters, Timeout);\r
  if (EFI_ERROR (Status)) {\r
    return EFI_DEVICE_ERROR;\r
  }\r
\r
  //\r
  // Fill the feature register, which is a two-byte FIFO. Need write twice.\r
  //\r
  IdeWritePortB (PciIo, IdeRegisters->ErrOrFeature, AtaCommandBlock->AtaFeaturesExp);\r
  IdeWritePortB (PciIo, IdeRegisters->ErrOrFeature, AtaCommandBlock->AtaFeatures);\r
\r
  //\r
  // Fill the sector count register, which is a two-byte FIFO. Need write twice.\r
  //\r
  IdeWritePortB (PciIo, IdeRegisters->SectorCount, AtaCommandBlock->AtaSectorCountExp);\r
  IdeWritePortB (PciIo, IdeRegisters->SectorCount, AtaCommandBlock->AtaSectorCount);\r
\r
  //\r
  // Fill the start LBA registers, which are also two-byte FIFO\r
  //\r
  IdeWritePortB (PciIo, IdeRegisters->SectorNumber, AtaCommandBlock->AtaSectorNumberExp);\r
  IdeWritePortB (PciIo, IdeRegisters->SectorNumber, AtaCommandBlock->AtaSectorNumber);\r
\r
  IdeWritePortB (PciIo, IdeRegisters->CylinderLsb, AtaCommandBlock->AtaCylinderLowExp);\r
  IdeWritePortB (PciIo, IdeRegisters->CylinderLsb, AtaCommandBlock->AtaCylinderLow);\r
\r
  IdeWritePortB (PciIo, IdeRegisters->CylinderMsb, AtaCommandBlock->AtaCylinderHighExp);\r
  IdeWritePortB (PciIo, IdeRegisters->CylinderMsb, AtaCommandBlock->AtaCylinderHigh);\r
\r
  //\r
  // Send command via Command Register\r
  //\r
  IdeWritePortB (PciIo, IdeRegisters->CmdOrStatus, AtaCommand);\r
\r
  //\r
  // Stall at least 400 microseconds.\r
  //\r
  MicroSecondDelay (400);\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  This function is used to send out ATA commands conforms to the PIO Data In Protocol.\r
\r
  @param[in]      PciIo            A pointer to ATA_ATAPI_PASS_THRU_INSTANCE data\r
                                   structure.\r
  @param[in]      IdeRegisters     A pointer to EFI_IDE_REGISTERS data structure.\r
  @param[in, out] Buffer           A pointer to the source buffer for the data.\r
  @param[in]      ByteCount        The length of the data.\r
  @param[in]      Read             Flag used to determine the data transfer direction.\r
                                   Read equals 1, means data transferred from device\r
                                   to host;Read equals 0, means data transferred\r
                                   from host to device.\r
  @param[in]      AtaCommandBlock  A pointer to EFI_ATA_COMMAND_BLOCK data structure.\r
  @param[in, out] AtaStatusBlock   A pointer to EFI_ATA_STATUS_BLOCK data structure.\r
  @param[in]      Timeout          The time to complete the command, uses 100ns as a unit.\r
  @param[in]      Task             Optional. Pointer to the ATA_NONBLOCK_TASK\r
                                   used by non-blocking mode.\r
\r
  @retval EFI_SUCCESS      send out the ATA command and device send required data successfully.\r
  @retval EFI_DEVICE_ERROR command sent failed.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
AtaPioDataInOut (\r
  IN     EFI_PCI_IO_PROTOCOL       *PciIo,\r
  IN     EFI_IDE_REGISTERS         *IdeRegisters,\r
  IN OUT VOID                      *Buffer,\r
  IN     UINT64                    ByteCount,\r
  IN     BOOLEAN                   Read,\r
  IN     EFI_ATA_COMMAND_BLOCK     *AtaCommandBlock,\r
  IN OUT EFI_ATA_STATUS_BLOCK      *AtaStatusBlock,\r
  IN     UINT64                    Timeout,\r
  IN     ATA_NONBLOCK_TASK         *Task\r
  )\r
{\r
  UINTN       WordCount;\r
  UINTN       Increment;\r
  UINT16      *Buffer16;\r
  EFI_STATUS  Status;\r
\r
  if ((PciIo == NULL) || (IdeRegisters == NULL) || (Buffer == NULL) || (AtaCommandBlock == NULL)) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  //\r
  // Issue ATA command\r
  //\r
  Status = AtaIssueCommand (PciIo, IdeRegisters, AtaCommandBlock, Timeout);\r
  if (EFI_ERROR (Status)) {\r
    Status = EFI_DEVICE_ERROR;\r
    goto Exit;\r
  }\r
\r
  Buffer16 = (UINT16 *) Buffer;\r
\r
  //\r
  // According to PIO data in protocol, host can perform a series of reads to\r
  // the data register after each time device set DRQ ready;\r
  // The data size of "a series of read" is command specific.\r
  // For most ATA command, data size received from device will not exceed\r
  // 1 sector, hence the data size for "a series of read" can be the whole data\r
  // size of one command request.\r
  // For ATA command such as Read Sector command, the data size of one ATA\r
  // command request is often larger than 1 sector, according to the\r
  // Read Sector command, the data size of "a series of read" is exactly 1\r
  // sector.\r
  // Here for simplification reason, we specify the data size for\r
  // "a series of read" to 1 sector (256 words) if data size of one ATA command\r
  // request is larger than 256 words.\r
  //\r
  Increment = 256;\r
\r
  //\r
  // used to record bytes of currently transfered data\r
  //\r
  WordCount = 0;\r
\r
  while (WordCount < RShiftU64(ByteCount, 1)) {\r
    //\r
    // Poll DRQ bit set, data transfer can be performed only when DRQ is ready\r
    //\r
    Status = DRQReady2 (PciIo, IdeRegisters, Timeout);\r
    if (EFI_ERROR (Status)) {\r
      Status = EFI_DEVICE_ERROR;\r
      goto Exit;\r
    }\r
\r
    //\r
    // Get the byte count for one series of read\r
    //\r
    if ((WordCount + Increment) > RShiftU64(ByteCount, 1)) {\r
      Increment = (UINTN)(RShiftU64(ByteCount, 1) - WordCount);\r
    }\r
\r
    if (Read) {\r
      IdeReadPortWMultiple (\r
        PciIo,\r
        IdeRegisters->Data,\r
        Increment,\r
        Buffer16\r
        );\r
    } else {\r
      IdeWritePortWMultiple (\r
        PciIo,\r
        IdeRegisters->Data,\r
        Increment,\r
        Buffer16\r
        );\r
    }\r
\r
    Status = CheckStatusRegister (PciIo, IdeRegisters);\r
    if (EFI_ERROR (Status)) {\r
      Status = EFI_DEVICE_ERROR;\r
      goto Exit;\r
    }\r
\r
    WordCount += Increment;\r
    Buffer16  += Increment;\r
  }\r
\r
  Status = DRQClear (PciIo, IdeRegisters, Timeout);\r
  if (EFI_ERROR (Status)) {\r
    Status = EFI_DEVICE_ERROR;\r
    goto Exit;\r
  }\r
\r
Exit:\r
  //\r
  // Dump All Ide registers to ATA_STATUS_BLOCK\r
  //\r
  DumpAllIdeRegisters (PciIo, IdeRegisters, AtaStatusBlock);\r
\r
  //\r
  // Not support the Non-blocking now,just do the blocking process.\r
  //\r
  return Status;\r
}\r
\r
/**\r
  Send ATA command into device with NON_DATA protocol\r
\r
  @param[in]      PciIo            A pointer to ATA_ATAPI_PASS_THRU_INSTANCE\r
                                   data structure.\r
  @param[in]      IdeRegisters     A pointer to EFI_IDE_REGISTERS data structure.\r
  @param[in]      AtaCommandBlock  A pointer to EFI_ATA_COMMAND_BLOCK data\r
                                   structure.\r
  @param[in, out] AtaStatusBlock   A pointer to EFI_ATA_STATUS_BLOCK data structure.\r
  @param[in]      Timeout          The time to complete the command, uses 100ns as a unit.\r
  @param[in]      Task             Optional. Pointer to the ATA_NONBLOCK_TASK\r
                                   used by non-blocking mode.\r
\r
  @retval  EFI_SUCCESS Reading succeed\r
  @retval  EFI_ABORTED Command failed\r
  @retval  EFI_DEVICE_ERROR Device status error.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
AtaNonDataCommandIn (\r
  IN     EFI_PCI_IO_PROTOCOL       *PciIo,\r
  IN     EFI_IDE_REGISTERS         *IdeRegisters,\r
  IN     EFI_ATA_COMMAND_BLOCK     *AtaCommandBlock,\r
  IN OUT EFI_ATA_STATUS_BLOCK      *AtaStatusBlock,\r
  IN     UINT64                    Timeout,\r
  IN     ATA_NONBLOCK_TASK         *Task\r
  )\r
{\r
  EFI_STATUS  Status;\r
\r
  if ((PciIo == NULL) || (IdeRegisters == NULL) || (AtaCommandBlock == NULL)) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  //\r
  // Issue ATA command\r
  //\r
  Status = AtaIssueCommand (PciIo, IdeRegisters, AtaCommandBlock, Timeout);\r
  if (EFI_ERROR (Status)) {\r
    Status = EFI_DEVICE_ERROR;\r
    goto Exit;\r
  }\r
\r
  //\r
  // Wait for command completion\r
  //\r
  Status = WaitForBSYClear (PciIo, IdeRegisters, Timeout);\r
  if (EFI_ERROR (Status)) {\r
    Status = EFI_DEVICE_ERROR;\r
    goto Exit;\r
  }\r
\r
  Status = CheckStatusRegister (PciIo, IdeRegisters);\r
  if (EFI_ERROR (Status)) {\r
    Status = EFI_DEVICE_ERROR;\r
    goto Exit;\r
  }\r
\r
Exit:\r
  //\r
  // Dump All Ide registers to ATA_STATUS_BLOCK\r
  //\r
  DumpAllIdeRegisters (PciIo, IdeRegisters, AtaStatusBlock);\r
\r
  //\r
  // Not support the Non-blocking now,just do the blocking process.\r
  //\r
  return Status;\r
}\r
\r
/**\r
  Wait for memory to be set.\r
\r
  @param[in]  PciIo           The PCI IO protocol instance.\r
  @param[in]  IdeRegisters    A pointer to EFI_IDE_REGISTERS data structure.\r
  @param[in]  Timeout         The time to complete the command, uses 100ns as a unit.\r
\r
  @retval EFI_DEVICE_ERROR  The memory is not set.\r
  @retval EFI_TIMEOUT       The memory setting is time out.\r
  @retval EFI_SUCCESS       The memory is correct set.\r
\r
**/\r
EFI_STATUS\r
AtaUdmStatusWait (\r
  IN  EFI_PCI_IO_PROTOCOL       *PciIo,\r
  IN  EFI_IDE_REGISTERS         *IdeRegisters,\r
  IN  UINT64                    Timeout\r
 )\r
{\r
  UINT8                         RegisterValue;\r
  EFI_STATUS                    Status;\r
  UINT16                        IoPortForBmis;\r
  UINT64                        Delay;\r
  BOOLEAN                       InfiniteWait;\r
\r
  if (Timeout == 0) {\r
    InfiniteWait = TRUE;\r
  } else {\r
    InfiniteWait = FALSE;\r
  }\r
\r
  Delay = DivU64x32 (Timeout, 1000) + 1;\r
\r
  do {\r
    Status = CheckStatusRegister (PciIo, IdeRegisters);\r
    if (EFI_ERROR (Status)) {\r
      Status = EFI_DEVICE_ERROR;\r
      break;\r
    }\r
\r
    IoPortForBmis = (UINT16) (IdeRegisters->BusMasterBaseAddr + BMIS_OFFSET);\r
    RegisterValue = IdeReadPortB (PciIo, IoPortForBmis);\r
    if (((RegisterValue & BMIS_ERROR) != 0) || (Timeout == 0)) {\r
      DEBUG ((EFI_D_ERROR, "ATA UDMA operation fails\n"));\r
      Status = EFI_DEVICE_ERROR;\r
      break;\r
    }\r
\r
    if ((RegisterValue & BMIS_INTERRUPT) != 0) {\r
      Status = EFI_SUCCESS;\r
      break;\r
    }\r
    //\r
    // Stall for 100 microseconds.\r
    //\r
    MicroSecondDelay (100);\r
    Delay--;\r
  } while (InfiniteWait || (Delay > 0));\r
\r
  return Status;\r
}\r
\r
/**\r
  Check if the memory to be set.\r
\r
  @param[in]  PciIo           The PCI IO protocol instance.\r
  @param[in]  Task            Optional. Pointer to the ATA_NONBLOCK_TASK\r
                              used by non-blocking mode.\r
  @param[in]  IdeRegisters    A pointer to EFI_IDE_REGISTERS data structure.\r
\r
  @retval EFI_DEVICE_ERROR  The memory setting met a issue.\r
  @retval EFI_NOT_READY     The memory is not set.\r
  @retval EFI_TIMEOUT       The memory setting is time out.\r
  @retval EFI_SUCCESS       The memory is correct set.\r
\r
**/\r
EFI_STATUS\r
AtaUdmStatusCheck (\r
  IN     EFI_PCI_IO_PROTOCOL        *PciIo,\r
  IN     ATA_NONBLOCK_TASK          *Task,\r
  IN     EFI_IDE_REGISTERS          *IdeRegisters\r
 )\r
{\r
  UINT8          RegisterValue;\r
  UINT16         IoPortForBmis;\r
  EFI_STATUS     Status;\r
\r
  Task->RetryTimes--;\r
\r
  Status = CheckStatusRegister (PciIo, IdeRegisters);\r
  if (EFI_ERROR (Status)) {\r
    return EFI_DEVICE_ERROR;\r
  }\r
\r
  IoPortForBmis = (UINT16) (IdeRegisters->BusMasterBaseAddr + BMIS_OFFSET);\r
  RegisterValue = IdeReadPortB (PciIo, IoPortForBmis);\r
\r
  if ((RegisterValue & BMIS_ERROR) != 0) {\r
    DEBUG ((EFI_D_ERROR, "ATA UDMA operation fails\n"));\r
    return EFI_DEVICE_ERROR;\r
  }\r
\r
  if ((RegisterValue & BMIS_INTERRUPT) != 0) {\r
    return EFI_SUCCESS;\r
  }\r
\r
  if (!Task->InfiniteWait && (Task->RetryTimes == 0)) {\r
    return EFI_TIMEOUT;\r
  } else {\r
    //\r
    // The memory is not set.\r
    //\r
    return EFI_NOT_READY;\r
  }\r
}\r
\r
/**\r
  Perform an ATA Udma operation (Read, ReadExt, Write, WriteExt).\r
\r
  @param[in]      Instance         A pointer to ATA_ATAPI_PASS_THRU_INSTANCE data\r
                                   structure.\r
  @param[in]      IdeRegisters     A pointer to EFI_IDE_REGISTERS data structure.\r
  @param[in]      Read             Flag used to determine the data transfer\r
                                   direction. Read equals 1, means data transferred\r
                                   from device to host;Read equals 0, means data\r
                                   transferred from host to device.\r
  @param[in]      DataBuffer       A pointer to the source buffer for the data.\r
  @param[in]      DataLength       The length of  the data.\r
  @param[in]      AtaCommandBlock  A pointer to EFI_ATA_COMMAND_BLOCK data structure.\r
  @param[in, out] AtaStatusBlock   A pointer to EFI_ATA_STATUS_BLOCK data structure.\r
  @param[in]      Timeout          The time to complete the command, uses 100ns as a unit.\r
  @param[in]      Task             Optional. Pointer to the ATA_NONBLOCK_TASK\r
                                   used by non-blocking mode.\r
\r
  @retval EFI_SUCCESS          the operation is successful.\r
  @retval EFI_OUT_OF_RESOURCES Build PRD table failed\r
  @retval EFI_UNSUPPORTED      Unknown channel or operations command\r
  @retval EFI_DEVICE_ERROR     Ata command execute failed\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
AtaUdmaInOut (\r
  IN     ATA_ATAPI_PASS_THRU_INSTANCE  *Instance,\r
  IN     EFI_IDE_REGISTERS             *IdeRegisters,\r
  IN     BOOLEAN                       Read,\r
  IN     VOID                          *DataBuffer,\r
  IN     UINT64                        DataLength,\r
  IN     EFI_ATA_COMMAND_BLOCK         *AtaCommandBlock,\r
  IN OUT EFI_ATA_STATUS_BLOCK          *AtaStatusBlock,\r
  IN     UINT64                        Timeout,\r
  IN     ATA_NONBLOCK_TASK             *Task\r
  )\r
{\r
  EFI_STATUS                    Status;\r
  UINT16                        IoPortForBmic;\r
  UINT16                        IoPortForBmis;\r
  UINT16                        IoPortForBmid;\r
\r
  UINTN                         PrdTableSize;\r
  EFI_PHYSICAL_ADDRESS          PrdTableMapAddr;\r
  VOID                          *PrdTableMap;\r
  EFI_PHYSICAL_ADDRESS          PrdTableBaseAddr;\r
  EFI_ATA_DMA_PRD               *TempPrdBaseAddr;\r
  UINTN                         PrdTableNum;\r
\r
  UINT8                         RegisterValue;\r
  UINTN                         PageCount;\r
  UINTN                         ByteCount;\r
  UINTN                         ByteRemaining;\r
  UINT8                         DeviceControl;\r
\r
  VOID                          *BufferMap;\r
  EFI_PHYSICAL_ADDRESS          BufferMapAddress;\r
  EFI_PCI_IO_PROTOCOL_OPERATION PciIoOperation;\r
\r
  UINT8                         DeviceHead;\r
  EFI_PCI_IO_PROTOCOL           *PciIo;\r
  EFI_TPL                       OldTpl;\r
\r
  UINTN                         AlignmentMask;\r
  UINTN                         RealPageCount;\r
  EFI_PHYSICAL_ADDRESS          BaseAddr;\r
  EFI_PHYSICAL_ADDRESS          BaseMapAddr;\r
\r
  Status        = EFI_SUCCESS;\r
  PrdTableMap   = NULL;\r
  BufferMap     = NULL;\r
  PageCount     = 0;\r
  RealPageCount = 0;\r
  BaseAddr      = 0;\r
  PciIo         = Instance->PciIo;\r
\r
  if ((PciIo == NULL) || (IdeRegisters == NULL) || (DataBuffer == NULL) || (AtaCommandBlock == NULL)) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  //\r
  // Before starting the Blocking BlockIO operation, push to finish all non-blocking\r
  // BlockIO tasks.\r
  // Delay 1ms to simulate the blocking time out checking.\r
  //\r
  OldTpl = gBS->RaiseTPL (TPL_NOTIFY);\r
  while ((Task == NULL) && (!IsListEmpty (&Instance->NonBlockingTaskList))) {\r
    AsyncNonBlockingTransferRoutine (NULL, Instance);\r
    //\r
    // Stall for 1 milliseconds.\r
    //\r
    MicroSecondDelay (1000);\r
  }\r
  gBS->RestoreTPL (OldTpl);\r
\r
  //\r
  // The data buffer should be even alignment\r
  //\r
  if (((UINTN)DataBuffer & 0x1) != 0) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  //\r
  // Set relevant IO Port address.\r
  //\r
  IoPortForBmic = (UINT16) (IdeRegisters->BusMasterBaseAddr + BMIC_OFFSET);\r
  IoPortForBmis = (UINT16) (IdeRegisters->BusMasterBaseAddr + BMIS_OFFSET);\r
  IoPortForBmid = (UINT16) (IdeRegisters->BusMasterBaseAddr + BMID_OFFSET);\r
\r
  //\r
  // For Blocking mode, start the command.\r
  // For non-blocking mode, when the command is not started, start it, otherwise\r
  // go to check the status.\r
  //\r
  if (((Task != NULL) && (!Task->IsStart)) || (Task == NULL)) {\r
    //\r
    // Calculate the number of PRD entry.\r
    // Every entry in PRD table can specify a 64K memory region.\r
    //\r
    PrdTableNum   = (UINTN)(RShiftU64(DataLength, 16) + 1);\r
\r
    //\r
    // Make sure that the memory region of PRD table is not cross 64K boundary\r
    //\r
    PrdTableSize = PrdTableNum * sizeof (EFI_ATA_DMA_PRD);\r
    if (PrdTableSize > 0x10000) {\r
      return EFI_INVALID_PARAMETER;\r
    }\r
\r
    //\r
    // Allocate buffer for PRD table initialization.\r
    // Note Ide Bus Master spec said the descriptor table must be aligned on a 4 byte\r
    // boundary and the table cannot cross a 64K boundary in memory.\r
    //\r
    PageCount     = EFI_SIZE_TO_PAGES (PrdTableSize);\r
    RealPageCount = PageCount + EFI_SIZE_TO_PAGES (SIZE_64KB);\r
\r
    //\r
    // Make sure that PageCount plus EFI_SIZE_TO_PAGES (SIZE_64KB) does not overflow.\r
    //\r
    ASSERT (RealPageCount > PageCount);\r
\r
    Status    = PciIo->AllocateBuffer (\r
                         PciIo,\r
                         AllocateAnyPages,\r
                         EfiBootServicesData,\r
                         RealPageCount,\r
                         (VOID **)&BaseAddr,\r
                         0\r
                         );\r
    if (EFI_ERROR (Status)) {\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
\r
    ByteCount = EFI_PAGES_TO_SIZE (RealPageCount);\r
    Status    = PciIo->Map (\r
                         PciIo,\r
                         EfiPciIoOperationBusMasterCommonBuffer,\r
                         (VOID*)(UINTN)BaseAddr,\r
                         &ByteCount,\r
                         &BaseMapAddr,\r
                         &PrdTableMap\r
                         );\r
    if (EFI_ERROR (Status) || (ByteCount != EFI_PAGES_TO_SIZE (RealPageCount))) {\r
      //\r
      // If the data length actually mapped is not equal to the requested amount,\r
      // it means the DMA operation may be broken into several discontinuous smaller chunks.\r
      // Can't handle this case.\r
      //\r
      PciIo->FreeBuffer (PciIo, RealPageCount, (VOID*)(UINTN)BaseAddr);\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
\r
    ZeroMem ((VOID *) ((UINTN) BaseAddr), ByteCount);\r
\r
    //\r
    // Calculate the 64K align address as PRD Table base address.\r
    //\r
    AlignmentMask    = SIZE_64KB - 1;\r
    PrdTableBaseAddr = ((UINTN) BaseAddr + AlignmentMask) & ~AlignmentMask;\r
    PrdTableMapAddr  = ((UINTN) BaseMapAddr + AlignmentMask) & ~AlignmentMask;\r
\r
    //\r
    // Map the host address of DataBuffer to DMA master address.\r
    //\r
    if (Read) {\r
      PciIoOperation = EfiPciIoOperationBusMasterWrite;\r
    } else {\r
      PciIoOperation = EfiPciIoOperationBusMasterRead;\r
    }\r
\r
    ByteCount = (UINTN)DataLength;\r
    Status    = PciIo->Map (\r
                         PciIo,\r
                         PciIoOperation,\r
                         DataBuffer,\r
                         &ByteCount,\r
                         &BufferMapAddress,\r
                         &BufferMap\r
                         );\r
    if (EFI_ERROR (Status) || (ByteCount != DataLength)) {\r
      PciIo->Unmap (PciIo, PrdTableMap);\r
      PciIo->FreeBuffer (PciIo, RealPageCount, (VOID*)(UINTN)BaseAddr);\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
\r
    //\r
    // According to Ata spec, it requires the buffer address and size to be even.\r
    //\r
    ASSERT ((BufferMapAddress & 0x1) == 0);\r
    ASSERT ((ByteCount & 0x1) == 0);\r
\r
    //\r
    // Fill the PRD table with appropriate bus master address of data buffer and data length.\r
    //\r
    ByteRemaining   = ByteCount;\r
    TempPrdBaseAddr = (EFI_ATA_DMA_PRD*)(UINTN)PrdTableBaseAddr;\r
    while (ByteRemaining != 0) {\r
      if (ByteRemaining <= 0x10000) {\r
        TempPrdBaseAddr->RegionBaseAddr = (UINT32) ((UINTN) BufferMapAddress);\r
        TempPrdBaseAddr->ByteCount      = (UINT16) ByteRemaining;\r
        TempPrdBaseAddr->EndOfTable     = 0x8000;\r
        break;\r
      }\r
\r
      TempPrdBaseAddr->RegionBaseAddr = (UINT32) ((UINTN) BufferMapAddress);\r
      TempPrdBaseAddr->ByteCount      = (UINT16) 0x0;\r
\r
      ByteRemaining    -= 0x10000;\r
      BufferMapAddress += 0x10000;\r
      TempPrdBaseAddr++;\r
    }\r
\r
    //\r
    // Start to enable the DMA operation\r
    //\r
    DeviceHead = AtaCommandBlock->AtaDeviceHead;\r
\r
    IdeWritePortB (PciIo, IdeRegisters->Head, (UINT8)(0xe0 | DeviceHead));\r
\r
    //\r
    // Enable interrupt to support UDMA\r
    //\r
    DeviceControl = 0;\r
    IdeWritePortB (PciIo, IdeRegisters->AltOrDev, DeviceControl);\r
\r
    //\r
    // Read BMIS register and clear ERROR and INTR bit\r
    //\r
    RegisterValue  = IdeReadPortB(PciIo, IoPortForBmis);\r
    RegisterValue |= (BMIS_INTERRUPT | BMIS_ERROR);\r
    IdeWritePortB (PciIo, IoPortForBmis, RegisterValue);\r
\r
    //\r
    // Set the base address to BMID register\r
    //\r
    IdeWritePortDW (PciIo, IoPortForBmid, (UINT32)PrdTableMapAddr);\r
\r
    //\r
    // Set BMIC register to identify the operation direction\r
    //\r
    RegisterValue = IdeReadPortB(PciIo, IoPortForBmic);\r
    if (Read) {\r
      RegisterValue |= BMIC_NREAD;\r
    } else {\r
      RegisterValue &= ~((UINT8) BMIC_NREAD);\r
    }\r
    IdeWritePortB (PciIo, IoPortForBmic, RegisterValue);\r
\r
    if (Task != NULL) {\r
      Task->Map            = BufferMap;\r
      Task->TableMap       = PrdTableMap;\r
      Task->MapBaseAddress = (EFI_ATA_DMA_PRD*)(UINTN)BaseAddr;\r
      Task->PageCount      = RealPageCount;\r
      Task->IsStart        = TRUE;\r
    }\r
\r
    //\r
    // Issue ATA command\r
    //\r
    Status = AtaIssueCommand (PciIo, IdeRegisters, AtaCommandBlock, Timeout);\r
\r
    if (EFI_ERROR (Status)) {\r
      Status = EFI_DEVICE_ERROR;\r
      goto Exit;\r
    }\r
\r
    Status = CheckStatusRegister (PciIo, IdeRegisters);\r
    if (EFI_ERROR (Status)) {\r
      Status = EFI_DEVICE_ERROR;\r
      goto Exit;\r
    }\r
    //\r
    // Set START bit of BMIC register\r
    //\r
    RegisterValue  = IdeReadPortB(PciIo, IoPortForBmic);\r
    RegisterValue |= BMIC_START;\r
    IdeWritePortB(PciIo, IoPortForBmic, RegisterValue);\r
\r
  }\r
\r
  //\r
  // Check the INTERRUPT and ERROR bit of BMIS\r
  //\r
  if (Task != NULL) {\r
    Status = AtaUdmStatusCheck (PciIo, Task, IdeRegisters);\r
  } else {\r
    Status = AtaUdmStatusWait (PciIo, IdeRegisters, Timeout);\r
  }\r
\r
  //\r
  // For blocking mode, clear registers and free buffers.\r
  // For non blocking mode, when the related registers have been set or time\r
  // out, or a error has been happened, it needs to clear the register and free\r
  // buffer.\r
  //\r
  if ((Task == NULL) || Status != EFI_NOT_READY) {\r
    //\r
    // Read BMIS register and clear ERROR and INTR bit\r
    //\r
    RegisterValue  = IdeReadPortB (PciIo, IoPortForBmis);\r
    RegisterValue |= (BMIS_INTERRUPT | BMIS_ERROR);\r
    IdeWritePortB (PciIo, IoPortForBmis, RegisterValue);\r
\r
    //\r
    // Read Status Register of IDE device to clear interrupt\r
    //\r
    RegisterValue  = IdeReadPortB(PciIo, IdeRegisters->CmdOrStatus);\r
\r
    //\r
    // Clear START bit of BMIC register\r
    //\r
    RegisterValue  = IdeReadPortB(PciIo, IoPortForBmic);\r
    RegisterValue &= ~((UINT8) BMIC_START);\r
    IdeWritePortB (PciIo, IoPortForBmic, RegisterValue);\r
\r
    //\r
    // Disable interrupt of Select device\r
    //\r
    DeviceControl  = IdeReadPortB (PciIo, IdeRegisters->AltOrDev);\r
    DeviceControl |= ATA_CTLREG_IEN_L;\r
    IdeWritePortB (PciIo, IdeRegisters->AltOrDev, DeviceControl);\r
    //\r
    // Stall for 10 milliseconds.\r
    //\r
    MicroSecondDelay (10000);\r
\r
  }\r
\r
Exit:\r
  //\r
  // Free all allocated resource\r
  //\r
  if ((Task == NULL) || Status != EFI_NOT_READY) {\r
    if (Task != NULL) {\r
      PciIo->Unmap (PciIo, Task->TableMap);\r
      PciIo->FreeBuffer (PciIo, Task->PageCount, Task->MapBaseAddress);\r
      PciIo->Unmap (PciIo, Task->Map);\r
    } else {\r
      PciIo->Unmap (PciIo, PrdTableMap);\r
      PciIo->FreeBuffer (PciIo, RealPageCount, (VOID*)(UINTN)BaseAddr);\r
      PciIo->Unmap (PciIo, BufferMap);\r
    }\r
\r
    //\r
    // Dump All Ide registers to ATA_STATUS_BLOCK\r
    //\r
    DumpAllIdeRegisters (PciIo, IdeRegisters, AtaStatusBlock);\r
  }\r
\r
  return Status;\r
}\r
\r
/**\r
  This function reads the pending data in the device.\r
\r
  @param PciIo         A pointer to ATA_ATAPI_PASS_THRU_INSTANCE data structure.\r
  @param IdeRegisters  A pointer to EFI_IDE_REGISTERS data structure.\r
\r
  @retval EFI_SUCCESS   Successfully read.\r
  @retval EFI_NOT_READY The BSY is set avoiding reading.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
AtaPacketReadPendingData (\r
  IN  EFI_PCI_IO_PROTOCOL       *PciIo,\r
  IN  EFI_IDE_REGISTERS         *IdeRegisters\r
  )\r
{\r
  UINT8     AltRegister;\r
  UINT16    TempWordBuffer;\r
\r
  AltRegister = IdeReadPortB (PciIo, IdeRegisters->AltOrDev);\r
  if ((AltRegister & ATA_STSREG_BSY) == ATA_STSREG_BSY) {\r
    return EFI_NOT_READY;\r
  }\r
\r
  if ((AltRegister & (ATA_STSREG_BSY | ATA_STSREG_DRQ)) == ATA_STSREG_DRQ) {\r
    TempWordBuffer = IdeReadPortB (PciIo, IdeRegisters->AltOrDev);\r
    while ((TempWordBuffer & (ATA_STSREG_BSY | ATA_STSREG_DRQ)) == ATA_STSREG_DRQ) {\r
      IdeReadPortWMultiple (\r
        PciIo,\r
        IdeRegisters->Data,\r
        1,\r
        &TempWordBuffer\r
        );\r
      TempWordBuffer = IdeReadPortB (PciIo, IdeRegisters->AltOrDev);\r
    }\r
  }\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  This function is called by AtaPacketCommandExecute().\r
  It is used to transfer data between host and device. The data direction is specified\r
  by the fourth parameter.\r
\r
  @param PciIo         A pointer to ATA_ATAPI_PASS_THRU_INSTANCE data structure.\r
  @param IdeRegisters  A pointer to EFI_IDE_REGISTERS data structure.\r
  @param Buffer        Buffer contained data transferred between host and device.\r
  @param ByteCount     Data size in byte unit of the buffer.\r
  @param Read          Flag used to determine the data transfer direction.\r
                       Read equals 1, means data transferred from device to host;\r
                       Read equals 0, means data transferred from host to device.\r
  @param Timeout       Timeout value for wait DRQ ready before each data stream's transfer\r
                       , uses 100ns as a unit.\r
\r
  @retval EFI_SUCCESS      data is transferred successfully.\r
  @retval EFI_DEVICE_ERROR the device failed to transfer data.\r
**/\r
EFI_STATUS\r
EFIAPI\r
AtaPacketReadWrite (\r
  IN     EFI_PCI_IO_PROTOCOL       *PciIo,\r
  IN     EFI_IDE_REGISTERS         *IdeRegisters,\r
  IN OUT VOID                      *Buffer,\r
  IN OUT UINT32                    *ByteCount,\r
  IN     BOOLEAN                   Read,\r
  IN     UINT64                    Timeout\r
  )\r
{\r
  UINT32      RequiredWordCount;\r
  UINT32      ActualWordCount;\r
  UINT32      WordCount;\r
  EFI_STATUS  Status;\r
  UINT16      *PtrBuffer;\r
\r
  PtrBuffer         = Buffer;\r
  RequiredWordCount = *ByteCount >> 1;\r
\r
  //\r
  // No data transfer is premitted.\r
  //\r
  if (RequiredWordCount == 0) {\r
    return EFI_SUCCESS;\r
  }\r
\r
  //\r
  // ActualWordCount means the word count of data really transferred.\r
  //\r
  ActualWordCount = 0;\r
\r
  while (ActualWordCount < RequiredWordCount) {\r
    //\r
    // before each data transfer stream, the host should poll DRQ bit ready,\r
    // to see whether indicates device is ready to transfer data.\r
    //\r
    Status = DRQReady2 (PciIo, IdeRegisters, Timeout);\r
    if (EFI_ERROR (Status)) {\r
      if (Status == EFI_NOT_READY) {\r
        //\r
        // Device provided less data than we intended to read, or wanted less\r
        // data than we intended to write, but it may still be successful.\r
        //\r
        break;\r
      } else {\r
        return Status;\r
      }\r
    }\r
\r
    //\r
    // get current data transfer size from Cylinder Registers.\r
    //\r
    WordCount  = IdeReadPortB (PciIo, IdeRegisters->CylinderMsb) << 8;\r
    WordCount  = WordCount | IdeReadPortB (PciIo, IdeRegisters->CylinderLsb);\r
    WordCount  = WordCount & 0xffff;\r
    WordCount /= 2;\r
\r
    WordCount = MIN (WordCount, (RequiredWordCount - ActualWordCount));\r
\r
    if (Read) {\r
      IdeReadPortWMultiple (\r
        PciIo,\r
        IdeRegisters->Data,\r
        WordCount,\r
        PtrBuffer\r
        );\r
    } else {\r
      IdeWritePortWMultiple (\r
        PciIo,\r
        IdeRegisters->Data,\r
        WordCount,\r
        PtrBuffer\r
        );\r
    }\r
\r
    //\r
    // read status register to check whether error happens.\r
    //\r
    Status = CheckStatusRegister (PciIo, IdeRegisters);\r
    if (EFI_ERROR (Status)) {\r
      return EFI_DEVICE_ERROR;\r
    }\r
\r
    PtrBuffer       += WordCount;\r
    ActualWordCount += WordCount;\r
  }\r
\r
  if (Read) {\r
    //\r
    // In the case where the drive wants to send more data than we need to read,\r
    // the DRQ bit will be set and cause delays from DRQClear2().\r
    // We need to read data from the drive until it clears DRQ so we can move on.\r
    //\r
    AtaPacketReadPendingData (PciIo, IdeRegisters);\r
  }\r
\r
  //\r
  // read status register to check whether error happens.\r
  //\r
  Status = CheckStatusRegister (PciIo, IdeRegisters);\r
  if (EFI_ERROR (Status)) {\r
    return EFI_DEVICE_ERROR;\r
  }\r
\r
  //\r
  // After data transfer is completed, normally, DRQ bit should clear.\r
  //\r
  Status = DRQClear (PciIo, IdeRegisters, Timeout);\r
  if (EFI_ERROR (Status)) {\r
    return EFI_DEVICE_ERROR;\r
  }\r
\r
  *ByteCount = ActualWordCount << 1;\r
  return Status;\r
}\r
\r
/**\r
  This function is used to send out ATAPI commands conforms to the Packet Command\r
  with PIO Data In Protocol.\r
\r
  @param[in] PciIo          Pointer to the EFI_PCI_IO_PROTOCOL instance\r
  @param[in] IdeRegisters   Pointer to EFI_IDE_REGISTERS which is used to\r
                            store the IDE i/o port registers' base addresses\r
  @param[in] Channel        The channel number of device.\r
  @param[in] Device         The device number of device.\r
  @param[in] Packet         A pointer to EFI_EXT_SCSI_PASS_THRU_SCSI_REQUEST_PACKET data structure.\r
\r
  @retval EFI_SUCCESS       send out the ATAPI packet command successfully\r
                            and device sends data successfully.\r
  @retval EFI_DEVICE_ERROR  the device failed to send data.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
AtaPacketCommandExecute (\r
  IN  EFI_PCI_IO_PROTOCOL                           *PciIo,\r
  IN  EFI_IDE_REGISTERS                             *IdeRegisters,\r
  IN  UINT8                                         Channel,\r
  IN  UINT8                                         Device,\r
  IN  EFI_EXT_SCSI_PASS_THRU_SCSI_REQUEST_PACKET    *Packet\r
  )\r
{\r
  EFI_ATA_COMMAND_BLOCK       AtaCommandBlock;\r
  EFI_STATUS                  Status;\r
  UINT8                       Count;\r
  UINT8                       PacketCommand[12];\r
\r
  ZeroMem (&AtaCommandBlock, sizeof (EFI_ATA_COMMAND_BLOCK));\r
\r
  //\r
  // Fill ATAPI Command Packet according to CDB.\r
  // For Atapi cmd, its length should be less than or equal to 12 bytes.\r
  //\r
  if (Packet->CdbLength > 12) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  ZeroMem (PacketCommand, 12);\r
  CopyMem (PacketCommand, Packet->Cdb, Packet->CdbLength);\r
\r
  //\r
  // No OVL; No DMA\r
  //\r
  AtaCommandBlock.AtaFeatures = 0x00;\r
  //\r
  // set the transfersize to ATAPI_MAX_BYTE_COUNT to let the device\r
  // determine how many data should be transferred.\r
  //\r
  AtaCommandBlock.AtaCylinderLow  = (UINT8) (ATAPI_MAX_BYTE_COUNT & 0x00ff);\r
  AtaCommandBlock.AtaCylinderHigh = (UINT8) (ATAPI_MAX_BYTE_COUNT >> 8);\r
  AtaCommandBlock.AtaDeviceHead   = (UINT8) (Device << 0x4);\r
  AtaCommandBlock.AtaCommand      = ATA_CMD_PACKET;\r
\r
  IdeWritePortB (PciIo, IdeRegisters->Head, (UINT8)(0xe0 | (Device << 0x4)));\r
  //\r
  //  Disable interrupt\r
  //\r
  IdeWritePortB (PciIo, IdeRegisters->AltOrDev, ATA_DEFAULT_CTL);\r
\r
  //\r
  // Issue ATA PACKET command firstly\r
  //\r
  Status = AtaIssueCommand (PciIo, IdeRegisters, &AtaCommandBlock, Packet->Timeout);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  Status = DRQReady (PciIo, IdeRegisters, Packet->Timeout);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  //\r
  // Send out ATAPI command packet\r
  //\r
  for (Count = 0; Count < 6; Count++) {\r
    IdeWritePortW (PciIo, IdeRegisters->Data, *((UINT16*)PacketCommand + Count));\r
    //\r
    // Stall for 10 microseconds.\r
    //\r
    MicroSecondDelay (10);\r
  }\r
\r
  //\r
  // Read/Write the data of ATAPI Command\r
  //\r
  if (Packet->DataDirection == EFI_EXT_SCSI_DATA_DIRECTION_READ) {\r
    Status = AtaPacketReadWrite (\r
               PciIo,\r
               IdeRegisters,\r
               Packet->InDataBuffer,\r
               &Packet->InTransferLength,\r
               TRUE,\r
               Packet->Timeout\r
               );\r
  } else {\r
    Status = AtaPacketReadWrite (\r
               PciIo,\r
               IdeRegisters,\r
               Packet->OutDataBuffer,\r
               &Packet->OutTransferLength,\r
               FALSE,\r
               Packet->Timeout\r
               );\r
  }\r
\r
  return Status;\r
}\r
\r
\r
/**\r
  Set the calculated Best transfer mode to a detected device.\r
\r
  @param Instance               A pointer to ATA_ATAPI_PASS_THRU_INSTANCE data structure.\r
  @param Channel                The channel number of device.\r
  @param Device                 The device number of device.\r
  @param TransferMode           A pointer to EFI_ATA_TRANSFER_MODE data structure.\r
  @param AtaStatusBlock         A pointer to EFI_ATA_STATUS_BLOCK data structure.\r
\r
  @retval EFI_SUCCESS          Set transfer mode successfully.\r
  @retval EFI_DEVICE_ERROR     Set transfer mode failed.\r
  @retval EFI_OUT_OF_RESOURCES Allocate memory failed.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
SetDeviceTransferMode (\r
  IN     ATA_ATAPI_PASS_THRU_INSTANCE  *Instance,\r
  IN     UINT8                         Channel,\r
  IN     UINT8                         Device,\r
  IN     EFI_ATA_TRANSFER_MODE         *TransferMode,\r
  IN OUT EFI_ATA_STATUS_BLOCK          *AtaStatusBlock\r
  )\r
{\r
  EFI_STATUS              Status;\r
  EFI_ATA_COMMAND_BLOCK   AtaCommandBlock;\r
\r
  ZeroMem (&AtaCommandBlock, sizeof (EFI_ATA_COMMAND_BLOCK));\r
\r
  AtaCommandBlock.AtaCommand     = ATA_CMD_SET_FEATURES;\r
  AtaCommandBlock.AtaDeviceHead  = (UINT8)(Device << 0x4);\r
  AtaCommandBlock.AtaFeatures    = 0x03;\r
  AtaCommandBlock.AtaSectorCount = *((UINT8 *)TransferMode);\r
\r
  //\r
  // Send SET FEATURE command (sub command 0x03) to set pio mode.\r
  //\r
  Status = AtaNonDataCommandIn (\r
             Instance->PciIo,\r
             &Instance->IdeRegisters[Channel],\r
             &AtaCommandBlock,\r
             AtaStatusBlock,\r
             ATA_ATAPI_TIMEOUT,\r
             NULL\r
             );\r
\r
  return Status;\r
}\r
\r
/**\r
  Set drive parameters for devices not support PACKETS command.\r
\r
  @param Instance         A pointer to ATA_ATAPI_PASS_THRU_INSTANCE data structure.\r
  @param Channel          The channel number of device.\r
  @param Device           The device number of device.\r
  @param DriveParameters  A pointer to EFI_ATA_DRIVE_PARMS data structure.\r
  @param AtaStatusBlock   A pointer to EFI_ATA_STATUS_BLOCK data structure.\r
\r
  @retval EFI_SUCCESS          Set drive parameter successfully.\r
  @retval EFI_DEVICE_ERROR     Set drive parameter failed.\r
  @retval EFI_OUT_OF_RESOURCES Allocate memory failed.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
SetDriveParameters (\r
  IN     ATA_ATAPI_PASS_THRU_INSTANCE  *Instance,\r
  IN     UINT8                         Channel,\r
  IN     UINT8                         Device,\r
  IN     EFI_ATA_DRIVE_PARMS           *DriveParameters,\r
  IN OUT EFI_ATA_STATUS_BLOCK          *AtaStatusBlock\r
  )\r
{\r
  EFI_STATUS              Status;\r
  EFI_ATA_COMMAND_BLOCK   AtaCommandBlock;\r
\r
  ZeroMem (&AtaCommandBlock, sizeof (EFI_ATA_COMMAND_BLOCK));\r
\r
  AtaCommandBlock.AtaCommand     = ATA_CMD_INIT_DRIVE_PARAM;\r
  AtaCommandBlock.AtaSectorCount = DriveParameters->Sector;\r
  AtaCommandBlock.AtaDeviceHead  = (UINT8) ((Device << 0x4) + DriveParameters->Heads);\r
\r
  //\r
  // Send Init drive parameters\r
  //\r
  Status = AtaNonDataCommandIn (\r
             Instance->PciIo,\r
             &Instance->IdeRegisters[Channel],\r
             &AtaCommandBlock,\r
             AtaStatusBlock,\r
             ATA_ATAPI_TIMEOUT,\r
             NULL\r
             );\r
\r
  //\r
  // Send Set Multiple parameters\r
  //\r
  AtaCommandBlock.AtaCommand     = ATA_CMD_SET_MULTIPLE_MODE;\r
  AtaCommandBlock.AtaSectorCount = DriveParameters->MultipleSector;\r
  AtaCommandBlock.AtaDeviceHead  = (UINT8)(Device << 0x4);\r
\r
  Status = AtaNonDataCommandIn (\r
             Instance->PciIo,\r
             &Instance->IdeRegisters[Channel],\r
             &AtaCommandBlock,\r
             AtaStatusBlock,\r
             ATA_ATAPI_TIMEOUT,\r
             NULL\r
             );\r
\r
  return Status;\r
}\r
\r
/**\r
  Send SMART Return Status command to check if the execution of SMART cmd is successful or not.\r
\r
  @param Instance         A pointer to ATA_ATAPI_PASS_THRU_INSTANCE data structure.\r
  @param Channel          The channel number of device.\r
  @param Device           The device number of device.\r
  @param AtaStatusBlock   A pointer to EFI_ATA_STATUS_BLOCK data structure.\r
\r
  @retval EFI_SUCCESS     Successfully get the return status of S.M.A.R.T command execution.\r
  @retval Others          Fail to get return status data.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
IdeAtaSmartReturnStatusCheck (\r
  IN     ATA_ATAPI_PASS_THRU_INSTANCE  *Instance,\r
  IN     UINT8                         Channel,\r
  IN     UINT8                         Device,\r
  IN OUT EFI_ATA_STATUS_BLOCK          *AtaStatusBlock\r
  )\r
{\r
  EFI_STATUS              Status;\r
  EFI_ATA_COMMAND_BLOCK   AtaCommandBlock;\r
  UINT8                   LBAMid;\r
  UINT8                   LBAHigh;\r
\r
  ZeroMem (&AtaCommandBlock, sizeof (EFI_ATA_COMMAND_BLOCK));\r
\r
  AtaCommandBlock.AtaCommand      = ATA_CMD_SMART;\r
  AtaCommandBlock.AtaFeatures     = ATA_SMART_RETURN_STATUS;\r
  AtaCommandBlock.AtaCylinderLow  = ATA_CONSTANT_4F;\r
  AtaCommandBlock.AtaCylinderHigh = ATA_CONSTANT_C2;\r
  AtaCommandBlock.AtaDeviceHead   = (UINT8) ((Device << 0x4) | 0xe0);\r
\r
  //\r
  // Send S.M.A.R.T Read Return Status command to device\r
  //\r
  Status = AtaNonDataCommandIn (\r
             Instance->PciIo,\r
             &Instance->IdeRegisters[Channel],\r
             &AtaCommandBlock,\r
             AtaStatusBlock,\r
             ATA_ATAPI_TIMEOUT,\r
             NULL\r
             );\r
\r
  if (EFI_ERROR (Status)) {\r
    REPORT_STATUS_CODE (\r
      EFI_ERROR_CODE | EFI_ERROR_MINOR,\r
      (EFI_IO_BUS_ATA_ATAPI | EFI_IOB_ATA_BUS_SMART_DISABLED)\r
      );\r
    return EFI_DEVICE_ERROR;\r
  }\r
\r
  REPORT_STATUS_CODE (\r
    EFI_PROGRESS_CODE,\r
    (EFI_IO_BUS_ATA_ATAPI | EFI_IOB_ATA_BUS_SMART_ENABLE)\r
    );\r
\r
  LBAMid  = IdeReadPortB (Instance->PciIo, Instance->IdeRegisters[Channel].CylinderLsb);\r
  LBAHigh = IdeReadPortB (Instance->PciIo, Instance->IdeRegisters[Channel].CylinderMsb);\r
\r
  if ((LBAMid == 0x4f) && (LBAHigh == 0xc2)) {\r
    //\r
    // The threshold exceeded condition is not detected by the device\r
    //\r
    DEBUG ((EFI_D_INFO, "The S.M.A.R.T threshold exceeded condition is not detected\n"));\r
    REPORT_STATUS_CODE (\r
          EFI_PROGRESS_CODE,\r
          (EFI_IO_BUS_ATA_ATAPI | EFI_IOB_ATA_BUS_SMART_UNDERTHRESHOLD)\r
          );\r
  } else if ((LBAMid == 0xf4) && (LBAHigh == 0x2c)) {\r
    //\r
    // The threshold exceeded condition is detected by the device\r
    //\r
    DEBUG ((EFI_D_INFO, "The S.M.A.R.T threshold exceeded condition is detected\n"));\r
    REPORT_STATUS_CODE (\r
         EFI_PROGRESS_CODE,\r
         (EFI_IO_BUS_ATA_ATAPI | EFI_IOB_ATA_BUS_SMART_OVERTHRESHOLD)\r
         );\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Enable SMART command of the disk if supported.\r
\r
  @param Instance         A pointer to ATA_ATAPI_PASS_THRU_INSTANCE data structure.\r
  @param Channel          The channel number of device.\r
  @param Device           The device number of device.\r
  @param IdentifyData     A pointer to data buffer which is used to contain IDENTIFY data.\r
  @param AtaStatusBlock   A pointer to EFI_ATA_STATUS_BLOCK data structure.\r
\r
**/\r
VOID\r
EFIAPI\r
IdeAtaSmartSupport (\r
  IN     ATA_ATAPI_PASS_THRU_INSTANCE  *Instance,\r
  IN     UINT8                         Channel,\r
  IN     UINT8                         Device,\r
  IN     EFI_IDENTIFY_DATA             *IdentifyData,\r
  IN OUT EFI_ATA_STATUS_BLOCK          *AtaStatusBlock\r
  )\r
{\r
  EFI_STATUS              Status;\r
  EFI_ATA_COMMAND_BLOCK   AtaCommandBlock;\r
\r
  //\r
  // Detect if the device supports S.M.A.R.T.\r
  //\r
  if ((IdentifyData->AtaData.command_set_supported_82 & 0x0001) != 0x0001) {\r
    //\r
    // S.M.A.R.T is not supported by the device\r
    //\r
    DEBUG ((EFI_D_INFO, "S.M.A.R.T feature is not supported at [%a] channel [%a] device!\n",\r
            (Channel == 1) ? "secondary" : "primary", (Device == 1) ? "slave" : "master"));\r
    REPORT_STATUS_CODE (\r
      EFI_ERROR_CODE | EFI_ERROR_MINOR,\r
      (EFI_IO_BUS_ATA_ATAPI | EFI_IOB_ATA_BUS_SMART_NOTSUPPORTED)\r
      );\r
  } else {\r
    //\r
    // Check if the feature is enabled. If not, then enable S.M.A.R.T.\r
    //\r
    if ((IdentifyData->AtaData.command_set_feature_enb_85 & 0x0001) != 0x0001) {\r
\r
      REPORT_STATUS_CODE (\r
        EFI_PROGRESS_CODE,\r
        (EFI_IO_BUS_ATA_ATAPI | EFI_IOB_ATA_BUS_SMART_DISABLE)\r
        );\r
\r
      ZeroMem (&AtaCommandBlock, sizeof (EFI_ATA_COMMAND_BLOCK));\r
\r
      AtaCommandBlock.AtaCommand      = ATA_CMD_SMART;\r
      AtaCommandBlock.AtaFeatures     = ATA_SMART_ENABLE_OPERATION;\r
      AtaCommandBlock.AtaCylinderLow  = ATA_CONSTANT_4F;\r
      AtaCommandBlock.AtaCylinderHigh = ATA_CONSTANT_C2;\r
      AtaCommandBlock.AtaDeviceHead   = (UINT8) ((Device << 0x4) | 0xe0);\r
\r
      //\r
      // Send S.M.A.R.T Enable command to device\r
      //\r
      Status = AtaNonDataCommandIn (\r
                 Instance->PciIo,\r
                 &Instance->IdeRegisters[Channel],\r
                 &AtaCommandBlock,\r
                 AtaStatusBlock,\r
                 ATA_ATAPI_TIMEOUT,\r
                 NULL\r
                 );\r
\r
      if (!EFI_ERROR (Status)) {\r
        //\r
        // Send S.M.A.R.T AutoSave command to device\r
        //\r
        ZeroMem (&AtaCommandBlock, sizeof (EFI_ATA_COMMAND_BLOCK));\r
\r
        AtaCommandBlock.AtaCommand      = ATA_CMD_SMART;\r
        AtaCommandBlock.AtaFeatures     = 0xD2;\r
        AtaCommandBlock.AtaSectorCount  = 0xF1;\r
        AtaCommandBlock.AtaCylinderLow  = ATA_CONSTANT_4F;\r
        AtaCommandBlock.AtaCylinderHigh = ATA_CONSTANT_C2;\r
        AtaCommandBlock.AtaDeviceHead   = (UINT8) ((Device << 0x4) | 0xe0);\r
\r
        Status = AtaNonDataCommandIn (\r
                   Instance->PciIo,\r
                   &Instance->IdeRegisters[Channel],\r
                   &AtaCommandBlock,\r
                   AtaStatusBlock,\r
                   ATA_ATAPI_TIMEOUT,\r
                   NULL\r
                   );\r
        if (!EFI_ERROR (Status)) {\r
          Status = IdeAtaSmartReturnStatusCheck (\r
                     Instance,\r
                     Channel,\r
                     Device,\r
                     AtaStatusBlock\r
                     );\r
        }\r
      }\r
    }\r
\r
    DEBUG ((EFI_D_INFO, "Enabled S.M.A.R.T feature at [%a] channel [%a] device!\n",\r
           (Channel == 1) ? "secondary" : "primary", (Device == 1) ? "slave" : "master"));\r
\r
  }\r
\r
  return ;\r
}\r
\r
\r
/**\r
  Sends out an ATA Identify Command to the specified device.\r
\r
  This function is called by DiscoverIdeDevice() during its device\r
  identification. It sends out the ATA Identify Command to the\r
  specified device. Only ATA device responses to this command. If\r
  the command succeeds, it returns the Identify data structure which\r
  contains information about the device. This function extracts the\r
  information it needs to fill the IDE_BLK_IO_DEV data structure,\r
  including device type, media block size, media capacity, and etc.\r
\r
  @param Instance         A pointer to ATA_ATAPI_PASS_THRU_INSTANCE data structure.\r
  @param Channel          The channel number of device.\r
  @param Device           The device number of device.\r
  @param Buffer           A pointer to data buffer which is used to contain IDENTIFY data.\r
  @param AtaStatusBlock   A pointer to EFI_ATA_STATUS_BLOCK data structure.\r
\r
  @retval EFI_SUCCESS          Identify ATA device successfully.\r
  @retval EFI_DEVICE_ERROR     ATA Identify Device Command failed or device is not ATA device.\r
  @retval EFI_OUT_OF_RESOURCES Allocate memory failed.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
AtaIdentify (\r
  IN     ATA_ATAPI_PASS_THRU_INSTANCE  *Instance,\r
  IN     UINT8                         Channel,\r
  IN     UINT8                         Device,\r
  IN OUT EFI_IDENTIFY_DATA             *Buffer,\r
  IN OUT EFI_ATA_STATUS_BLOCK          *AtaStatusBlock\r
  )\r
{\r
  EFI_STATUS             Status;\r
  EFI_ATA_COMMAND_BLOCK  AtaCommandBlock;\r
\r
  ZeroMem (&AtaCommandBlock, sizeof (EFI_ATA_COMMAND_BLOCK));\r
\r
  AtaCommandBlock.AtaCommand    = ATA_CMD_IDENTIFY_DRIVE;\r
  AtaCommandBlock.AtaDeviceHead = (UINT8)(Device << 0x4);\r
\r
  Status = AtaPioDataInOut (\r
             Instance->PciIo,\r
             &Instance->IdeRegisters[Channel],\r
             Buffer,\r
             sizeof (EFI_IDENTIFY_DATA),\r
             TRUE,\r
             &AtaCommandBlock,\r
             AtaStatusBlock,\r
             ATA_ATAPI_TIMEOUT,\r
             NULL\r
             );\r
\r
  return Status;\r
}\r
\r
/**\r
  This function is called by DiscoverIdeDevice() during its device\r
  identification.\r
  Its main purpose is to get enough information for the device media\r
  to fill in the Media data structure of the Block I/O Protocol interface.\r
\r
  There are 5 steps to reach such objective:\r
  1. Sends out the ATAPI Identify Command to the specified device.\r
  Only ATAPI device responses to this command. If the command succeeds,\r
  it returns the Identify data structure which filled with information\r
  about the device. Since the ATAPI device contains removable media,\r
  the only meaningful information is the device module name.\r
  2. Sends out ATAPI Inquiry Packet Command to the specified device.\r
  This command will return inquiry data of the device, which contains\r
  the device type information.\r
  3. Allocate sense data space for future use. We don't detect the media\r
  presence here to improvement boot performance, especially when CD\r
  media is present. The media detection will be performed just before\r
  each BLK_IO read/write\r
\r
  @param Instance         A pointer to ATA_ATAPI_PASS_THRU_INSTANCE data structure.\r
  @param Channel          The channel number of device.\r
  @param Device           The device number of device.\r
  @param Buffer           A pointer to data buffer which is used to contain IDENTIFY data.\r
  @param AtaStatusBlock   A pointer to EFI_ATA_STATUS_BLOCK data structure.\r
\r
  @retval EFI_SUCCESS          Identify ATAPI device successfully.\r
  @retval EFI_DEVICE_ERROR     ATA Identify Packet Device Command failed or device type\r
                               is not supported by this IDE driver.\r
  @retval EFI_OUT_OF_RESOURCES Allocate memory failed.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
AtaIdentifyPacket (\r
  IN     ATA_ATAPI_PASS_THRU_INSTANCE  *Instance,\r
  IN     UINT8                         Channel,\r
  IN     UINT8                         Device,\r
  IN OUT EFI_IDENTIFY_DATA             *Buffer,\r
  IN OUT EFI_ATA_STATUS_BLOCK          *AtaStatusBlock\r
  )\r
{\r
  EFI_STATUS             Status;\r
  EFI_ATA_COMMAND_BLOCK  AtaCommandBlock;\r
\r
  ZeroMem (&AtaCommandBlock, sizeof (EFI_ATA_COMMAND_BLOCK));\r
\r
  AtaCommandBlock.AtaCommand    = ATA_CMD_IDENTIFY_DEVICE;\r
  AtaCommandBlock.AtaDeviceHead = (UINT8)(Device << 0x4);\r
\r
  //\r
  // Send ATAPI Identify Command to get IDENTIFY data.\r
  //\r
  Status = AtaPioDataInOut (\r
             Instance->PciIo,\r
             &Instance->IdeRegisters[Channel],\r
             (VOID *) Buffer,\r
             sizeof (EFI_IDENTIFY_DATA),\r
             TRUE,\r
             &AtaCommandBlock,\r
             AtaStatusBlock,\r
             ATA_ATAPI_TIMEOUT,\r
             NULL\r
             );\r
\r
  return Status;\r
}\r
\r
\r
/**\r
  This function is used for detect whether the IDE device exists in the\r
  specified Channel as the specified Device Number.\r
\r
  There is two IDE channels: one is Primary Channel, the other is\r
  Secondary Channel.(Channel is the logical name for the physical "Cable".)\r
  Different channel has different register group.\r
\r
  On each IDE channel, at most two IDE devices attach,\r
  one is called Device 0 (Master device), the other is called Device 1\r
  (Slave device). The devices on the same channel co-use the same register\r
  group, so before sending out a command for a specified device via command\r
  register, it is a must to select the current device to accept the command\r
  by set the device number in the Head/Device Register.\r
\r
  @param Instance         A pointer to ATA_ATAPI_PASS_THRU_INSTANCE data structure.\r
  @param IdeChannel       The channel number of device.\r
\r
  @retval EFI_SUCCESS successfully detects device.\r
  @retval other       any failure during detection process will return this value.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
DetectAndConfigIdeDevice (\r
  IN  ATA_ATAPI_PASS_THRU_INSTANCE  *Instance,\r
  IN  UINT8                         IdeChannel\r
  )\r
{\r
  EFI_STATUS                        Status;\r
  UINT8                             SectorCountReg;\r
  UINT8                             LBALowReg;\r
  UINT8                             LBAMidReg;\r
  UINT8                             LBAHighReg;\r
  EFI_ATA_DEVICE_TYPE               DeviceType;\r
  UINT8                             IdeDevice;\r
  EFI_IDE_REGISTERS                 *IdeRegisters;\r
  EFI_IDENTIFY_DATA                 Buffer;\r
\r
  EFI_IDE_CONTROLLER_INIT_PROTOCOL  *IdeInit;\r
  EFI_PCI_IO_PROTOCOL               *PciIo;\r
\r
  EFI_ATA_COLLECTIVE_MODE           *SupportedModes;\r
  EFI_ATA_TRANSFER_MODE             TransferMode;\r
  EFI_ATA_DRIVE_PARMS               DriveParameters;\r
\r
  IdeRegisters = &Instance->IdeRegisters[IdeChannel];\r
  IdeInit      = Instance->IdeControllerInit;\r
  PciIo        = Instance->PciIo;\r
\r
  for (IdeDevice = 0; IdeDevice < EfiIdeMaxDevice; IdeDevice++) {\r
    //\r
    // Select Master or Slave device to get the return signature for ATA DEVICE DIAGNOSTIC cmd.\r
    //\r
    IdeWritePortB (PciIo, IdeRegisters->Head, (UINT8)((IdeDevice << 4) | 0xe0));\r
\r
    //\r
    // Send ATA Device Execut Diagnostic command.\r
    // This command should work no matter DRDY is ready or not\r
    //\r
    IdeWritePortB (PciIo, IdeRegisters->CmdOrStatus, ATA_CMD_EXEC_DRIVE_DIAG);\r
\r
    Status = WaitForBSYClear (PciIo, IdeRegisters, 350000000);\r
    if (EFI_ERROR (Status)) {\r
      DEBUG((EFI_D_ERROR, "New detecting method: Send Execute Diagnostic Command: WaitForBSYClear: Status: %d\n", Status));\r
      continue;\r
    }\r
\r
    //\r
    // Select Master or Slave device to get the return signature for ATA DEVICE DIAGNOSTIC cmd.\r
    //\r
    IdeWritePortB (PciIo, IdeRegisters->Head, (UINT8)((IdeDevice << 4) | 0xe0));\r
    //\r
    // Stall for 1 milliseconds.\r
    //\r
    MicroSecondDelay (1000);\r
\r
    SectorCountReg = IdeReadPortB (PciIo, IdeRegisters->SectorCount);\r
    LBALowReg      = IdeReadPortB (PciIo, IdeRegisters->SectorNumber);\r
    LBAMidReg      = IdeReadPortB (PciIo, IdeRegisters->CylinderLsb);\r
    LBAHighReg     = IdeReadPortB (PciIo, IdeRegisters->CylinderMsb);\r
\r
    //\r
    // Refer to ATA/ATAPI 4 Spec, section 9.1\r
    //\r
    if ((SectorCountReg == 0x1) && (LBALowReg == 0x1) && (LBAMidReg == 0x0) && (LBAHighReg == 0x0)) {\r
      DeviceType = EfiIdeHarddisk;\r
    } else if ((LBAMidReg == 0x14) && (LBAHighReg == 0xeb)) {\r
      DeviceType = EfiIdeCdrom;\r
    } else {\r
      continue;\r
    }\r
\r
    //\r
    // Send IDENTIFY cmd to the device to test if it is really attached.\r
    //\r
    if (DeviceType == EfiIdeHarddisk) {\r
      Status = AtaIdentify (Instance, IdeChannel, IdeDevice, &Buffer, NULL);\r
      //\r
      // if identifying ata device is failure, then try to send identify packet cmd.\r
      //\r
      if (EFI_ERROR (Status)) {\r
        REPORT_STATUS_CODE (EFI_PROGRESS_CODE, (EFI_PERIPHERAL_FIXED_MEDIA | EFI_P_EC_NOT_DETECTED));\r
\r
        DeviceType = EfiIdeCdrom;\r
        Status     = AtaIdentifyPacket (Instance, IdeChannel, IdeDevice, &Buffer, NULL);\r
      }\r
    } else {\r
      Status = AtaIdentifyPacket (Instance, IdeChannel, IdeDevice, &Buffer, NULL);\r
      //\r
      // if identifying atapi device is failure, then try to send identify cmd.\r
      //\r
      if (EFI_ERROR (Status)) {\r
        DeviceType = EfiIdeHarddisk;\r
        Status     = AtaIdentify (Instance, IdeChannel, IdeDevice, &Buffer, NULL);\r
      }\r
    }\r
\r
    if (EFI_ERROR (Status)) {\r
      //\r
      // No device is found at this port\r
      //\r
      continue;\r
    }\r
\r
    DEBUG ((EFI_D_INFO, "[%a] channel [%a] [%a] device\n",\r
            (IdeChannel == 1) ? "secondary" : "primary  ", (IdeDevice == 1) ? "slave " : "master",\r
            DeviceType == EfiIdeCdrom ? "cdrom   " : "harddisk"));\r
    //\r
    // If the device is a hard disk, then try to enable S.M.A.R.T feature\r
    //\r
    if ((DeviceType == EfiIdeHarddisk) && PcdGetBool (PcdAtaSmartEnable)) {\r
      IdeAtaSmartSupport (\r
        Instance,\r
        IdeChannel,\r
        IdeDevice,\r
        &Buffer,\r
        NULL\r
        );\r
    }\r
\r
    //\r
    // Submit identify data to IDE controller init driver\r
    //\r
    IdeInit->SubmitData (IdeInit, IdeChannel, IdeDevice, &Buffer);\r
\r
    //\r
    // Now start to config ide device parameter and transfer mode.\r
    //\r
    Status = IdeInit->CalculateMode (\r
                        IdeInit,\r
                        IdeChannel,\r
                        IdeDevice,\r
                        &SupportedModes\r
                        );\r
    if (EFI_ERROR (Status)) {\r
      DEBUG ((EFI_D_ERROR, "Calculate Mode Fail, Status = %r\n", Status));\r
      continue;\r
    }\r
\r
    //\r
    // Set best supported PIO mode on this IDE device\r
    //\r
    if (SupportedModes->PioMode.Mode <= EfiAtaPioMode2) {\r
      TransferMode.ModeCategory = EFI_ATA_MODE_DEFAULT_PIO;\r
    } else {\r
      TransferMode.ModeCategory = EFI_ATA_MODE_FLOW_PIO;\r
    }\r
\r
    TransferMode.ModeNumber = (UINT8) (SupportedModes->PioMode.Mode);\r
\r
    if (SupportedModes->ExtModeCount == 0){\r
      Status = SetDeviceTransferMode (Instance, IdeChannel, IdeDevice, &TransferMode, NULL);\r
\r
      if (EFI_ERROR (Status)) {\r
        DEBUG ((EFI_D_ERROR, "Set transfer Mode Fail, Status = %r\n", Status));\r
        continue;\r
      }\r
    }\r
\r
    //\r
    // Set supported DMA mode on this IDE device. Note that UDMA & MDMA cann't\r
    // be set together. Only one DMA mode can be set to a device. If setting\r
    // DMA mode operation fails, we can continue moving on because we only use\r
    // PIO mode at boot time. DMA modes are used by certain kind of OS booting\r
    //\r
    if (SupportedModes->UdmaMode.Valid) {\r
      TransferMode.ModeCategory = EFI_ATA_MODE_UDMA;\r
      TransferMode.ModeNumber   = (UINT8) (SupportedModes->UdmaMode.Mode);\r
      Status = SetDeviceTransferMode (Instance, IdeChannel, IdeDevice, &TransferMode, NULL);\r
\r
      if (EFI_ERROR (Status)) {\r
        DEBUG ((EFI_D_ERROR, "Set transfer Mode Fail, Status = %r\n", Status));\r
        continue;\r
      }\r
    } else if (SupportedModes->MultiWordDmaMode.Valid) {\r
      TransferMode.ModeCategory = EFI_ATA_MODE_MDMA;\r
      TransferMode.ModeNumber   = (UINT8) SupportedModes->MultiWordDmaMode.Mode;\r
      Status = SetDeviceTransferMode (Instance, IdeChannel, IdeDevice, &TransferMode, NULL);\r
\r
      if (EFI_ERROR (Status)) {\r
        DEBUG ((EFI_D_ERROR, "Set transfer Mode Fail, Status = %r\n", Status));\r
        continue;\r
      }\r
    }\r
\r
    //\r
    // Set Parameters for the device:\r
    // 1) Init\r
    // 2) Establish the block count for READ/WRITE MULTIPLE (EXT) command\r
    //\r
    if (DeviceType == EfiIdeHarddisk) {\r
      //\r
      // Init driver parameters\r
      //\r
      DriveParameters.Sector         = (UINT8) ((ATA5_IDENTIFY_DATA *)(&Buffer.AtaData))->sectors_per_track;\r
      DriveParameters.Heads          = (UINT8) (((ATA5_IDENTIFY_DATA *)(&Buffer.AtaData))->heads - 1);\r
      DriveParameters.MultipleSector = (UINT8) ((ATA5_IDENTIFY_DATA *)(&Buffer.AtaData))->multi_sector_cmd_max_sct_cnt;\r
\r
      Status = SetDriveParameters (Instance, IdeChannel, IdeDevice, &DriveParameters, NULL);\r
    }\r
\r
    //\r
    // Set IDE controller Timing Blocks in the PCI Configuration Space\r
    //\r
    IdeInit->SetTiming (IdeInit, IdeChannel, IdeDevice, SupportedModes);\r
\r
    //\r
    // IDE controller and IDE device timing is configured successfully.\r
    // Now insert the device into device list.\r
    //\r
    Status = CreateNewDeviceInfo (Instance, IdeChannel, IdeDevice, DeviceType, &Buffer);\r
    if (EFI_ERROR (Status)) {\r
      continue;\r
    }\r
\r
    if (DeviceType == EfiIdeHarddisk) {\r
      REPORT_STATUS_CODE (EFI_PROGRESS_CODE, (EFI_PERIPHERAL_FIXED_MEDIA | EFI_P_PC_ENABLE));\r
    }\r
  }\r
  return EFI_SUCCESS;\r
}\r
\r
\r
/**\r
  Initialize ATA host controller at IDE mode.\r
\r
  The function is designed to initialize ATA host controller.\r
\r
  @param[in]  Instance          A pointer to the ATA_ATAPI_PASS_THRU_INSTANCE instance.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
IdeModeInitialization (\r
  IN  ATA_ATAPI_PASS_THRU_INSTANCE    *Instance\r
  )\r
{\r
  EFI_STATUS                        Status;\r
  EFI_IDE_CONTROLLER_INIT_PROTOCOL  *IdeInit;\r
  EFI_PCI_IO_PROTOCOL               *PciIo;\r
  UINT8                             Channel;\r
  UINT8                             IdeChannel;\r
  BOOLEAN                           ChannelEnabled;\r
  UINT8                             MaxDevices;\r
\r
  IdeInit = Instance->IdeControllerInit;\r
  PciIo   = Instance->PciIo;\r
  Channel = IdeInit->ChannelCount;\r
\r
  //\r
  // Obtain IDE IO port registers' base addresses\r
  //\r
  Status = GetIdeRegisterIoAddr (PciIo, Instance->IdeRegisters);\r
  if (EFI_ERROR (Status)) {\r
    goto ErrorExit;\r
  }\r
\r
  for (IdeChannel = 0; IdeChannel < Channel; IdeChannel++) {\r
    IdeInit->NotifyPhase (IdeInit, EfiIdeBeforeChannelEnumeration, IdeChannel);\r
\r
    //\r
    // now obtain channel information fron IdeControllerInit protocol.\r
    //\r
    Status = IdeInit->GetChannelInfo (\r
                        IdeInit,\r
                        IdeChannel,\r
                        &ChannelEnabled,\r
                        &MaxDevices\r
                        );\r
    if (EFI_ERROR (Status)) {\r
      DEBUG ((EFI_D_ERROR, "[GetChannel, Status=%x]", Status));\r
      continue;\r
    }\r
\r
    if (!ChannelEnabled) {\r
      continue;\r
    }\r
\r
    ASSERT (MaxDevices <= 2);\r
    //\r
    // Now inform the IDE Controller Init Module.\r
    //\r
    IdeInit->NotifyPhase (IdeInit, EfiIdeBeforeChannelReset, IdeChannel);\r
\r
    //\r
    // No reset channel function implemented.\r
    //\r
    IdeInit->NotifyPhase (IdeInit, EfiIdeAfterChannelReset, IdeChannel);\r
\r
    //\r
    // Now inform the IDE Controller Init Module.\r
    //\r
    IdeInit->NotifyPhase (IdeInit, EfiIdeBusBeforeDevicePresenceDetection, IdeChannel);\r
\r
    //\r
    // Detect all attached ATA devices and set the transfer mode for each device.\r
    //\r
    DetectAndConfigIdeDevice (Instance, IdeChannel);\r
  }\r
\r
  //\r
  // All configurations done! Notify IdeController to do post initialization\r
  // work such as saving IDE controller PCI settings for S3 resume\r
  //\r
  IdeInit->NotifyPhase (IdeInit, EfiIdeBusPhaseMaximum, 0);\r
\r
ErrorExit:\r
  return Status;\r
}\r
\r