XenPvBlkDxe.c

Go to the documentation of this file.

 
#include "XenPvBlkDxe.h"
 
#include "BlockFront.h"
 
EFI_DRIVER_BINDING_PROTOCOL  gXenPvBlkDxeDriverBinding = {
  XenPvBlkDxeDriverBindingSupported,
  XenPvBlkDxeDriverBindingStart,
  XenPvBlkDxeDriverBindingStop,
  XEN_PV_BLK_DXE_VERSION,
  NULL,
  NULL
};
 
EFI_STATUS
EFIAPI
XenPvBlkDxeUnload (
  IN EFI_HANDLE  ImageHandle
  )
{
  EFI_STATUS  Status;
 
  EFI_HANDLE  *HandleBuffer;
  UINTN       HandleCount;
  UINTN       Index;
 
  //
  // Retrieve array of all handles in the handle database
  //
  Status = gBS->LocateHandleBuffer (
                  AllHandles,
                  NULL,
                  NULL,
                  &HandleCount,
                  &HandleBuffer
                  );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  //
  // Disconnect the current driver from handles in the handle database
  //
  for (Index = 0; Index < HandleCount; Index++) {
    gBS->DisconnectController (HandleBuffer[Index], gImageHandle, NULL);
  }
 
  //
  // Free the array of handles
  //
  FreePool (HandleBuffer);
 
  //
  // Uninstall protocols installed in the driver entry point
  //
  Status = gBS->UninstallMultipleProtocolInterfaces (
                  ImageHandle,
                  &gEfiDriverBindingProtocolGuid,
                  &gXenPvBlkDxeDriverBinding,
                  &gEfiComponentNameProtocolGuid,
                  &gXenPvBlkDxeComponentName,
                  &gEfiComponentName2ProtocolGuid,
                  &gXenPvBlkDxeComponentName2,
                  NULL
                  );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
XenPvBlkDxeDriverEntryPoint (
  IN EFI_HANDLE        ImageHandle,
  IN EFI_SYSTEM_TABLE  *SystemTable
  )
{
  EFI_STATUS  Status;
 
  //
  // Install UEFI Driver Model protocol(s).
  //
  Status = EfiLibInstallDriverBindingComponentName2 (
             ImageHandle,
             SystemTable,
             &gXenPvBlkDxeDriverBinding,
             ImageHandle,
             &gXenPvBlkDxeComponentName,
             &gXenPvBlkDxeComponentName2
             );
  ASSERT_EFI_ERROR (Status);
 
  return Status;
}
 
EFI_STATUS
EFIAPI
XenPvBlkDxeDriverBindingSupported (
  IN EFI_DRIVER_BINDING_PROTOCOL  *This,
  IN EFI_HANDLE                   ControllerHandle,
  IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath OPTIONAL
  )
{
  EFI_STATUS       Status;
  XENBUS_PROTOCOL  *XenBusIo;
 
  Status = gBS->OpenProtocol (
                  ControllerHandle,
                  &gXenBusProtocolGuid,
                  (VOID **)&XenBusIo,
                  This->DriverBindingHandle,
                  ControllerHandle,
                  EFI_OPEN_PROTOCOL_BY_DRIVER
                  );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  if (AsciiStrCmp (XenBusIo->Type, "vbd") == 0) {
    Status = EFI_SUCCESS;
  } else {
    Status = EFI_UNSUPPORTED;
  }
 
  gBS->CloseProtocol (
         ControllerHandle,
         &gXenBusProtocolGuid,
         This->DriverBindingHandle,
         ControllerHandle
         );
 
  return Status;
}
 
EFI_STATUS
EFIAPI
XenPvBlkDxeDriverBindingStart (
  IN EFI_DRIVER_BINDING_PROTOCOL  *This,
  IN EFI_HANDLE                   ControllerHandle,
  IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath OPTIONAL
  )
{
  EFI_STATUS              Status;
  XENBUS_PROTOCOL         *XenBusIo;
  XEN_BLOCK_FRONT_DEVICE  *Dev;
  EFI_BLOCK_IO_MEDIA      *Media;
 
  Status = gBS->OpenProtocol (
                  ControllerHandle,
                  &gXenBusProtocolGuid,
                  (VOID **)&XenBusIo,
                  This->DriverBindingHandle,
                  ControllerHandle,
                  EFI_OPEN_PROTOCOL_BY_DRIVER
                  );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  Status = XenPvBlockFrontInitialization (XenBusIo, XenBusIo->Node, &Dev);
  if (EFI_ERROR (Status)) {
    goto CloseProtocol;
  }
 
  CopyMem (&Dev->BlockIo, &gXenPvBlkDxeBlockIo, sizeof (EFI_BLOCK_IO_PROTOCOL));
  Media = AllocateCopyPool (
            sizeof (EFI_BLOCK_IO_MEDIA),
            &gXenPvBlkDxeBlockIoMedia
            );
  if (Dev->MediaInfo.VDiskInfo & VDISK_REMOVABLE) {
    Media->RemovableMedia = TRUE;
  }
 
  Media->MediaPresent = TRUE;
  Media->ReadOnly     = !Dev->MediaInfo.ReadWrite;
  if (Dev->MediaInfo.CdRom) {
    //
    // If it's a cdrom, the blocksize value need to be 2048 for OVMF to
    // recognize it as a cdrom:
    //    MdeModulePkg/Universal/Disk/PartitionDxe/ElTorito.c
    //
    Media->BlockSize = 2048;
    Media->LastBlock = DivU64x32 (
                         Dev->MediaInfo.Sectors,
                         Media->BlockSize / Dev->MediaInfo.SectorSize
                         ) - 1;
  } else {
    Media->BlockSize = Dev->MediaInfo.SectorSize;
    Media->LastBlock = Dev->MediaInfo.Sectors - 1;
  }
 
  ASSERT (Media->BlockSize % 512 == 0);
  Dev->BlockIo.Media = Media;
 
  Status = gBS->InstallMultipleProtocolInterfaces (
                  &ControllerHandle,
                  &gEfiBlockIoProtocolGuid,
                  &Dev->BlockIo,
                  NULL
                  );
  if (EFI_ERROR (Status)) {
    DEBUG ((DEBUG_ERROR, "XenPvBlk: install protocol fail: %r\n", Status));
    goto UninitBlockFront;
  }
 
  return EFI_SUCCESS;
 
UninitBlockFront:
  FreePool (Media);
  XenPvBlockFrontShutdown (Dev);
CloseProtocol:
  gBS->CloseProtocol (
         ControllerHandle,
         &gXenBusProtocolGuid,
         This->DriverBindingHandle,
         ControllerHandle
         );
  return Status;
}
 
EFI_STATUS
EFIAPI
XenPvBlkDxeDriverBindingStop (
  IN EFI_DRIVER_BINDING_PROTOCOL  *This,
  IN EFI_HANDLE                   ControllerHandle,
  IN UINTN                        NumberOfChildren,
  IN EFI_HANDLE                   *ChildHandleBuffer OPTIONAL
  )
{
  EFI_BLOCK_IO_PROTOCOL   *BlockIo;
  XEN_BLOCK_FRONT_DEVICE  *Dev;
  EFI_BLOCK_IO_MEDIA      *Media;
  EFI_STATUS              Status;
 
  Status = gBS->OpenProtocol (
                  ControllerHandle,
                  &gEfiBlockIoProtocolGuid,
                  (VOID **)&BlockIo,
                  This->DriverBindingHandle,
                  ControllerHandle,
                  EFI_OPEN_PROTOCOL_GET_PROTOCOL
                  );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  Status = gBS->UninstallProtocolInterface (
                  ControllerHandle,
                  &gEfiBlockIoProtocolGuid,
                  BlockIo
                  );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  Media = BlockIo->Media;
  Dev   = XEN_BLOCK_FRONT_FROM_BLOCK_IO (BlockIo);
  XenPvBlockFrontShutdown (Dev);
 
  FreePool (Media);
 
  gBS->CloseProtocol (
         ControllerHandle,
         &gXenBusProtocolGuid,
         This->DriverBindingHandle,
         ControllerHandle
         );
 
  return EFI_SUCCESS;
}