[mirror_edk2.git] / MdeModulePkg / Bus / Usb / UsbMassStorageDxe / UsbMassCbi.c

/** @file\r
\r
Copyright (c) 2007, Intel Corporation\r
All rights reserved. This program and the accompanying materials\r
are licensed and made available under the terms and conditions of the BSD License\r
which accompanies this distribution.  The full text of the license may be found at\r
http://opensource.org/licenses/bsd-license.php\r
\r
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
\r
Module Name:\r
\r
  UsbMassCbi.c\r
\r
Abstract:\r
\r
  Implementation of the USB mass storage Control/Bulk/Interrupt transpor.\r
  Notice: it is being obseleted by the standard body in favor of the BOT\r
  (Bulk-Only Transport).\r
\r
Revision History\r
\r
\r
**/\r
\r
#include "UsbMass.h"\r
#include "UsbMassCbi.h"\r
\r
STATIC\r
EFI_STATUS\r
UsbCbiResetDevice (\r
  IN  VOID                    *Context,\r
  IN  BOOLEAN                  ExtendedVerification\r
  );\r
\r
\r
/**\r
  Initialize the USB mass storage class CBI transport protocol.\r
  If Context isn't NULL, it will save its context in it.\r
\r
  @param  UsbIo                 The USB IO to use\r
  @param  Controller            The device controller\r
  @param  Context               The variable to save context in\r
\r
  @retval EFI_OUT_OF_RESOURCES  Failed to allocate memory\r
  @retval EFI_UNSUPPORTED       The device isn't supported\r
  @retval EFI_SUCCESS           The CBI protocol is initialized.\r
\r
**/\r
STATIC\r
EFI_STATUS\r
UsbCbiInit (\r
  IN  EFI_USB_IO_PROTOCOL   *UsbIo,\r
  IN  EFI_HANDLE            Controller,\r
  OUT VOID                  **Context       OPTIONAL\r
  )\r
{\r
  USB_CBI_PROTOCOL              *UsbCbi;\r
  EFI_USB_INTERFACE_DESCRIPTOR  *Interface;\r
  EFI_USB_ENDPOINT_DESCRIPTOR   EndPoint;\r
  EFI_STATUS                    Status;\r
  UINT8                         Index;\r
\r
  //\r
  // Allocate the CBI context\r
  //\r
  UsbCbi = AllocateZeroPool (\r
             sizeof (USB_CBI_PROTOCOL) + 3 * sizeof (EFI_USB_ENDPOINT_DESCRIPTOR)\r
             );\r
\r
  if (UsbCbi == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  UsbCbi->UsbIo = UsbIo;\r
\r
  //\r
  // Get the interface descriptor and validate that it is a USB mass\r
  // storage class CBI interface.\r
  //\r
  Status = UsbIo->UsbGetInterfaceDescriptor (UsbIo, &UsbCbi->Interface);\r
  if (EFI_ERROR (Status)) {\r
    goto ON_ERROR;\r
  }\r
\r
  Interface = &UsbCbi->Interface;\r
  if ((Interface->InterfaceProtocol != USB_MASS_STORE_CBI0)\r
      && (Interface->InterfaceProtocol != USB_MASS_STORE_CBI1)) {\r
    Status = EFI_UNSUPPORTED;\r
    goto ON_ERROR;\r
  }\r
\r
  //\r
  // Locate and save the bulk-in, bulk-out, and interrupt endpoint\r
  //\r
  for (Index = 0; Index < Interface->NumEndpoints; Index++) {\r
    Status = UsbIo->UsbGetEndpointDescriptor (UsbIo, Index, &EndPoint);\r
    if (EFI_ERROR (Status)) {\r
      continue;\r
    }\r
\r
    if (USB_IS_BULK_ENDPOINT (EndPoint.Attributes)) {\r
      //\r
      // Use the first Bulk-In and Bulk-Out endpoints\r
      //\r
      if (USB_IS_IN_ENDPOINT (EndPoint.EndpointAddress) &&\r
         (UsbCbi->BulkInEndpoint == NULL)) {\r
\r
        UsbCbi->BulkInEndpoint  = (EFI_USB_ENDPOINT_DESCRIPTOR *) (UsbCbi + 1);\r
        CopyMem(UsbCbi->BulkInEndpoint, &EndPoint, sizeof (EndPoint));;\r
      }\r
\r
      if (USB_IS_OUT_ENDPOINT (EndPoint.EndpointAddress) &&\r
         (UsbCbi->BulkOutEndpoint == NULL)) {\r
\r
        UsbCbi->BulkOutEndpoint   = (EFI_USB_ENDPOINT_DESCRIPTOR *) (UsbCbi + 1) + 1;\r
        CopyMem(UsbCbi->BulkOutEndpoint, &EndPoint, sizeof (EndPoint));\r
      }\r
\r
    } else if (USB_IS_INTERRUPT_ENDPOINT (EndPoint.Attributes)) {\r
      //\r
      // Use the first interrupt endpoint if it is CBI0\r
      //\r
      if ((Interface->InterfaceProtocol == USB_MASS_STORE_CBI0) &&\r
          (UsbCbi->InterruptEndpoint == NULL)) {\r
\r
        UsbCbi->InterruptEndpoint   = (EFI_USB_ENDPOINT_DESCRIPTOR *) (UsbCbi + 1) + 2;\r
        CopyMem(UsbCbi->InterruptEndpoint, &EndPoint, sizeof (EndPoint));\r
      }\r
    }\r
  }\r
\r
  if ((UsbCbi->BulkInEndpoint == NULL)\r
      || (UsbCbi->BulkOutEndpoint == NULL)\r
      || ((Interface->InterfaceProtocol == USB_MASS_STORE_CBI0)\r
          && (UsbCbi->InterruptEndpoint == NULL))) {\r
    Status = EFI_UNSUPPORTED;\r
    goto ON_ERROR;\r
  }\r
\r
  if (Context != NULL) {\r
    *Context = UsbCbi;\r
  } else {\r
    gBS->FreePool (UsbCbi);\r
  }\r
  return EFI_SUCCESS;\r
\r
ON_ERROR:\r
  gBS->FreePool (UsbCbi);\r
  return Status;\r
}\r
\r
\r
\r
/**\r
  Send the command to the device using class specific control transfer.\r
\r
  @param  UsbCbi                The USB CBI protocol\r
  @param  Cmd                   The high level command to transfer to device\r
  @param  CmdLen                The length of the command\r
  @param  Timeout               The time to wait the command to finish\r
\r
  @retval EFI_SUCCESS           The command is transferred to device\r
  @retval Others                The command failed to transfer to device\r
\r
**/\r
STATIC\r
EFI_STATUS\r
UsbCbiSendCommand (\r
  IN USB_CBI_PROTOCOL       *UsbCbi,\r
  IN UINT8                  *Cmd,\r
  IN UINT8                  CmdLen,\r
  IN UINT32                 Timeout\r
  )\r
{\r
  EFI_USB_DEVICE_REQUEST  Request;\r
  EFI_STATUS              Status;\r
  UINT32                  TransStatus;\r
  UINTN                   DataLen;\r
  INTN                    Retry;\r
\r
  //\r
  // Fill in the device request, CBI use the "Accept Device-Specific\r
  // Cmd" (ADSC) class specific request to send commands\r
  //\r
  Request.RequestType = 0x21;\r
  Request.Request     = 0;\r
  Request.Value       = 0;\r
  Request.Index       = UsbCbi->Interface.InterfaceNumber;\r
  Request.Length      = CmdLen;\r
\r
  Status              = EFI_SUCCESS;\r
  Timeout             = Timeout / USB_MASS_1_MILLISECOND;\r
\r
  for (Retry = 0; Retry < USB_CBI_MAX_RETRY; Retry++) {\r
    //\r
    // Use the UsbIo to send the command to the device\r
    //\r
    TransStatus = 0;\r
    DataLen     = CmdLen;\r
\r
    Status = UsbCbi->UsbIo->UsbControlTransfer (\r
                              UsbCbi->UsbIo,\r
                              &Request,\r
                              EfiUsbDataOut,\r
                              Timeout,\r
                              Cmd,\r
                              DataLen,\r
                              &TransStatus\r
                              );\r
    //\r
    // The device can fail the command by STALL the control endpoint.\r
    // It can delay the command by NAK the data or status stage, this\r
    // is a "class-specific exemption to the USB specification". Retry\r
    // if the command is NAKed.\r
    //\r
    if (EFI_ERROR (Status) && (TransStatus == EFI_USB_ERR_NAK)) {\r
      continue;\r
    }\r
\r
    break;\r
  }\r
\r
  return Status;\r
}\r
\r
\r
/**\r
  Transfer data between the device and host. The CBI contains three phase,\r
  command, data, and status. This is data phase.\r
\r
  @param  UsbCbi                The USB CBI device\r
  @param  DataDir               The direction of the data transfer\r
  @param  Data                  The buffer to hold the data\r
  @param  TransLen              The expected transfer length\r
  @param  Timeout               The time to wait the command to execute\r
\r
  @retval EFI_SUCCESS           The data transfer succeeded\r
  @retval Others                Failed to transfer all the data\r
\r
**/\r
STATIC\r
EFI_STATUS\r
UsbCbiDataTransfer (\r
  IN USB_CBI_PROTOCOL         *UsbCbi,\r
  IN EFI_USB_DATA_DIRECTION   DataDir,\r
  IN OUT UINT8                *Data,\r
  IN OUT UINTN                *TransLen,\r
  IN UINT32                   Timeout\r
  )\r
{\r
  EFI_USB_ENDPOINT_DESCRIPTOR *Endpoint;\r
  EFI_STATUS                  Status;\r
  UINT32                      TransStatus;\r
  UINTN                       Remain;\r
  UINTN                       Increment;\r
  UINT8                       *Next;\r
  UINTN                       Retry;\r
\r
  //\r
  // It's OK if no data to transfer\r
  //\r
  if ((DataDir == EfiUsbNoData) || (*TransLen == 0)) {\r
    return EFI_SUCCESS;\r
  }\r
\r
  //\r
  // Select the endpoint then issue the transfer\r
  //\r
  if (DataDir == EfiUsbDataIn) {\r
    Endpoint = UsbCbi->BulkInEndpoint;\r
  } else {\r
    Endpoint = UsbCbi->BulkOutEndpoint;\r
  }\r
\r
  Next    = Data;\r
  Remain  = *TransLen;\r
  Retry   = 0;\r
  Status  = EFI_SUCCESS;\r
  Timeout = Timeout / USB_MASS_1_MILLISECOND;\r
\r
  //\r
  // Transfer the data, if the device returns NAK, retry it.\r
  //\r
  while (Remain > 0) {\r
    TransStatus = 0;\r
\r
    if (Remain > (UINTN) USB_CBI_MAX_PACKET_NUM * Endpoint->MaxPacketSize) {\r
      Increment = USB_CBI_MAX_PACKET_NUM * Endpoint->MaxPacketSize;\r
    } else {\r
      Increment = Remain;\r
    }\r
\r
    Status = UsbCbi->UsbIo->UsbBulkTransfer (\r
                              UsbCbi->UsbIo,\r
                              Endpoint->EndpointAddress,\r
                              Next,\r
                              &Increment,\r
                              Timeout,\r
                              &TransStatus\r
                              );\r
    if (EFI_ERROR (Status)) {\r
      if (TransStatus == EFI_USB_ERR_NAK) {\r
        //\r
        // The device can NAK the host if either the data/buffer isn't\r
        // aviable or the command is in-progress. The data can be partly\r
        // transferred. The transfer is aborted if several succssive data\r
        // transfer commands are NAKed.\r
        //\r
        if (Increment == 0) {\r
          if (++Retry > USB_CBI_MAX_RETRY) {\r
            goto ON_EXIT;\r
          }\r
\r
        } else {\r
          Next   += Increment;\r
          Remain -= Increment;\r
          Retry   = 0;\r
        }\r
\r
        continue;\r
      }\r
\r
      //\r
      // The device can fail the command by STALL the bulk endpoint.\r
      // Clear the stall if that is the case.\r
      //\r
      if (TransStatus == EFI_USB_ERR_STALL) {\r
        UsbClearEndpointStall (UsbCbi->UsbIo, Endpoint->EndpointAddress);\r
      }\r
\r
      goto ON_EXIT;\r
    }\r
\r
    Next += Increment;\r
    Remain -= Increment;\r
  }\r
\r
ON_EXIT:\r
  *TransLen -= Remain;\r
  return Status;\r
}\r
\r
\r
/**\r
  Get the result of high level command execution from interrupt\r
  endpoint. This function returns the USB transfer status, and\r
  put the high level command execution result in Result.\r
\r
  @param  UsbCbi                The USB CBI protocol\r
  @param  Timeout               The time to wait the command to execute\r
  @param  Result                GC_TODO: add argument description\r
\r
  @retval EFI_SUCCESS           The high level command execution result is\r
                                retrieved in Result.\r
  @retval Others                Failed to retrieve the result.\r
\r
**/\r
STATIC\r
EFI_STATUS\r
UsbCbiGetStatus (\r
  IN  USB_CBI_PROTOCOL        *UsbCbi,\r
  IN  UINT32                  Timeout,\r
  OUT USB_CBI_STATUS          *Result\r
  )\r
{\r
  UINTN                     Len;\r
  UINT8                     Endpoint;\r
  EFI_STATUS                Status;\r
  UINT32                    TransStatus;\r
  INTN                      Retry;\r
\r
  Endpoint  = UsbCbi->InterruptEndpoint->EndpointAddress;\r
  Status    = EFI_SUCCESS;\r
  Timeout   = Timeout / USB_MASS_1_MILLISECOND;\r
\r
  //\r
  // Attemp to the read the result from interrupt endpoint\r
  //\r
  for (Retry = 0; Retry < USB_CBI_MAX_RETRY; Retry++) {\r
    TransStatus = 0;\r
    Len         = sizeof (USB_CBI_STATUS);\r
\r
    Status = UsbCbi->UsbIo->UsbSyncInterruptTransfer (\r
                              UsbCbi->UsbIo,\r
                              Endpoint,\r
                              Result,\r
                              &Len,\r
                              Timeout,\r
                              &TransStatus\r
                              );\r
    //\r
    // The CBI can NAK the interrupt endpoint if the command is in-progress.\r
    //\r
    if (EFI_ERROR (Status) && (TransStatus == EFI_USB_ERR_NAK)) {\r
      continue;\r
    }\r
\r
    break;\r
  }\r
\r
  return Status;\r
}\r
\r
\r
/**\r
  Execute USB mass storage command through the CBI0/CBI1 transport protocol\r
\r
  @param  Context               The USB CBI device\r
  @param  Cmd                   The command to transfer to device\r
  @param  CmdLen                The length of the command\r
  @param  DataDir               The direction of data transfer\r
  @param  Data                  The buffer to hold the data\r
  @param  DataLen               The length of the buffer\r
  @param  Timeout               The time to wait\r
  @param  CmdStatus             The result of the command execution\r
\r
  @retval EFI_SUCCESS           The command is executed OK and result in CmdStatus.\r
  @retval EFI_DEVICE_ERROR      Failed to execute the command\r
\r
**/\r
STATIC\r
EFI_STATUS\r
UsbCbiExecCommand (\r
  IN  VOID                    *Context,\r
  IN  VOID                    *Cmd,\r
  IN  UINT8                   CmdLen,\r
  IN  EFI_USB_DATA_DIRECTION  DataDir,\r
  IN  VOID                    *Data,\r
  IN  UINT32                  DataLen,\r
  IN  UINT32                  Timeout,\r
  OUT UINT32                  *CmdStatus\r
  )\r
{\r
  USB_CBI_PROTOCOL          *UsbCbi;\r
  USB_CBI_STATUS            Result;\r
  EFI_STATUS                Status;\r
  UINTN                     TransLen;\r
\r
  *CmdStatus  = USB_MASS_CMD_SUCCESS;\r
  UsbCbi      = (USB_CBI_PROTOCOL *) Context;\r
\r
  //\r
  // Send the command to the device. Return immediately if device\r
  // rejects the command.\r
  //\r
  Status = UsbCbiSendCommand (UsbCbi, Cmd, CmdLen, Timeout);\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((EFI_D_ERROR, "UsbCbiExecCommand: UsbCbiSendCommand (%r)\n",Status));\r
    return Status;\r
  }\r
\r
  //\r
  // Transfer the data, return this status if no interrupt endpoint\r
  // is used to report the transfer status.\r
  //\r
  TransLen = (UINTN) DataLen;\r
\r
  Status   = UsbCbiDataTransfer (UsbCbi, DataDir, Data, &TransLen, Timeout);\r
  if (UsbCbi->InterruptEndpoint == NULL) {\r
    DEBUG ((EFI_D_ERROR, "UsbCbiExecCommand: UsbCbiDataTransfer (%r)\n",Status));\r
    return Status;\r
  }\r
\r
  //\r
  // Get the status, if that succeeds, interpret the result\r
  //\r
  Status = UsbCbiGetStatus (UsbCbi, Timeout, &Result);\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((EFI_D_ERROR, "UsbCbiExecCommand: UsbCbiGetStatus (%r)\n",Status));\r
    return EFI_DEVICE_ERROR;\r
  }\r
\r
  if (UsbCbi->Interface.InterfaceSubClass == USB_MASS_STORE_UFI) {\r
    //\r
    // For UFI device, ASC and ASCQ are returned.\r
    //\r
    if (Result.Type != 0) {\r
      *CmdStatus = USB_MASS_CMD_FAIL;\r
    }\r
\r
  } else {\r
    //\r
    // Check page 27, CBI spec 1.1 for vaious reture status.\r
    //\r
    switch (Result.Value & 0x03) {\r
    case 0x00:\r
      //\r
      // Pass\r
      //\r
      *CmdStatus = USB_MASS_CMD_SUCCESS;\r
      break;\r
\r
    case 0x02:\r
      //\r
      // Phase Error, response with reset. Fall through to Fail.\r
      //\r
      UsbCbiResetDevice (UsbCbi, FALSE);\r
\r
    case 0x01:\r
      //\r
      // Fail\r
      //\r
      *CmdStatus = USB_MASS_CMD_FAIL;\r
      break;\r
\r
    case 0x03:\r
      //\r
      // Persistent Fail, need to send REQUEST SENSE.\r
      //\r
      *CmdStatus = USB_MASS_CMD_PERSISTENT;\r
      break;\r
    }\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
\r
/**\r
  Call the Usb mass storage class transport protocol to\r
  reset the device. The reset is defined as a Non-Data\r
  command. Don't use UsbCbiExecCommand to send the command\r
  to device because that may introduce recursive loop.\r
\r
  @param  Context               The USB CBI device protocol\r
\r
  @retval EFI_SUCCESS           the device is reset\r
  @retval Others                Failed to reset the device\r
\r
**/\r
STATIC\r
EFI_STATUS\r
UsbCbiResetDevice (\r
  IN  VOID                    *Context,\r
  IN  BOOLEAN                  ExtendedVerification\r
  )\r
{\r
  UINT8                     ResetCmd[USB_CBI_RESET_CMD_LEN];\r
  USB_CBI_PROTOCOL          *UsbCbi;\r
  USB_CBI_STATUS            Result;\r
  EFI_STATUS                Status;\r
  UINT32                    Timeout;\r
\r
  UsbCbi = (USB_CBI_PROTOCOL *) Context;\r
\r
  //\r
  // Fill in the reset command.\r
  //\r
  SetMem (ResetCmd, USB_CBI_RESET_CMD_LEN, 0xFF);\r
\r
  ResetCmd[0] = 0x1D;\r
  ResetCmd[1] = 0x04;\r
  Timeout     = USB_CBI_RESET_DEVICE_TIMEOUT / USB_MASS_1_MILLISECOND;\r
\r
  //\r
  // Send the command to the device. Don't use UsbCbiExecCommand here.\r
  //\r
  Status = UsbCbiSendCommand (UsbCbi, ResetCmd, USB_CBI_RESET_CMD_LEN, Timeout);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  //\r
  // Just retrieve the status and ignore that. Then stall\r
  // 50ms to wait it complete\r
  //\r
  UsbCbiGetStatus (UsbCbi, Timeout, &Result);\r
  gBS->Stall (USB_CBI_RESET_DEVICE_STALL);\r
\r
  //\r
  // Clear the Bulk-In and Bulk-Out stall condition and\r
  // init data toggle.\r
  //\r
  UsbClearEndpointStall (UsbCbi->UsbIo, UsbCbi->BulkInEndpoint->EndpointAddress);\r
  UsbClearEndpointStall (UsbCbi->UsbIo, UsbCbi->BulkOutEndpoint->EndpointAddress);\r
  return Status;\r
}\r
\r
\r
/**\r
  Clean up the CBI protocol's resource\r
\r
  @param  Context               The CBI protocol\r
\r
  @retval EFI_SUCCESS           The resource is cleaned up.\r
\r
**/\r
STATIC\r
EFI_STATUS\r
UsbCbiFini (\r
  IN  VOID                   *Context\r
  )\r
{\r
  gBS->FreePool (Context);\r
  return EFI_SUCCESS;\r
}\r
\r
USB_MASS_TRANSPORT\r
mUsbCbi0Transport = {\r
  USB_MASS_STORE_CBI0,\r
  UsbCbiInit,\r
  UsbCbiExecCommand,\r
  UsbCbiResetDevice,\r
  UsbCbiFini\r
};\r
\r
USB_MASS_TRANSPORT\r
mUsbCbi1Transport = {\r
  USB_MASS_STORE_CBI1,\r
  UsbCbiInit,\r
  UsbCbiExecCommand,\r
  UsbCbiResetDevice,\r
  UsbCbiFini\r
};\r
Commit	Line	Data
e237e7ae	1	/** @file\r
	2	\r
	3	Copyright (c) 2007, Intel Corporation\r
	4	All rights reserved. This program and the accompanying materials\r
	5	are licensed and made available under the terms and conditions of the BSD License\r
	6	which accompanies this distribution. The full text of the license may be found at\r
	7	http://opensource.org/licenses/bsd-license.php\r
	8	\r
	9	THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
	10	WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
	11	\r
	12	Module Name:\r
	13	\r
	14	UsbMassCbi.c\r
	15	\r
	16	Abstract:\r
	17	\r
	18	Implementation of the USB mass storage Control/Bulk/Interrupt transpor.\r
	19	Notice: it is being obseleted by the standard body in favor of the BOT\r
	20	(Bulk-Only Transport).\r
	21	\r
	22	Revision History\r
	23	\r
	24	\r
	25	**/\r
	26	\r
	27	#include "UsbMass.h"\r
	28	#include "UsbMassCbi.h"\r
	29	\r
e237e7ae	30	STATIC\r
	31	EFI_STATUS\r
	32	UsbCbiResetDevice (\r
	33	IN VOID *Context,\r
	34	IN BOOLEAN ExtendedVerification\r
	35	);\r
	36	\r
	37	\r
	38	/**\r
	39	Initialize the USB mass storage class CBI transport protocol.\r
	40	If Context isn't NULL, it will save its context in it.\r
	41	\r
	42	@param UsbIo The USB IO to use\r
	43	@param Controller The device controller\r
	44	@param Context The variable to save context in\r
	45	\r
	46	@retval EFI_OUT_OF_RESOURCES Failed to allocate memory\r
	47	@retval EFI_UNSUPPORTED The device isn't supported\r
	48	@retval EFI_SUCCESS The CBI protocol is initialized.\r
	49	\r
	50	**/\r
	51	STATIC\r
	52	EFI_STATUS\r
	53	UsbCbiInit (\r
	54	IN EFI_USB_IO_PROTOCOL *UsbIo,\r
	55	IN EFI_HANDLE Controller,\r
	56	OUT VOID **Context OPTIONAL\r
	57	)\r
	58	{\r
	59	USB_CBI_PROTOCOL *UsbCbi;\r
	60	EFI_USB_INTERFACE_DESCRIPTOR *Interface;\r
	61	EFI_USB_ENDPOINT_DESCRIPTOR EndPoint;\r
	62	EFI_STATUS Status;\r
	63	UINT8 Index;\r
	64	\r
	65	//\r
	66	// Allocate the CBI context\r
	67	//\r
	68	UsbCbi = AllocateZeroPool (\r
	69	sizeof (USB_CBI_PROTOCOL) + 3 * sizeof (EFI_USB_ENDPOINT_DESCRIPTOR)\r
	70	);\r
	71	\r
	72	if (UsbCbi == NULL) {\r
	73	return EFI_OUT_OF_RESOURCES;\r
	74	}\r
	75	\r
	76	UsbCbi->UsbIo = UsbIo;\r
	77	\r
	78	//\r
	79	// Get the interface descriptor and validate that it is a USB mass\r
	80	// storage class CBI interface.\r
	81	//\r
	82	Status = UsbIo->UsbGetInterfaceDescriptor (UsbIo, &UsbCbi->Interface);\r
	83	if (EFI_ERROR (Status)) {\r
	84	goto ON_ERROR;\r
	85	}\r
	86	\r
	87	Interface = &UsbCbi->Interface;\r
	88	if ((Interface->InterfaceProtocol != USB_MASS_STORE_CBI0)\r
	89	&& (Interface->InterfaceProtocol != USB_MASS_STORE_CBI1)) {\r
	90	Status = EFI_UNSUPPORTED;\r
	91	goto ON_ERROR;\r
	92	}\r
	93	\r
94	//\r
95	// Locate and save the bulk-in, bulk-out, and interrupt endpoint\r
96	//\r
97	for (Index = 0; Index < Interface->NumEndpoints; Index++) {\r
98	Status = UsbIo->UsbGetEndpointDescriptor (UsbIo, Index, &EndPoint);\r
99	if (EFI_ERROR (Status)) {\r
100	continue;\r
101	}\r
102	\r
103	if (USB_IS_BULK_ENDPOINT (EndPoint.Attributes)) {\r
104	//\r
105	// Use the first Bulk-In and Bulk-Out endpoints\r
106	//\r
107	if (USB_IS_IN_ENDPOINT (EndPoint.EndpointAddress) &&\r
108	(UsbCbi->BulkInEndpoint == NULL)) {\r
109	\r
110	UsbCbi->BulkInEndpoint = (EFI_USB_ENDPOINT_DESCRIPTOR *) (UsbCbi + 1);\r
84b5c78e	111	CopyMem(UsbCbi->BulkInEndpoint, &EndPoint, sizeof (EndPoint));;\r
e237e7ae	112	}\r
	113	\r
	114	if (USB_IS_OUT_ENDPOINT (EndPoint.EndpointAddress) &&\r
	115	(UsbCbi->BulkOutEndpoint == NULL)) {\r
	116	\r
	117	UsbCbi->BulkOutEndpoint = (EFI_USB_ENDPOINT_DESCRIPTOR *) (UsbCbi + 1) + 1;\r
84b5c78e	118	CopyMem(UsbCbi->BulkOutEndpoint, &EndPoint, sizeof (EndPoint));\r
e237e7ae	119	}\r
	120	\r
	121	} else if (USB_IS_INTERRUPT_ENDPOINT (EndPoint.Attributes)) {\r
	122	//\r
	123	// Use the first interrupt endpoint if it is CBI0\r
	124	//\r
	125	if ((Interface->InterfaceProtocol == USB_MASS_STORE_CBI0) &&\r
	126	(UsbCbi->InterruptEndpoint == NULL)) {\r
	127	\r
	128	UsbCbi->InterruptEndpoint = (EFI_USB_ENDPOINT_DESCRIPTOR *) (UsbCbi + 1) + 2;\r
84b5c78e	129	CopyMem(UsbCbi->InterruptEndpoint, &EndPoint, sizeof (EndPoint));\r
e237e7ae	130	}\r
	131	}\r
	132	}\r
	133	\r
	134	if ((UsbCbi->BulkInEndpoint == NULL)\r
	135	\|\| (UsbCbi->BulkOutEndpoint == NULL)\r
	136	\|\| ((Interface->InterfaceProtocol == USB_MASS_STORE_CBI0)\r
	137	&& (UsbCbi->InterruptEndpoint == NULL))) {\r
	138	Status = EFI_UNSUPPORTED;\r
	139	goto ON_ERROR;\r
	140	}\r
	141	\r
	142	if (Context != NULL) {\r
	143	*Context = UsbCbi;\r
	144	} else {\r
	145	gBS->FreePool (UsbCbi);\r
	146	}\r
	147	return EFI_SUCCESS;\r
	148	\r
	149	ON_ERROR:\r
	150	gBS->FreePool (UsbCbi);\r
	151	return Status;\r
	152	}\r
	153	\r
	154	\r
	155	\r
	156	/**\r
	157	Send the command to the device using class specific control transfer.\r
	158	\r
	159	@param UsbCbi The USB CBI protocol\r
	160	@param Cmd The high level command to transfer to device\r
	161	@param CmdLen The length of the command\r
	162	@param Timeout The time to wait the command to finish\r
	163	\r
	164	@retval EFI_SUCCESS The command is transferred to device\r
	165	@retval Others The command failed to transfer to device\r
	166	\r
	167	**/\r
	168	STATIC\r
	169	EFI_STATUS\r
	170	UsbCbiSendCommand (\r
	171	IN USB_CBI_PROTOCOL *UsbCbi,\r
	172	IN UINT8 *Cmd,\r
	173	IN UINT8 CmdLen,\r
	174	IN UINT32 Timeout\r
	175	)\r
	176	{\r
	177	EFI_USB_DEVICE_REQUEST Request;\r
	178	EFI_STATUS Status;\r
	179	UINT32 TransStatus;\r
	180	UINTN DataLen;\r
	181	INTN Retry;\r
	182	\r
	183	//\r
	184	// Fill in the device request, CBI use the "Accept Device-Specific\r
	185	// Cmd" (ADSC) class specific request to send commands\r
	186	//\r
	187	Request.RequestType = 0x21;\r
	188	Request.Request = 0;\r
	189	Request.Value = 0;\r
	190	Request.Index = UsbCbi->Interface.InterfaceNumber;\r
	191	Request.Length = CmdLen;\r
	192	\r
	193	Status = EFI_SUCCESS;\r
41e8ff27	194	Timeout = Timeout / USB_MASS_1_MILLISECOND;\r
e237e7ae	195	\r
	196	for (Retry = 0; Retry < USB_CBI_MAX_RETRY; Retry++) {\r
	197	//\r
	198	// Use the UsbIo to send the command to the device\r
	199	//\r
	200	TransStatus = 0;\r
	201	DataLen = CmdLen;\r
	202	\r
	203	Status = UsbCbi->UsbIo->UsbControlTransfer (\r
	204	UsbCbi->UsbIo,\r
	205	&Request,\r
	206	EfiUsbDataOut,\r
	207	Timeout,\r
	208	Cmd,\r
	209	DataLen,\r
	210	&TransStatus\r
	211	);\r
	212	//\r
	213	// The device can fail the command by STALL the control endpoint.\r
	214	// It can delay the command by NAK the data or status stage, this\r
	215	// is a "class-specific exemption to the USB specification". Retry\r
	216	// if the command is NAKed.\r
	217	//\r
	218	if (EFI_ERROR (Status) && (TransStatus == EFI_USB_ERR_NAK)) {\r
	219	continue;\r
	220	}\r
	221	\r
	222	break;\r
	223	}\r
	224	\r
	225	return Status;\r
	226	}\r
	227	\r
	228	\r
	229	/**\r
	230	Transfer data between the device and host. The CBI contains three phase,\r
	231	command, data, and status. This is data phase.\r
	232	\r
	233	@param UsbCbi The USB CBI device\r
	234	@param DataDir The direction of the data transfer\r
	235	@param Data The buffer to hold the data\r
	236	@param TransLen The expected transfer length\r
	237	@param Timeout The time to wait the command to execute\r
	238	\r
	239	@retval EFI_SUCCESS The data transfer succeeded\r
	240	@retval Others Failed to transfer all the data\r
	241	\r
	242	**/\r
	243	STATIC\r
	244	EFI_STATUS\r
	245	UsbCbiDataTransfer (\r
	246	IN USB_CBI_PROTOCOL *UsbCbi,\r
	247	IN EFI_USB_DATA_DIRECTION DataDir,\r
	248	IN OUT UINT8 *Data,\r
	249	IN OUT UINTN *TransLen,\r
	250	IN UINT32 Timeout\r
	251	)\r
	252	{\r
	253	EFI_USB_ENDPOINT_DESCRIPTOR *Endpoint;\r
	254	EFI_STATUS Status;\r
	255	UINT32 TransStatus;\r
	256	UINTN Remain;\r
	257	UINTN Increment;\r
	258	UINT8 *Next;\r
259	UINTN Retry;\r
260	\r
261	//\r
262	// It's OK if no data to transfer\r
263	//\r
264	if ((DataDir == EfiUsbNoData) \|\| (*TransLen == 0)) {\r
265	return EFI_SUCCESS;\r
266	}\r
267	\r
268	//\r
269	// Select the endpoint then issue the transfer\r
270	//\r
271	if (DataDir == EfiUsbDataIn) {\r
272	Endpoint = UsbCbi->BulkInEndpoint;\r
273	} else {\r
274	Endpoint = UsbCbi->BulkOutEndpoint;\r
275	}\r
276	\r
277	Next = Data;\r
278	Remain = *TransLen;\r
279	Retry = 0;\r
280	Status = EFI_SUCCESS;\r
41e8ff27	281	Timeout = Timeout / USB_MASS_1_MILLISECOND;\r
e237e7ae	282	\r
	283	//\r
	284	// Transfer the data, if the device returns NAK, retry it.\r
	285	//\r
	286	while (Remain > 0) {\r
	287	TransStatus = 0;\r
	288	\r
	289	if (Remain > (UINTN) USB_CBI_MAX_PACKET_NUM * Endpoint->MaxPacketSize) {\r
	290	Increment = USB_CBI_MAX_PACKET_NUM * Endpoint->MaxPacketSize;\r
	291	} else {\r
	292	Increment = Remain;\r
	293	}\r
	294	\r
	295	Status = UsbCbi->UsbIo->UsbBulkTransfer (\r
	296	UsbCbi->UsbIo,\r
	297	Endpoint->EndpointAddress,\r
	298	Next,\r
	299	&Increment,\r
	300	Timeout,\r
	301	&TransStatus\r
	302	);\r
	303	if (EFI_ERROR (Status)) {\r
	304	if (TransStatus == EFI_USB_ERR_NAK) {\r
	305	//\r
	306	// The device can NAK the host if either the data/buffer isn't\r
	307	// aviable or the command is in-progress. The data can be partly\r
	308	// transferred. The transfer is aborted if several succssive data\r
	309	// transfer commands are NAKed.\r
	310	//\r
	311	if (Increment == 0) {\r
	312	if (++Retry > USB_CBI_MAX_RETRY) {\r
	313	goto ON_EXIT;\r
	314	}\r
	315	\r
	316	} else {\r
	317	Next += Increment;\r
	318	Remain -= Increment;\r
	319	Retry = 0;\r
	320	}\r
	321	\r
	322	continue;\r
	323	}\r
	324	\r
	325	//\r
	326	// The device can fail the command by STALL the bulk endpoint.\r
	327	// Clear the stall if that is the case.\r
	328	//\r
	329	if (TransStatus == EFI_USB_ERR_STALL) {\r
	330	UsbClearEndpointStall (UsbCbi->UsbIo, Endpoint->EndpointAddress);\r
	331	}\r
	332	\r
	333	goto ON_EXIT;\r
	334	}\r
	335	\r
	336	Next += Increment;\r
	337	Remain -= Increment;\r
	338	}\r
	339	\r
	340	ON_EXIT:\r
	341	*TransLen -= Remain;\r
	342	return Status;\r
	343	}\r
	344	\r
	345	\r
346	/**\r
347	Get the result of high level command execution from interrupt\r
348	endpoint. This function returns the USB transfer status, and\r
349	put the high level command execution result in Result.\r
350	\r
351	@param UsbCbi The USB CBI protocol\r
352	@param Timeout The time to wait the command to execute\r
353	@param Result GC_TODO: add argument description\r
354	\r
355	@retval EFI_SUCCESS The high level command execution result is\r
356	retrieved in Result.\r
357	@retval Others Failed to retrieve the result.\r
358	\r
359	**/\r
360	STATIC\r
361	EFI_STATUS\r
362	UsbCbiGetStatus (\r
363	IN USB_CBI_PROTOCOL *UsbCbi,\r
364	IN UINT32 Timeout,\r
365	OUT USB_CBI_STATUS *Result\r
366	)\r
367	{\r
368	UINTN Len;\r
369	UINT8 Endpoint;\r
370	EFI_STATUS Status;\r
371	UINT32 TransStatus;\r
372	INTN Retry;\r
373	\r
374	Endpoint = UsbCbi->InterruptEndpoint->EndpointAddress;\r
375	Status = EFI_SUCCESS;\r
41e8ff27	376	Timeout = Timeout / USB_MASS_1_MILLISECOND;\r
e237e7ae	377	\r
	378	//\r
	379	// Attemp to the read the result from interrupt endpoint\r
	380	//\r
	381	for (Retry = 0; Retry < USB_CBI_MAX_RETRY; Retry++) {\r
	382	TransStatus = 0;\r
	383	Len = sizeof (USB_CBI_STATUS);\r
	384	\r
	385	Status = UsbCbi->UsbIo->UsbSyncInterruptTransfer (\r
	386	UsbCbi->UsbIo,\r
	387	Endpoint,\r
	388	Result,\r
	389	&Len,\r
	390	Timeout,\r
	391	&TransStatus\r
	392	);\r
	393	//\r
	394	// The CBI can NAK the interrupt endpoint if the command is in-progress.\r
	395	//\r
	396	if (EFI_ERROR (Status) && (TransStatus == EFI_USB_ERR_NAK)) {\r
	397	continue;\r
	398	}\r
	399	\r
	400	break;\r
	401	}\r
	402	\r
	403	return Status;\r
	404	}\r
	405	\r
	406	\r
	407	/**\r
	408	Execute USB mass storage command through the CBI0/CBI1 transport protocol\r
	409	\r
	410	@param Context The USB CBI device\r
	411	@param Cmd The command to transfer to device\r
	412	@param CmdLen The length of the command\r
	413	@param DataDir The direction of data transfer\r
	414	@param Data The buffer to hold the data\r
	415	@param DataLen The length of the buffer\r
	416	@param Timeout The time to wait\r
	417	@param CmdStatus The result of the command execution\r
	418	\r
	419	@retval EFI_SUCCESS The command is executed OK and result in CmdStatus.\r
	420	@retval EFI_DEVICE_ERROR Failed to execute the command\r
	421	\r
	422	**/\r
	423	STATIC\r
	424	EFI_STATUS\r
	425	UsbCbiExecCommand (\r
	426	IN VOID *Context,\r
	427	IN VOID *Cmd,\r
	428	IN UINT8 CmdLen,\r
	429	IN EFI_USB_DATA_DIRECTION DataDir,\r
	430	IN VOID *Data,\r
	431	IN UINT32 DataLen,\r
	432	IN UINT32 Timeout,\r
	433	OUT UINT32 *CmdStatus\r
	434	)\r
	435	{\r
	436	USB_CBI_PROTOCOL *UsbCbi;\r
	437	USB_CBI_STATUS Result;\r
	438	EFI_STATUS Status;\r
	439	UINTN TransLen;\r
	440	\r
441	*CmdStatus = USB_MASS_CMD_SUCCESS;\r
442	UsbCbi = (USB_CBI_PROTOCOL *) Context;\r
443	\r
444	//\r
445	// Send the command to the device. Return immediately if device\r
446	// rejects the command.\r
447	//\r
448	Status = UsbCbiSendCommand (UsbCbi, Cmd, CmdLen, Timeout);\r
449	if (EFI_ERROR (Status)) {\r
1c619535	450	DEBUG ((EFI_D_ERROR, "UsbCbiExecCommand: UsbCbiSendCommand (%r)\n",Status));\r
e237e7ae	451	return Status;\r
	452	}\r
	453	\r
	454	//\r
	455	// Transfer the data, return this status if no interrupt endpoint\r
	456	// is used to report the transfer status.\r
	457	//\r
	458	TransLen = (UINTN) DataLen;\r
	459	\r
	460	Status = UsbCbiDataTransfer (UsbCbi, DataDir, Data, &TransLen, Timeout);\r
	461	if (UsbCbi->InterruptEndpoint == NULL) {\r
1c619535	462	DEBUG ((EFI_D_ERROR, "UsbCbiExecCommand: UsbCbiDataTransfer (%r)\n",Status));\r
e237e7ae	463	return Status;\r
	464	}\r
	465	\r
	466	//\r
	467	// Get the status, if that succeeds, interpret the result\r
	468	//\r
	469	Status = UsbCbiGetStatus (UsbCbi, Timeout, &Result);\r
	470	if (EFI_ERROR (Status)) {\r
1c619535	471	DEBUG ((EFI_D_ERROR, "UsbCbiExecCommand: UsbCbiGetStatus (%r)\n",Status));\r
e237e7ae	472	return EFI_DEVICE_ERROR;\r
	473	}\r
	474	\r
	475	if (UsbCbi->Interface.InterfaceSubClass == USB_MASS_STORE_UFI) {\r
	476	//\r
	477	// For UFI device, ASC and ASCQ are returned.\r
	478	//\r
	479	if (Result.Type != 0) {\r
	480	*CmdStatus = USB_MASS_CMD_FAIL;\r
	481	}\r
	482	\r
	483	} else {\r
	484	//\r
	485	// Check page 27, CBI spec 1.1 for vaious reture status.\r
	486	//\r
	487	switch (Result.Value & 0x03) {\r
	488	case 0x00:\r
	489	//\r
	490	// Pass\r
	491	//\r
	492	*CmdStatus = USB_MASS_CMD_SUCCESS;\r
	493	break;\r
	494	\r
	495	case 0x02:\r
	496	//\r
	497	// Phase Error, response with reset. Fall through to Fail.\r
	498	//\r
	499	UsbCbiResetDevice (UsbCbi, FALSE);\r
	500	\r
	501	case 0x01:\r
	502	//\r
	503	// Fail\r
	504	//\r
	505	*CmdStatus = USB_MASS_CMD_FAIL;\r
	506	break;\r
	507	\r
	508	case 0x03:\r
	509	//\r
	510	// Persistent Fail, need to send REQUEST SENSE.\r
	511	//\r
	512	*CmdStatus = USB_MASS_CMD_PERSISTENT;\r
	513	break;\r
	514	}\r
	515	}\r
	516	\r
	517	return EFI_SUCCESS;\r
	518	}\r
	519	\r
	520	\r
	521	/**\r
	522	Call the Usb mass storage class transport protocol to\r
	523	reset the device. The reset is defined as a Non-Data\r
	524	command. Don't use UsbCbiExecCommand to send the command\r
	525	to device because that may introduce recursive loop.\r
	526	\r
	527	@param Context The USB CBI device protocol\r
	528	\r
	529	@retval EFI_SUCCESS the device is reset\r
	530	@retval Others Failed to reset the device\r
	531	\r
	532	**/\r
	533	STATIC\r
	534	EFI_STATUS\r
	535	UsbCbiResetDevice (\r
536	IN VOID *Context,\r
537	IN BOOLEAN ExtendedVerification\r
538	)\r
539	{\r
540	UINT8 ResetCmd[USB_CBI_RESET_CMD_LEN];\r
541	USB_CBI_PROTOCOL *UsbCbi;\r
542	USB_CBI_STATUS Result;\r
543	EFI_STATUS Status;\r
544	UINT32 Timeout;\r
545	\r
546	UsbCbi = (USB_CBI_PROTOCOL *) Context;\r
547	\r
548	//\r
549	// Fill in the reset command.\r
550	//\r
551	SetMem (ResetCmd, USB_CBI_RESET_CMD_LEN, 0xFF);\r
552	\r
553	ResetCmd[0] = 0x1D;\r
554	ResetCmd[1] = 0x04;\r
41e8ff27	555	Timeout = USB_CBI_RESET_DEVICE_TIMEOUT / USB_MASS_1_MILLISECOND;\r
e237e7ae	556	\r
	557	//\r
	558	// Send the command to the device. Don't use UsbCbiExecCommand here.\r
	559	//\r
	560	Status = UsbCbiSendCommand (UsbCbi, ResetCmd, USB_CBI_RESET_CMD_LEN, Timeout);\r
	561	if (EFI_ERROR (Status)) {\r
	562	return Status;\r
	563	}\r
	564	\r
	565	//\r
	566	// Just retrieve the status and ignore that. Then stall\r
	567	// 50ms to wait it complete\r
	568	//\r
	569	UsbCbiGetStatus (UsbCbi, Timeout, &Result);\r
41e8ff27	570	gBS->Stall (USB_CBI_RESET_DEVICE_STALL);\r
e237e7ae	571	\r
	572	//\r
	573	// Clear the Bulk-In and Bulk-Out stall condition and\r
	574	// init data toggle.\r
	575	//\r
	576	UsbClearEndpointStall (UsbCbi->UsbIo, UsbCbi->BulkInEndpoint->EndpointAddress);\r
	577	UsbClearEndpointStall (UsbCbi->UsbIo, UsbCbi->BulkOutEndpoint->EndpointAddress);\r
	578	return Status;\r
	579	}\r
	580	\r
	581	\r
	582	/**\r
	583	Clean up the CBI protocol's resource\r
	584	\r
	585	@param Context The CBI protocol\r
	586	\r
	587	@retval EFI_SUCCESS The resource is cleaned up.\r
	588	\r
	589	**/\r
	590	STATIC\r
	591	EFI_STATUS\r
	592	UsbCbiFini (\r
	593	IN VOID *Context\r
	594	)\r
	595	{\r
	596	gBS->FreePool (Context);\r
	597	return EFI_SUCCESS;\r
	598	}\r
	599	\r
	600	USB_MASS_TRANSPORT\r
	601	mUsbCbi0Transport = {\r
	602	USB_MASS_STORE_CBI0,\r
	603	UsbCbiInit,\r
	604	UsbCbiExecCommand,\r
	605	UsbCbiResetDevice,\r
	606	UsbCbiFini\r
	607	};\r
	608	\r
	609	USB_MASS_TRANSPORT\r
	610	mUsbCbi1Transport = {\r
	611	USB_MASS_STORE_CBI1,\r
	612	UsbCbiInit,\r
	613	UsbCbiExecCommand,\r
	614	UsbCbiResetDevice,\r
	615	UsbCbiFini\r
	616	};\r