UsbBotPeim.c

Go to the documentation of this file.

 
#include "UsbBotPeim.h"
#include "BotPeim.h"
 
//
// Global function
//
EFI_PEI_NOTIFY_DESCRIPTOR  mNotifyList = {
  EFI_PEI_PPI_DESCRIPTOR_NOTIFY_DISPATCH | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST,
  &gPeiUsbIoPpiGuid,
  NotifyOnUsbIoPpi
};
 
EFI_PEI_RECOVERY_BLOCK_IO_PPI  mRecoveryBlkIoPpi = {
  BotGetNumberOfBlockDevices,
  BotGetMediaInfo,
  BotReadBlocks
};
 
EFI_PEI_RECOVERY_BLOCK_IO2_PPI  mRecoveryBlkIo2Ppi = {
  EFI_PEI_RECOVERY_BLOCK_IO2_PPI_REVISION,
  BotGetNumberOfBlockDevices2,
  BotGetMediaInfo2,
  BotReadBlocks2
};
 
EFI_PEI_PPI_DESCRIPTOR  mPpiList[2] = {
  {
    EFI_PEI_PPI_DESCRIPTOR_PPI,
    &gEfiPeiVirtualBlockIoPpiGuid,
    NULL
  },
  {
    EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST,
    &gEfiPeiVirtualBlockIo2PpiGuid,
    NULL
  }
};
 
EFI_STATUS
PeiBotDetectMedia (
  IN  EFI_PEI_SERVICES  **PeiServices,
  IN  PEI_BOT_DEVICE    *PeiBotDev
  );
 
EFI_STATUS
EFIAPI
PeimInitializeUsbBot (
  IN EFI_PEI_FILE_HANDLE     FileHandle,
  IN CONST EFI_PEI_SERVICES  **PeiServices
  )
{
  EFI_STATUS              Status;
  UINTN                   UsbIoPpiInstance;
  EFI_PEI_PPI_DESCRIPTOR  *TempPpiDescriptor;
  PEI_USB_IO_PPI          *UsbIoPpi;
 
  //
  // Shadow this PEIM to run from memory
  //
  if (!EFI_ERROR (PeiServicesRegisterForShadow (FileHandle))) {
    return EFI_SUCCESS;
  }
 
  //
  // locate all usb io PPIs
  //
  for (UsbIoPpiInstance = 0; UsbIoPpiInstance < PEI_FAT_MAX_USB_IO_PPI; UsbIoPpiInstance++) {
    Status = PeiServicesLocatePpi (
               &gPeiUsbIoPpiGuid,
               UsbIoPpiInstance,
               &TempPpiDescriptor,
               (VOID **)&UsbIoPpi
               );
    if (EFI_ERROR (Status)) {
      break;
    }
  }
 
  //
  // Register a notify function
  //
  return PeiServicesNotifyPpi (&mNotifyList);
}
 
EFI_STATUS
EFIAPI
NotifyOnUsbIoPpi (
  IN  EFI_PEI_SERVICES           **PeiServices,
  IN  EFI_PEI_NOTIFY_DESCRIPTOR  *NotifyDesc,
  IN  VOID                       *InvokePpi
  )
{
  PEI_USB_IO_PPI  *UsbIoPpi;
 
  UsbIoPpi = (PEI_USB_IO_PPI *)InvokePpi;
 
  InitUsbBot (PeiServices, UsbIoPpi);
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
InitUsbBot (
  IN  EFI_PEI_SERVICES  **PeiServices,
  IN  PEI_USB_IO_PPI    *UsbIoPpi
  )
{
  PEI_BOT_DEVICE                *PeiBotDevice;
  EFI_STATUS                    Status;
  EFI_USB_INTERFACE_DESCRIPTOR  *InterfaceDesc;
  UINTN                         MemPages;
  EFI_PHYSICAL_ADDRESS          AllocateAddress;
  EFI_USB_ENDPOINT_DESCRIPTOR   *EndpointDesc;
  UINT8                         Index;
 
  //
  // Check its interface
  //
  Status = UsbIoPpi->UsbGetInterfaceDescriptor (
                       PeiServices,
                       UsbIoPpi,
                       &InterfaceDesc
                       );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  //
  // Check if it is the BOT device we support
  //
  if ((InterfaceDesc->InterfaceClass != 0x08) || (InterfaceDesc->InterfaceProtocol != 0x50)) {
    return EFI_NOT_FOUND;
  }
 
  MemPages = sizeof (PEI_BOT_DEVICE) / EFI_PAGE_SIZE + 1;
  Status   = PeiServicesAllocatePages (
               EfiBootServicesCode,
               MemPages,
               &AllocateAddress
               );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  PeiBotDevice = (PEI_BOT_DEVICE *)((UINTN)AllocateAddress);
 
  PeiBotDevice->Signature       = PEI_BOT_DEVICE_SIGNATURE;
  PeiBotDevice->UsbIoPpi        = UsbIoPpi;
  PeiBotDevice->AllocateAddress = (UINTN)AllocateAddress;
  PeiBotDevice->BotInterface    = InterfaceDesc;
 
  //
  // Default value
  //
  PeiBotDevice->Media.DeviceType      = UsbMassStorage;
  PeiBotDevice->Media.BlockSize       = 0x200;
  PeiBotDevice->Media2.InterfaceType  = MSG_USB_DP;
  PeiBotDevice->Media2.BlockSize      = 0x200;
  PeiBotDevice->Media2.RemovableMedia = FALSE;
  PeiBotDevice->Media2.ReadOnly       = FALSE;
 
  //
  // Check its Bulk-in/Bulk-out endpoint
  //
  for (Index = 0; Index < 2; Index++) {
    Status = UsbIoPpi->UsbGetEndpointDescriptor (
                         PeiServices,
                         UsbIoPpi,
                         Index,
                         &EndpointDesc
                         );
 
    if (EFI_ERROR (Status)) {
      return Status;
    }
 
    if ((EndpointDesc->EndpointAddress & 0x80) != 0) {
      PeiBotDevice->BulkInEndpoint = EndpointDesc;
    } else {
      PeiBotDevice->BulkOutEndpoint = EndpointDesc;
    }
  }
 
  CopyMem (
    &(PeiBotDevice->BlkIoPpi),
    &mRecoveryBlkIoPpi,
    sizeof (EFI_PEI_RECOVERY_BLOCK_IO_PPI)
    );
  CopyMem (
    &(PeiBotDevice->BlkIo2Ppi),
    &mRecoveryBlkIo2Ppi,
    sizeof (EFI_PEI_RECOVERY_BLOCK_IO2_PPI)
    );
  CopyMem (
    &(PeiBotDevice->BlkIoPpiList),
    &mPpiList[0],
    sizeof (EFI_PEI_PPI_DESCRIPTOR)
    );
  CopyMem (
    &(PeiBotDevice->BlkIo2PpiList),
    &mPpiList[1],
    sizeof (EFI_PEI_PPI_DESCRIPTOR)
    );
  PeiBotDevice->BlkIoPpiList.Ppi  = &PeiBotDevice->BlkIoPpi;
  PeiBotDevice->BlkIo2PpiList.Ppi = &PeiBotDevice->BlkIo2Ppi;
 
  Status = PeiUsbInquiry (PeiServices, PeiBotDevice);
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  Status = PeiServicesAllocatePages (
             EfiBootServicesCode,
             1,
             &AllocateAddress
             );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  PeiBotDevice->SensePtr = (ATAPI_REQUEST_SENSE_DATA *)((UINTN)AllocateAddress);
 
  Status = PeiServicesInstallPpi (&PeiBotDevice->BlkIoPpiList);
 
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
BotGetNumberOfBlockDevices (
  IN  EFI_PEI_SERVICES               **PeiServices,
  IN  EFI_PEI_RECOVERY_BLOCK_IO_PPI  *This,
  OUT UINTN                          *NumberBlockDevices
  )
{
  //
  // For Usb devices, this value should be always 1
  //
  *NumberBlockDevices = 1;
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
BotGetMediaInfo (
  IN  EFI_PEI_SERVICES               **PeiServices,
  IN  EFI_PEI_RECOVERY_BLOCK_IO_PPI  *This,
  IN  UINTN                          DeviceIndex,
  OUT EFI_PEI_BLOCK_IO_MEDIA         *MediaInfo
  )
{
  PEI_BOT_DEVICE  *PeiBotDev;
  EFI_STATUS      Status;
 
  PeiBotDev = PEI_BOT_DEVICE_FROM_THIS (This);
 
  //
  // First test unit ready
  //
  PeiUsbTestUnitReady (
    PeiServices,
    PeiBotDev
    );
 
  Status = PeiBotDetectMedia (
             PeiServices,
             PeiBotDev
             );
 
  if (EFI_ERROR (Status)) {
    return EFI_DEVICE_ERROR;
  }
 
  CopyMem (
    MediaInfo,
    &(PeiBotDev->Media),
    sizeof (EFI_PEI_BLOCK_IO_MEDIA)
    );
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
BotReadBlocks (
  IN  EFI_PEI_SERVICES               **PeiServices,
  IN  EFI_PEI_RECOVERY_BLOCK_IO_PPI  *This,
  IN  UINTN                          DeviceIndex,
  IN  EFI_PEI_LBA                    StartLBA,
  IN  UINTN                          BufferSize,
  OUT VOID                           *Buffer
  )
{
  PEI_BOT_DEVICE  *PeiBotDev;
  EFI_STATUS      Status;
  UINTN           BlockSize;
  UINTN           NumberOfBlocks;
 
  Status    = EFI_SUCCESS;
  PeiBotDev = PEI_BOT_DEVICE_FROM_THIS (This);
 
  //
  // Check parameters
  //
  if (Buffer == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  if (BufferSize == 0) {
    return EFI_SUCCESS;
  }
 
  if (!PeiBotDev->Media.MediaPresent) {
    return EFI_NO_MEDIA;
  }
 
  BlockSize = PeiBotDev->Media.BlockSize;
 
  if (BufferSize % BlockSize != 0) {
    Status = EFI_BAD_BUFFER_SIZE;
  }
 
  if (StartLBA > PeiBotDev->Media2.LastBlock) {
    Status = EFI_INVALID_PARAMETER;
  }
 
  NumberOfBlocks = BufferSize / (PeiBotDev->Media.BlockSize);
 
  if (Status == EFI_SUCCESS) {
    Status = PeiUsbTestUnitReady (
               PeiServices,
               PeiBotDev
               );
    if (Status == EFI_SUCCESS) {
      Status = PeiUsbRead10 (
                 PeiServices,
                 PeiBotDev,
                 Buffer,
                 StartLBA,
                 1
                 );
    }
  } else {
    //
    // To generate sense data for DetectMedia use.
    //
    PeiUsbTestUnitReady (
      PeiServices,
      PeiBotDev
      );
  }
 
  if (EFI_ERROR (Status)) {
    //
    // if any error encountered, detect what happened to the media and
    // update the media info accordingly.
    //
    Status = PeiBotDetectMedia (
               PeiServices,
               PeiBotDev
               );
    if (Status != EFI_SUCCESS) {
      return EFI_DEVICE_ERROR;
    }
 
    NumberOfBlocks = BufferSize / PeiBotDev->Media.BlockSize;
 
    if (!(PeiBotDev->Media.MediaPresent)) {
      return EFI_NO_MEDIA;
    }
 
    if (BufferSize % (PeiBotDev->Media.BlockSize) != 0) {
      return EFI_BAD_BUFFER_SIZE;
    }
 
    if (StartLBA > PeiBotDev->Media2.LastBlock) {
      return EFI_INVALID_PARAMETER;
    }
 
    if ((StartLBA + NumberOfBlocks - 1) > PeiBotDev->Media2.LastBlock) {
      return EFI_INVALID_PARAMETER;
    }
 
    Status = PeiUsbRead10 (
               PeiServices,
               PeiBotDev,
               Buffer,
               StartLBA,
               NumberOfBlocks
               );
 
    switch (Status) {
      case EFI_SUCCESS:
        return EFI_SUCCESS;
 
      default:
        return EFI_DEVICE_ERROR;
    }
  } else {
    StartLBA       += 1;
    NumberOfBlocks -= 1;
    Buffer          = (UINT8 *)Buffer + PeiBotDev->Media.BlockSize;
 
    if (NumberOfBlocks == 0) {
      return EFI_SUCCESS;
    }
 
    Status = PeiUsbRead10 (
               PeiServices,
               PeiBotDev,
               Buffer,
               StartLBA,
               NumberOfBlocks
               );
    switch (Status) {
      case EFI_SUCCESS:
        return EFI_SUCCESS;
 
      default:
        return EFI_DEVICE_ERROR;
    }
  }
}
 
EFI_STATUS
EFIAPI
BotGetNumberOfBlockDevices2 (
  IN  EFI_PEI_SERVICES                **PeiServices,
  IN  EFI_PEI_RECOVERY_BLOCK_IO2_PPI  *This,
  OUT UINTN                           *NumberBlockDevices
  )
{
  //
  // For Usb devices, this value should be always 1
  //
  *NumberBlockDevices = 1;
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
BotGetMediaInfo2 (
  IN  EFI_PEI_SERVICES                **PeiServices,
  IN  EFI_PEI_RECOVERY_BLOCK_IO2_PPI  *This,
  IN  UINTN                           DeviceIndex,
  OUT EFI_PEI_BLOCK_IO2_MEDIA         *MediaInfo
  )
{
  PEI_BOT_DEVICE  *PeiBotDev;
  EFI_STATUS      Status;
 
  PeiBotDev = PEI_BOT_DEVICE2_FROM_THIS (This);
 
  Status = BotGetMediaInfo (
             PeiServices,
             &PeiBotDev->BlkIoPpi,
             DeviceIndex,
             &PeiBotDev->Media
             );
 
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  CopyMem (
    MediaInfo,
    &(PeiBotDev->Media2),
    sizeof (EFI_PEI_BLOCK_IO2_MEDIA)
    );
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
BotReadBlocks2 (
  IN  EFI_PEI_SERVICES                **PeiServices,
  IN  EFI_PEI_RECOVERY_BLOCK_IO2_PPI  *This,
  IN  UINTN                           DeviceIndex,
  IN  EFI_PEI_LBA                     StartLBA,
  IN  UINTN                           BufferSize,
  OUT VOID                            *Buffer
  )
{
  PEI_BOT_DEVICE  *PeiBotDev;
  EFI_STATUS      Status;
 
  if (This == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  Status    = EFI_SUCCESS;
  PeiBotDev = PEI_BOT_DEVICE2_FROM_THIS (This);
 
  Status = BotReadBlocks (
             PeiServices,
             &PeiBotDev->BlkIoPpi,
             DeviceIndex,
             StartLBA,
             BufferSize,
             Buffer
             );
 
  return Status;
}
 
EFI_STATUS
PeiBotDetectMedia (
  IN  EFI_PEI_SERVICES  **PeiServices,
  IN  PEI_BOT_DEVICE    *PeiBotDev
  )
{
  EFI_STATUS                Status;
  EFI_STATUS                FloppyStatus;
  UINTN                     SenseCounts;
  BOOLEAN                   NeedReadCapacity;
  EFI_PHYSICAL_ADDRESS      AllocateAddress;
  ATAPI_REQUEST_SENSE_DATA  *SensePtr;
  UINTN                     Retry;
 
  //
  // if there is no media present,or media not changed,
  // the request sense command will detect faster than read capacity command.
  // read capacity command can be bypassed, thus improve performance.
  //
  SenseCounts      = 0;
  NeedReadCapacity = TRUE;
 
  Status = PeiServicesAllocatePages (
             EfiBootServicesCode,
             1,
             &AllocateAddress
             );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  SensePtr = PeiBotDev->SensePtr;
  ZeroMem (SensePtr, EFI_PAGE_SIZE);
 
  Status = PeiUsbRequestSense (
             PeiServices,
             PeiBotDev,
             &SenseCounts,
             (UINT8 *)SensePtr
             );
 
  if (Status == EFI_SUCCESS) {
    //
    // No Media
    //
    if (IsNoMedia (SensePtr, SenseCounts)) {
      NeedReadCapacity               = FALSE;
      PeiBotDev->Media.MediaPresent  = FALSE;
      PeiBotDev->Media.LastBlock     = 0;
      PeiBotDev->Media2.MediaPresent = FALSE;
      PeiBotDev->Media2.LastBlock    = 0;
    } else {
      //
      // Media Changed
      //
      if (IsMediaChange (SensePtr, SenseCounts)) {
        PeiBotDev->Media.MediaPresent  = TRUE;
        PeiBotDev->Media2.MediaPresent = TRUE;
      }
 
      //
      // Media Error
      //
      if (IsMediaError (SensePtr, SenseCounts)) {
        //
        // if media error encountered, make it look like no media present.
        //
        PeiBotDev->Media.MediaPresent  = FALSE;
        PeiBotDev->Media.LastBlock     = 0;
        PeiBotDev->Media2.MediaPresent = FALSE;
        PeiBotDev->Media2.LastBlock    = 0;
      }
    }
  }
 
  if (NeedReadCapacity) {
    //
    // Retry at most 4 times to detect media info
    //
    for (Retry = 0; Retry < 4; Retry++) {
      switch (PeiBotDev->DeviceType) {
        case USBCDROM:
          Status = PeiUsbReadCapacity (
                     PeiServices,
                     PeiBotDev
                     );
          break;
 
        case USBFLOPPY2:
          Status = PeiUsbReadFormattedCapacity (
                     PeiServices,
                     PeiBotDev
                     );
          if (EFI_ERROR (Status) ||
              !PeiBotDev->Media.MediaPresent)
          {
            //
            // retry the ReadCapacity command
            //
            PeiBotDev->DeviceType = USBFLOPPY;
            Status                = EFI_DEVICE_ERROR;
          }
 
          break;
 
        case USBFLOPPY:
          Status = PeiUsbReadCapacity (
                     PeiServices,
                     PeiBotDev
                     );
          if (EFI_ERROR (Status)) {
            //
            // retry the ReadFormatCapacity command
            //
            PeiBotDev->DeviceType = USBFLOPPY2;
          }
 
          break;
 
        default:
          return EFI_INVALID_PARAMETER;
      }
 
      SenseCounts = 0;
      ZeroMem (SensePtr, EFI_PAGE_SIZE);
 
      if (Status == EFI_SUCCESS) {
        break;
      }
 
      FloppyStatus = PeiUsbRequestSense (
                       PeiServices,
                       PeiBotDev,
                       &SenseCounts,
                       (UINT8 *)SensePtr
                       );
 
      //
      // If Request Sense data failed,retry.
      //
      if (EFI_ERROR (FloppyStatus)) {
        continue;
      }
 
      //
      // No Media
      //
      if (IsNoMedia (SensePtr, SenseCounts)) {
        PeiBotDev->Media.MediaPresent  = FALSE;
        PeiBotDev->Media.LastBlock     = 0;
        PeiBotDev->Media2.MediaPresent = FALSE;
        PeiBotDev->Media2.LastBlock    = 0;
        break;
      }
 
      if (IsMediaError (SensePtr, SenseCounts)) {
        //
        // if media error encountered, make it look like no media present.
        //
        PeiBotDev->Media.MediaPresent  = FALSE;
        PeiBotDev->Media.LastBlock     = 0;
        PeiBotDev->Media2.MediaPresent = FALSE;
        PeiBotDev->Media2.LastBlock    = 0;
        break;
      }
    }
 
    //
    // ENDFOR
    //
    // tell whether the readcapacity process is successful or not
    // ("Status" variable record the latest status returned
    // by ReadCapacity )
    //
    if (Status != EFI_SUCCESS) {
      return EFI_DEVICE_ERROR;
    }
  }
 
  return EFI_SUCCESS;
}