OvmfPkg/VirtioFsDxe/DriverBinding.c

   1 /** @file
   2   Provide EFI_SIMPLE_FILE_SYSTEM_PROTOCOL instances on virtio-fs devices.
   3
   4   Copyright (C) 2020, Red Hat, Inc.
   5
   6   SPDX-License-Identifier: BSD-2-Clause-Patent
   7 **/
   8
   9 #include <IndustryStandard/Virtio.h>          // VIRTIO_SUBSYSTEM_FILESYSTEM
  10 #include <Library/BaseLib.h>                  // AsciiStrCmp()
  11 #include <Library/MemoryAllocationLib.h>      // AllocatePool()
  12 #include <Library/UefiBootServicesTableLib.h> // gBS
  13 #include <Protocol/ComponentName2.h>          // EFI_COMPONENT_NAME2_PROTOCOL
  14 #include <Protocol/DriverBinding.h>           // EFI_DRIVER_BINDING_PROTOCOL
  15
  16 #include "VirtioFsDxe.h"
  17
  18 //
  19 // UEFI Driver Model protocol instances.
  20 //
  21 STATIC EFI_DRIVER_BINDING_PROTOCOL  mDriverBinding;
  22 STATIC EFI_COMPONENT_NAME2_PROTOCOL mComponentName2;
  23
  24 //
  25 // UEFI Driver Model protocol member functions.
  26 //
  27 EFI_STATUS
  28 EFIAPI
  29 VirtioFsBindingSupported (
  30   IN EFI_DRIVER_BINDING_PROTOCOL *This,
  31   IN EFI_HANDLE                  ControllerHandle,
  32   IN EFI_DEVICE_PATH_PROTOCOL    *RemainingDevicePath OPTIONAL
  33   )
  34 {
  35   EFI_STATUS             Status;
  36   VIRTIO_DEVICE_PROTOCOL *Virtio;
  37   EFI_STATUS             CloseStatus;
  38
  39   Status = gBS->OpenProtocol (ControllerHandle, &gVirtioDeviceProtocolGuid,
  40                   (VOID **)&Virtio, This->DriverBindingHandle,
  41                   ControllerHandle, EFI_OPEN_PROTOCOL_BY_DRIVER);
  42   if (EFI_ERROR (Status)) {
  43     return Status;
  44   }
  45
  46   if (Virtio->SubSystemDeviceId != VIRTIO_SUBSYSTEM_FILESYSTEM) {
  47     Status = EFI_UNSUPPORTED;
  48   }
  49
  50   CloseStatus = gBS->CloseProtocol (ControllerHandle,
  51                        &gVirtioDeviceProtocolGuid, This->DriverBindingHandle,
  52                        ControllerHandle);
  53   ASSERT_EFI_ERROR (CloseStatus);
  54
  55   return Status;
  56 }
  57
  58 EFI_STATUS
  59 EFIAPI
  60 VirtioFsBindingStart (
  61   IN EFI_DRIVER_BINDING_PROTOCOL *This,
  62   IN EFI_HANDLE                  ControllerHandle,
  63   IN EFI_DEVICE_PATH_PROTOCOL    *RemainingDevicePath OPTIONAL
  64   )
  65 {
  66   VIRTIO_FS  *VirtioFs;
  67   EFI_STATUS Status;
  68   EFI_STATUS CloseStatus;
  69
  70   VirtioFs = AllocatePool (sizeof *VirtioFs);
  71   if (VirtioFs == NULL) {
  72     return EFI_OUT_OF_RESOURCES;
  73   }
  74   VirtioFs->Signature = VIRTIO_FS_SIG;
  75
  76   Status = gBS->OpenProtocol (ControllerHandle, &gVirtioDeviceProtocolGuid,
  77                   (VOID **)&VirtioFs->Virtio, This->DriverBindingHandle,
  78                   ControllerHandle, EFI_OPEN_PROTOCOL_BY_DRIVER);
  79   if (EFI_ERROR (Status)) {
  80     goto FreeVirtioFs;
  81   }
  82
  83   VirtioFs->SimpleFs.Revision   = EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_REVISION;
  84   VirtioFs->SimpleFs.OpenVolume = VirtioFsOpenVolume;
  85
  86   Status = gBS->InstallProtocolInterface (&ControllerHandle,
  87                   &gEfiSimpleFileSystemProtocolGuid, EFI_NATIVE_INTERFACE,
  88                   &VirtioFs->SimpleFs);
  89   if (EFI_ERROR (Status)) {
  90     goto CloseVirtio;
  91   }
  92
  93   return EFI_SUCCESS;
  94
  95 CloseVirtio:
  96   CloseStatus = gBS->CloseProtocol (ControllerHandle,
  97                        &gVirtioDeviceProtocolGuid, This->DriverBindingHandle,
  98                        ControllerHandle);
  99   ASSERT_EFI_ERROR (CloseStatus);
 100
 101 FreeVirtioFs:
 102   FreePool (VirtioFs);
 103
 104   return Status;
 105 }
 106
 107 EFI_STATUS
 108 EFIAPI
 109 VirtioFsBindingStop (
 110   IN EFI_DRIVER_BINDING_PROTOCOL *This,
 111   IN EFI_HANDLE                  ControllerHandle,
 112   IN UINTN                       NumberOfChildren,
 113   IN EFI_HANDLE                  *ChildHandleBuffer OPTIONAL
 114   )
 115 {
 116   EFI_STATUS                      Status;
 117   EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *SimpleFs;
 118   VIRTIO_FS                       *VirtioFs;
 119
 120   Status = gBS->OpenProtocol (ControllerHandle,
 121                   &gEfiSimpleFileSystemProtocolGuid, (VOID **)&SimpleFs,
 122                   This->DriverBindingHandle, ControllerHandle,
 123                   EFI_OPEN_PROTOCOL_GET_PROTOCOL);
 124   if (EFI_ERROR (Status)) {
 125     return Status;
 126   }
 127
 128   VirtioFs = VIRTIO_FS_FROM_SIMPLE_FS (SimpleFs);
 129
 130   Status = gBS->UninstallProtocolInterface (ControllerHandle,
 131                   &gEfiSimpleFileSystemProtocolGuid, SimpleFs);
 132   if (EFI_ERROR (Status)) {
 133     return Status;
 134   }
 135
 136   Status = gBS->CloseProtocol (ControllerHandle, &gVirtioDeviceProtocolGuid,
 137                   This->DriverBindingHandle, ControllerHandle);
 138   ASSERT_EFI_ERROR (Status);
 139
 140   FreePool (VirtioFs);
 141
 142   return EFI_SUCCESS;
 143 }
 144
 145 EFI_STATUS
 146 EFIAPI
 147 VirtioFsGetDriverName (
 148   IN  EFI_COMPONENT_NAME2_PROTOCOL *This,
 149   IN  CHAR8                        *Language,
 150   OUT CHAR16                       **DriverName
 151   )
 152 {
 153   if (AsciiStrCmp (Language, "en") != 0) {
 154     return EFI_UNSUPPORTED;
 155   }
 156   *DriverName = L"Virtio Filesystem Driver";
 157   return EFI_SUCCESS;
 158 }
 159
 160 EFI_STATUS
 161 EFIAPI
 162 VirtioFsGetControllerName (
 163   IN  EFI_COMPONENT_NAME2_PROTOCOL *This,
 164   IN  EFI_HANDLE                   ControllerHandle,
 165   IN  EFI_HANDLE                   ChildHandle OPTIONAL,
 166   IN  CHAR8                        *Language,
 167   OUT CHAR16                       **ControllerName
 168   )
 169 {
 170   return EFI_UNSUPPORTED;
 171 }
 172
 173 //
 174 // Entry point of this driver.
 175 //
 176 EFI_STATUS
 177 EFIAPI
 178 VirtioFsEntryPoint (
 179   IN EFI_HANDLE       ImageHandle,
 180   IN EFI_SYSTEM_TABLE *SystemTable
 181   )
 182 {
 183   EFI_STATUS Status;
 184
 185   mDriverBinding.Supported           = VirtioFsBindingSupported;
 186   mDriverBinding.Start               = VirtioFsBindingStart;
 187   mDriverBinding.Stop                = VirtioFsBindingStop;
 188   mDriverBinding.Version             = 0x10;
 189   mDriverBinding.ImageHandle         = ImageHandle;
 190   mDriverBinding.DriverBindingHandle = ImageHandle;
 191
 192   mComponentName2.GetDriverName      = VirtioFsGetDriverName;
 193   mComponentName2.GetControllerName  = VirtioFsGetControllerName;
 194   mComponentName2.SupportedLanguages = "en";
 195
 196   Status = gBS->InstallMultipleProtocolInterfaces (&ImageHandle,
 197                   &gEfiDriverBindingProtocolGuid, &mDriverBinding,
 198                   &gEfiComponentName2ProtocolGuid, &mComponentName2, NULL);
 199   return Status;
 200 }