UsbMassCbi.c

Go to the documentation of this file.

 
#include "UsbMass.h"
 
//
// Definition of USB CBI0 Transport Protocol
//
USB_MASS_TRANSPORT  mUsbCbi0Transport = {
  USB_MASS_STORE_CBI0,
  UsbCbiInit,
  UsbCbiExecCommand,
  UsbCbiResetDevice,
  NULL,
  UsbCbiCleanUp
};
 
//
// Definition of USB CBI1 Transport Protocol
//
USB_MASS_TRANSPORT  mUsbCbi1Transport = {
  USB_MASS_STORE_CBI1,
  UsbCbiInit,
  UsbCbiExecCommand,
  UsbCbiResetDevice,
  NULL,
  UsbCbiCleanUp
};
 
EFI_STATUS
UsbCbiInit (
  IN  EFI_USB_IO_PROTOCOL  *UsbIo,
  OUT VOID                 **Context       OPTIONAL
  )
{
  USB_CBI_PROTOCOL              *UsbCbi;
  EFI_USB_INTERFACE_DESCRIPTOR  *Interface;
  EFI_USB_ENDPOINT_DESCRIPTOR   EndPoint;
  EFI_STATUS                    Status;
  UINT8                         Index;
 
  //
  // Allocate the CBI context for USB_CBI_PROTOCOL and 3 endpoint descriptors.
  //
  UsbCbi = AllocateZeroPool (
             sizeof (USB_CBI_PROTOCOL) + 3 * sizeof (EFI_USB_ENDPOINT_DESCRIPTOR)
             );
  ASSERT (UsbCbi != NULL);
 
  UsbCbi->UsbIo = UsbIo;
 
  //
  // Get the interface descriptor and validate that it
  // is a USB Mass Storage CBI interface.
  //
  Status = UsbIo->UsbGetInterfaceDescriptor (UsbIo, &UsbCbi->Interface);
  if (EFI_ERROR (Status)) {
    goto ON_ERROR;
  }
 
  Interface = &UsbCbi->Interface;
  if (  (Interface->InterfaceProtocol != USB_MASS_STORE_CBI0)
     && (Interface->InterfaceProtocol != USB_MASS_STORE_CBI1))
  {
    Status = EFI_UNSUPPORTED;
    goto ON_ERROR;
  }
 
  //
  // Locate and save the bulk-in, bulk-out, and interrupt endpoint
  //
  for (Index = 0; Index < Interface->NumEndpoints; Index++) {
    Status = UsbIo->UsbGetEndpointDescriptor (UsbIo, Index, &EndPoint);
    if (EFI_ERROR (Status)) {
      continue;
    }
 
    if (USB_IS_BULK_ENDPOINT (EndPoint.Attributes)) {
      //
      // Use the first Bulk-In and Bulk-Out endpoints
      //
      if (USB_IS_IN_ENDPOINT (EndPoint.EndpointAddress) &&
          (UsbCbi->BulkInEndpoint == NULL))
      {
        UsbCbi->BulkInEndpoint = (EFI_USB_ENDPOINT_DESCRIPTOR *)(UsbCbi + 1);
        CopyMem (UsbCbi->BulkInEndpoint, &EndPoint, sizeof (EndPoint));
      }
 
      if (USB_IS_OUT_ENDPOINT (EndPoint.EndpointAddress) &&
          (UsbCbi->BulkOutEndpoint == NULL))
      {
        UsbCbi->BulkOutEndpoint = (EFI_USB_ENDPOINT_DESCRIPTOR *)(UsbCbi + 1) + 1;
        CopyMem (UsbCbi->BulkOutEndpoint, &EndPoint, sizeof (EndPoint));
      }
    } else if (USB_IS_INTERRUPT_ENDPOINT (EndPoint.Attributes)) {
      //
      // Use the first interrupt endpoint if it is CBI0
      //
      if ((Interface->InterfaceProtocol == USB_MASS_STORE_CBI0) &&
          (UsbCbi->InterruptEndpoint == NULL))
      {
        UsbCbi->InterruptEndpoint = (EFI_USB_ENDPOINT_DESCRIPTOR *)(UsbCbi + 1) + 2;
        CopyMem (UsbCbi->InterruptEndpoint, &EndPoint, sizeof (EndPoint));
      }
    }
  }
 
  if ((UsbCbi->BulkInEndpoint == NULL) || (UsbCbi->BulkOutEndpoint == NULL)) {
    Status = EFI_UNSUPPORTED;
    goto ON_ERROR;
  }
 
  if ((Interface->InterfaceProtocol == USB_MASS_STORE_CBI0) && (UsbCbi->InterruptEndpoint == NULL)) {
    Status = EFI_UNSUPPORTED;
    goto ON_ERROR;
  }
 
  if (Context != NULL) {
    *Context = UsbCbi;
  } else {
    FreePool (UsbCbi);
  }
 
  return EFI_SUCCESS;
 
ON_ERROR:
  FreePool (UsbCbi);
  return Status;
}
 
EFI_STATUS
UsbCbiSendCommand (
  IN USB_CBI_PROTOCOL  *UsbCbi,
  IN UINT8             *Cmd,
  IN UINT8             CmdLen,
  IN UINT32            Timeout
  )
{
  EFI_USB_DEVICE_REQUEST  Request;
  EFI_STATUS              Status;
  UINT32                  TransStatus;
  UINTN                   DataLen;
  INTN                    Retry;
 
  //
  // Fill in the device request, CBI use the "Accept Device-Specific
  // Cmd" (ADSC) class specific request to send commands.
  //
  Request.RequestType = 0x21;
  Request.Request     = 0;
  Request.Value       = 0;
  Request.Index       = UsbCbi->Interface.InterfaceNumber;
  Request.Length      = CmdLen;
 
  Status  = EFI_SUCCESS;
  Timeout = Timeout / USB_MASS_1_MILLISECOND;
 
  for (Retry = 0; Retry < USB_CBI_MAX_RETRY; Retry++) {
    //
    // Use USB I/O Protocol to send the command to the device
    //
    TransStatus = 0;
    DataLen     = CmdLen;
 
    Status = UsbCbi->UsbIo->UsbControlTransfer (
                              UsbCbi->UsbIo,
                              &Request,
                              EfiUsbDataOut,
                              Timeout,
                              Cmd,
                              DataLen,
                              &TransStatus
                              );
    //
    // The device can fail the command by STALL the control endpoint.
    // It can delay the command by NAK the data or status stage, this
    // is a "class-specific exemption to the USB specification". Retry
    // if the command is NAKed.
    //
    if (EFI_ERROR (Status) && (TransStatus == EFI_USB_ERR_NAK)) {
      continue;
    }
 
    break;
  }
 
  return Status;
}
 
EFI_STATUS
UsbCbiDataTransfer (
  IN USB_CBI_PROTOCOL        *UsbCbi,
  IN EFI_USB_DATA_DIRECTION  DataDir,
  IN OUT UINT8               *Data,
  IN OUT UINTN               *TransLen,
  IN UINT32                  Timeout
  )
{
  EFI_USB_ENDPOINT_DESCRIPTOR  *Endpoint;
  EFI_STATUS                   Status;
  UINT32                       TransStatus;
  UINTN                        Remain;
  UINTN                        Increment;
  UINT8                        *Next;
  UINTN                        Retry;
 
  //
  // If no data to transfer, just return EFI_SUCCESS.
  //
  if ((DataDir == EfiUsbNoData) || (*TransLen == 0)) {
    return EFI_SUCCESS;
  }
 
  //
  // Select the endpoint then issue the transfer
  //
  if (DataDir == EfiUsbDataIn) {
    Endpoint = UsbCbi->BulkInEndpoint;
  } else {
    Endpoint = UsbCbi->BulkOutEndpoint;
  }
 
  Next    = Data;
  Remain  = *TransLen;
  Retry   = 0;
  Status  = EFI_SUCCESS;
  Timeout = Timeout / USB_MASS_1_MILLISECOND;
 
  //
  // Transfer the data with a loop. The length of data transferred once is restricted.
  //
  while (Remain > 0) {
    TransStatus = 0;
 
    if (Remain > (UINTN)USB_CBI_MAX_PACKET_NUM * Endpoint->MaxPacketSize) {
      Increment = USB_CBI_MAX_PACKET_NUM * Endpoint->MaxPacketSize;
    } else {
      Increment = Remain;
    }
 
    Status = UsbCbi->UsbIo->UsbBulkTransfer (
                              UsbCbi->UsbIo,
                              Endpoint->EndpointAddress,
                              Next,
                              &Increment,
                              Timeout,
                              &TransStatus
                              );
    if (EFI_ERROR (Status)) {
      if (TransStatus == EFI_USB_ERR_NAK) {
        //
        // The device can NAK the host if either the data/buffer isn't
        // available or the command is in-progress.
        // If data are partially transferred, we just ignore NAK and continue.
        // If all data have been transferred and status is NAK, then we retry for several times.
        // If retry exceeds the USB_CBI_MAX_RETRY, then return error status.
        //
        if (Increment == 0) {
          if (++Retry > USB_CBI_MAX_RETRY) {
            goto ON_EXIT;
          }
        } else {
          Next   += Increment;
          Remain -= Increment;
          Retry   = 0;
        }
 
        continue;
      }
 
      //
      // The device can fail the command by STALL the bulk endpoint.
      // Clear the stall if that is the case.
      //
      if (TransStatus == EFI_USB_ERR_STALL) {
        UsbClearEndpointStall (UsbCbi->UsbIo, Endpoint->EndpointAddress);
      }
 
      goto ON_EXIT;
    }
 
    Next   += Increment;
    Remain -= Increment;
  }
 
ON_EXIT:
  *TransLen -= Remain;
  return Status;
}
 
EFI_STATUS
UsbCbiGetStatus (
  IN  USB_CBI_PROTOCOL  *UsbCbi,
  IN  UINT32            Timeout,
  OUT USB_CBI_STATUS    *Result
  )
{
  UINTN       Len;
  UINT8       Endpoint;
  EFI_STATUS  Status;
  UINT32      TransStatus;
  INTN        Retry;
 
  Endpoint = UsbCbi->InterruptEndpoint->EndpointAddress;
  Status   = EFI_SUCCESS;
  Timeout  = Timeout / USB_MASS_1_MILLISECOND;
 
  //
  // Attempt to the read the result from interrupt endpoint
  //
  for (Retry = 0; Retry < USB_CBI_MAX_RETRY; Retry++) {
    TransStatus = 0;
    Len         = sizeof (USB_CBI_STATUS);
 
    Status = UsbCbi->UsbIo->UsbSyncInterruptTransfer (
                              UsbCbi->UsbIo,
                              Endpoint,
                              Result,
                              &Len,
                              Timeout,
                              &TransStatus
                              );
    //
    // The CBI can NAK the interrupt endpoint if the command is in-progress.
    //
    if (EFI_ERROR (Status) && (TransStatus == EFI_USB_ERR_NAK)) {
      continue;
    }
 
    break;
  }
 
  return Status;
}
 
EFI_STATUS
UsbCbiExecCommand (
  IN  VOID                    *Context,
  IN  VOID                    *Cmd,
  IN  UINT8                   CmdLen,
  IN  EFI_USB_DATA_DIRECTION  DataDir,
  IN  VOID                    *Data,
  IN  UINT32                  DataLen,
  IN  UINT8                   Lun,
  IN  UINT32                  Timeout,
  OUT UINT32                  *CmdStatus
  )
{
  USB_CBI_PROTOCOL  *UsbCbi;
  USB_CBI_STATUS    Result;
  EFI_STATUS        Status;
  UINTN             TransLen;
 
  *CmdStatus = USB_MASS_CMD_SUCCESS;
  UsbCbi     = (USB_CBI_PROTOCOL *)Context;
 
  //
  // Send the command to the device. Return immediately if device
  // rejects the command.
  //
  Status = UsbCbiSendCommand (UsbCbi, Cmd, CmdLen, Timeout);
  if (EFI_ERROR (Status)) {
    gBS->Stall (10 * USB_MASS_1_MILLISECOND);
    DEBUG ((DEBUG_ERROR, "UsbCbiExecCommand: UsbCbiSendCommand (%r)\n", Status));
    return Status;
  }
 
  //
  // Transfer the data. Return this status if no interrupt endpoint
  // is used to report the transfer status.
  //
  TransLen = (UINTN)DataLen;
 
  Status = UsbCbiDataTransfer (UsbCbi, DataDir, Data, &TransLen, Timeout);
  if (UsbCbi->InterruptEndpoint == NULL) {
    DEBUG ((DEBUG_ERROR, "UsbCbiExecCommand: UsbCbiDataTransfer (%r)\n", Status));
    return Status;
  }
 
  //
  // Get the status. If it succeeds, interpret the result.
  //
  Status = UsbCbiGetStatus (UsbCbi, Timeout, &Result);
  if (EFI_ERROR (Status)) {
    DEBUG ((DEBUG_ERROR, "UsbCbiExecCommand: UsbCbiGetStatus (%r)\n", Status));
    return Status;
  }
 
  if (UsbCbi->Interface.InterfaceSubClass == USB_MASS_STORE_UFI) {
    //
    // For UFI device, ASC and ASCQ are returned.
    //
    // Do not set the USB_MASS_CMD_FAIL for a request sense command
    // as a bad result type doesn't mean a cmd failure
    //
    if ((Result.Type != 0) && (*(UINT8 *)Cmd != 0x03)) {
      *CmdStatus = USB_MASS_CMD_FAIL;
    }
  } else {
    //
    // Check page 27, CBI spec 1.1 for vaious reture status.
    //
    switch (Result.Value & 0x03) {
      case 0x00:
        //
        // Pass
        //
        *CmdStatus = USB_MASS_CMD_SUCCESS;
        break;
 
      case 0x02:
        //
        // Phase Error, response with reset.
        // No break here to fall through to "Fail".
        //
        UsbCbiResetDevice (UsbCbi, FALSE);
 
      case 0x01:
        //
        // Fail
        //
        *CmdStatus = USB_MASS_CMD_FAIL;
        break;
 
      case 0x03:
        //
        // Persistent Fail. Need to send REQUEST SENSE.
        //
        *CmdStatus = USB_MASS_CMD_PERSISTENT;
        break;
    }
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
UsbCbiResetDevice (
  IN  VOID     *Context,
  IN  BOOLEAN  ExtendedVerification
  )
{
  UINT8             ResetCmd[USB_CBI_RESET_CMD_LEN];
  USB_CBI_PROTOCOL  *UsbCbi;
  USB_CBI_STATUS    Result;
  EFI_STATUS        Status;
  UINT32            Timeout;
 
  UsbCbi = (USB_CBI_PROTOCOL *)Context;
 
  //
  // Fill in the reset command.
  //
  SetMem (ResetCmd, USB_CBI_RESET_CMD_LEN, 0xFF);
 
  ResetCmd[0] = 0x1D;
  ResetCmd[1] = 0x04;
  Timeout     = USB_CBI_RESET_DEVICE_TIMEOUT / USB_MASS_1_MILLISECOND;
 
  //
  // Send the command to the device. Don't use UsbCbiExecCommand here.
  //
  Status = UsbCbiSendCommand (UsbCbi, ResetCmd, USB_CBI_RESET_CMD_LEN, Timeout);
  if (EFI_ERROR (Status)) {
    return EFI_DEVICE_ERROR;
  }
 
  //
  // Just retrieve the status and ignore that. Then stall
  // 50ms to wait for it to complete.
  //
  UsbCbiGetStatus (UsbCbi, Timeout, &Result);
  gBS->Stall (USB_CBI_RESET_DEVICE_STALL);
 
  //
  // Clear the Bulk-In and Bulk-Out stall condition and init data toggle.
  //
  UsbClearEndpointStall (UsbCbi->UsbIo, UsbCbi->BulkInEndpoint->EndpointAddress);
  UsbClearEndpointStall (UsbCbi->UsbIo, UsbCbi->BulkOutEndpoint->EndpointAddress);
 
  return Status;
}
 
EFI_STATUS
UsbCbiCleanUp (
  IN  VOID  *Context
  )
{
  FreePool (Context);
  return EFI_SUCCESS;
}