usbmassstorage.c

来自「EFI BIOS是Intel提出的下一代的BIOS标准。这里上传的Edk源代码是」· C语言 代码 · 共 756 行 · 第 1/2 页

/*++

Copyright (c) 2004, Intel Corporation                                                         
All rights reserved. This program and the accompanying materials                          
are licensed and made available under the terms and conditions of the BSD License         
which accompanies this distribution.  The full text of the license may be found at        
http://opensource.org/licenses/bsd-license.php                                            
                                                                                          
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

Module Name:

  UsbMassStorage.c
    
Abstract:

  USB Mass Storage Driver

Revision History

--*/

#include "UsbMassStorage.h"
#include "UsbMassStorageHelper.h"

extern EFI_COMPONENT_NAME_PROTOCOL  gUsbMassStorageComponentName;

//
// Prototypes
// Driver model protocol interface
//
EFI_STATUS
EFIAPI
USBMassStorageDriverBindingEntryPoint (
  IN EFI_HANDLE           ImageHandle,
  IN EFI_SYSTEM_TABLE     *SystemTable
  );

EFI_STATUS
EFIAPI
USBFloppyDriverBindingSupported (
  IN EFI_DRIVER_BINDING_PROTOCOL    *This,
  IN EFI_HANDLE                     Controller,
  IN EFI_DEVICE_PATH_PROTOCOL       *RemainingDevicePath
  );

EFI_STATUS
EFIAPI
USBFloppyDriverBindingStart (
  IN EFI_DRIVER_BINDING_PROTOCOL    *This,
  IN EFI_HANDLE                     Controller,
  IN EFI_DEVICE_PATH_PROTOCOL       *RemainingDevicePath
  );

EFI_STATUS
EFIAPI
USBFloppyDriverBindingStop (
  IN  EFI_DRIVER_BINDING_PROTOCOL    *This,
  IN  EFI_HANDLE                     Controller,
  IN  UINTN                          NumberOfChildren,
  IN  EFI_HANDLE                     *ChildHandleBuffer
  );

//
// Block I/O Protocol Interface
//
STATIC
EFI_STATUS
EFIAPI
USBFloppyReset (
  IN  EFI_BLOCK_IO_PROTOCOL   *This,
  IN  BOOLEAN                 ExtendedVerification
  );

STATIC
EFI_STATUS
EFIAPI
USBFloppyReadBlocks (
  IN  EFI_BLOCK_IO_PROTOCOL   *This,
  IN  UINT32                  MediaId,
  IN  EFI_LBA                 LBA,
  IN  UINTN                   BufferSize,
  OUT VOID                    *Buffer
  );

STATIC
EFI_STATUS
EFIAPI
USBFloppyWriteBlocks (
  IN  EFI_BLOCK_IO_PROTOCOL   *This,
  IN  UINT32                  MediaId,
  IN  EFI_LBA                 LBA,
  IN  UINTN                   BufferSize,
  IN  VOID                    *Buffer
  );

STATIC
EFI_STATUS
EFIAPI
USBFloppyFlushBlocks (
  IN  EFI_BLOCK_IO_PROTOCOL   *This
  );

//
// USB Floppy Driver Global Variables
//
EFI_DRIVER_BINDING_PROTOCOL         gUSBFloppyDriverBinding = {
  USBFloppyDriverBindingSupported,
  USBFloppyDriverBindingStart,
  USBFloppyDriverBindingStop,
  0x10,
  NULL,
  NULL
};


EFI_DRIVER_ENTRY_POINT (USBMassStorageDriverBindingEntryPoint)

EFI_STATUS
EFIAPI
USBMassStorageDriverBindingEntryPoint (
  IN EFI_HANDLE           ImageHandle,
  IN EFI_SYSTEM_TABLE     *SystemTable
  )
/*++

  Routine Description:
    Entry point for EFI drivers.

  Arguments:
   ImageHandle - EFI_HANDLE
   SystemTable - EFI_SYSTEM_TABLE
  Returns:
    EFI_SUCCESS
    others

--*/
{
  EFI_STATUS  Status;

  //
  // Install driver binding protocol
  //
  Status = EfiLibInstallAllDriverProtocols (
            ImageHandle,
            SystemTable,
            &gUSBFloppyDriverBinding,
            ImageHandle,
            &gUsbMassStorageComponentName,
            NULL,
            NULL
            );

  return Status;
}


EFI_STATUS
EFIAPI
USBFloppyDriverBindingSupported (
  IN EFI_DRIVER_BINDING_PROTOCOL    *This,
  IN EFI_HANDLE                     Controller,
  IN EFI_DEVICE_PATH_PROTOCOL       *RemainingDevicePath
  )
/*++

  Routine Description:
    Test to see if this driver supports ControllerHandle. Any ControllerHandle
    that has UsbHcProtocol installed will be supported.

  Arguments:
    This                - Protocol instance pointer.
    Controller         - Handle of device to test
    RemainingDevicePath - Not used

  Returns:
    EFI_SUCCESS         - This driver supports this device.
    EFI_UNSUPPORTED     - This driver does not support this device.

--*/
{
  EFI_STATUS              OpenStatus;
  EFI_USB_ATAPI_PROTOCOL  *AtapiProtocol;

  //
  // check whether EFI_USB_ATAPI_PROTOCOL exists, if it does,
  // then the controller must be a USB Mass Storage Controller
  //
  OpenStatus = gBS->OpenProtocol (
                      Controller,
                      &gEfiUsbAtapiProtocolGuid,
                      &AtapiProtocol,
                      This->DriverBindingHandle,
                      Controller,
                      EFI_OPEN_PROTOCOL_BY_DRIVER
                      );
  if (EFI_ERROR (OpenStatus)) {
    return OpenStatus;
  }

  gBS->CloseProtocol (
        Controller,
        &gEfiUsbAtapiProtocolGuid,
        This->DriverBindingHandle,
        Controller
        );

  return EFI_SUCCESS;
}

EFI_STATUS
EFIAPI
USBFloppyDriverBindingStart (
  IN EFI_DRIVER_BINDING_PROTOCOL    *This,
  IN EFI_HANDLE                     Controller,
  IN EFI_DEVICE_PATH_PROTOCOL       *RemainingDevicePath
  )
/*++

  Routine Description:
    Starting the Usb Bus Driver

  Arguments:
    This                - Protocol instance pointer.
    Controller          - Handle of device to test
    RemainingDevicePath - Not used

  Returns:
    EFI_SUCCESS         - This driver supports this device.
    EFI_UNSUPPORTED     - This driver does not support this device.
    EFI_DEVICE_ERROR    - This driver cannot be started due to device
                          Error
    EFI_OUT_OF_RESOURCES- Can't allocate memory resources
    EFI_ALREADY_STARTED - Thios driver has been started
--*/
{ 
  EFI_STATUS                Status; 
  EFI_USB_ATAPI_PROTOCOL    *AtapiProtocol;
  USB_FLOPPY_DEV            *UsbFloppyDevice;
  
  UsbFloppyDevice = NULL;
  //
  // Check whether Usb Atapi Protocol attached on the controller handle.
  //
  Status = gBS->OpenProtocol (
                  Controller,
                  &gEfiUsbAtapiProtocolGuid,
                  &AtapiProtocol,
                  This->DriverBindingHandle,
                  Controller,
                  EFI_OPEN_PROTOCOL_BY_DRIVER
                  );
  if (EFI_ERROR (Status)) {
    return Status;
  }

  Status = gBS->AllocatePool (
                  EfiBootServicesData,
                  sizeof (USB_FLOPPY_DEV),
                  &UsbFloppyDevice
                  );
  if (EFI_ERROR (Status)) {
    gBS->CloseProtocol (
          Controller,
          &gEfiUsbAtapiProtocolGuid,
          This->DriverBindingHandle,
          Controller
          );
    return Status;
  }

  EfiZeroMem (UsbFloppyDevice, sizeof (USB_FLOPPY_DEV));

  UsbFloppyDevice->Handle             = Controller;
  UsbFloppyDevice->BlkIo.Media        = &UsbFloppyDevice->BlkMedia;
  UsbFloppyDevice->Signature          = USB_FLOPPY_DEV_SIGNATURE;
  UsbFloppyDevice->BlkIo.Reset        = USBFloppyReset;
  UsbFloppyDevice->BlkIo.ReadBlocks   = USBFloppyReadBlocks;
  UsbFloppyDevice->BlkIo.WriteBlocks  = USBFloppyWriteBlocks;
  UsbFloppyDevice->BlkIo.FlushBlocks  = USBFloppyFlushBlocks;
  UsbFloppyDevice->AtapiProtocol      = AtapiProtocol;
  UsbFloppyDevice->NeedReadCapacity   = TRUE;

  //
  // Identify drive type and retrieve media information.
  //
  Status = USBFloppyIdentify (UsbFloppyDevice);
  if (EFI_ERROR (Status)) {
    if (UsbFloppyDevice->SenseData != NULL) {
      gBS->FreePool (UsbFloppyDevice->SenseData);
    }

    gBS->FreePool (UsbFloppyDevice);
    gBS->CloseProtocol (
          Controller,
          &gEfiUsbAtapiProtocolGuid,
          This->DriverBindingHandle,
          Controller
          );
    return Status;
  }
  //
  // Install Block I/O protocol for the usb floppy device.
  //
  Status = gBS->InstallProtocolInterface (
                  &Controller,
                  &gEfiBlockIoProtocolGuid,
                  EFI_NATIVE_INTERFACE,
                  &UsbFloppyDevice->BlkIo
                  );
  if (EFI_ERROR (Status)) {
    if (UsbFloppyDevice->SenseData != NULL) {
      gBS->FreePool (UsbFloppyDevice->SenseData);
    }

    gBS->FreePool (UsbFloppyDevice);
    gBS->CloseProtocol (
          Controller,
          &gEfiUsbAtapiProtocolGuid,
          This->DriverBindingHandle,
          Controller
          );
    return Status;
  }

  return EFI_SUCCESS;

}


EFI_STATUS
EFIAPI
USBFloppyDriverBindingStop (
  IN  EFI_DRIVER_BINDING_PROTOCOL     *This,
  IN  EFI_HANDLE                      Controller,
  IN  UINTN                           NumberOfChildren,
  IN  EFI_HANDLE                      *ChildHandleBuffer
  )
/*++

  Routine Description:
    Stop this driver on ControllerHandle. Support stoping any child handles
    created by this driver.

  Arguments:
    This              - Protocol instance pointer.
    Controller        - Handle of device to stop driver on
    NumberOfChildren  - Number of Children in the ChildHandleBuffer
    ChildHandleBuffer - List of handles for the children we need to stop.

  Returns:
    EFI_SUCCESS
    EFI_DEVICE_ERROR
    others

--*/  
{
  EFI_STATUS            Status;
  USB_FLOPPY_DEV        *UsbFloppyDevice;
  EFI_BLOCK_IO_PROTOCOL *BlkIo;

  //
  // First find USB_FLOPPY_DEV
  //
  gBS->OpenProtocol (
        Controller,
        &gEfiBlockIoProtocolGuid,
        &BlkIo,
        This->DriverBindingHandle,
        Controller,
        EFI_OPEN_PROTOCOL_GET_PROTOCOL
        );

  UsbFloppyDevice = USB_FLOPPY_DEV_FROM_THIS (BlkIo);

  //
  // Uninstall Block I/O protocol from the device handle