BotPeim.c

Go to the documentation of this file.

 
#include "UsbBotPeim.h"
#include "BotPeim.h"
#include "PeiUsbLib.h"
 
EFI_STATUS
BotRecoveryReset (
  IN  EFI_PEI_SERVICES  **PeiServices,
  IN  PEI_BOT_DEVICE    *PeiBotDev
  )
{
  EFI_USB_DEVICE_REQUEST  DevReq;
  UINT32                  Timeout;
  PEI_USB_IO_PPI          *UsbIoPpi;
  UINT8                   EndpointAddr;
  EFI_STATUS              Status;
 
  UsbIoPpi = PeiBotDev->UsbIoPpi;
 
  if (UsbIoPpi == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  ZeroMem (&DevReq, sizeof (EFI_USB_DEVICE_REQUEST));
 
  DevReq.RequestType = 0x21;
  DevReq.Request     = 0xFF;
  DevReq.Value       = 0;
  DevReq.Index       = 0;
  DevReq.Length      = 0;
 
  Timeout = 3000;
 
  Status = UsbIoPpi->UsbControlTransfer (
                       PeiServices,
                       UsbIoPpi,
                       &DevReq,
                       EfiUsbNoData,
                       Timeout,
                       NULL,
                       0
                       );
 
  //
  // clear bulk in endpoint stall feature
  //
  EndpointAddr = (PeiBotDev->BulkInEndpoint)->EndpointAddress;
  PeiUsbClearEndpointHalt (PeiServices, UsbIoPpi, EndpointAddr);
 
  //
  // clear bulk out endpoint stall feature
  //
  EndpointAddr = (PeiBotDev->BulkOutEndpoint)->EndpointAddress;
  PeiUsbClearEndpointHalt (PeiServices, UsbIoPpi, EndpointAddr);
 
  return Status;
}
 
EFI_STATUS
BotCommandPhase (
  IN  EFI_PEI_SERVICES        **PeiServices,
  IN  PEI_BOT_DEVICE          *PeiBotDev,
  IN  VOID                    *Command,
  IN  UINT8                   CommandSize,
  IN  UINT32                  DataTransferLength,
  IN  EFI_USB_DATA_DIRECTION  Direction,
  IN  UINT16                  Timeout
  )
{
  CBW             Cbw;
  EFI_STATUS      Status;
  PEI_USB_IO_PPI  *UsbIoPpi;
  UINTN           DataSize;
 
  UsbIoPpi = PeiBotDev->UsbIoPpi;
 
  ZeroMem (&Cbw, sizeof (CBW));
 
  //
  // Fill the command block, detailed see BOT spec
  //
  Cbw.Signature          = CBWSIG;
  Cbw.Tag                = 0x01;
  Cbw.DataTransferLength = DataTransferLength;
  Cbw.Flags              = (UINT8)((Direction == EfiUsbDataIn) ? 0x80 : 0);
  Cbw.Lun                = 0;
  Cbw.CmdLen             = CommandSize;
 
  CopyMem (Cbw.CmdBlock, Command, CommandSize);
 
  DataSize = sizeof (CBW);
 
  Status = UsbIoPpi->UsbBulkTransfer (
                       PeiServices,
                       UsbIoPpi,
                       (PeiBotDev->BulkOutEndpoint)->EndpointAddress,
                       (UINT8 *)&Cbw,
                       &DataSize,
                       Timeout
                       );
  if (EFI_ERROR (Status)) {
    //
    // Command phase fail, we need to recovery reset this device
    //
    BotRecoveryReset (PeiServices, PeiBotDev);
    return EFI_DEVICE_ERROR;
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
BotDataPhase (
  IN  EFI_PEI_SERVICES        **PeiServices,
  IN  PEI_BOT_DEVICE          *PeiBotDev,
  IN  UINT32                  *DataSize,
  IN  OUT VOID                *DataBuffer,
  IN  EFI_USB_DATA_DIRECTION  Direction,
  IN  UINT16                  Timeout
  )
{
  EFI_STATUS      Status;
  PEI_USB_IO_PPI  *UsbIoPpi;
  UINT8           EndpointAddr;
  UINTN           Remain;
  UINTN           Increment;
  UINT32          MaxPacketLen;
  UINT8           *BufferPtr;
  UINTN           TransferredSize;
 
  UsbIoPpi = PeiBotDev->UsbIoPpi;
 
  Remain          = *DataSize;
  BufferPtr       = (UINT8 *)DataBuffer;
  TransferredSize = 0;
 
  //
  // retrieve the max packet length of the given endpoint
  //
  if (Direction == EfiUsbDataIn) {
    MaxPacketLen = (PeiBotDev->BulkInEndpoint)->MaxPacketSize;
    EndpointAddr = (PeiBotDev->BulkInEndpoint)->EndpointAddress;
  } else {
    MaxPacketLen = (PeiBotDev->BulkOutEndpoint)->MaxPacketSize;
    EndpointAddr = (PeiBotDev->BulkOutEndpoint)->EndpointAddress;
  }
 
  while (Remain > 0) {
    //
    // Using 15 packets to avoid Bitstuff error
    //
    if (Remain > 16 * MaxPacketLen) {
      Increment = 16 * MaxPacketLen;
    } else {
      Increment = Remain;
    }
 
    Status = UsbIoPpi->UsbBulkTransfer (
                         PeiServices,
                         UsbIoPpi,
                         EndpointAddr,
                         BufferPtr,
                         &Increment,
                         Timeout
                         );
 
    TransferredSize += Increment;
 
    if (EFI_ERROR (Status)) {
      PeiUsbClearEndpointHalt (PeiServices, UsbIoPpi, EndpointAddr);
      return Status;
    }
 
    BufferPtr += Increment;
    Remain    -= Increment;
  }
 
  *DataSize = (UINT32)TransferredSize;
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
BotStatusPhase (
  IN  EFI_PEI_SERVICES  **PeiServices,
  IN  PEI_BOT_DEVICE    *PeiBotDev,
  OUT UINT8             *TransferStatus,
  IN  UINT16            Timeout
  )
{
  CSW             Csw;
  EFI_STATUS      Status;
  PEI_USB_IO_PPI  *UsbIoPpi;
  UINT8           EndpointAddr;
  UINTN           DataSize;
 
  UsbIoPpi = PeiBotDev->UsbIoPpi;
 
  ZeroMem (&Csw, sizeof (CSW));
 
  EndpointAddr = (PeiBotDev->BulkInEndpoint)->EndpointAddress;
 
  DataSize = sizeof (CSW);
 
  //
  // Get the status field from bulk transfer
  //
  Status = UsbIoPpi->UsbBulkTransfer (
                       PeiServices,
                       UsbIoPpi,
                       EndpointAddr,
                       &Csw,
                       &DataSize,
                       Timeout
                       );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  if (Csw.Signature == CSWSIG) {
    *TransferStatus = Csw.Status;
  } else {
    return EFI_DEVICE_ERROR;
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
PeiAtapiCommand (
  IN  EFI_PEI_SERVICES        **PeiServices,
  IN  PEI_BOT_DEVICE          *PeiBotDev,
  IN  VOID                    *Command,
  IN  UINT8                   CommandSize,
  IN  VOID                    *DataBuffer,
  IN  UINT32                  BufferLength,
  IN  EFI_USB_DATA_DIRECTION  Direction,
  IN  UINT16                  TimeOutInMilliSeconds
  )
{
  EFI_STATUS  Status;
  EFI_STATUS  BotDataStatus;
  UINT8       TransferStatus;
  UINT32      BufferSize;
 
  BotDataStatus = EFI_SUCCESS;
  //
  // First send ATAPI command through Bot
  //
  Status = BotCommandPhase (
             PeiServices,
             PeiBotDev,
             Command,
             CommandSize,
             BufferLength,
             Direction,
             TimeOutInMilliSeconds
             );
 
  if (EFI_ERROR (Status)) {
    return EFI_DEVICE_ERROR;
  }
 
  //
  // Send/Get Data if there is a Data Stage
  //
  switch (Direction) {
    case EfiUsbDataIn:
    case EfiUsbDataOut:
      BufferSize = BufferLength;
 
      BotDataStatus = BotDataPhase (
                        PeiServices,
                        PeiBotDev,
                        &BufferSize,
                        DataBuffer,
                        Direction,
                        TimeOutInMilliSeconds
                        );
      break;
 
    case EfiUsbNoData:
      break;
  }
 
  //
  // Status Phase
  //
  Status = BotStatusPhase (
             PeiServices,
             PeiBotDev,
             &TransferStatus,
             TimeOutInMilliSeconds
             );
  if (EFI_ERROR (Status)) {
    BotRecoveryReset (PeiServices, PeiBotDev);
    return EFI_DEVICE_ERROR;
  }
 
  if (TransferStatus == 0x01) {
    return EFI_DEVICE_ERROR;
  }
 
  return BotDataStatus;
}