/** @file
BOT Transportation implementation.

Copyright (c) 2006 - 2018, Intel Corporation. All rights reserved.<BR>

SPDX-License-Identifier: BSD-2-Clause-Patent

**/

#include "UsbBotPeim.h"
#include "BotPeim.h"
#include "PeiUsbLib.h"

/**
  Reset the given usb device.

  @param  PeiServices            The pointer of EFI_PEI_SERVICES.
  @param  PeiBotDev              The instance to PEI_BOT_DEVICE.

  @retval EFI_INVALID_PARAMETER  Can not get usb io ppi.
  @retval EFI_SUCCESS            Failed to reset the given usb device.

**/
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;
}

/**
  Send the command to the device using Bulk-Out endpoint.

  This function sends the command to the device using Bulk-Out endpoint.
  BOT transfer is composed of three phases: Command, Data, and Status.
  This is the Command phase.

  @param  PeiServices            The pointer of EFI_PEI_SERVICES.
  @param  PeiBotDev              The instance to PEI_BOT_DEVICE.
  @param  Command                The command to transfer to device.
  @param  CommandSize            The length of the command.
  @param  DataTransferLength     The expected length of the data.
  @param  Direction              The direction of the data.
  @param  Timeout                Indicates the maximum time, in millisecond, which the
                                 transfer is allowed to complete.

  @retval EFI_DEVICE_ERROR       Successful to send the command to device.
  @retval EFI_SUCCESS            Failed to send the command to device.

**/
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;
}

/**
  Transfer the data between the device and host.

  This function transfers the data between the device and host.
  BOT transfer is composed of three phases: Command, Data, and Status.
  This is the Data phase.

  @param  PeiServices            The pointer of EFI_PEI_SERVICES.
  @param  PeiBotDev              The instance to PEI_BOT_DEVICE.
  @param  DataSize               The length of the data.
  @param  DataBuffer             The pointer to the data.
  @param  Direction              The direction of the data.
  @param  Timeout                Indicates the maximum time, in millisecond, which the
                                 transfer is allowed to complete.

  @retval EFI_DEVICE_ERROR       Successful to send the data to device.
  @retval EFI_SUCCESS            Failed to send the data to device.

**/
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;
}

/**
  Get the command execution status from device.

  This function gets the command execution status from device.
  BOT transfer is composed of three phases: Command, Data, and Status.
  This is the Status phase.

  @param  PeiServices            The pointer of EFI_PEI_SERVICES.
  @param  PeiBotDev              The instance to PEI_BOT_DEVICE.
  @param  TransferStatus         The status of the transaction.
  @param  Timeout                Indicates the maximum time, in millisecond, which the
                                 transfer is allowed to complete.

  @retval EFI_DEVICE_ERROR       Successful to get the status of device.
  @retval EFI_SUCCESS            Failed to get the status of device.

**/
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;
}

/**
  Send ATAPI command using BOT protocol.

  @param  PeiServices            The pointer of EFI_PEI_SERVICES.
  @param  PeiBotDev              The instance to PEI_BOT_DEVICE.
  @param  Command                The command to be sent to ATAPI device.
  @param  CommandSize            The length of the data to be sent.
  @param  DataBuffer             The pointer to the data.
  @param  BufferLength           The length of the data.
  @param  Direction              The direction of the data.
  @param  TimeOutInMilliSeconds  Indicates the maximum time, in millisecond, which the
                                 transfer is allowed to complete.

  @retval EFI_DEVICE_ERROR       Successful to get the status of device.
  @retval EFI_SUCCESS            Failed to get the status of device.

**/
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;
}