Commands.c

Go to the documentation of this file.

 
#include <Library/VirtioLib.h>
 
#include "VirtioGpu.h"
 
EFI_STATUS
VirtioGpuInit (
  IN OUT VGPU_DEV  *VgpuDev
  )
{
  UINT8       NextDevStat;
  EFI_STATUS  Status;
  UINT64      Features;
  UINT16      QueueSize;
  UINT64      RingBaseShift;
 
  //
  // Execute virtio-v1.0-cs04, 3.1.1 Driver Requirements: Device
  // Initialization.
  //
  // 1. Reset the device.
  //
  NextDevStat = 0;
  Status      = VgpuDev->VirtIo->SetDeviceStatus (VgpuDev->VirtIo, NextDevStat);
  if (EFI_ERROR (Status)) {
    goto Failed;
  }
 
  //
  // 2. Set the ACKNOWLEDGE status bit [...]
  //
  NextDevStat |= VSTAT_ACK;
  Status       = VgpuDev->VirtIo->SetDeviceStatus (VgpuDev->VirtIo, NextDevStat);
  if (EFI_ERROR (Status)) {
    goto Failed;
  }
 
  //
  // 3. Set the DRIVER status bit [...]
  //
  NextDevStat |= VSTAT_DRIVER;
  Status       = VgpuDev->VirtIo->SetDeviceStatus (VgpuDev->VirtIo, NextDevStat);
  if (EFI_ERROR (Status)) {
    goto Failed;
  }
 
  //
  // 4. Read device feature bits...
  //
  Status = VgpuDev->VirtIo->GetDeviceFeatures (VgpuDev->VirtIo, &Features);
  if (EFI_ERROR (Status)) {
    goto Failed;
  }
 
  if ((Features & VIRTIO_F_VERSION_1) == 0) {
    Status = EFI_UNSUPPORTED;
    goto Failed;
  }
 
  //
  // We only want the most basic 2D features.
  //
  Features &= VIRTIO_F_VERSION_1 | VIRTIO_F_IOMMU_PLATFORM;
 
  //
  // ... and write the subset of feature bits understood by the [...] driver to
  // the device. [...]
  // 5. Set the FEATURES_OK status bit.
  // 6. Re-read device status to ensure the FEATURES_OK bit is still set [...]
  //
  Status = Virtio10WriteFeatures (VgpuDev->VirtIo, Features, &NextDevStat);
  if (EFI_ERROR (Status)) {
    goto Failed;
  }
 
  //
  // 7. Perform device-specific setup, including discovery of virtqueues for
  // the device [...]
  //
  Status = VgpuDev->VirtIo->SetQueueSel (
                              VgpuDev->VirtIo,
                              VIRTIO_GPU_CONTROL_QUEUE
                              );
  if (EFI_ERROR (Status)) {
    goto Failed;
  }
 
  Status = VgpuDev->VirtIo->GetQueueNumMax (VgpuDev->VirtIo, &QueueSize);
  if (EFI_ERROR (Status)) {
    goto Failed;
  }
 
  //
  // We implement each VirtIo GPU command that we use with two descriptors:
  // request, response.
  //
  if (QueueSize < 2) {
    Status = EFI_UNSUPPORTED;
    goto Failed;
  }
 
  //
  // [...] population of virtqueues [...]
  //
  Status = VirtioRingInit (VgpuDev->VirtIo, QueueSize, &VgpuDev->Ring);
  if (EFI_ERROR (Status)) {
    goto Failed;
  }
 
  //
  // If anything fails from here on, we have to release the ring.
  //
  Status = VirtioRingMap (
             VgpuDev->VirtIo,
             &VgpuDev->Ring,
             &RingBaseShift,
             &VgpuDev->RingMap
             );
  if (EFI_ERROR (Status)) {
    goto ReleaseQueue;
  }
 
  //
  // If anything fails from here on, we have to unmap the ring.
  //
  Status = VgpuDev->VirtIo->SetQueueAddress (
                              VgpuDev->VirtIo,
                              &VgpuDev->Ring,
                              RingBaseShift
                              );
  if (EFI_ERROR (Status)) {
    goto UnmapQueue;
  }
 
  //
  // 8. Set the DRIVER_OK status bit.
  //
  NextDevStat |= VSTAT_DRIVER_OK;
  Status       = VgpuDev->VirtIo->SetDeviceStatus (VgpuDev->VirtIo, NextDevStat);
  if (EFI_ERROR (Status)) {
    goto UnmapQueue;
  }
 
  return EFI_SUCCESS;
 
UnmapQueue:
  VgpuDev->VirtIo->UnmapSharedBuffer (VgpuDev->VirtIo, VgpuDev->RingMap);
 
ReleaseQueue:
  VirtioRingUninit (VgpuDev->VirtIo, &VgpuDev->Ring);
 
Failed:
  //
  // If any of these steps go irrecoverably wrong, the driver SHOULD set the
  // FAILED status bit to indicate that it has given up on the device (it can
  // reset the device later to restart if desired). [...]
  //
  // VirtIo access failure here should not mask the original error.
  //
  NextDevStat |= VSTAT_FAILED;
  VgpuDev->VirtIo->SetDeviceStatus (VgpuDev->VirtIo, NextDevStat);
 
  return Status;
}
 
VOID
VirtioGpuUninit (
  IN OUT VGPU_DEV  *VgpuDev
  )
{
  //
  // Resetting the VirtIo device makes it release its resources and forget its
  // configuration.
  //
  VgpuDev->VirtIo->SetDeviceStatus (VgpuDev->VirtIo, 0);
  VgpuDev->VirtIo->UnmapSharedBuffer (VgpuDev->VirtIo, VgpuDev->RingMap);
  VirtioRingUninit (VgpuDev->VirtIo, &VgpuDev->Ring);
}
 
EFI_STATUS
VirtioGpuAllocateZeroAndMapBackingStore (
  IN  VGPU_DEV              *VgpuDev,
  IN  UINTN                 NumberOfPages,
  OUT VOID                  **HostAddress,
  OUT EFI_PHYSICAL_ADDRESS  *DeviceAddress,
  OUT VOID                  **Mapping
  )
{
  EFI_STATUS  Status;
  VOID        *NewHostAddress;
 
  Status = VgpuDev->VirtIo->AllocateSharedPages (
                              VgpuDev->VirtIo,
                              NumberOfPages,
                              &NewHostAddress
                              );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  //
  // Avoid exposing stale data to the device even temporarily: zero the area
  // before mapping it.
  //
  ZeroMem (NewHostAddress, EFI_PAGES_TO_SIZE (NumberOfPages));
 
  Status = VirtioMapAllBytesInSharedBuffer (
             VgpuDev->VirtIo,                      // VirtIo
             VirtioOperationBusMasterCommonBuffer, // Operation
             NewHostAddress,                       // HostAddress
             EFI_PAGES_TO_SIZE (NumberOfPages),    // NumberOfBytes
             DeviceAddress,                        // DeviceAddress
             Mapping                               // Mapping
             );
  if (EFI_ERROR (Status)) {
    goto FreeSharedPages;
  }
 
  *HostAddress = NewHostAddress;
  return EFI_SUCCESS;
 
FreeSharedPages:
  VgpuDev->VirtIo->FreeSharedPages (
                     VgpuDev->VirtIo,
                     NumberOfPages,
                     NewHostAddress
                     );
  return Status;
}
 
VOID
VirtioGpuUnmapAndFreeBackingStore (
  IN VGPU_DEV  *VgpuDev,
  IN UINTN     NumberOfPages,
  IN VOID      *HostAddress,
  IN VOID      *Mapping
  )
{
  VgpuDev->VirtIo->UnmapSharedBuffer (
                     VgpuDev->VirtIo,
                     Mapping
                     );
  VgpuDev->VirtIo->FreeSharedPages (
                     VgpuDev->VirtIo,
                     NumberOfPages,
                     HostAddress
                     );
}
 
VOID
EFIAPI
VirtioGpuExitBoot (
  IN EFI_EVENT  Event,
  IN VOID       *Context
  )
{
  VGPU_DEV  *VgpuDev;
 
  DEBUG ((DEBUG_VERBOSE, "%a: Context=0x%p\n", __func__, Context));
  VgpuDev = Context;
  VgpuDev->VirtIo->SetDeviceStatus (VgpuDev->VirtIo, 0);
}
 
STATIC
EFI_STATUS
VirtioGpuSendCommandWithReply (
  IN OUT VGPU_DEV                            *VgpuDev,
  IN     VIRTIO_GPU_CONTROL_TYPE             RequestType,
  IN     BOOLEAN                             Fence,
  IN OUT volatile VIRTIO_GPU_CONTROL_HEADER  *Header,
  IN     UINTN                               RequestSize,
  IN     VIRTIO_GPU_CONTROL_TYPE             ResponseType,
  IN OUT volatile VIRTIO_GPU_CONTROL_HEADER  *Response,
  IN     UINTN                               ResponseSize
  )
{
  DESC_INDICES          Indices;
  EFI_STATUS            Status;
  UINT32                ResponseSizeRet;
  EFI_PHYSICAL_ADDRESS  RequestDeviceAddress;
  VOID                  *RequestMap;
  EFI_PHYSICAL_ADDRESS  ResponseDeviceAddress;
  VOID                  *ResponseMap;
 
  //
  // Initialize Header.
  //
  Header->Type = RequestType;
  if (Fence) {
    Header->Flags   = VIRTIO_GPU_FLAG_FENCE;
    Header->FenceId = VgpuDev->FenceId++;
  } else {
    Header->Flags   = 0;
    Header->FenceId = 0;
  }
 
  Header->CtxId   = 0;
  Header->Padding = 0;
 
  ASSERT (RequestSize >= sizeof *Header);
  ASSERT (RequestSize <= MAX_UINT32);
 
  //
  // Map request and response to bus master device addresses.
  //
  Status = VirtioMapAllBytesInSharedBuffer (
             VgpuDev->VirtIo,
             VirtioOperationBusMasterRead,
             (VOID *)Header,
             RequestSize,
             &RequestDeviceAddress,
             &RequestMap
             );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  Status = VirtioMapAllBytesInSharedBuffer (
             VgpuDev->VirtIo,
             VirtioOperationBusMasterWrite,
             (VOID *)Response,
             ResponseSize,
             &ResponseDeviceAddress,
             &ResponseMap
             );
  if (EFI_ERROR (Status)) {
    goto UnmapRequest;
  }
 
  //
  // Compose the descriptor chain.
  //
  VirtioPrepare (&VgpuDev->Ring, &Indices);
  VirtioAppendDesc (
    &VgpuDev->Ring,
    RequestDeviceAddress,
    (UINT32)RequestSize,
    VRING_DESC_F_NEXT,
    &Indices
    );
  VirtioAppendDesc (
    &VgpuDev->Ring,
    ResponseDeviceAddress,
    (UINT32)ResponseSize,
    VRING_DESC_F_WRITE,
    &Indices
    );
 
  //
  // Send the command.
  //
  Status = VirtioFlush (
             VgpuDev->VirtIo,
             VIRTIO_GPU_CONTROL_QUEUE,
             &VgpuDev->Ring,
             &Indices,
             &ResponseSizeRet
             );
  if (EFI_ERROR (Status)) {
    goto UnmapResponse;
  }
 
  //
  // Verify response size.
  //
  if (ResponseSize != ResponseSizeRet) {
    DEBUG ((
      DEBUG_ERROR,
      "%a: malformed response to Request=0x%x\n",
      __func__,
      (UINT32)RequestType
      ));
    Status = EFI_PROTOCOL_ERROR;
    goto UnmapResponse;
  }
 
  //
  // Unmap response and request, in reverse order of mapping. On error, the
  // respective mapping is invalidated anyway, only the data may not have been
  // committed to system memory (in case of VirtioOperationBusMasterWrite).
  //
  Status = VgpuDev->VirtIo->UnmapSharedBuffer (VgpuDev->VirtIo, ResponseMap);
  if (EFI_ERROR (Status)) {
    goto UnmapRequest;
  }
 
  Status = VgpuDev->VirtIo->UnmapSharedBuffer (VgpuDev->VirtIo, RequestMap);
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  //
  // Parse the response.
  //
  if (Response->Type == (UINT32)ResponseType) {
    return EFI_SUCCESS;
  }
 
  DEBUG ((
    DEBUG_ERROR,
    "%a: Request=0x%x Response=0x%x (expected 0x%x)\n",
    __func__,
    (UINT32)RequestType,
    Response->Type,
    ResponseType
    ));
  return EFI_DEVICE_ERROR;
 
UnmapResponse:
  VgpuDev->VirtIo->UnmapSharedBuffer (VgpuDev->VirtIo, ResponseMap);
 
UnmapRequest:
  VgpuDev->VirtIo->UnmapSharedBuffer (VgpuDev->VirtIo, RequestMap);
 
  return Status;
}
 
STATIC
EFI_STATUS
VirtioGpuSendCommand (
  IN OUT VGPU_DEV                            *VgpuDev,
  IN     VIRTIO_GPU_CONTROL_TYPE             RequestType,
  IN     BOOLEAN                             Fence,
  IN OUT volatile VIRTIO_GPU_CONTROL_HEADER  *Header,
  IN     UINTN                               RequestSize
  )
{
  volatile VIRTIO_GPU_CONTROL_HEADER  Response;
 
  return VirtioGpuSendCommandWithReply (
           VgpuDev,
           RequestType,
           Fence,
           Header,
           RequestSize,
           VirtioGpuRespOkNodata,
           &Response,
           sizeof (Response)
           );
}
 
EFI_STATUS
VirtioGpuResourceCreate2d (
  IN OUT VGPU_DEV            *VgpuDev,
  IN     UINT32              ResourceId,
  IN     VIRTIO_GPU_FORMATS  Format,
  IN     UINT32              Width,
  IN     UINT32              Height
  )
{
  volatile VIRTIO_GPU_RESOURCE_CREATE_2D  Request;
 
  if (ResourceId == 0) {
    return EFI_INVALID_PARAMETER;
  }
 
  Request.ResourceId = ResourceId;
  Request.Format     = (UINT32)Format;
  Request.Width      = Width;
  Request.Height     = Height;
 
  return VirtioGpuSendCommand (
           VgpuDev,
           VirtioGpuCmdResourceCreate2d,
           FALSE,                        // Fence
           &Request.Header,
           sizeof Request
           );
}
 
EFI_STATUS
VirtioGpuResourceUnref (
  IN OUT VGPU_DEV  *VgpuDev,
  IN     UINT32    ResourceId
  )
{
  volatile VIRTIO_GPU_RESOURCE_UNREF  Request;
 
  if (ResourceId == 0) {
    return EFI_INVALID_PARAMETER;
  }
 
  Request.ResourceId = ResourceId;
  Request.Padding    = 0;
 
  return VirtioGpuSendCommand (
           VgpuDev,
           VirtioGpuCmdResourceUnref,
           FALSE,                     // Fence
           &Request.Header,
           sizeof Request
           );
}
 
EFI_STATUS
VirtioGpuResourceAttachBacking (
  IN OUT VGPU_DEV              *VgpuDev,
  IN     UINT32                ResourceId,
  IN     EFI_PHYSICAL_ADDRESS  BackingStoreDeviceAddress,
  IN     UINTN                 NumberOfPages
  )
{
  volatile VIRTIO_GPU_RESOURCE_ATTACH_BACKING  Request;
 
  if (ResourceId == 0) {
    return EFI_INVALID_PARAMETER;
  }
 
  Request.ResourceId    = ResourceId;
  Request.NrEntries     = 1;
  Request.Entry.Addr    = BackingStoreDeviceAddress;
  Request.Entry.Length  = (UINT32)EFI_PAGES_TO_SIZE (NumberOfPages);
  Request.Entry.Padding = 0;
 
  return VirtioGpuSendCommand (
           VgpuDev,
           VirtioGpuCmdResourceAttachBacking,
           FALSE,                             // Fence
           &Request.Header,
           sizeof Request
           );
}
 
EFI_STATUS
VirtioGpuResourceDetachBacking (
  IN OUT VGPU_DEV  *VgpuDev,
  IN     UINT32    ResourceId
  )
{
  volatile VIRTIO_GPU_RESOURCE_DETACH_BACKING  Request;
 
  if (ResourceId == 0) {
    return EFI_INVALID_PARAMETER;
  }
 
  Request.ResourceId = ResourceId;
  Request.Padding    = 0;
 
  //
  // In this case, we set Fence to TRUE, because after this function returns,
  // the caller might reasonably want to repurpose the backing pages
  // immediately. Thus we should ensure that the host releases all references
  // to the backing pages before we return.
  //
  return VirtioGpuSendCommand (
           VgpuDev,
           VirtioGpuCmdResourceDetachBacking,
           TRUE,                              // Fence
           &Request.Header,
           sizeof Request
           );
}
 
EFI_STATUS
VirtioGpuSetScanout (
  IN OUT VGPU_DEV  *VgpuDev,
  IN     UINT32    X,
  IN     UINT32    Y,
  IN     UINT32    Width,
  IN     UINT32    Height,
  IN     UINT32    ScanoutId,
  IN     UINT32    ResourceId
  )
{
  volatile VIRTIO_GPU_SET_SCANOUT  Request;
 
  //
  // Unlike for most other commands, ResourceId=0 is valid; it
  // is used to disable a scanout.
  //
  Request.Rectangle.X      = X;
  Request.Rectangle.Y      = Y;
  Request.Rectangle.Width  = Width;
  Request.Rectangle.Height = Height;
  Request.ScanoutId        = ScanoutId;
  Request.ResourceId       = ResourceId;
 
  return VirtioGpuSendCommand (
           VgpuDev,
           VirtioGpuCmdSetScanout,
           FALSE,                  // Fence
           &Request.Header,
           sizeof Request
           );
}
 
EFI_STATUS
VirtioGpuTransferToHost2d (
  IN OUT VGPU_DEV  *VgpuDev,
  IN     UINT32    X,
  IN     UINT32    Y,
  IN     UINT32    Width,
  IN     UINT32    Height,
  IN     UINT64    Offset,
  IN     UINT32    ResourceId
  )
{
  volatile VIRTIO_GPU_CMD_TRANSFER_TO_HOST_2D  Request;
 
  if (ResourceId == 0) {
    return EFI_INVALID_PARAMETER;
  }
 
  Request.Rectangle.X      = X;
  Request.Rectangle.Y      = Y;
  Request.Rectangle.Width  = Width;
  Request.Rectangle.Height = Height;
  Request.Offset           = Offset;
  Request.ResourceId       = ResourceId;
  Request.Padding          = 0;
 
  return VirtioGpuSendCommand (
           VgpuDev,
           VirtioGpuCmdTransferToHost2d,
           FALSE,                        // Fence
           &Request.Header,
           sizeof Request
           );
}
 
EFI_STATUS
VirtioGpuResourceFlush (
  IN OUT VGPU_DEV  *VgpuDev,
  IN     UINT32    X,
  IN     UINT32    Y,
  IN     UINT32    Width,
  IN     UINT32    Height,
  IN     UINT32    ResourceId
  )
{
  volatile VIRTIO_GPU_RESOURCE_FLUSH  Request;
 
  if (ResourceId == 0) {
    return EFI_INVALID_PARAMETER;
  }
 
  Request.Rectangle.X      = X;
  Request.Rectangle.Y      = Y;
  Request.Rectangle.Width  = Width;
  Request.Rectangle.Height = Height;
  Request.ResourceId       = ResourceId;
  Request.Padding          = 0;
 
  return VirtioGpuSendCommand (
           VgpuDev,
           VirtioGpuCmdResourceFlush,
           FALSE,                     // Fence
           &Request.Header,
           sizeof Request
           );
}
 
EFI_STATUS
VirtioGpuGetDisplayInfo (
  IN OUT VGPU_DEV                        *VgpuDev,
  volatile VIRTIO_GPU_RESP_DISPLAY_INFO  *Response
  )
{
  volatile VIRTIO_GPU_CONTROL_HEADER  Request;
 
  return VirtioGpuSendCommandWithReply (
           VgpuDev,
           VirtioGpuCmdGetDisplayInfo,
           FALSE,                     // Fence
           &Request,
           sizeof Request,
           VirtioGpuRespOkDisplayInfo,
           &Response->Header,
           sizeof *Response
           );
}