[mirror_edk2.git] / MdeModulePkg / Bus / Usb / UsbMassStorageDxe / UsbMassImpl.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
  UsbMassImpl.c\r
\r
Abstract:\r
\r
  The implementation of USB mass storage class device driver.\r
  The command set supported is "USB Mass Storage Specification\r
  for Bootability".\r
\r
Revision History\r
\r
\r
**/\r
\r
#include "UsbMassImpl.h"\r
\r
//\r
// The underlying transport protocol. CBI support isn't included\r
// in the current build. It is being obseleted by the standard\r
// body. If you want to enable it, remove the if directive here,\r
// then add the UsbMassCbi.c/.h to the driver's inf file.\r
//\r
STATIC\r
USB_MASS_TRANSPORT *mUsbMassTransport[] = {\r
  &mUsbCbi0Transport,\r
  &mUsbCbi1Transport,\r
  &mUsbBotTransport,\r
  NULL\r
};\r
\r
UINTN mUsbMscInfo  = DEBUG_INFO;\r
UINTN mUsbMscError = DEBUG_ERROR;\r
\r
\r
/**\r
  Retrieve the media parameters such as disk gemotric for the\r
  device's BLOCK IO protocol.\r
\r
  @param  UsbMass                The USB mass storage device\r
\r
  @retval EFI_SUCCESS            The media parameters is updated successfully.\r
  @retval Others                 Failed to get the media parameters.\r
\r
**/\r
EFI_STATUS\r
UsbMassInitMedia (\r
  IN USB_MASS_DEVICE          *UsbMass\r
  )\r
{\r
  EFI_BLOCK_IO_MEDIA          *Media;\r
  EFI_STATUS                  Status;\r
  UINTN                       Index;\r
\r
  Media = &UsbMass->BlockIoMedia;\r
\r
  //\r
  // Initialize the MediaPrsent/ReadOnly and others to the default.\r
  // We are not forced to get it right at this time, check UEFI2.0\r
  // spec for more information:\r
  //\r
  // MediaPresent: This field shows the media present status as\r
  //               of the most recent ReadBlocks or WriteBlocks call.\r
  //\r
  // ReadOnly    : This field shows the read-only status as of the\r
  //               recent WriteBlocks call.\r
  //\r
  // but remember to update MediaId/MediaPresent/ReadOnly status\r
  // after ReadBlocks and WriteBlocks\r
  //\r
  Media->MediaPresent     = FALSE;\r
  Media->LogicalPartition = FALSE;\r
  Media->ReadOnly         = FALSE;\r
  Media->WriteCaching     = FALSE;\r
  Media->IoAlign          = 0;\r
\r
  //\r
  // Some device may spend several seconds before it is ready.\r
  // Try several times before giving up. Wait 5s at most.\r
  //\r
  Status = EFI_SUCCESS;\r
\r
  for (Index = 0; Index < USB_BOOT_INIT_MEDIA_RETRY; Index++) {\r
\r
    Status = UsbBootGetParams (UsbMass);\r
    if ((Status != EFI_MEDIA_CHANGED)\r
        && (Status != EFI_NOT_READY)\r
        && (Status != EFI_TIMEOUT)) {\r
      break;\r
    }\r
\r
    Status = UsbBootIsUnitReady (UsbMass);\r
    if (EFI_ERROR (Status)) {\r
      gBS->Stall (USB_BOOT_RETRY_UNIT_READY_STALL * (Index + 1)); \r
    }\r
\r
  }\r
\r
  return Status;\r
}\r
\r
\r
/**\r
  Reset the block device. ExtendedVerification is ignored for this.\r
\r
  @param  This                   The BLOCK IO protocol\r
  @param  ExtendedVerification   Whether to execute extended verfication.\r
\r
  @retval EFI_SUCCESS            The device is successfully resetted.\r
  @retval Others                 Failed to reset the device.\r
\r
**/\r
EFI_STATUS\r
UsbMassReset (\r
  IN EFI_BLOCK_IO_PROTOCOL    *This,\r
  IN BOOLEAN                  ExtendedVerification\r
  )\r
{\r
  USB_MASS_DEVICE *UsbMass;\r
  EFI_TPL         OldTpl;\r
  EFI_STATUS      Status;\r
\r
  OldTpl  = gBS->RaiseTPL (USB_MASS_TPL);\r
\r
  UsbMass = USB_MASS_DEVICE_FROM_BLOCKIO (This);\r
  Status  = UsbMass->Transport->Reset (UsbMass->Context, ExtendedVerification);\r
\r
  gBS->RestoreTPL (OldTpl);\r
\r
  return Status;\r
}\r
\r
\r
/**\r
  Read some blocks of data from the block device.\r
\r
  @param  This                   The Block IO protocol\r
  @param  MediaId                The media's ID of the device for current request\r
  @param  Lba                    The start block number\r
  @param  BufferSize             The size of buffer to read data in\r
  @param  Buffer                 The buffer to read data to\r
\r
  @retval EFI_SUCCESS            The data is successfully read\r
  @retval EFI_NO_MEDIA           Media isn't present\r
  @retval EFI_MEDIA_CHANGED      The device media has been changed, that is,\r
                                 MediaId changed\r
  @retval EFI_INVALID_PARAMETER  Some parameters are invalid, such as Buffer is\r
                                 NULL.\r
  @retval EFI_BAD_BUFFER_SIZE    The buffer size isn't a multiple of media's block\r
                                 size,  or overflow the last block number.\r
\r
**/\r
EFI_STATUS\r
UsbMassReadBlocks (\r
  IN EFI_BLOCK_IO_PROTOCOL    *This,\r
  IN UINT32                   MediaId,\r
  IN EFI_LBA                  Lba,\r
  IN UINTN                    BufferSize,\r
  OUT VOID                    *Buffer\r
  )\r
{\r
  USB_MASS_DEVICE     *UsbMass;\r
  EFI_BLOCK_IO_MEDIA  *Media;\r
  EFI_STATUS          Status;\r
  EFI_TPL             OldTpl;\r
  UINTN               TotalBlock;\r
  \r
  OldTpl  = gBS->RaiseTPL (USB_MASS_TPL);\r
  UsbMass = USB_MASS_DEVICE_FROM_BLOCKIO (This);\r
  Media   = &UsbMass->BlockIoMedia;\r
\r
  //\r
  // First, validate the parameters\r
  //\r
  if ((Buffer == NULL) || (BufferSize == 0)) {\r
    Status = EFI_INVALID_PARAMETER;\r
    goto ON_EXIT;\r
  }\r
  \r
  //\r
  // If it is a removable media, such as CD-Rom or Usb-Floppy,\r
  // need to detect the media before each rw. While some of \r
  // Usb-Flash is marked as removable media.\r
  // \r
  // \r
  if (Media->RemovableMedia == TRUE) {\r
    Status = UsbBootDetectMedia (UsbMass);\r
    if (EFI_ERROR (Status)) {\r
      DEBUG ((mUsbMscError, "UsbMassReadBlocks: UsbBootDetectMedia (%r)\n", Status));\r
      goto ON_EXIT;\r
    } \r
  }\r
  \r
  //\r
  // Make sure BlockSize and LBA is consistent with BufferSize\r
  //\r
  if ((BufferSize % Media->BlockSize) != 0) {\r
    Status = EFI_BAD_BUFFER_SIZE;\r
    goto ON_EXIT;\r
  }\r
\r
  TotalBlock = BufferSize / Media->BlockSize;\r
\r
  if (Lba + TotalBlock - 1 > Media->LastBlock) {\r
    Status = EFI_BAD_BUFFER_SIZE;\r
    goto ON_EXIT;\r
  }\r
  \r
  Status = UsbBootReadBlocks (UsbMass, (UINT32) Lba, TotalBlock, Buffer);\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((mUsbMscError, "UsbMassReadBlocks: UsbBootReadBlocks (%r) -> Reset\n", Status));\r
    UsbMassReset (This, TRUE);\r
  }\r
\r
ON_EXIT:\r
  gBS->RestoreTPL (OldTpl);\r
  return Status;\r
}\r
\r
\r
/**\r
  Write some blocks of data to the block device.\r
\r
  @param  This                   The Block IO protocol\r
  @param  MediaId                The media's ID of the device for current request\r
  @param  Lba                    The start block number\r
  @param  BufferSize             The size of buffer to write data to\r
  @param  Buffer                 The buffer to write data to\r
\r
  @retval EFI_SUCCESS            The data is successfully written\r
  @retval EFI_NO_MEDIA           Media isn't present\r
  @retval EFI_MEDIA_CHANGED      The device media has been changed, that is,\r
                                 MediaId changed\r
  @retval EFI_INVALID_PARAMETER  Some parameters are invalid, such as Buffer is\r
                                 NULL.\r
  @retval EFI_BAD_BUFFER_SIZE    The buffer size isn't a multiple of media's block\r
                                 size,\r
\r
**/\r
EFI_STATUS\r
UsbMassWriteBlocks (\r
  IN EFI_BLOCK_IO_PROTOCOL    *This,\r
  IN UINT32                   MediaId,\r
  IN EFI_LBA                  Lba,\r
  IN UINTN                    BufferSize,\r
  IN VOID                     *Buffer\r
  )\r
{\r
  USB_MASS_DEVICE     *UsbMass;\r
  EFI_BLOCK_IO_MEDIA  *Media;\r
  EFI_STATUS          Status;\r
  EFI_TPL             OldTpl;\r
  UINTN               TotalBlock;\r
\r
  OldTpl  = gBS->RaiseTPL (USB_MASS_TPL);\r
  UsbMass = USB_MASS_DEVICE_FROM_BLOCKIO (This);\r
  Media   = &UsbMass->BlockIoMedia;\r
\r
  //\r
  // First, validate the parameters\r
  //\r
  if ((Buffer == NULL) || (BufferSize == 0)) {\r
    Status = EFI_INVALID_PARAMETER;\r
    goto ON_EXIT;\r
  }\r
  \r
  //\r
  // If it is a removable media, such as CD-Rom or Usb-Floppy,\r
  // need to detect the media before each rw. While some of \r
  // Usb-Flash is marked as removable media.\r
  // \r
  // \r
  if (Media->RemovableMedia == TRUE) {\r
    Status = UsbBootDetectMedia (UsbMass);\r
    if (EFI_ERROR (Status)) {\r
      DEBUG ((mUsbMscError, "UsbMassWriteBlocks: UsbBootDetectMedia (%r)\n", Status));\r
      goto ON_EXIT;\r
    } \r
  }\r
  \r
  //\r
  // Make sure BlockSize and LBA is consistent with BufferSize\r
  //\r
  if ((BufferSize % Media->BlockSize) != 0) {\r
    Status = EFI_BAD_BUFFER_SIZE;\r
    goto ON_EXIT;\r
  }\r
\r
  TotalBlock = BufferSize / Media->BlockSize;\r
\r
  if (Lba + TotalBlock - 1 > Media->LastBlock) {\r
    Status = EFI_BAD_BUFFER_SIZE;\r
    goto ON_EXIT;\r
  }\r
  \r
  //\r
  // Try to write the data even the device is marked as ReadOnly,\r
  // and clear the status should the write succeed.\r
  //\r
  Status = UsbBootWriteBlocks (UsbMass, (UINT32) Lba, TotalBlock, Buffer);\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((mUsbMscError, "UsbMassWriteBlocks: UsbBootWriteBlocks (%r) -> Reset\n", Status));\r
    UsbMassReset (This, TRUE);\r
  }\r
  \r
ON_EXIT:\r
  gBS->RestoreTPL (OldTpl);\r
  return Status;\r
}\r
\r
\r
/**\r
  Flush the cached writes to disks. USB mass storage device doesn't\r
  support write cache, so return EFI_SUCCESS directly.\r
\r
  @param  This                   The BLOCK IO protocol\r
\r
  @retval EFI_SUCCESS            Always returns success\r
\r
**/\r
EFI_STATUS\r
UsbMassFlushBlocks (\r
  IN EFI_BLOCK_IO_PROTOCOL  *This\r
  )\r
{\r
  return EFI_SUCCESS;\r
}\r
\r
\r
/**\r
  Check whether the controller is a supported USB mass storage.\r
\r
  @param  This                   The USB mass driver's driver binding.\r
  @param  Controller             The device to test against.\r
  @param  RemainingDevicePath    The remaining device path\r
\r
  @retval EFI_SUCCESS            This device is a supported USB mass storage.\r
  @retval EFI_UNSUPPORTED        The device isn't supported\r
  @retval Others                 Some error happened.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
USBMassDriverBindingSupported (\r
  IN EFI_DRIVER_BINDING_PROTOCOL  *This,\r
  IN EFI_HANDLE                   Controller,\r
  IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath\r
  )\r
{\r
  EFI_USB_IO_PROTOCOL           *UsbIo;\r
  EFI_USB_INTERFACE_DESCRIPTOR  Interface;\r
  USB_MASS_TRANSPORT            *Transport;\r
  EFI_STATUS                    Status;\r
  INTN                          Index;\r
\r
  //\r
  // Check whether the controlelr support USB_IO\r
  //\r
  Status = gBS->OpenProtocol (\r
                  Controller,\r
                  &gEfiUsbIoProtocolGuid,\r
                  (VOID **) &UsbIo,\r
                  This->DriverBindingHandle,\r
                  Controller,\r
                  EFI_OPEN_PROTOCOL_BY_DRIVER\r
                  );\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  //\r
  // Get the interface to check the USB class and find a transport\r
  // protocol handler.\r
  //\r
  Status = UsbIo->UsbGetInterfaceDescriptor (UsbIo, &Interface);\r
  if (EFI_ERROR (Status)) {\r
    goto ON_EXIT;\r
  }\r
\r
  Status = EFI_UNSUPPORTED;\r
\r
  if (Interface.InterfaceClass != USB_MASS_STORE_CLASS) {\r
    goto ON_EXIT;\r
  }\r
\r
  for (Index = 0; mUsbMassTransport[Index] != NULL; Index++) {\r
    Transport = mUsbMassTransport[Index];\r
    if (Interface.InterfaceProtocol == Transport->Protocol) {\r
      Status = Transport->Init (UsbIo, Controller, NULL);\r
      break;\r
    }\r
  }\r
\r
  DEBUG ((mUsbMscInfo, "Found a USB mass store device %r\n", Status));\r
\r
ON_EXIT:\r
  gBS->CloseProtocol (\r
        Controller,\r
        &gEfiUsbIoProtocolGuid,\r
        This->DriverBindingHandle,\r
        Controller\r
        );\r
\r
  return Status;\r
}\r
\r
\r
/**\r
  Start the USB mass storage device on the controller. It will\r
  install a BLOCK_IO protocol on the device if everything is OK.\r
\r
  @param  This                   The USB mass storage driver binding.\r
  @param  Controller             The USB mass storage device to start on\r
  @param  RemainingDevicePath    The remaining device path.\r
\r
  @retval EFI_SUCCESS            The driver has started on the device.\r
  @retval EFI_OUT_OF_RESOURCES   Failed to allocate memory\r
  @retval Others                 Failed to start the driver on the device.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
USBMassDriverBindingStart (\r
  IN EFI_DRIVER_BINDING_PROTOCOL  *This,\r
  IN EFI_HANDLE                   Controller,\r
  IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath\r
  )\r
{\r
  EFI_USB_IO_PROTOCOL           *UsbIo;\r
  EFI_USB_INTERFACE_DESCRIPTOR  Interface;\r
  USB_MASS_DEVICE               *UsbMass;\r
  USB_MASS_TRANSPORT            *Transport;\r
  EFI_STATUS                    Status;\r
  UINTN                         Index;\r
\r
  Status = gBS->OpenProtocol (\r
                  Controller,\r
                  &gEfiUsbIoProtocolGuid,\r
                  (VOID **) &UsbIo,\r
                  This->DriverBindingHandle,\r
                  Controller,\r
                  EFI_OPEN_PROTOCOL_BY_DRIVER\r
                  );\r
\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  UsbMass = AllocateZeroPool (sizeof (USB_MASS_DEVICE));\r
  if (UsbMass == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  //\r
  // Initialize the transport protocols\r
  //\r
  Status = UsbIo->UsbGetInterfaceDescriptor (UsbIo, &Interface);\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((mUsbMscError, "USBMassDriverBindingStart: UsbIo->UsbGetInterfaceDescriptor (%r)\n", Status));\r
    goto ON_ERROR;\r
  }\r
\r
  Status = EFI_UNSUPPORTED;\r
\r
  for (Index = 0; mUsbMassTransport[Index] != NULL; Index++) {\r
    Transport = mUsbMassTransport[Index];\r
\r
    if (Interface.InterfaceProtocol == Transport->Protocol) {\r
      UsbMass->Transport = Transport;\r
      Status             = Transport->Init (UsbIo, Controller, &UsbMass->Context);\r
      break;\r
    }\r
  }\r
\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((mUsbMscError, "USBMassDriverBindingStart: Transport->Init (%r)\n", Status));\r
    goto ON_ERROR;\r
  }\r
\r
  UsbMass->Signature            = USB_MASS_SIGNATURE;\r
  UsbMass->Controller           = Controller;\r
  UsbMass->UsbIo                = UsbIo;\r
  UsbMass->BlockIo.Media        = &UsbMass->BlockIoMedia;\r
  UsbMass->BlockIo.Reset        = UsbMassReset;\r
  UsbMass->BlockIo.ReadBlocks   = UsbMassReadBlocks;\r
  UsbMass->BlockIo.WriteBlocks  = UsbMassWriteBlocks;\r
  UsbMass->BlockIo.FlushBlocks  = UsbMassFlushBlocks;\r
  UsbMass->OpticalStorage       = FALSE;\r
\r
  //\r
  // Get the storage's parameters, such as last block number.\r
  // then install the BLOCK_IO\r
  //\r
  Status = UsbMassInitMedia (UsbMass);\r
  if (!EFI_ERROR (Status)) {\r
    if ((UsbMass->Pdt != USB_PDT_DIRECT_ACCESS) &&\r
         (UsbMass->Pdt != USB_PDT_CDROM) &&\r
         (UsbMass->Pdt != USB_PDT_OPTICAL) &&\r
         (UsbMass->Pdt != USB_PDT_SIMPLE_DIRECT)) {\r
      DEBUG ((mUsbMscError, "USBMassDriverBindingStart: Found an unsupported peripheral type[%d]\n", UsbMass->Pdt));\r
      goto ON_ERROR;\r
    }\r
  } else if (Status != EFI_NO_MEDIA){\r
    DEBUG ((mUsbMscError, "USBMassDriverBindingStart: UsbMassInitMedia (%r)\n", Status));\r
    goto ON_ERROR;\r
  }\r
\r
  Status = gBS->InstallProtocolInterface (\r
                  &Controller,\r
                  &gEfiBlockIoProtocolGuid,\r
                  EFI_NATIVE_INTERFACE,\r
                  &UsbMass->BlockIo\r
                  );\r
  if (EFI_ERROR (Status)) {\r
    goto ON_ERROR;\r
  }\r
\r
  return EFI_SUCCESS;\r
\r
ON_ERROR:\r
  gBS->FreePool (UsbMass);\r
\r
  gBS->CloseProtocol (\r
        Controller,\r
        &gEfiUsbIoProtocolGuid,\r
        This->DriverBindingHandle,\r
        Controller\r
        );\r
\r
  return Status;\r
}\r
\r
\r
/**\r
  Stop controlling the device.\r
\r
  @param  This                   The USB mass storage driver binding\r
  @param  Controller             The device controller controlled by the driver.\r
  @param  NumberOfChildren       The number of children of this device\r
  @param  ChildHandleBuffer      The buffer of children handle.\r
\r
  @retval EFI_SUCCESS            The driver stopped from controlling the device.\r
  @retval Others                 Failed to stop the driver\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
USBMassDriverBindingStop (\r
  IN  EFI_DRIVER_BINDING_PROTOCOL *This,\r
  IN  EFI_HANDLE                  Controller,\r
  IN  UINTN                       NumberOfChildren,\r
  IN  EFI_HANDLE                  *ChildHandleBuffer\r
  )\r
{\r
  EFI_STATUS            Status;\r
  USB_MASS_DEVICE       *UsbMass;\r
  EFI_BLOCK_IO_PROTOCOL *BlockIo;\r
\r
  //\r
  // First, get our context back from the BLOCK_IO\r
  //\r
  Status = gBS->OpenProtocol (\r
                  Controller,\r
                  &gEfiBlockIoProtocolGuid,\r
                  (VOID **) &BlockIo,\r
                  This->DriverBindingHandle,\r
                  Controller,\r
                  EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
                  );\r
\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  UsbMass = USB_MASS_DEVICE_FROM_BLOCKIO (BlockIo);\r
\r
  //\r
  // Uninstall Block I/O protocol from the device handle,\r
  // then call the transport protocol to stop itself.\r
  //\r
  Status = gBS->UninstallProtocolInterface (\r
                  Controller,\r
                  &gEfiBlockIoProtocolGuid,\r
                  &UsbMass->BlockIo\r
                  );\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  gBS->CloseProtocol (\r
        Controller,\r
        &gEfiUsbIoProtocolGuid,\r
        This->DriverBindingHandle,\r
        Controller\r
        );\r
\r
  UsbMass->Transport->Fini (UsbMass->Context);\r
  gBS->FreePool (UsbMass);\r
\r
  return EFI_SUCCESS;\r
}\r
\r
EFI_DRIVER_BINDING_PROTOCOL gUSBMassDriverBinding = {\r
  USBMassDriverBindingSupported,\r
  USBMassDriverBindingStart,\r
  USBMassDriverBindingStop,\r
  0x11,\r
  NULL,\r
  NULL\r
};\r
\r
EFI_STATUS\r
EFIAPI\r
USBMassStorageEntryPoint (\r
  IN EFI_HANDLE               ImageHandle,\r
  IN EFI_SYSTEM_TABLE         *SystemTable\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  The entry point for the driver, which will install the driver binding and\r
  component name protocol\r
\r
Arguments:\r
\r
  ImageHandle - The image handle of this driver\r
  SystemTable - The system table\r
\r
Returns:\r
\r
  EFI_SUCCESS - the protocols are installed OK\r
  Others      - Failed to install protocols.\r
\r
--*/\r
{\r
  EFI_STATUS  Status;\r
\r
  //\r
  // Install driver binding protocol\r
  //\r
  Status = EfiLibInstallDriverBindingComponentName2 (\r
             ImageHandle,\r
             SystemTable,\r
             &gUSBMassDriverBinding,\r
             ImageHandle,\r
             &gUsbMassStorageComponentName,\r
             &gUsbMassStorageComponentName2\r
             );\r
\r
  return Status;\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	UsbMassImpl.c\r
	15	\r
	16	Abstract:\r
	17	\r
	18	The implementation of USB mass storage class device driver.\r
	19	The command set supported is "USB Mass Storage Specification\r
	20	for Bootability".\r
	21	\r
	22	Revision History\r
	23	\r
	24	\r
	25	**/\r
	26	\r
	27	#include "UsbMassImpl.h"\r
	28	\r
	29	//\r
	30	// The underlying transport protocol. CBI support isn't included\r
	31	// in the current build. It is being obseleted by the standard\r
	32	// body. If you want to enable it, remove the if directive here,\r
	33	// then add the UsbMassCbi.c/.h to the driver's inf file.\r
	34	//\r
	35	STATIC\r
	36	USB_MASS_TRANSPORT *mUsbMassTransport[] = {\r
	37	&mUsbCbi0Transport,\r
	38	&mUsbCbi1Transport,\r
	39	&mUsbBotTransport,\r
	40	NULL\r
	41	};\r
	42	\r
	43	UINTN mUsbMscInfo = DEBUG_INFO;\r
	44	UINTN mUsbMscError = DEBUG_ERROR;\r
	45	\r
	46	\r
	47	/**\r
	48	Retrieve the media parameters such as disk gemotric for the\r
	49	device's BLOCK IO protocol.\r
	50	\r
	51	@param UsbMass The USB mass storage device\r
	52	\r
	53	@retval EFI_SUCCESS The media parameters is updated successfully.\r
	54	@retval Others Failed to get the media parameters.\r
	55	\r
	56	**/\r
	57	EFI_STATUS\r
	58	UsbMassInitMedia (\r
	59	IN USB_MASS_DEVICE *UsbMass\r
	60	)\r
	61	{\r
	62	EFI_BLOCK_IO_MEDIA *Media;\r
	63	EFI_STATUS Status;\r
	64	UINTN Index;\r
65	\r
66	Media = &UsbMass->BlockIoMedia;\r
67	\r
68	//\r
69	// Initialize the MediaPrsent/ReadOnly and others to the default.\r
70	// We are not forced to get it right at this time, check UEFI2.0\r
71	// spec for more information:\r
72	//\r
73	// MediaPresent: This field shows the media present status as\r
74	// of the most recent ReadBlocks or WriteBlocks call.\r
75	//\r
76	// ReadOnly : This field shows the read-only status as of the\r
77	// recent WriteBlocks call.\r
78	//\r
79	// but remember to update MediaId/MediaPresent/ReadOnly status\r
80	// after ReadBlocks and WriteBlocks\r
81	//\r
82	Media->MediaPresent = FALSE;\r
83	Media->LogicalPartition = FALSE;\r
84	Media->ReadOnly = FALSE;\r
85	Media->WriteCaching = FALSE;\r
86	Media->IoAlign = 0;\r
87	\r
88	//\r
89	// Some device may spend several seconds before it is ready.\r
90	// Try several times before giving up. Wait 5s at most.\r
91	//\r
92	Status = EFI_SUCCESS;\r
93	\r
41e8ff27	94	for (Index = 0; Index < USB_BOOT_INIT_MEDIA_RETRY; Index++) {\r
e237e7ae	95	\r
	96	Status = UsbBootGetParams (UsbMass);\r
	97	if ((Status != EFI_MEDIA_CHANGED)\r
	98	&& (Status != EFI_NOT_READY)\r
	99	&& (Status != EFI_TIMEOUT)) {\r
	100	break;\r
	101	}\r
	102	\r
	103	Status = UsbBootIsUnitReady (UsbMass);\r
	104	if (EFI_ERROR (Status)) {\r
41e8ff27	105	gBS->Stall (USB_BOOT_RETRY_UNIT_READY_STALL * (Index + 1)); \r
e237e7ae	106	}\r
	107	\r
	108	}\r
	109	\r
	110	return Status;\r
	111	}\r
	112	\r
	113	\r
	114	/**\r
	115	Reset the block device. ExtendedVerification is ignored for this.\r
	116	\r
	117	@param This The BLOCK IO protocol\r
	118	@param ExtendedVerification Whether to execute extended verfication.\r
	119	\r
	120	@retval EFI_SUCCESS The device is successfully resetted.\r
	121	@retval Others Failed to reset the device.\r
	122	\r
	123	**/\r
	124	EFI_STATUS\r
	125	UsbMassReset (\r
	126	IN EFI_BLOCK_IO_PROTOCOL *This,\r
	127	IN BOOLEAN ExtendedVerification\r
	128	)\r
	129	{\r
	130	USB_MASS_DEVICE *UsbMass;\r
41e8ff27	131	EFI_TPL OldTpl;\r
	132	EFI_STATUS Status;\r
	133	\r
	134	OldTpl = gBS->RaiseTPL (USB_MASS_TPL);\r
e237e7ae	135	\r
e237e7ae	136	UsbMass = USB_MASS_DEVICE_FROM_BLOCKIO (This);\r
41e8ff27	137	Status = UsbMass->Transport->Reset (UsbMass->Context, ExtendedVerification);\r
	138	\r
	139	gBS->RestoreTPL (OldTpl);\r
	140	\r
	141	return Status;\r
e237e7ae	142	}\r
	143	\r
	144	\r
	145	/**\r
	146	Read some blocks of data from the block device.\r
	147	\r
	148	@param This The Block IO protocol\r
	149	@param MediaId The media's ID of the device for current request\r
	150	@param Lba The start block number\r
	151	@param BufferSize The size of buffer to read data in\r
	152	@param Buffer The buffer to read data to\r
	153	\r
	154	@retval EFI_SUCCESS The data is successfully read\r
	155	@retval EFI_NO_MEDIA Media isn't present\r
	156	@retval EFI_MEDIA_CHANGED The device media has been changed, that is,\r
	157	MediaId changed\r
	158	@retval EFI_INVALID_PARAMETER Some parameters are invalid, such as Buffer is\r
	159	NULL.\r
	160	@retval EFI_BAD_BUFFER_SIZE The buffer size isn't a multiple of media's block\r
	161	size, or overflow the last block number.\r
	162	\r
	163	**/\r
	164	EFI_STATUS\r
	165	UsbMassReadBlocks (\r
	166	IN EFI_BLOCK_IO_PROTOCOL *This,\r
	167	IN UINT32 MediaId,\r
	168	IN EFI_LBA Lba,\r
	169	IN UINTN BufferSize,\r
	170	OUT VOID *Buffer\r
	171	)\r
	172	{\r
	173	USB_MASS_DEVICE *UsbMass;\r
	174	EFI_BLOCK_IO_MEDIA *Media;\r
	175	EFI_STATUS Status;\r
41e8ff27	176	EFI_TPL OldTpl;\r
e237e7ae	177	UINTN TotalBlock;\r
41e8ff27	178	\r
41e8ff27	179	OldTpl = gBS->RaiseTPL (USB_MASS_TPL);\r
e237e7ae	180	UsbMass = USB_MASS_DEVICE_FROM_BLOCKIO (This);\r
	181	Media = &UsbMass->BlockIoMedia;\r
	182	\r
	183	//\r
	184	// First, validate the parameters\r
	185	//\r
	186	if ((Buffer == NULL) \|\| (BufferSize == 0)) {\r
41e8ff27	187	Status = EFI_INVALID_PARAMETER;\r
41e8ff27	188	goto ON_EXIT;\r
e237e7ae	189	}\r
41e8ff27	190	\r
e237e7ae	191	//\r
41e8ff27	192	// If it is a removable media, such as CD-Rom or Usb-Floppy,\r
	193	// need to detect the media before each rw. While some of \r
	194	// Usb-Flash is marked as removable media.\r
	195	// \r
	196	// \r
	197	if (Media->RemovableMedia == TRUE) {\r
	198	Status = UsbBootDetectMedia (UsbMass);\r
	199	if (EFI_ERROR (Status)) {\r
	200	DEBUG ((mUsbMscError, "UsbMassReadBlocks: UsbBootDetectMedia (%r)\n", Status));\r
	201	goto ON_EXIT;\r
	202	} \r
e237e7ae	203	}\r
41e8ff27	204	\r
e237e7ae	205	//\r
	206	// Make sure BlockSize and LBA is consistent with BufferSize\r
	207	//\r
	208	if ((BufferSize % Media->BlockSize) != 0) {\r
41e8ff27	209	Status = EFI_BAD_BUFFER_SIZE;\r
41e8ff27	210	goto ON_EXIT;\r
e237e7ae	211	}\r
	212	\r
	213	TotalBlock = BufferSize / Media->BlockSize;\r
	214	\r
	215	if (Lba + TotalBlock - 1 > Media->LastBlock) {\r
41e8ff27	216	Status = EFI_BAD_BUFFER_SIZE;\r
41e8ff27	217	goto ON_EXIT;\r
e237e7ae	218	}\r
41e8ff27	219	\r
e237e7ae	220	Status = UsbBootReadBlocks (UsbMass, (UINT32) Lba, TotalBlock, Buffer);\r
	221	if (EFI_ERROR (Status)) {\r
	222	DEBUG ((mUsbMscError, "UsbMassReadBlocks: UsbBootReadBlocks (%r) -> Reset\n", Status));\r
	223	UsbMassReset (This, TRUE);\r
	224	}\r
	225	\r
41e8ff27	226	ON_EXIT:\r
41e8ff27	227	gBS->RestoreTPL (OldTpl);\r
e237e7ae	228	return Status;\r
	229	}\r
	230	\r
	231	\r
	232	/**\r
	233	Write some blocks of data to the block device.\r
	234	\r
	235	@param This The Block IO protocol\r
	236	@param MediaId The media's ID of the device for current request\r
	237	@param Lba The start block number\r
	238	@param BufferSize The size of buffer to write data to\r
	239	@param Buffer The buffer to write data to\r
	240	\r
	241	@retval EFI_SUCCESS The data is successfully written\r
	242	@retval EFI_NO_MEDIA Media isn't present\r
	243	@retval EFI_MEDIA_CHANGED The device media has been changed, that is,\r
	244	MediaId changed\r
	245	@retval EFI_INVALID_PARAMETER Some parameters are invalid, such as Buffer is\r
	246	NULL.\r
	247	@retval EFI_BAD_BUFFER_SIZE The buffer size isn't a multiple of media's block\r
	248	size,\r
	249	\r
	250	**/\r
	251	EFI_STATUS\r
	252	UsbMassWriteBlocks (\r
	253	IN EFI_BLOCK_IO_PROTOCOL *This,\r
	254	IN UINT32 MediaId,\r
	255	IN EFI_LBA Lba,\r
	256	IN UINTN BufferSize,\r
	257	IN VOID *Buffer\r
	258	)\r
	259	{\r
	260	USB_MASS_DEVICE *UsbMass;\r
	261	EFI_BLOCK_IO_MEDIA *Media;\r
	262	EFI_STATUS Status;\r
41e8ff27	263	EFI_TPL OldTpl;\r
e237e7ae	264	UINTN TotalBlock;\r
e237e7ae	265	\r
41e8ff27	266	OldTpl = gBS->RaiseTPL (USB_MASS_TPL);\r
e237e7ae	267	UsbMass = USB_MASS_DEVICE_FROM_BLOCKIO (This);\r
	268	Media = &UsbMass->BlockIoMedia;\r
	269	\r
	270	//\r
	271	// First, validate the parameters\r
	272	//\r
	273	if ((Buffer == NULL) \|\| (BufferSize == 0)) {\r
41e8ff27	274	Status = EFI_INVALID_PARAMETER;\r
41e8ff27	275	goto ON_EXIT;\r
e237e7ae	276	}\r
41e8ff27	277	\r
e237e7ae	278	//\r
41e8ff27	279	// If it is a removable media, such as CD-Rom or Usb-Floppy,\r
	280	// need to detect the media before each rw. While some of \r
	281	// Usb-Flash is marked as removable media.\r
	282	// \r
	283	// \r
	284	if (Media->RemovableMedia == TRUE) {\r
	285	Status = UsbBootDetectMedia (UsbMass);\r
	286	if (EFI_ERROR (Status)) {\r
	287	DEBUG ((mUsbMscError, "UsbMassWriteBlocks: UsbBootDetectMedia (%r)\n", Status));\r
	288	goto ON_EXIT;\r
	289	} \r
e237e7ae	290	}\r
41e8ff27	291	\r
e237e7ae	292	//\r
	293	// Make sure BlockSize and LBA is consistent with BufferSize\r
	294	//\r
	295	if ((BufferSize % Media->BlockSize) != 0) {\r
41e8ff27	296	Status = EFI_BAD_BUFFER_SIZE;\r
41e8ff27	297	goto ON_EXIT;\r
e237e7ae	298	}\r
	299	\r
	300	TotalBlock = BufferSize / Media->BlockSize;\r
	301	\r
	302	if (Lba + TotalBlock - 1 > Media->LastBlock) {\r
41e8ff27	303	Status = EFI_BAD_BUFFER_SIZE;\r
41e8ff27	304	goto ON_EXIT;\r
e237e7ae	305	}\r
41e8ff27	306	\r
e237e7ae	307	//\r
	308	// Try to write the data even the device is marked as ReadOnly,\r
	309	// and clear the status should the write succeed.\r
	310	//\r
	311	Status = UsbBootWriteBlocks (UsbMass, (UINT32) Lba, TotalBlock, Buffer);\r
	312	if (EFI_ERROR (Status)) {\r
	313	DEBUG ((mUsbMscError, "UsbMassWriteBlocks: UsbBootWriteBlocks (%r) -> Reset\n", Status));\r
	314	UsbMassReset (This, TRUE);\r
	315	}\r
41e8ff27	316	\r
	317	ON_EXIT:\r
	318	gBS->RestoreTPL (OldTpl);\r
e237e7ae	319	return Status;\r
	320	}\r
	321	\r
	322	\r
	323	/**\r
	324	Flush the cached writes to disks. USB mass storage device doesn't\r
	325	support write cache, so return EFI_SUCCESS directly.\r
	326	\r
	327	@param This The BLOCK IO protocol\r
	328	\r
	329	@retval EFI_SUCCESS Always returns success\r
	330	\r
	331	**/\r
	332	EFI_STATUS\r
	333	UsbMassFlushBlocks (\r
	334	IN EFI_BLOCK_IO_PROTOCOL *This\r
	335	)\r
	336	{\r
	337	return EFI_SUCCESS;\r
	338	}\r
	339	\r
	340	\r
	341	/**\r
	342	Check whether the controller is a supported USB mass storage.\r
	343	\r
	344	@param This The USB mass driver's driver binding.\r
	345	@param Controller The device to test against.\r
	346	@param RemainingDevicePath The remaining device path\r
	347	\r
	348	@retval EFI_SUCCESS This device is a supported USB mass storage.\r
	349	@retval EFI_UNSUPPORTED The device isn't supported\r
	350	@retval Others Some error happened.\r
	351	\r
	352	**/\r
	353	EFI_STATUS\r
	354	EFIAPI\r
	355	USBMassDriverBindingSupported (\r
	356	IN EFI_DRIVER_BINDING_PROTOCOL *This,\r
	357	IN EFI_HANDLE Controller,\r
	358	IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath\r
	359	)\r
	360	{\r
	361	EFI_USB_IO_PROTOCOL *UsbIo;\r
	362	EFI_USB_INTERFACE_DESCRIPTOR Interface;\r
	363	USB_MASS_TRANSPORT *Transport;\r
	364	EFI_STATUS Status;\r
	365	INTN Index;\r
	366	\r
	367	//\r
	368	// Check whether the controlelr support USB_IO\r
	369	//\r
	370	Status = gBS->OpenProtocol (\r
	371	Controller,\r
	372	&gEfiUsbIoProtocolGuid,\r
c52fa98c	373	(VOID **) &UsbIo,\r
e237e7ae	374	This->DriverBindingHandle,\r
	375	Controller,\r
	376	EFI_OPEN_PROTOCOL_BY_DRIVER\r
	377	);\r
	378	if (EFI_ERROR (Status)) {\r
	379	return Status;\r
	380	}\r
	381	\r
	382	//\r
	383	// Get the interface to check the USB class and find a transport\r
	384	// protocol handler.\r
	385	//\r
	386	Status = UsbIo->UsbGetInterfaceDescriptor (UsbIo, &Interface);\r
	387	if (EFI_ERROR (Status)) {\r
	388	goto ON_EXIT;\r
	389	}\r
	390	\r
	391	Status = EFI_UNSUPPORTED;\r
	392	\r
	393	if (Interface.InterfaceClass != USB_MASS_STORE_CLASS) {\r
	394	goto ON_EXIT;\r
	395	}\r
	396	\r
	397	for (Index = 0; mUsbMassTransport[Index] != NULL; Index++) {\r
	398	Transport = mUsbMassTransport[Index];\r
	399	if (Interface.InterfaceProtocol == Transport->Protocol) {\r
	400	Status = Transport->Init (UsbIo, Controller, NULL);\r
	401	break;\r
	402	}\r
	403	}\r
	404	\r
	405	DEBUG ((mUsbMscInfo, "Found a USB mass store device %r\n", Status));\r
	406	\r
	407	ON_EXIT:\r
	408	gBS->CloseProtocol (\r
	409	Controller,\r
	410	&gEfiUsbIoProtocolGuid,\r
	411	This->DriverBindingHandle,\r
	412	Controller\r
	413	);\r
	414	\r
	415	return Status;\r
	416	}\r
	417	\r
	418	\r
	419	/**\r
	420	Start the USB mass storage device on the controller. It will\r
	421	install a BLOCK_IO protocol on the device if everything is OK.\r
	422	\r
	423	@param This The USB mass storage driver binding.\r
	424	@param Controller The USB mass storage device to start on\r
	425	@param RemainingDevicePath The remaining device path.\r
	426	\r
	427	@retval EFI_SUCCESS The driver has started on the device.\r
	428	@retval EFI_OUT_OF_RESOURCES Failed to allocate memory\r
	429	@retval Others Failed to start the driver on the device.\r
	430	\r
	431	**/\r
	432	EFI_STATUS\r
	433	EFIAPI\r
	434	USBMassDriverBindingStart (\r
	435	IN EFI_DRIVER_BINDING_PROTOCOL *This,\r
	436	IN EFI_HANDLE Controller,\r
	437	IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath\r
438	)\r
439	{\r
440	EFI_USB_IO_PROTOCOL *UsbIo;\r
441	EFI_USB_INTERFACE_DESCRIPTOR Interface;\r
442	USB_MASS_DEVICE *UsbMass;\r
443	USB_MASS_TRANSPORT *Transport;\r
444	EFI_STATUS Status;\r
445	UINTN Index;\r
446	\r
447	Status = gBS->OpenProtocol (\r
448	Controller,\r
449	&gEfiUsbIoProtocolGuid,\r
c52fa98c	450	(VOID **) &UsbIo,\r
e237e7ae	451	This->DriverBindingHandle,\r
	452	Controller,\r
	453	EFI_OPEN_PROTOCOL_BY_DRIVER\r
	454	);\r
	455	\r
	456	if (EFI_ERROR (Status)) {\r
	457	return Status;\r
	458	}\r
	459	\r
	460	UsbMass = AllocateZeroPool (sizeof (USB_MASS_DEVICE));\r
	461	if (UsbMass == NULL) {\r
	462	return EFI_OUT_OF_RESOURCES;\r
	463	}\r
	464	\r
	465	//\r
	466	// Initialize the transport protocols\r
	467	//\r
	468	Status = UsbIo->UsbGetInterfaceDescriptor (UsbIo, &Interface);\r
	469	if (EFI_ERROR (Status)) {\r
	470	DEBUG ((mUsbMscError, "USBMassDriverBindingStart: UsbIo->UsbGetInterfaceDescriptor (%r)\n", Status));\r
	471	goto ON_ERROR;\r
	472	}\r
	473	\r
	474	Status = EFI_UNSUPPORTED;\r
	475	\r
	476	for (Index = 0; mUsbMassTransport[Index] != NULL; Index++) {\r
	477	Transport = mUsbMassTransport[Index];\r
	478	\r
	479	if (Interface.InterfaceProtocol == Transport->Protocol) {\r
	480	UsbMass->Transport = Transport;\r
	481	Status = Transport->Init (UsbIo, Controller, &UsbMass->Context);\r
	482	break;\r
	483	}\r
	484	}\r
	485	\r
	486	if (EFI_ERROR (Status)) {\r
	487	DEBUG ((mUsbMscError, "USBMassDriverBindingStart: Transport->Init (%r)\n", Status));\r
	488	goto ON_ERROR;\r
	489	}\r
	490	\r
	491	UsbMass->Signature = USB_MASS_SIGNATURE;\r
	492	UsbMass->Controller = Controller;\r
	493	UsbMass->UsbIo = UsbIo;\r
	494	UsbMass->BlockIo.Media = &UsbMass->BlockIoMedia;\r
	495	UsbMass->BlockIo.Reset = UsbMassReset;\r
	496	UsbMass->BlockIo.ReadBlocks = UsbMassReadBlocks;\r
	497	UsbMass->BlockIo.WriteBlocks = UsbMassWriteBlocks;\r
	498	UsbMass->BlockIo.FlushBlocks = UsbMassFlushBlocks;\r
	499	UsbMass->OpticalStorage = FALSE;\r
	500	\r
	501	//\r
	502	// Get the storage's parameters, such as last block number.\r
	503	// then install the BLOCK_IO\r
	504	//\r
	505	Status = UsbMassInitMedia (UsbMass);\r
	506	if (!EFI_ERROR (Status)) {\r
	507	if ((UsbMass->Pdt != USB_PDT_DIRECT_ACCESS) &&\r
	508	(UsbMass->Pdt != USB_PDT_CDROM) &&\r
	509	(UsbMass->Pdt != USB_PDT_OPTICAL) &&\r
	510	(UsbMass->Pdt != USB_PDT_SIMPLE_DIRECT)) {\r
	511	DEBUG ((mUsbMscError, "USBMassDriverBindingStart: Found an unsupported peripheral type[%d]\n", UsbMass->Pdt));\r
	512	goto ON_ERROR;\r
	513	}\r
	514	} else if (Status != EFI_NO_MEDIA){\r
515	DEBUG ((mUsbMscError, "USBMassDriverBindingStart: UsbMassInitMedia (%r)\n", Status));\r
516	goto ON_ERROR;\r
517	}\r
518	\r
519	Status = gBS->InstallProtocolInterface (\r
520	&Controller,\r
521	&gEfiBlockIoProtocolGuid,\r
522	EFI_NATIVE_INTERFACE,\r
523	&UsbMass->BlockIo\r
524	);\r
525	if (EFI_ERROR (Status)) {\r
526	goto ON_ERROR;\r
527	}\r
528	\r
529	return EFI_SUCCESS;\r
530	\r
531	ON_ERROR:\r
532	gBS->FreePool (UsbMass);\r
533	\r
534	gBS->CloseProtocol (\r
535	Controller,\r
536	&gEfiUsbIoProtocolGuid,\r
537	This->DriverBindingHandle,\r
538	Controller\r
539	);\r
540	\r
541	return Status;\r
542	}\r
543	\r
544	\r
545	/**\r
546	Stop controlling the device.\r
547	\r
548	@param This The USB mass storage driver binding\r
549	@param Controller The device controller controlled by the driver.\r
550	@param NumberOfChildren The number of children of this device\r
551	@param ChildHandleBuffer The buffer of children handle.\r
552	\r
553	@retval EFI_SUCCESS The driver stopped from controlling the device.\r
554	@retval Others Failed to stop the driver\r
555	\r
556	**/\r
557	EFI_STATUS\r
558	EFIAPI\r
559	USBMassDriverBindingStop (\r
560	IN EFI_DRIVER_BINDING_PROTOCOL *This,\r
561	IN EFI_HANDLE Controller,\r
562	IN UINTN NumberOfChildren,\r
563	IN EFI_HANDLE *ChildHandleBuffer\r
564	)\r
565	{\r
566	EFI_STATUS Status;\r
567	USB_MASS_DEVICE *UsbMass;\r
568	EFI_BLOCK_IO_PROTOCOL *BlockIo;\r
569	\r
570	//\r
571	// First, get our context back from the BLOCK_IO\r
572	//\r
573	Status = gBS->OpenProtocol (\r
574	Controller,\r
575	&gEfiBlockIoProtocolGuid,\r
c52fa98c	576	(VOID **) &BlockIo,\r
e237e7ae	577	This->DriverBindingHandle,\r
	578	Controller,\r
	579	EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
	580	);\r
	581	\r
	582	if (EFI_ERROR (Status)) {\r
	583	return Status;\r
	584	}\r
	585	\r
	586	UsbMass = USB_MASS_DEVICE_FROM_BLOCKIO (BlockIo);\r
	587	\r
	588	//\r
	589	// Uninstall Block I/O protocol from the device handle,\r
	590	// then call the transport protocol to stop itself.\r
	591	//\r
	592	Status = gBS->UninstallProtocolInterface (\r
	593	Controller,\r
	594	&gEfiBlockIoProtocolGuid,\r
	595	&UsbMass->BlockIo\r
	596	);\r
	597	if (EFI_ERROR (Status)) {\r
	598	return Status;\r
	599	}\r
	600	\r
	601	gBS->CloseProtocol (\r
	602	Controller,\r
	603	&gEfiUsbIoProtocolGuid,\r
	604	This->DriverBindingHandle,\r
	605	Controller\r
	606	);\r
	607	\r
	608	UsbMass->Transport->Fini (UsbMass->Context);\r
	609	gBS->FreePool (UsbMass);\r
	610	\r
	611	return EFI_SUCCESS;\r
	612	}\r
	613	\r
	614	EFI_DRIVER_BINDING_PROTOCOL gUSBMassDriverBinding = {\r
	615	USBMassDriverBindingSupported,\r
	616	USBMassDriverBindingStart,\r
	617	USBMassDriverBindingStop,\r
	618	0x11,\r
	619	NULL,\r
	620	NULL\r
	621	};\r
	622	\r
e237e7ae	623	EFI_STATUS\r
	624	EFIAPI\r
	625	USBMassStorageEntryPoint (\r
	626	IN EFI_HANDLE ImageHandle,\r
	627	IN EFI_SYSTEM_TABLE *SystemTable\r
	628	)\r
	629	/*++\r
	630	\r
	631	Routine Description:\r
	632	\r
	633	The entry point for the driver, which will install the driver binding and\r
	634	component name protocol\r
	635	\r
	636	Arguments:\r
	637	\r
	638	ImageHandle - The image handle of this driver\r
	639	SystemTable - The system table\r
	640	\r
	641	Returns:\r
	642	\r
	643	EFI_SUCCESS - the protocols are installed OK\r
	644	Others - Failed to install protocols.\r
	645	\r
	646	--*/\r
	647	{\r
	648	EFI_STATUS Status;\r
	649	\r
	650	//\r
	651	// Install driver binding protocol\r
	652	//\r
62b9bb55	653	Status = EfiLibInstallDriverBindingComponentName2 (\r
e237e7ae	654	ImageHandle,\r
	655	SystemTable,\r
	656	&gUSBMassDriverBinding,\r
	657	ImageHandle,\r
	658	&gUsbMassStorageComponentName,\r
62b9bb55	659	&gUsbMassStorageComponentName2\r
e237e7ae	660	);\r
	661	\r
	662	return Status;\r
	663	}\r