AhciPeiPassThru.c

Go to the documentation of this file.

 
#include "AhciPei.h"
 
PEI_AHCI_ATA_DEVICE_DATA *
SearchDeviceByPort (
  IN PEI_AHCI_CONTROLLER_PRIVATE_DATA  *Private,
  IN UINT16                            Port,
  IN UINT16                            PortMultiplierPort
  )
{
  PEI_AHCI_ATA_DEVICE_DATA  *DeviceData;
  LIST_ENTRY                *Node;
 
  Node = GetFirstNode (&Private->DeviceList);
  while (!IsNull (&Private->DeviceList, Node)) {
    DeviceData = AHCI_PEI_ATA_DEVICE_INFO_FROM_THIS (Node);
 
    if ((DeviceData->Port == Port) &&
        (DeviceData->PortMultiplier == PortMultiplierPort))
    {
      return DeviceData;
    }
 
    Node = GetNextNode (&Private->DeviceList, Node);
  }
 
  return NULL;
}
 
EFI_STATUS
AhciPassThruExecute (
  IN     PEI_AHCI_CONTROLLER_PRIVATE_DATA  *Private,
  IN     UINT16                            Port,
  IN     UINT16                            PortMultiplierPort,
  IN     UINT8                             FisIndex,
  IN OUT EFI_ATA_PASS_THRU_COMMAND_PACKET  *Packet
  )
{
  EFI_STATUS  Status;
 
  if (PortMultiplierPort == 0xFFFF) {
    //
    // If there is no port multiplier, PortMultiplierPort will be 0xFFFF
    // according to UEFI spec. Here, we convert its value to 0 to follow
    // AHCI spec.
    //
    PortMultiplierPort = 0;
  }
 
  switch (Packet->Protocol) {
    case EFI_ATA_PASS_THRU_PROTOCOL_ATA_NON_DATA:
      Status = AhciNonDataTransfer (
                 Private,
                 (UINT8)Port,
                 (UINT8)PortMultiplierPort,
                 FisIndex,
                 Packet->Acb,
                 Packet->Asb,
                 Packet->Timeout
                 );
      break;
    case EFI_ATA_PASS_THRU_PROTOCOL_PIO_DATA_IN:
      Status = AhciPioTransfer (
                 Private,
                 (UINT8)Port,
                 (UINT8)PortMultiplierPort,
                 FisIndex,
                 TRUE,
                 Packet->Acb,
                 Packet->Asb,
                 Packet->InDataBuffer,
                 Packet->InTransferLength,
                 Packet->Timeout
                 );
      break;
    case EFI_ATA_PASS_THRU_PROTOCOL_PIO_DATA_OUT:
      Status = AhciPioTransfer (
                 Private,
                 (UINT8)Port,
                 (UINT8)PortMultiplierPort,
                 FisIndex,
                 FALSE,
                 Packet->Acb,
                 Packet->Asb,
                 Packet->OutDataBuffer,
                 Packet->OutTransferLength,
                 Packet->Timeout
                 );
      break;
    default:
      return EFI_UNSUPPORTED;
  }
 
  return Status;
}
 
EFI_STATUS
EFIAPI
AhciAtaPassThruPassThru (
  IN     EDKII_PEI_ATA_PASS_THRU_PPI       *This,
  IN     UINT16                            Port,
  IN     UINT16                            PortMultiplierPort,
  IN OUT EFI_ATA_PASS_THRU_COMMAND_PACKET  *Packet
  )
{
  UINT32                            IoAlign;
  PEI_AHCI_CONTROLLER_PRIVATE_DATA  *Private;
  PEI_AHCI_ATA_DEVICE_DATA          *DeviceData;
  UINT32                            MaxSectorCount;
  UINT32                            BlockSize;
 
  if ((This == NULL) || (Packet == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  IoAlign = This->Mode->IoAlign;
  if ((IoAlign > 1) && !ADDRESS_IS_ALIGNED (Packet->InDataBuffer, IoAlign)) {
    return EFI_INVALID_PARAMETER;
  }
 
  if ((IoAlign > 1) && !ADDRESS_IS_ALIGNED (Packet->OutDataBuffer, IoAlign)) {
    return EFI_INVALID_PARAMETER;
  }
 
  if ((IoAlign > 1) && !ADDRESS_IS_ALIGNED (Packet->Asb, IoAlign)) {
    return EFI_INVALID_PARAMETER;
  }
 
  Private    = GET_AHCI_PEIM_HC_PRIVATE_DATA_FROM_THIS_PASS_THRU (This);
  DeviceData = SearchDeviceByPort (Private, Port, PortMultiplierPort);
  if (DeviceData == NULL) {
    return EFI_NOT_FOUND;
  }
 
  MaxSectorCount = mMaxTransferBlockNumber[DeviceData->Lba48Bit];
  BlockSize      = DeviceData->Media.BlockSize;
 
  //
  // Convert the transfer length from sector count to byte.
  //
  if (((Packet->Length & EFI_ATA_PASS_THRU_LENGTH_BYTES) == 0) &&
      (Packet->InTransferLength != 0))
  {
    Packet->InTransferLength = Packet->InTransferLength * BlockSize;
  }
 
  //
  // Convert the transfer length from sector count to byte.
  //
  if (((Packet->Length & EFI_ATA_PASS_THRU_LENGTH_BYTES) == 0) &&
      (Packet->OutTransferLength != 0))
  {
    Packet->OutTransferLength = Packet->OutTransferLength * BlockSize;
  }
 
  //
  // If the data buffer described by InDataBuffer/OutDataBuffer and
  // InTransferLength/OutTransferLength is too big to be transferred in a single
  // command, then no data is transferred and EFI_BAD_BUFFER_SIZE is returned.
  //
  if (((Packet->InTransferLength != 0) && (Packet->InTransferLength > MaxSectorCount * BlockSize)) ||
      ((Packet->OutTransferLength != 0) && (Packet->OutTransferLength > MaxSectorCount * BlockSize)))
  {
    return EFI_BAD_BUFFER_SIZE;
  }
 
  return AhciPassThruExecute (
           Private,
           DeviceData->Port,
           DeviceData->PortMultiplier,
           DeviceData->FisIndex,
           Packet
           );
}
 
EFI_STATUS
EFIAPI
AhciAtaPassThruGetNextPort (
  IN     EDKII_PEI_ATA_PASS_THRU_PPI  *This,
  IN OUT UINT16                       *Port
  )
{
  PEI_AHCI_CONTROLLER_PRIVATE_DATA  *Private;
  PEI_AHCI_ATA_DEVICE_DATA          *DeviceData;
  LIST_ENTRY                        *Node;
 
  if ((This == NULL) || (Port == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  Private = GET_AHCI_PEIM_HC_PRIVATE_DATA_FROM_THIS_PASS_THRU (This);
 
  if (*Port == 0xFFFF) {
    //
    // If the Port is all 0xFF's, start to traverse the device list from the
    // beginning.
    //
    Node = GetFirstNode (&Private->DeviceList);
    if (!IsNull (&Private->DeviceList, Node)) {
      DeviceData = AHCI_PEI_ATA_DEVICE_INFO_FROM_THIS (Node);
 
      *Port = DeviceData->Port;
      goto Exit;
    }
 
    return EFI_NOT_FOUND;
  } else if (*Port == Private->PreviousPort) {
    Node = GetFirstNode (&Private->DeviceList);
 
    while (!IsNull (&Private->DeviceList, Node)) {
      DeviceData = AHCI_PEI_ATA_DEVICE_INFO_FROM_THIS (Node);
 
      if (DeviceData->Port > *Port) {
        *Port = DeviceData->Port;
        goto Exit;
      }
 
      Node = GetNextNode (&Private->DeviceList, Node);
    }
 
    return EFI_NOT_FOUND;
  } else {
    //
    // Port is not equal to all 0xFF's and not equal to previous return value.
    //
    return EFI_INVALID_PARAMETER;
  }
 
Exit:
  //
  // Update the PreviousPort.
  //
  Private->PreviousPort = *Port;
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
AhciAtaPassThruGetNextDevice (
  IN     EDKII_PEI_ATA_PASS_THRU_PPI  *This,
  IN     UINT16                       Port,
  IN OUT UINT16                       *PortMultiplierPort
  )
{
  PEI_AHCI_CONTROLLER_PRIVATE_DATA  *Private;
  PEI_AHCI_ATA_DEVICE_DATA          *DeviceData;
  LIST_ENTRY                        *Node;
 
  if ((This == NULL) || (PortMultiplierPort == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  Private = GET_AHCI_PEIM_HC_PRIVATE_DATA_FROM_THIS_PASS_THRU (This);
 
  if (Private->PreviousPortMultiplier == 0xFFFF) {
    //
    // If a device is directly attached on a port, previous call to this
    // function will return the value 0xFFFF for PortMultiplierPort. In
    // this case, there should be no more device on the port multiplier.
    //
    Private->PreviousPortMultiplier = 0;
    return EFI_NOT_FOUND;
  }
 
  if (*PortMultiplierPort == Private->PreviousPortMultiplier) {
    Node = GetFirstNode (&Private->DeviceList);
 
    while (!IsNull (&Private->DeviceList, Node)) {
      DeviceData = AHCI_PEI_ATA_DEVICE_INFO_FROM_THIS (Node);
 
      if ((DeviceData->Port == Port) &&
          (DeviceData->PortMultiplier > *PortMultiplierPort))
      {
        *PortMultiplierPort = DeviceData->PortMultiplier;
        goto Exit;
      }
 
      Node = GetNextNode (&Private->DeviceList, Node);
    }
 
    return EFI_NOT_FOUND;
  } else if (*PortMultiplierPort == 0xFFFF) {
    //
    // If the PortMultiplierPort is all 0xFF's, start to traverse the device list
    // from the beginning.
    //
    Node = GetFirstNode (&Private->DeviceList);
 
    while (!IsNull (&Private->DeviceList, Node)) {
      DeviceData = AHCI_PEI_ATA_DEVICE_INFO_FROM_THIS (Node);
 
      if (DeviceData->Port == Port) {
        *PortMultiplierPort = DeviceData->PortMultiplier;
        goto Exit;
      }
 
      Node = GetNextNode (&Private->DeviceList, Node);
    }
 
    return EFI_NOT_FOUND;
  } else {
    //
    // PortMultiplierPort is not equal to all 0xFF's and not equal to previous
    // return value.
    //
    return EFI_INVALID_PARAMETER;
  }
 
Exit:
  //
  // Update the PreviousPortMultiplier.
  //
  Private->PreviousPortMultiplier = *PortMultiplierPort;
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
AhciAtaPassThruGetDevicePath (
  IN  EDKII_PEI_ATA_PASS_THRU_PPI  *This,
  OUT UINTN                        *DevicePathLength,
  OUT EFI_DEVICE_PATH_PROTOCOL     **DevicePath
  )
{
  PEI_AHCI_CONTROLLER_PRIVATE_DATA  *Private;
 
  if ((This == NULL) || (DevicePathLength == NULL) || (DevicePath == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  Private = GET_AHCI_PEIM_HC_PRIVATE_DATA_FROM_THIS_PASS_THRU (This);
 
  *DevicePathLength = Private->DevicePathLength;
  *DevicePath       = AllocateCopyPool (Private->DevicePathLength, Private->DevicePath);
  if (*DevicePath == NULL) {
    *DevicePathLength = 0;
    return EFI_OUT_OF_RESOURCES;
  }
 
  return EFI_SUCCESS;
}