usbmassstorage.c

Next BIOS Source code : Extensible Firmware Interface

    ExtendedVerification:
              Indicates that the driver may perform a more exhaustive
              verification operation of the device during reset.
              (This parameter is ingored in this driver.)
    
  Returns:  

--*/      
{
  USB_FLOPPY_DEV              *UsbFloppyDevice;
  EFI_USB_ATAPI_PROTOCOL      *UsbAtapiInterface;
  EFI_STATUS                  Status;
  
  UsbFloppyDevice = USB_FLOPPY_DEV_FROM_THIS(This);
  
  UsbAtapiInterface = UsbFloppyDevice->AtapiProtocol;
  
  //
  // directly calling EFI_USB_ATAPI_PROTOCOL.Reset() to implement reset.
  //
  Status = UsbAtapiInterface->UsbAtapiReset(UsbAtapiInterface, TRUE);
  
  return Status;
} 

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

  Routine Description:
    Implements EFI_BLOCK_IO_PROTOCOL.ReadBlocks() function.
  
  Arguments:
    This:     The EFI_BLOCK_IO_PROTOCOL instance.
    MediaId:  The media id that the read request is for.
    LBA:      The starting logical block address to read from on the device.
    BufferSize:
              The size of the Buffer in bytes. This must be a multiple of 
              the intrinsic block size of the device.
    Buffer:   A pointer to the destination buffer for the data. The caller 
              is responsible for either having implicit or explicit ownership
              of the buffer.                               
  
  Returns:  

--*/      
{
  USB_FLOPPY_DEV        *UsbFloppyDevice;
  EFI_STATUS            Status;  
  EFI_BLOCK_IO_MEDIA    *Media;
  UINTN                 BlockSize;            
  UINTN                 NumberOfBlocks ;
  BOOLEAN               MediaChange;
  
  Status = EFI_SUCCESS;
  MediaChange = FALSE;
  
  UsbFloppyDevice = USB_FLOPPY_DEV_FROM_THIS(This);
  
  //
  // Check parameters
  //
  
  Media     = UsbFloppyDevice->BlkIo.Media ;
  BlockSize = Media->BlockSize ;
  NumberOfBlocks = BufferSize / BlockSize ;

  //
  //Check buffer alignment
  //
  if((Media->IoAlign > 1) && ((UINTN)Buffer & (UINTN)(Media->IoAlign -1 ))){
    return EFI_INVALID_PARAMETER;
  }
  
  if ( !(Media -> MediaPresent)) {
    Status = EFI_NO_MEDIA;
  }    
  
  if (MediaId != Media->MediaId) {
    Status = EFI_MEDIA_CHANGED;
  }
  
  if (LBA > Media->LastBlock) {
    Status = EFI_INVALID_PARAMETER;
  }
  
  if ((LBA + NumberOfBlocks - 1) > Media->LastBlock) {
    Status = EFI_INVALID_PARAMETER;
  }   
  
  if (BufferSize % BlockSize != 0) {
    Status = EFI_BAD_BUFFER_SIZE;
  }
    
  if (Buffer == NULL) {    
    return EFI_INVALID_PARAMETER;
  }

  if (BufferSize == 0 ) {    
    return EFI_SUCCESS;
  }  
  
  if (!EFI_ERROR(Status)) {
  
    Status = UsbFloppyTestUnitReady (UsbFloppyDevice);
    if (!EFI_ERROR(Status)) {
      Status = USBFloppyRead10 (UsbFloppyDevice, Buffer, LBA, 1);
    }
  } else {
    //
    // To generate sense data for DetectMedia use.
    //
    UsbFloppyTestUnitReady (UsbFloppyDevice);
  }
    
  if (EFI_ERROR(Status)) {
    //
    // if any error encountered, detect what happened to the media and
    // update the media info accordingly.
    //
    Status = UsbFloppyDetectMedia (UsbFloppyDevice,&MediaChange);
    if (EFI_ERROR(Status)) {
      return EFI_DEVICE_ERROR ;
    }
    if (MediaChange) {
      gBS->ReinstallProtocolInterface (UsbFloppyDevice->Handle,
                                      &gEfiBlockIoProtocolGuid,
                                      &UsbFloppyDevice->BlkIo,
                                      &UsbFloppyDevice->BlkIo
                                      );                                
    }
  
    //
    // Get the intrinsic block size
    //
    Media     = UsbFloppyDevice->BlkIo.Media ;
    BlockSize = Media->BlockSize ;
  
    NumberOfBlocks = BufferSize / BlockSize ;

    //
    //Check buffer alignment
    //
    if((Media->IoAlign > 1) && ((UINTN)Buffer & (UINTN)(Media->IoAlign -1 ))){
      return EFI_INVALID_PARAMETER;
    }

    
    if ( !(Media -> MediaPresent)) {
      return EFI_NO_MEDIA;
    }
  
    if (MediaId != Media->MediaId) {
      return EFI_MEDIA_CHANGED;
    }
  
    if (BufferSize % BlockSize != 0) {
      return EFI_BAD_BUFFER_SIZE;
    }
    
    if (LBA > Media->LastBlock) {
      return EFI_INVALID_PARAMETER;
    }
  
    if ((LBA + NumberOfBlocks - 1) > Media->LastBlock) {
      return EFI_INVALID_PARAMETER;
    }   
    
    Status = USBFloppyRead10 (UsbFloppyDevice, Buffer, LBA, NumberOfBlocks) ;
    if (EFI_ERROR(Status)) {
      This->Reset (This,TRUE);
      return EFI_DEVICE_ERROR;
    }
    return EFI_SUCCESS;
  
  } else {
    
    LBA += 1;
    NumberOfBlocks -= 1;
    Buffer = (UINT8*)Buffer + This->Media->BlockSize;
    
    if (NumberOfBlocks == 0) {
      return EFI_SUCCESS;
    }
    
    Status = USBFloppyRead10 ( UsbFloppyDevice, Buffer, LBA, NumberOfBlocks ) ;
    if (EFI_ERROR(Status)) {
      This->Reset (This,TRUE);
      return EFI_DEVICE_ERROR;
    }
    return EFI_SUCCESS;
  } 

}     

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

  Routine Description:
    Implements EFI_BLOCK_IO_PROTOCOL.WriteBlocks() function.
  
  Arguments:
    This:     The EFI_BLOCK_IO_PROTOCOL instance.
    MediaId:  The media id that the write request is for.
    LBA:      The starting logical block address to be written.
              The caller is responsible for writing to only 
              legitimate locations.
    BufferSize:
              The size of the Buffer in bytes. This must be a multiple of 
              the intrinsic block size of the device.
    Buffer:   A pointer to the source buffer for the data. The caller 
              is responsible for either having implicit or explicit ownership
              of the buffer.                               
  
  Returns:  

--*/        
{
  USB_FLOPPY_DEV          *UsbFloppyDevice;
  EFI_STATUS              Status;  
  EFI_BLOCK_IO_MEDIA      *Media;
  UINTN                   BlockSize;            
  UINTN                   NumberOfBlocks ;  
  BOOLEAN                 MediaChange;
  
  Status = EFI_SUCCESS;
  MediaChange = FALSE;
  
  UsbFloppyDevice = USB_FLOPPY_DEV_FROM_THIS(This);
  
  //
  // Check parameters.
  //  
  Media     = UsbFloppyDevice->BlkIo.Media ;
  BlockSize = Media->BlockSize ;
  NumberOfBlocks = BufferSize / BlockSize ;
  
  //
  //Check buffer alignment
  //
  if((Media->IoAlign > 1) && ((UINTN)Buffer & (UINTN)(Media->IoAlign -1 ))){
    return EFI_INVALID_PARAMETER;
  }

  if ( !(Media -> MediaPresent)) {
    Status = EFI_NO_MEDIA;
  }    
  
  if (MediaId != Media->MediaId) {
    Status = EFI_MEDIA_CHANGED;
  }

  if (Media->ReadOnly) {
    return EFI_WRITE_PROTECTED;
  }
  
  if (LBA > Media->LastBlock) {
    Status = EFI_INVALID_PARAMETER;
  }
  
  if ((LBA + NumberOfBlocks - 1) > Media->LastBlock) {
    Status = EFI_INVALID_PARAMETER;
  }   
  
  if (BufferSize % BlockSize != 0) {
    Status = EFI_BAD_BUFFER_SIZE;
  }
    
  if (Buffer == NULL) {    
    return EFI_INVALID_PARAMETER;
  }

  if (BufferSize == 0 ) {    
    return EFI_SUCCESS;
  }
  
  if (!EFI_ERROR(Status)) {
    Status = UsbFloppyTestUnitReady (UsbFloppyDevice);
    if (!EFI_ERROR(Status)) {
      Status = USBFloppyWrite10 ( UsbFloppyDevice, Buffer, LBA, 1) ;
    }
  } else {
    //
    // To generate sense data for DetectMedia use.
    //
    UsbFloppyTestUnitReady (UsbFloppyDevice);
  }
  
  if (EFI_ERROR(Status)) {
    //
    // if any error encountered, detect what happened to the media and
    // update the media info accordingly.
    //
    Status = UsbFloppyDetectMedia (UsbFloppyDevice,&MediaChange);
    if (EFI_ERROR(Status)) {
      return EFI_DEVICE_ERROR ;
    }
    if (MediaChange) {
      gBS->ReinstallProtocolInterface (UsbFloppyDevice->Handle,
                                      &gEfiBlockIoProtocolGuid,
                                      &UsbFloppyDevice->BlkIo,
                                      &UsbFloppyDevice->BlkIo
                                      );                                
    }
  
    //
    //Get the intrinsic block size
    //
    Media     = UsbFloppyDevice->BlkIo.Media ;
    BlockSize = Media->BlockSize ;
  
    NumberOfBlocks = BufferSize/BlockSize ;
    
    if ( !(Media -> MediaPresent)) {
      return EFI_NO_MEDIA;
    }
  
    if (MediaId != Media->MediaId) {
     return EFI_MEDIA_CHANGED;
    }
  
    if (BufferSize % BlockSize != 0) {
     return EFI_BAD_BUFFER_SIZE;
    }
    
    if (LBA > Media->LastBlock) {
     return EFI_INVALID_PARAMETER;
    }
  
    if ((LBA + NumberOfBlocks - 1) > Media->LastBlock) {
      return EFI_INVALID_PARAMETER;
    }
    
    //
    // Write blocks of data to device using command Write10.
    //
    Status = USBFloppyWrite10 ( UsbFloppyDevice, Buffer, LBA, NumberOfBlocks ) ;
    if (EFI_ERROR(Status)) {
      This->Reset (This,TRUE);
      return EFI_DEVICE_ERROR;
    }
    return EFI_SUCCESS;
    
  } else {
    LBA += 1;
    NumberOfBlocks -= 1;
    Buffer = (UINT8*)Buffer + This->Media->BlockSize;
    
    if (NumberOfBlocks == 0) {
      return EFI_SUCCESS;
    }
    
    Status = USBFloppyWrite10 ( UsbFloppyDevice, Buffer, LBA, NumberOfBlocks ) ;
    if (EFI_ERROR(Status)) {
      This->Reset (This,TRUE);
      return EFI_DEVICE_ERROR;
    }
    return EFI_SUCCESS;
  }  
}   
    
STATIC
EFI_STATUS 
EFIAPI 
USBFloppyFlushBlocks (
  IN  EFI_BLOCK_IO_PROTOCOL   *This
  )
/*++

  Routine Description:
    Implements EFI_BLOCK_IO_PROTOCOL.FlushBlocks() function.
    (In this driver, this function just returns EFI_SUCCESS.)
  
  Arguments:
    This:     The EFI_BLOCK_IO_PROTOCOL instance.
  
  Returns:  

--*/    
{
  return EFI_SUCCESS;
}