usbmassstorage.c

Next BIOS Source code : Extensible Firmware Interface

/*++

Copyright (c)  1999 - 2002 Intel Corporation. All rights reserved
This software and associated documentation (if any) is furnished
under a license and may only be used or copied in accordance
with the terms of the license. Except as permitted by such
license, no part of this software or documentation may be
reproduced, stored in a retrieval system, or transmitted in any
form or by any means without the express written consent of
Intel Corporation.


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
USBMassStorageDriverBindingEntryPoint (
  IN EFI_HANDLE           ImageHandle,
  IN EFI_SYSTEM_TABLE     *SystemTable
  );

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

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

EFI_STATUS
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
USBMassStorageDriverBindingEntryPoint (
  IN EFI_HANDLE           ImageHandle,
  IN EFI_SYSTEM_TABLE     *SystemTable
  )
/*++
  
  Routine Description:
    Driver Entry Point.
        
  Arguments:
    (Standard EFI Image entry - EFI_IMAGE_ENTRY_POINT)
  
  Returns:
    EFI_STATUS
  
--*/       
{
  EFI_STATUS  Status;

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

  return Status;
}


EFI_STATUS
USBFloppyDriverBindingSupported (
  IN EFI_DRIVER_BINDING_PROTOCOL  *This,
  IN EFI_HANDLE                     Controller,
  IN EFI_DEVICE_PATH_PROTOCOL       *RemainingDevicePath
  )  
/*++
  
  Routine Description:
    Supported.
    
  Arguments:
    (Standard DriverBinding Protocol Supported() function)
    
  Returns:
    EFI_STATUS
  
--*/ 
{
  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
USBFloppyDriverBindingStart (
  IN EFI_DRIVER_BINDING_PROTOCOL    *This,
  IN EFI_HANDLE                     Controller,
  IN EFI_DEVICE_PATH_PROTOCOL       *RemainingDevicePath
  )
/*++
  
  Routine Description:
    Start.
  
  Arguments:
    (Standard DriverBinding Protocol Start() function)
    
  Returns:
    EFI_STATUS
  
--*/       
{ 
  EFI_STATUS          Status; 
  EFI_USB_ATAPI_PROTOCOL    *AtapiProtocol;
  USB_FLOPPY_DEV      *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;

  //
  // 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
USBFloppyDriverBindingStop (
  IN  EFI_DRIVER_BINDING_PROTOCOL     *This,
  IN  EFI_HANDLE                      Controller,
  IN  UINTN                           NumberOfChildren,
  IN  EFI_HANDLE                      *ChildHandleBuffer
  )
/*++
  
  Routine Description:
    Stop.
  
  Arguments:
    (Standard DriverBinding Protocol Stop() function)
  
  Returns:
    EFI_STATUS
  
--*/       
{
  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
  //
  Status = gBS->UninstallProtocolInterface(
                  Controller,
                  &gEfiBlockIoProtocolGuid,    
                  &UsbFloppyDevice->BlkIo
                  );
  if (EFI_ERROR (Status)) {
    return Status;
  }

  //  
  // Stop using EFI_USB_ATAPI_PROTOCOL
  //
  gBS->CloseProtocol (
           Controller, 
           &gEfiUsbAtapiProtocolGuid, 
           This->DriverBindingHandle,   
           Controller   
           );

  if (UsbFloppyDevice->SenseData != NULL) {
    gBS->FreePool (UsbFloppyDevice->SenseData);
  }

  gBS->FreePool (UsbFloppyDevice);
      
  return EFI_SUCCESS;
}


STATIC
EFI_STATUS 
EFIAPI 
USBFloppyReset (
    IN  EFI_BLOCK_IO_PROTOCOL   *This, 
    IN  BOOLEAN                 ExtendedVerification
    )
/*++

  Routine Description:
    Implements EFI_BLOCK_IO_PROTOCOL.Reset() function.
  
  Arguments:
    This:     The EFI_BLOCK_IO_PROTOCOL instance.