AtaBus.c

Go to the documentation of this file.

 
#include "AtaBus.h"
 
//
// ATA Bus Driver Binding Protocol Instance
//
EFI_DRIVER_BINDING_PROTOCOL  gAtaBusDriverBinding = {
  AtaBusDriverBindingSupported,
  AtaBusDriverBindingStart,
  AtaBusDriverBindingStop,
  0x10,
  NULL,
  NULL
};
 
//
// Template for ATA Child Device.
//
ATA_DEVICE  gAtaDeviceTemplate = {
  ATA_DEVICE_SIGNATURE,              // Signature
  NULL,                              // Handle
  {                            // BlockIo
    EFI_BLOCK_IO_PROTOCOL_REVISION,
    NULL,
    AtaBlockIoReset,
    AtaBlockIoReadBlocks,
    AtaBlockIoWriteBlocks,
    AtaBlockIoFlushBlocks
  },
  {                            // BlockIo2
    NULL,
    AtaBlockIoResetEx,
    AtaBlockIoReadBlocksEx,
    AtaBlockIoWriteBlocksEx,
    AtaBlockIoFlushBlocksEx
  },
  {                            // BlockMedia
    0,                         // MediaId
    FALSE,                     // RemovableMedia
    TRUE,                      // MediaPresent
    FALSE,                     // LogicPartition
    FALSE,                     // ReadOnly
    FALSE,                     // WritingCache
    0x200,                     // BlockSize
    0,                         // IoAlign
    0,                         // LastBlock
    0,                         // LowestAlignedLba
    1                          // LogicalBlocksPerPhysicalBlock
  },
  {                            // DiskInfo
    EFI_DISK_INFO_IDE_INTERFACE_GUID,
    AtaDiskInfoInquiry,
    AtaDiskInfoIdentify,
    AtaDiskInfoSenseData,
    AtaDiskInfoWhichIde
  },
  NULL,                              // DevicePath
  {
    AtaStorageSecurityReceiveData,
    AtaStorageSecuritySendData
  },
  NULL,                                       // AtaBusDriverData
  0,                                          // Port
  0,                                          // PortMultiplierPort
  { 0,                                     }, // Packet
  {
    { 0 },
  },                                          // Acb
  NULL,                                       // Asb
  FALSE,                                      // UdmaValid
  FALSE,                                      // Lba48Bit
  NULL,                                       // IdentifyData
  NULL,                                       // ControllerNameTable
  { L'\0',                                 }, // ModelName
  { NULL,                            NULL  }, // AtaTaskList
  { NULL,                            NULL  }, // AtaSubTaskList
  FALSE                                       // Abort
};
 
VOID *
AllocateAlignedBuffer (
  IN ATA_DEVICE  *AtaDevice,
  IN UINTN       BufferSize
  )
{
  return AllocateAlignedPages (EFI_SIZE_TO_PAGES (BufferSize), AtaDevice->AtaBusDriverData->AtaPassThru->Mode->IoAlign);
}
 
VOID
FreeAlignedBuffer (
  IN VOID   *Buffer,
  IN UINTN  BufferSize
  )
{
  if (Buffer != NULL) {
    FreeAlignedPages (Buffer, EFI_SIZE_TO_PAGES (BufferSize));
  }
}
 
VOID
ReleaseAtaResources (
  IN ATA_DEVICE  *AtaDevice
  )
{
  ATA_BUS_ASYN_SUB_TASK  *SubTask;
  ATA_BUS_ASYN_TASK      *AtaTask;
  LIST_ENTRY             *Entry;
  LIST_ENTRY             *DelEntry;
  EFI_TPL                OldTpl;
 
  FreeUnicodeStringTable (AtaDevice->ControllerNameTable);
  FreeAlignedBuffer (AtaDevice->Asb, sizeof (EFI_ATA_STATUS_BLOCK));
  FreeAlignedBuffer (AtaDevice->IdentifyData, sizeof (ATA_IDENTIFY_DATA));
  if (AtaDevice->DevicePath != NULL) {
    FreePool (AtaDevice->DevicePath);
  }
 
  OldTpl = gBS->RaiseTPL (TPL_NOTIFY);
  if (!IsListEmpty (&AtaDevice->AtaSubTaskList)) {
    //
    // Free the Subtask list.
    //
    for (Entry = AtaDevice->AtaSubTaskList.ForwardLink;
         Entry != (&AtaDevice->AtaSubTaskList);
         )
    {
      DelEntry = Entry;
      Entry    = Entry->ForwardLink;
      SubTask  = ATA_ASYN_SUB_TASK_FROM_ENTRY (DelEntry);
 
      RemoveEntryList (DelEntry);
      FreeAtaSubTask (SubTask);
    }
  }
 
  if (!IsListEmpty (&AtaDevice->AtaTaskList)) {
    //
    // Free the Subtask list.
    //
    for (Entry = AtaDevice->AtaTaskList.ForwardLink;
         Entry != (&AtaDevice->AtaTaskList);
         )
    {
      DelEntry = Entry;
      Entry    = Entry->ForwardLink;
      AtaTask  = ATA_ASYN_TASK_FROM_ENTRY (DelEntry);
 
      RemoveEntryList (DelEntry);
      FreePool (AtaTask);
    }
  }
 
  gBS->RestoreTPL (OldTpl);
  FreePool (AtaDevice);
}
 
EFI_STATUS
RegisterAtaDevice (
  IN OUT ATA_BUS_DRIVER_DATA  *AtaBusDriverData,
  IN     UINT16               Port,
  IN     UINT16               PortMultiplierPort
  )
{
  EFI_STATUS                  Status;
  ATA_DEVICE                  *AtaDevice;
  EFI_ATA_PASS_THRU_PROTOCOL  *AtaPassThru;
  EFI_DEVICE_PATH_PROTOCOL    *NewDevicePathNode;
  EFI_DEVICE_PATH_PROTOCOL    *DevicePath;
  EFI_DEVICE_PATH_PROTOCOL    *RemainingDevicePath;
  EFI_HANDLE                  DeviceHandle;
 
  AtaDevice           = NULL;
  NewDevicePathNode   = NULL;
  DevicePath          = NULL;
  RemainingDevicePath = NULL;
 
  //
  // Build device path
  //
  AtaPassThru = AtaBusDriverData->AtaPassThru;
  Status      = AtaPassThru->BuildDevicePath (AtaPassThru, Port, PortMultiplierPort, &NewDevicePathNode);
  if (EFI_ERROR (Status)) {
    goto Done;
  }
 
  DevicePath = AppendDevicePathNode (AtaBusDriverData->ParentDevicePath, NewDevicePathNode);
  if (DevicePath == NULL) {
    Status = EFI_OUT_OF_RESOURCES;
    goto Done;
  }
 
  DeviceHandle        = NULL;
  RemainingDevicePath = DevicePath;
  Status              = gBS->LocateDevicePath (&gEfiDevicePathProtocolGuid, &RemainingDevicePath, &DeviceHandle);
  if (!EFI_ERROR (Status) && (DeviceHandle != NULL) && IsDevicePathEnd (RemainingDevicePath)) {
    Status = EFI_ALREADY_STARTED;
    FreePool (DevicePath);
    goto Done;
  }
 
  //
  // Allocate ATA device from the template.
  //
  AtaDevice = AllocateCopyPool (sizeof (ATA_DEVICE), &gAtaDeviceTemplate);
  if (AtaDevice == NULL) {
    Status = EFI_OUT_OF_RESOURCES;
    goto Done;
  }
 
  //
  // Initializes ATA device structures and allocates the required buffer.
  //
  AtaDevice->BlockIo.Media      = &AtaDevice->BlockMedia;
  AtaDevice->BlockIo2.Media     = &AtaDevice->BlockMedia;
  AtaDevice->AtaBusDriverData   = AtaBusDriverData;
  AtaDevice->DevicePath         = DevicePath;
  AtaDevice->Port               = Port;
  AtaDevice->PortMultiplierPort = PortMultiplierPort;
  AtaDevice->Asb                = AllocateAlignedBuffer (AtaDevice, sizeof (EFI_ATA_STATUS_BLOCK));
  if (AtaDevice->Asb == NULL) {
    Status = EFI_OUT_OF_RESOURCES;
    goto Done;
  }
 
  AtaDevice->IdentifyData = AllocateAlignedBuffer (AtaDevice, sizeof (ATA_IDENTIFY_DATA));
  if (AtaDevice->IdentifyData == NULL) {
    Status = EFI_OUT_OF_RESOURCES;
    goto Done;
  }
 
  //
  // Initial Ata Task List
  //
  InitializeListHead (&AtaDevice->AtaTaskList);
  InitializeListHead (&AtaDevice->AtaSubTaskList);
 
  //
  // Report Status Code to indicate the ATA device will be enabled
  //
  REPORT_STATUS_CODE_WITH_DEVICE_PATH (
    EFI_PROGRESS_CODE,
    (EFI_IO_BUS_ATA_ATAPI | EFI_IOB_PC_ENABLE),
    AtaBusDriverData->ParentDevicePath
    );
 
  //
  // Try to identify the ATA device via the ATA pass through command.
  //
  Status = DiscoverAtaDevice (AtaDevice);
  if (EFI_ERROR (Status)) {
    goto Done;
  }
 
  //
  // Build controller name for Component Name (2) protocol.
  //
  Status = AddUnicodeString2 (
             "eng",
             gAtaBusComponentName.SupportedLanguages,
             &AtaDevice->ControllerNameTable,
             AtaDevice->ModelName,
             TRUE
             );
  if (EFI_ERROR (Status)) {
    goto Done;
  }
 
  Status = AddUnicodeString2 (
             "en",
             gAtaBusComponentName2.SupportedLanguages,
             &AtaDevice->ControllerNameTable,
             AtaDevice->ModelName,
             FALSE
             );
  if (EFI_ERROR (Status)) {
    goto Done;
  }
 
  //
  // Update to AHCI interface GUID based on device path node. The default one
  // is IDE interface GUID copied from template.
  //
  if (NewDevicePathNode->SubType == MSG_SATA_DP) {
    CopyGuid (&AtaDevice->DiskInfo.Interface, &gEfiDiskInfoAhciInterfaceGuid);
  }
 
  Status = gBS->InstallMultipleProtocolInterfaces (
                  &AtaDevice->Handle,
                  &gEfiDevicePathProtocolGuid,
                  AtaDevice->DevicePath,
                  &gEfiBlockIoProtocolGuid,
                  &AtaDevice->BlockIo,
                  &gEfiBlockIo2ProtocolGuid,
                  &AtaDevice->BlockIo2,
                  &gEfiDiskInfoProtocolGuid,
                  &AtaDevice->DiskInfo,
                  NULL
                  );
  if (EFI_ERROR (Status)) {
    goto Done;
  }
 
  //
  // See if the ata device support trust computing feature or not.
  // If yes, then install Storage Security Protocol at the ata device handle.
  //
  if ((AtaDevice->IdentifyData->trusted_computing_support & BIT0) != 0) {
    DEBUG ((DEBUG_INFO, "Found TCG support in Port %x PortMultiplierPort %x\n", Port, PortMultiplierPort));
    Status = gBS->InstallProtocolInterface (
                    &AtaDevice->Handle,
                    &gEfiStorageSecurityCommandProtocolGuid,
                    EFI_NATIVE_INTERFACE,
                    &AtaDevice->StorageSecurity
                    );
    if (EFI_ERROR (Status)) {
      goto Done;
    }
 
    DEBUG ((DEBUG_INFO, "Successfully Install Storage Security Protocol on the ATA device\n"));
  }
 
  gBS->OpenProtocol (
         AtaBusDriverData->Controller,
         &gEfiAtaPassThruProtocolGuid,
         (VOID **)&AtaPassThru,
         AtaBusDriverData->DriverBindingHandle,
         AtaDevice->Handle,
         EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
         );
 
Done:
  if (NewDevicePathNode != NULL) {
    FreePool (NewDevicePathNode);
  }
 
  if (EFI_ERROR (Status) && (AtaDevice != NULL)) {
    ReleaseAtaResources (AtaDevice);
    DEBUG ((DEBUG_ERROR | DEBUG_INIT, "Failed to initialize Port %x PortMultiplierPort %x, status = %r\n", Port, PortMultiplierPort, Status));
  }
 
  return Status;
}
 
EFI_STATUS
UnregisterAtaDevice (
  IN  EFI_DRIVER_BINDING_PROTOCOL  *This,
  IN  EFI_HANDLE                   Controller,
  IN  EFI_HANDLE                   Handle
  )
{
  EFI_STATUS                             Status;
  EFI_BLOCK_IO_PROTOCOL                  *BlockIo;
  EFI_BLOCK_IO2_PROTOCOL                 *BlockIo2;
  ATA_DEVICE                             *AtaDevice;
  EFI_ATA_PASS_THRU_PROTOCOL             *AtaPassThru;
  EFI_STORAGE_SECURITY_COMMAND_PROTOCOL  *StorageSecurity;
 
  BlockIo2 =     NULL;
  BlockIo  =     NULL;
 
  Status = gBS->OpenProtocol (
                  Handle,
                  &gEfiBlockIoProtocolGuid,
                  (VOID **)&BlockIo,
                  This->DriverBindingHandle,
                  Controller,
                  EFI_OPEN_PROTOCOL_GET_PROTOCOL
                  );
  if (EFI_ERROR (Status)) {
    //
    // Locate BlockIo2 protocol
    //
    Status = gBS->OpenProtocol (
                    Handle,
                    &gEfiBlockIo2ProtocolGuid,
                    (VOID **)&BlockIo2,
                    This->DriverBindingHandle,
                    Controller,
                    EFI_OPEN_PROTOCOL_GET_PROTOCOL
                    );
    if (EFI_ERROR (Status)) {
      return Status;
    }
  }
 
  //
  // Get AtaDevice data.
  //
  if (BlockIo != NULL) {
    AtaDevice = ATA_DEVICE_FROM_BLOCK_IO (BlockIo);
  } else {
    ASSERT (BlockIo2 != NULL);
    AtaDevice = ATA_DEVICE_FROM_BLOCK_IO2 (BlockIo2);
  }
 
  //
  // Close the child handle
  //
  gBS->CloseProtocol (
         Controller,
         &gEfiAtaPassThruProtocolGuid,
         This->DriverBindingHandle,
         Handle
         );
 
  //
  // The Ata Bus driver installs the BlockIo and BlockIo2 in the DriverBindingStart().
  // Here should uninstall both of them.
  //
  Status = gBS->UninstallMultipleProtocolInterfaces (
                  Handle,
                  &gEfiDevicePathProtocolGuid,
                  AtaDevice->DevicePath,
                  &gEfiBlockIoProtocolGuid,
                  &AtaDevice->BlockIo,
                  &gEfiBlockIo2ProtocolGuid,
                  &AtaDevice->BlockIo2,
                  &gEfiDiskInfoProtocolGuid,
                  &AtaDevice->DiskInfo,
                  NULL
                  );
 
  if (EFI_ERROR (Status)) {
    gBS->OpenProtocol (
           Controller,
           &gEfiAtaPassThruProtocolGuid,
           (VOID **)&AtaPassThru,
           This->DriverBindingHandle,
           Handle,
           EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
           );
    return Status;
  }
 
  //
  // If Storage Security Command Protocol is installed, then uninstall this protocol.
  //
  Status = gBS->OpenProtocol (
                  Handle,
                  &gEfiStorageSecurityCommandProtocolGuid,
                  (VOID **)&StorageSecurity,
                  This->DriverBindingHandle,
                  Controller,
                  EFI_OPEN_PROTOCOL_GET_PROTOCOL
                  );
 
  if (!EFI_ERROR (Status)) {
    Status = gBS->UninstallProtocolInterface (
                    Handle,
                    &gEfiStorageSecurityCommandProtocolGuid,
                    &AtaDevice->StorageSecurity
                    );
    if (EFI_ERROR (Status)) {
      gBS->OpenProtocol (
             Controller,
             &gEfiAtaPassThruProtocolGuid,
             (VOID **)&AtaPassThru,
             This->DriverBindingHandle,
             Handle,
             EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
             );
      return Status;
    }
  }
 
  ReleaseAtaResources (AtaDevice);
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
AtaBusDriverBindingSupported (
  IN EFI_DRIVER_BINDING_PROTOCOL  *This,
  IN EFI_HANDLE                   Controller,
  IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath
  )
{
  EFI_STATUS                  Status;
  EFI_DEVICE_PATH_PROTOCOL    *ParentDevicePath;
  EFI_ATA_PASS_THRU_PROTOCOL  *AtaPassThru;
  UINT16                      Port;
  UINT16                      PortMultiplierPort;
 
  //
  // Test EFI_ATA_PASS_THRU_PROTOCOL on controller handle.
  //
  Status = gBS->OpenProtocol (
                  Controller,
                  &gEfiAtaPassThruProtocolGuid,
                  (VOID **)&AtaPassThru,
                  This->DriverBindingHandle,
                  Controller,
                  EFI_OPEN_PROTOCOL_BY_DRIVER
                  );
 
  if (Status == EFI_ALREADY_STARTED) {
    return EFI_SUCCESS;
  }
 
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  //
  // Test to see if this ATA Pass Thru Protocol is for a LOGICAL channel
  //
  if ((AtaPassThru->Mode->Attributes & EFI_ATA_PASS_THRU_ATTRIBUTES_LOGICAL) == 0) {
    //
    // Close the I/O Abstraction(s) used to perform the supported test
    //
    gBS->CloseProtocol (
           Controller,
           &gEfiAtaPassThruProtocolGuid,
           This->DriverBindingHandle,
           Controller
           );
    return EFI_UNSUPPORTED;
  }
 
  //
  // Test RemainingDevicePath is valid or not.
  //
  if ((RemainingDevicePath != NULL) && !IsDevicePathEnd (RemainingDevicePath)) {
    Status = AtaPassThru->GetDevice (AtaPassThru, RemainingDevicePath, &Port, &PortMultiplierPort);
    if (EFI_ERROR (Status)) {
      //
      // Close the I/O Abstraction(s) used to perform the supported test
      //
      gBS->CloseProtocol (
             Controller,
             &gEfiAtaPassThruProtocolGuid,
             This->DriverBindingHandle,
             Controller
             );
      return Status;
    }
  }
 
  //
  // Close the I/O Abstraction(s) used to perform the supported test
  //
  gBS->CloseProtocol (
         Controller,
         &gEfiAtaPassThruProtocolGuid,
         This->DriverBindingHandle,
         Controller
         );
 
  //
  // Open the EFI Device Path protocol needed to perform the supported test
  //
  Status = gBS->OpenProtocol (
                  Controller,
                  &gEfiDevicePathProtocolGuid,
                  (VOID **)&ParentDevicePath,
                  This->DriverBindingHandle,
                  Controller,
                  EFI_OPEN_PROTOCOL_GET_PROTOCOL
                  );
  return Status;
}
 
EFI_STATUS
EFIAPI
AtaBusDriverBindingStart (
  IN EFI_DRIVER_BINDING_PROTOCOL  *This,
  IN EFI_HANDLE                   Controller,
  IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath
  )
{
  EFI_STATUS                  Status;
  EFI_ATA_PASS_THRU_PROTOCOL  *AtaPassThru;
  EFI_DEVICE_PATH_PROTOCOL    *ParentDevicePath;
  ATA_BUS_DRIVER_DATA         *AtaBusDriverData;
  UINT16                      Port;
  UINT16                      PortMultiplierPort;
 
  AtaBusDriverData = NULL;
 
  Status = gBS->OpenProtocol (
                  Controller,
                  &gEfiDevicePathProtocolGuid,
                  (VOID **)&ParentDevicePath,
                  This->DriverBindingHandle,
                  Controller,
                  EFI_OPEN_PROTOCOL_GET_PROTOCOL
                  );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  //
  // Report Status Code to indicate ATA bus starts
  //
  REPORT_STATUS_CODE_WITH_DEVICE_PATH (
    EFI_PROGRESS_CODE,
    (EFI_IO_BUS_ATA_ATAPI | EFI_IOB_PC_INIT),
    ParentDevicePath
    );
 
  Status = gBS->OpenProtocol (
                  Controller,
                  &gEfiAtaPassThruProtocolGuid,
                  (VOID **)&AtaPassThru,
                  This->DriverBindingHandle,
                  Controller,
                  EFI_OPEN_PROTOCOL_BY_DRIVER
                  );
  if ((EFI_ERROR (Status)) && (Status != EFI_ALREADY_STARTED)) {
    goto ErrorExit;
  }
 
  //
  // Check EFI_ALREADY_STARTED to reuse the original ATA_BUS_DRIVER_DATA.
  //
  if (Status != EFI_ALREADY_STARTED) {
    AtaBusDriverData = AllocateZeroPool (sizeof (ATA_BUS_DRIVER_DATA));
    if (AtaBusDriverData == NULL) {
      Status = EFI_OUT_OF_RESOURCES;
      goto ErrorExit;
    }
 
    AtaBusDriverData->AtaPassThru         = AtaPassThru;
    AtaBusDriverData->Controller          = Controller;
    AtaBusDriverData->ParentDevicePath    = ParentDevicePath;
    AtaBusDriverData->DriverBindingHandle = This->DriverBindingHandle;
 
    Status = gBS->InstallMultipleProtocolInterfaces (
                    &Controller,
                    &gEfiCallerIdGuid,
                    AtaBusDriverData,
                    NULL
                    );
    if (EFI_ERROR (Status)) {
      goto ErrorExit;
    }
  } else {
    Status = gBS->OpenProtocol (
                    Controller,
                    &gEfiCallerIdGuid,
                    (VOID **)&AtaBusDriverData,
                    This->DriverBindingHandle,
                    Controller,
                    EFI_OPEN_PROTOCOL_GET_PROTOCOL
                    );
    if (EFI_ERROR (Status)) {
      AtaBusDriverData = NULL;
      goto ErrorExit;
    }
  }
 
  //
  // Report Status Code to indicate detecting devices on bus
  //
  REPORT_STATUS_CODE_WITH_DEVICE_PATH (
    EFI_PROGRESS_CODE,
    (EFI_IO_BUS_ATA_ATAPI | EFI_IOB_PC_DETECT),
    ParentDevicePath
    );
 
  if (RemainingDevicePath == NULL) {
    Port = 0xFFFF;
    while (TRUE) {
      Status = AtaPassThru->GetNextPort (AtaPassThru, &Port);
      if (EFI_ERROR (Status)) {
        //
        // We cannot find more legal port then we are done.
        //
        break;
      }
 
      PortMultiplierPort = 0xFFFF;
      while (TRUE) {
        Status = AtaPassThru->GetNextDevice (AtaPassThru, Port, &PortMultiplierPort);
        if (EFI_ERROR (Status)) {
          //
          // We cannot find more legal port multiplier port number for ATA device
          // on the port, then we are done.
          //
          break;
        }
 
        RegisterAtaDevice (AtaBusDriverData, Port, PortMultiplierPort);
      }
    }
 
    Status = EFI_SUCCESS;
  } else if (!IsDevicePathEnd (RemainingDevicePath)) {
    Status = AtaPassThru->GetDevice (AtaPassThru, RemainingDevicePath, &Port, &PortMultiplierPort);
    if (!EFI_ERROR (Status)) {
      Status = RegisterAtaDevice (AtaBusDriverData, Port, PortMultiplierPort);
    }
  }
 
  return Status;
 
ErrorExit:
 
  if (AtaBusDriverData != NULL) {
    gBS->UninstallMultipleProtocolInterfaces (
           Controller,
           &gEfiCallerIdGuid,
           AtaBusDriverData,
           NULL
           );
    FreePool (AtaBusDriverData);
  }
 
  gBS->CloseProtocol (
         Controller,
         &gEfiAtaPassThruProtocolGuid,
         This->DriverBindingHandle,
         Controller
         );
 
  return Status;
}
 
EFI_STATUS
EFIAPI
AtaBusDriverBindingStop (
  IN  EFI_DRIVER_BINDING_PROTOCOL  *This,
  IN  EFI_HANDLE                   Controller,
  IN  UINTN                        NumberOfChildren,
  IN  EFI_HANDLE                   *ChildHandleBuffer
  )
{
  EFI_STATUS           Status;
  BOOLEAN              AllChildrenStopped;
  UINTN                Index;
  ATA_BUS_DRIVER_DATA  *AtaBusDriverData;
 
  if (NumberOfChildren == 0) {
    Status = gBS->OpenProtocol (
                    Controller,
                    &gEfiCallerIdGuid,
                    (VOID **)&AtaBusDriverData,
                    This->DriverBindingHandle,
                    Controller,
                    EFI_OPEN_PROTOCOL_GET_PROTOCOL
                    );
    if (!EFI_ERROR (Status)) {
      gBS->UninstallMultipleProtocolInterfaces (
             Controller,
             &gEfiCallerIdGuid,
             AtaBusDriverData,
             NULL
             );
      FreePool (AtaBusDriverData);
    }
 
    gBS->CloseProtocol (
           Controller,
           &gEfiAtaPassThruProtocolGuid,
           This->DriverBindingHandle,
           Controller
           );
 
    return EFI_SUCCESS;
  }
 
  AllChildrenStopped = TRUE;
 
  for (Index = 0; Index < NumberOfChildren; Index++) {
    Status = UnregisterAtaDevice (This, Controller, ChildHandleBuffer[Index]);
    if (EFI_ERROR (Status)) {
      AllChildrenStopped = FALSE;
    }
  }
 
  if (!AllChildrenStopped) {
    return EFI_DEVICE_ERROR;
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
AtaBlockIoReset (
  IN  EFI_BLOCK_IO_PROTOCOL  *This,
  IN  BOOLEAN                ExtendedVerification
  )
{
  EFI_STATUS  Status;
  ATA_DEVICE  *AtaDevice;
  EFI_TPL     OldTpl;
 
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 
  AtaDevice = ATA_DEVICE_FROM_BLOCK_IO (This);
 
  Status = ResetAtaDevice (AtaDevice);
 
  if (EFI_ERROR (Status)) {
    Status = EFI_DEVICE_ERROR;
  }
 
  gBS->RestoreTPL (OldTpl);
  return Status;
}
 
EFI_STATUS
BlockIoReadWrite (
  IN     VOID                 *This,
  IN     UINT32               MediaId,
  IN     EFI_LBA              Lba,
  IN OUT EFI_BLOCK_IO2_TOKEN  *Token,
  IN     UINTN                BufferSize,
  OUT    VOID                 *Buffer,
  IN     BOOLEAN              IsBlockIo2,
  IN     BOOLEAN              IsWrite
  )
{
  ATA_DEVICE          *AtaDevice;
  EFI_STATUS          Status;
  EFI_TPL             OldTpl;
  EFI_BLOCK_IO_MEDIA  *Media;
  UINTN               BlockSize;
  UINTN               NumberOfBlocks;
  UINTN               IoAlign;
 
  if (IsBlockIo2) {
    Media     = ((EFI_BLOCK_IO2_PROTOCOL *)This)->Media;
    AtaDevice = ATA_DEVICE_FROM_BLOCK_IO2 (This);
  } else {
    Media     = ((EFI_BLOCK_IO_PROTOCOL *)This)->Media;
    AtaDevice = ATA_DEVICE_FROM_BLOCK_IO (This);
  }
 
  if (MediaId != Media->MediaId) {
    return EFI_MEDIA_CHANGED;
  }
 
  //
  // Check parameters.
  //
  if (Buffer == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  if (BufferSize == 0) {
    if ((Token != NULL) && (Token->Event != NULL)) {
      Token->TransactionStatus = EFI_SUCCESS;
      gBS->SignalEvent (Token->Event);
    }
 
    return EFI_SUCCESS;
  }
 
  BlockSize = Media->BlockSize;
  if ((BufferSize % BlockSize) != 0) {
    return EFI_BAD_BUFFER_SIZE;
  }
 
  NumberOfBlocks = BufferSize / BlockSize;
  if ((Lba + NumberOfBlocks - 1) > Media->LastBlock) {
    return EFI_INVALID_PARAMETER;
  }
 
  IoAlign = Media->IoAlign;
  if ((IoAlign > 0) && (((UINTN)Buffer & (IoAlign - 1)) != 0)) {
    return EFI_INVALID_PARAMETER;
  }
 
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 
  //
  // Invoke low level AtaDevice Access Routine.
  //
  Status = AccessAtaDevice (AtaDevice, Buffer, Lba, NumberOfBlocks, IsWrite, Token);
 
  gBS->RestoreTPL (OldTpl);
 
  return Status;
}
 
EFI_STATUS
EFIAPI
AtaBlockIoReadBlocks (
  IN  EFI_BLOCK_IO_PROTOCOL  *This,
  IN  UINT32                 MediaId,
  IN  EFI_LBA                Lba,
  IN  UINTN                  BufferSize,
  OUT VOID                   *Buffer
  )
{
  return BlockIoReadWrite ((VOID *)This, MediaId, Lba, NULL, BufferSize, Buffer, FALSE, FALSE);
}
 
EFI_STATUS
EFIAPI
AtaBlockIoWriteBlocks (
  IN  EFI_BLOCK_IO_PROTOCOL  *This,
  IN  UINT32                 MediaId,
  IN  EFI_LBA                Lba,
  IN  UINTN                  BufferSize,
  IN  VOID                   *Buffer
  )
{
  return BlockIoReadWrite ((VOID *)This, MediaId, Lba, NULL, BufferSize, Buffer, FALSE, TRUE);
}
 
EFI_STATUS
EFIAPI
AtaBlockIoFlushBlocks (
  IN  EFI_BLOCK_IO_PROTOCOL  *This
  )
{
  //
  // return directly
  //
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
AtaBlockIoResetEx (
  IN  EFI_BLOCK_IO2_PROTOCOL  *This,
  IN  BOOLEAN                 ExtendedVerification
  )
{
  EFI_STATUS  Status;
  ATA_DEVICE  *AtaDevice;
  EFI_TPL     OldTpl;
 
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 
  AtaDevice = ATA_DEVICE_FROM_BLOCK_IO2 (This);
 
  AtaTerminateNonBlockingTask (AtaDevice);
 
  Status = ResetAtaDevice (AtaDevice);
 
  if (EFI_ERROR (Status)) {
    Status = EFI_DEVICE_ERROR;
  }
 
  gBS->RestoreTPL (OldTpl);
  return Status;
}
 
EFI_STATUS
EFIAPI
AtaBlockIoReadBlocksEx (
  IN  EFI_BLOCK_IO2_PROTOCOL  *This,
  IN  UINT32                  MediaId,
  IN  EFI_LBA                 Lba,
  IN OUT EFI_BLOCK_IO2_TOKEN  *Token,
  IN  UINTN                   BufferSize,
  OUT VOID                    *Buffer
  )
{
  return BlockIoReadWrite ((VOID *)This, MediaId, Lba, Token, BufferSize, Buffer, TRUE, FALSE);
}
 
EFI_STATUS
EFIAPI
AtaBlockIoWriteBlocksEx (
  IN  EFI_BLOCK_IO2_PROTOCOL  *This,
  IN  UINT32                  MediaId,
  IN  EFI_LBA                 Lba,
  IN OUT EFI_BLOCK_IO2_TOKEN  *Token,
  IN  UINTN                   BufferSize,
  IN  VOID                    *Buffer
  )
{
  return BlockIoReadWrite ((VOID *)This, MediaId, Lba, Token, BufferSize, Buffer, TRUE, TRUE);
}
 
EFI_STATUS
EFIAPI
AtaBlockIoFlushBlocksEx (
  IN  EFI_BLOCK_IO2_PROTOCOL  *This,
  IN OUT EFI_BLOCK_IO2_TOKEN  *Token
  )
{
  //
  // Signal event and return directly.
  //
  if ((Token != NULL) && (Token->Event != NULL)) {
    Token->TransactionStatus = EFI_SUCCESS;
    gBS->SignalEvent (Token->Event);
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
AtaDiskInfoInquiry (
  IN     EFI_DISK_INFO_PROTOCOL  *This,
  IN OUT VOID                    *InquiryData,
  IN OUT UINT32                  *InquiryDataSize
  )
{
  return EFI_NOT_FOUND;
}
 
EFI_STATUS
EFIAPI
AtaDiskInfoIdentify (
  IN     EFI_DISK_INFO_PROTOCOL  *This,
  IN OUT VOID                    *IdentifyData,
  IN OUT UINT32                  *IdentifyDataSize
  )
{
  EFI_STATUS  Status;
  ATA_DEVICE  *AtaDevice;
 
  AtaDevice = ATA_DEVICE_FROM_DISK_INFO (This);
 
  Status = EFI_BUFFER_TOO_SMALL;
  if (*IdentifyDataSize >= sizeof (ATA_IDENTIFY_DATA)) {
    Status = EFI_SUCCESS;
    CopyMem (IdentifyData, AtaDevice->IdentifyData, sizeof (ATA_IDENTIFY_DATA));
  }
 
  *IdentifyDataSize = sizeof (ATA_IDENTIFY_DATA);
 
  return Status;
}
 
EFI_STATUS
EFIAPI
AtaDiskInfoSenseData (
  IN     EFI_DISK_INFO_PROTOCOL  *This,
  IN OUT VOID                    *SenseData,
  IN OUT UINT32                  *SenseDataSize,
  OUT    UINT8                   *SenseDataNumber
  )
{
  return EFI_NOT_FOUND;
}
 
EFI_STATUS
EFIAPI
AtaDiskInfoWhichIde (
  IN  EFI_DISK_INFO_PROTOCOL  *This,
  OUT UINT32                  *IdeChannel,
  OUT UINT32                  *IdeDevice
  )
{
  ATA_DEVICE  *AtaDevice;
 
  AtaDevice   = ATA_DEVICE_FROM_DISK_INFO (This);
  *IdeChannel = AtaDevice->Port;
  *IdeDevice  = AtaDevice->PortMultiplierPort;
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
AtaStorageSecurityReceiveData (
  IN EFI_STORAGE_SECURITY_COMMAND_PROTOCOL  *This,
  IN UINT32                                 MediaId,
  IN UINT64                                 Timeout,
  IN UINT8                                  SecurityProtocolId,
  IN UINT16                                 SecurityProtocolSpecificData,
  IN UINTN                                  PayloadBufferSize,
  OUT VOID                                  *PayloadBuffer,
  OUT UINTN                                 *PayloadTransferSize
  )
{
  EFI_STATUS  Status;
  ATA_DEVICE  *Private;
  EFI_TPL     OldTpl;
 
  DEBUG ((DEBUG_INFO, "EFI Storage Security Protocol - Read\n"));
  if (((PayloadBuffer == NULL) || (PayloadTransferSize == NULL)) && (PayloadBufferSize != 0)) {
    return EFI_INVALID_PARAMETER;
  }
 
  Status  = EFI_SUCCESS;
  Private = ATA_DEVICE_FROM_STORAGE_SECURITY (This);
 
  if (MediaId != Private->BlockIo.Media->MediaId) {
    return EFI_MEDIA_CHANGED;
  }
 
  if (!Private->BlockIo.Media->MediaPresent) {
    return EFI_NO_MEDIA;
  }
 
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 
  Status = TrustTransferAtaDevice (
             Private,
             PayloadBuffer,
             SecurityProtocolId,
             SecurityProtocolSpecificData,
             PayloadBufferSize,
             FALSE,
             Timeout,
             PayloadTransferSize
             );
 
  gBS->RestoreTPL (OldTpl);
  return Status;
}
 
EFI_STATUS
EFIAPI
AtaStorageSecuritySendData (
  IN EFI_STORAGE_SECURITY_COMMAND_PROTOCOL  *This,
  IN UINT32                                 MediaId,
  IN UINT64                                 Timeout,
  IN UINT8                                  SecurityProtocolId,
  IN UINT16                                 SecurityProtocolSpecificData,
  IN UINTN                                  PayloadBufferSize,
  IN VOID                                   *PayloadBuffer
  )
{
  EFI_STATUS  Status;
  ATA_DEVICE  *Private;
  EFI_TPL     OldTpl;
 
  DEBUG ((DEBUG_INFO, "EFI Storage Security Protocol - Send\n"));
  if ((PayloadBuffer == NULL) && (PayloadBufferSize != 0)) {
    return EFI_INVALID_PARAMETER;
  }
 
  Status  = EFI_SUCCESS;
  Private = ATA_DEVICE_FROM_STORAGE_SECURITY (This);
 
  if (MediaId != Private->BlockIo.Media->MediaId) {
    return EFI_MEDIA_CHANGED;
  }
 
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
  Status = TrustTransferAtaDevice (
             Private,
             PayloadBuffer,
             SecurityProtocolId,
             SecurityProtocolSpecificData,
             PayloadBufferSize,
             TRUE,
             Timeout,
             NULL
             );
 
  gBS->RestoreTPL (OldTpl);
  return Status;
}
 
EFI_STATUS
EFIAPI
InitializeAtaBus (
  IN EFI_HANDLE        ImageHandle,
  IN EFI_SYSTEM_TABLE  *SystemTable
  )
{
  EFI_STATUS  Status;
 
  //
  // Install driver model protocol(s).
  //
  Status = EfiLibInstallDriverBindingComponentName2 (
             ImageHandle,
             SystemTable,
             &gAtaBusDriverBinding,
             ImageHandle,
             &gAtaBusComponentName,
             &gAtaBusComponentName2
             );
  ASSERT_EFI_ERROR (Status);
 
  return Status;
}