[mirror_edk2.git] / OvmfPkg / VirtioGpuDxe / Gop.c

/** @file\r
\r
  EFI_GRAPHICS_OUTPUT_PROTOCOL member functions for the VirtIo GPU driver.\r
\r
  Copyright (C) 2016, Red Hat, Inc.\r
\r
  SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
\r
#include <Library/MemoryAllocationLib.h>\r
#include <Library/PcdLib.h>\r
\r
#include "VirtioGpu.h"\r
\r
/**\r
  Release guest-side and host-side resources that are related to an initialized\r
  VGPU_GOP.Gop.\r
\r
  param[in,out] VgpuGop  The VGPU_GOP object to release resources for.\r
\r
                         On input, the caller is responsible for having called\r
                         VgpuGop->Gop.SetMode() at least once successfully.\r
                         (This is equivalent to the requirement that\r
                         VgpuGop->BackingStore be non-NULL. It is also\r
                         equivalent to the requirement that VgpuGop->ResourceId\r
                         be nonzero.)\r
\r
                         On output, resources will be released, and\r
                         VgpuGop->BackingStore and VgpuGop->ResourceId will be\r
                         nulled.\r
\r
  param[in] DisableHead  Whether this head (scanout) currently references the\r
                         resource identified by VgpuGop->ResourceId. Only pass\r
                         FALSE when VgpuGop->Gop.SetMode() calls this function\r
                         while switching between modes, and set it to TRUE\r
                         every other time.\r
**/\r
VOID\r
ReleaseGopResources (\r
  IN OUT VGPU_GOP  *VgpuGop,\r
  IN     BOOLEAN   DisableHead\r
  )\r
{\r
  EFI_STATUS  Status;\r
\r
  ASSERT (VgpuGop->ResourceId != 0);\r
  ASSERT (VgpuGop->BackingStore != NULL);\r
\r
  //\r
  // If any of the following host-side destruction steps fail, we can't get out\r
  // of an inconsistent state, so we'll hang. In general errors in object\r
  // destruction can hardly be recovered from.\r
  //\r
  if (DisableHead) {\r
    //\r
    // Dissociate head (scanout) #0 from the currently used 2D host resource,\r
    // by setting ResourceId=0 for it.\r
    //\r
    Status = VirtioGpuSetScanout (\r
               VgpuGop->ParentBus, // VgpuDev\r
               0,\r
               0,\r
               0,\r
               0,                  // X, Y, Width, Height\r
               0,                  // ScanoutId\r
               0                   // ResourceId\r
               );\r
    //\r
    // HACK BEGINS HERE\r
    //\r
    // According to the GPU Device section of the VirtIo specification, the\r
    // above operation is valid:\r
    //\r
    // "The driver can use resource_id = 0 to disable a scanout."\r
    //\r
    // However, in practice QEMU does not allow us to disable head (scanout) #0\r
    // -- it rejects the command with response code 0x1202\r
    // (VIRTIO_GPU_RESP_ERR_INVALID_SCANOUT_ID). Looking at the QEMU source\r
    // code, function virtio_gpu_set_scanout() in "hw/display/virtio-gpu.c",\r
    // this appears fully intentional, despite not being documented in the\r
    // spec.\r
    //\r
    // Surprisingly, ignoring the error here, and proceeding to release\r
    // host-side resources that presumably underlie head (scanout) #0, work\r
    // without any problems -- the driver survives repeated "disconnect" /\r
    // "connect -r" commands in the UEFI shell.\r
    //\r
    // So, for now, let's just suppress the error.\r
    //\r
    Status = EFI_SUCCESS;\r
    //\r
    // HACK ENDS HERE\r
    //\r
\r
    ASSERT_EFI_ERROR (Status);\r
    if (EFI_ERROR (Status)) {\r
      CpuDeadLoop ();\r
    }\r
  }\r
\r
  //\r
  // Detach backing pages from the currently used 2D host resource.\r
  //\r
  Status = VirtioGpuResourceDetachBacking (\r
             VgpuGop->ParentBus, // VgpuDev\r
             VgpuGop->ResourceId // ResourceId\r
             );\r
  ASSERT_EFI_ERROR (Status);\r
  if (EFI_ERROR (Status)) {\r
    CpuDeadLoop ();\r
  }\r
\r
  //\r
  // Unmap and release backing pages.\r
  //\r
  VirtioGpuUnmapAndFreeBackingStore (\r
    VgpuGop->ParentBus,      // VgpuDev\r
    VgpuGop->NumberOfPages,  // NumberOfPages\r
    VgpuGop->BackingStore,   // HostAddress\r
    VgpuGop->BackingStoreMap // Mapping\r
    );\r
  VgpuGop->BackingStore    = NULL;\r
  VgpuGop->NumberOfPages   = 0;\r
  VgpuGop->BackingStoreMap = NULL;\r
\r
  //\r
  // Destroy the currently used 2D host resource.\r
  //\r
  Status = VirtioGpuResourceUnref (\r
             VgpuGop->ParentBus, // VgpuDev\r
             VgpuGop->ResourceId // ResourceId\r
             );\r
  ASSERT_EFI_ERROR (Status);\r
  if (EFI_ERROR (Status)) {\r
    CpuDeadLoop ();\r
  }\r
\r
  VgpuGop->ResourceId = 0;\r
}\r
\r
//\r
// The resolutions supported by this driver.\r
//\r
typedef struct {\r
  UINT32    Width;\r
  UINT32    Height;\r
} GOP_RESOLUTION;\r
\r
STATIC CONST GOP_RESOLUTION  mGopResolutions[] = {\r
  { 640,  480  },\r
  { 800,  480  },\r
  { 800,  600  },\r
  { 832,  624  },\r
  { 960,  640  },\r
  { 1024, 600  },\r
  { 1024, 768  },\r
  { 1152, 864  },\r
  { 1152, 870  },\r
  { 1280, 720  },\r
  { 1280, 760  },\r
  { 1280, 768  },\r
  { 1280, 800  },\r
  { 1280, 960  },\r
  { 1280, 1024 },\r
  { 1360, 768  },\r
  { 1366, 768  },\r
  { 1400, 1050 },\r
  { 1440, 900  },\r
  { 1600, 900  },\r
  { 1600, 1200 },\r
  { 1680, 1050 },\r
  { 1920, 1080 },\r
  { 1920, 1200 },\r
  { 1920, 1440 },\r
  { 2000, 2000 },\r
  { 2048, 1536 },\r
  { 2048, 2048 },\r
  { 2560, 1440 },\r
  { 2560, 1600 },\r
  { 2560, 2048 },\r
  { 2800, 2100 },\r
  { 3200, 2400 },\r
  { 3840, 2160 },\r
  { 4096, 2160 },\r
  { 7680, 4320 },\r
  { 8192, 4320 },\r
};\r
\r
//\r
// Macro for casting VGPU_GOP.Gop to VGPU_GOP.\r
//\r
#define VGPU_GOP_FROM_GOP(GopPointer) \\r
          CR (GopPointer, VGPU_GOP, Gop, VGPU_GOP_SIG)\r
\r
STATIC\r
VOID\r
EFIAPI\r
GopNativeResolution (\r
  IN  VGPU_GOP  *VgpuGop,\r
  OUT UINT32    *XRes,\r
  OUT UINT32    *YRes\r
  )\r
{\r
  volatile VIRTIO_GPU_RESP_DISPLAY_INFO  DisplayInfo;\r
  EFI_STATUS                             Status;\r
  UINTN                                  Index;\r
\r
  Status = VirtioGpuGetDisplayInfo (VgpuGop->ParentBus, &DisplayInfo);\r
  if (Status != EFI_SUCCESS) {\r
    return;\r
  }\r
\r
  for (Index = 0; Index < VIRTIO_GPU_MAX_SCANOUTS; Index++) {\r
    if (!DisplayInfo.Pmodes[Index].Enabled ||\r
        !DisplayInfo.Pmodes[Index].Rectangle.Width ||\r
        !DisplayInfo.Pmodes[Index].Rectangle.Height)\r
    {\r
      continue;\r
    }\r
\r
    DEBUG ((\r
      DEBUG_INFO,\r
      "%a: #%d: %dx%d\n",\r
      __FUNCTION__,\r
      Index,\r
      DisplayInfo.Pmodes[Index].Rectangle.Width,\r
      DisplayInfo.Pmodes[Index].Rectangle.Height\r
      ));\r
    if ((*XRes == 0) || (*YRes == 0)) {\r
      *XRes = DisplayInfo.Pmodes[Index].Rectangle.Width;\r
      *YRes = DisplayInfo.Pmodes[Index].Rectangle.Height;\r
    }\r
  }\r
}\r
\r
STATIC\r
VOID\r
EFIAPI\r
GopInitialize (\r
  IN  EFI_GRAPHICS_OUTPUT_PROTOCOL  *This\r
  )\r
{\r
  VGPU_GOP    *VgpuGop;\r
  EFI_STATUS  Status;\r
  UINT32      XRes = 0, YRes = 0, Index;\r
\r
  VgpuGop = VGPU_GOP_FROM_GOP (This);\r
\r
  //\r
  // Set up the Gop -> GopMode -> GopModeInfo pointer chain, and the other\r
  // (nonzero) constant fields.\r
  //\r
  // No direct framebuffer access is supported, only Blt() is.\r
  //\r
  VgpuGop->Gop.Mode = &VgpuGop->GopMode;\r
\r
  VgpuGop->GopMode.MaxMode    = (UINT32)(ARRAY_SIZE (mGopResolutions));\r
  VgpuGop->GopMode.Info       = &VgpuGop->GopModeInfo;\r
  VgpuGop->GopMode.SizeOfInfo = sizeof VgpuGop->GopModeInfo;\r
\r
  VgpuGop->GopModeInfo.PixelFormat = PixelBltOnly;\r
\r
  //\r
  // query host for display resolution\r
  //\r
  GopNativeResolution (VgpuGop, &XRes, &YRes);\r
  if ((XRes == 0) || (YRes == 0)) {\r
    return;\r
  }\r
\r
  if (PcdGet8 (PcdVideoResolutionSource) == 0) {\r
    Status = PcdSet32S (PcdVideoHorizontalResolution, XRes);\r
    ASSERT_RETURN_ERROR (Status);\r
    Status = PcdSet32S (PcdVideoVerticalResolution, YRes);\r
    ASSERT_RETURN_ERROR (Status);\r
    Status = PcdSet8S (PcdVideoResolutionSource, 2);\r
    ASSERT_RETURN_ERROR (Status);\r
  }\r
\r
  VgpuGop->NativeXRes = XRes;\r
  VgpuGop->NativeYRes = YRes;\r
  for (Index = 0; Index < ARRAY_SIZE (mGopResolutions); Index++) {\r
    if ((mGopResolutions[Index].Width == XRes) &&\r
        (mGopResolutions[Index].Height == YRes))\r
    {\r
      // native resolution already is in mode list\r
      return;\r
    }\r
  }\r
\r
  // add to mode list\r
  VgpuGop->GopMode.MaxMode++;\r
}\r
\r
//\r
// EFI_GRAPHICS_OUTPUT_PROTOCOL member functions.\r
//\r
STATIC\r
EFI_STATUS\r
EFIAPI\r
GopQueryMode (\r
  IN  EFI_GRAPHICS_OUTPUT_PROTOCOL          *This,\r
  IN  UINT32                                ModeNumber,\r
  OUT UINTN                                 *SizeOfInfo,\r
  OUT EFI_GRAPHICS_OUTPUT_MODE_INFORMATION  **Info\r
  )\r
{\r
  EFI_GRAPHICS_OUTPUT_MODE_INFORMATION  *GopModeInfo;\r
\r
  if ((Info == NULL) ||\r
      (SizeOfInfo == NULL) ||\r
      (ModeNumber >= This->Mode->MaxMode))\r
  {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  GopModeInfo = AllocateZeroPool (sizeof *GopModeInfo);\r
  if (GopModeInfo == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  if (ModeNumber < ARRAY_SIZE (mGopResolutions)) {\r
    GopModeInfo->HorizontalResolution = mGopResolutions[ModeNumber].Width;\r
    GopModeInfo->VerticalResolution   = mGopResolutions[ModeNumber].Height;\r
  } else {\r
    VGPU_GOP  *VgpuGop = VGPU_GOP_FROM_GOP (This);\r
    GopModeInfo->HorizontalResolution = VgpuGop->NativeXRes;\r
    GopModeInfo->VerticalResolution   = VgpuGop->NativeYRes;\r
  }\r
\r
  GopModeInfo->PixelFormat       = PixelBltOnly;\r
  GopModeInfo->PixelsPerScanLine = GopModeInfo->HorizontalResolution;\r
\r
  *SizeOfInfo = sizeof *GopModeInfo;\r
  *Info       = GopModeInfo;\r
  return EFI_SUCCESS;\r
}\r
\r
STATIC\r
EFI_STATUS\r
EFIAPI\r
GopSetMode (\r
  IN  EFI_GRAPHICS_OUTPUT_PROTOCOL  *This,\r
  IN  UINT32                        ModeNumber\r
  )\r
{\r
  VGPU_GOP                              *VgpuGop;\r
  UINT32                                NewResourceId;\r
  UINTN                                 NewNumberOfBytes;\r
  UINTN                                 NewNumberOfPages;\r
  VOID                                  *NewBackingStore;\r
  EFI_PHYSICAL_ADDRESS                  NewBackingStoreDeviceAddress;\r
  VOID                                  *NewBackingStoreMap;\r
  UINTN                                 SizeOfInfo;\r
  EFI_GRAPHICS_OUTPUT_MODE_INFORMATION  *GopModeInfo;\r
\r
  EFI_STATUS  Status;\r
  EFI_STATUS  Status2;\r
\r
  if (!This->Mode) {\r
    // SetMode() call in InitVgpuGop() triggers this.\r
    GopInitialize (This);\r
  }\r
\r
  Status = GopQueryMode (This, ModeNumber, &SizeOfInfo, &GopModeInfo);\r
  if (Status != EFI_SUCCESS) {\r
    return Status;\r
  }\r
\r
  VgpuGop = VGPU_GOP_FROM_GOP (This);\r
\r
  //\r
  // Distinguish the first (internal) call from the other (protocol consumer)\r
  // calls.\r
  //\r
  if (VgpuGop->ResourceId == 0) {\r
    //\r
    // This is the first time we create a host side resource.\r
    //\r
    NewResourceId = 1;\r
  } else {\r
    //\r
    // We already have an active host side resource. Create the new one without\r
    // interfering with the current one, so that we can cleanly bail out on\r
    // error, without disturbing the current graphics mode.\r
    //\r
    // The formula below will alternate between IDs 1 and 2.\r
    //\r
    NewResourceId = 3 - VgpuGop->ResourceId;\r
  }\r
\r
  //\r
  // Create the 2D host resource.\r
  //\r
  Status = VirtioGpuResourceCreate2d (\r
             VgpuGop->ParentBus,                // VgpuDev\r
             NewResourceId,                     // ResourceId\r
             VirtioGpuFormatB8G8R8X8Unorm,      // Format\r
             GopModeInfo->HorizontalResolution, // Width\r
             GopModeInfo->VerticalResolution    // Height\r
             );\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  //\r
  // Allocate, zero and map guest backing store, for bus master common buffer\r
  // operation.\r
  //\r
  NewNumberOfBytes = GopModeInfo->HorizontalResolution *\r
                     GopModeInfo->VerticalResolution * sizeof (UINT32);\r
  NewNumberOfPages = EFI_SIZE_TO_PAGES (NewNumberOfBytes);\r
  Status           = VirtioGpuAllocateZeroAndMapBackingStore (\r
                       VgpuGop->ParentBus,            // VgpuDev\r
                       NewNumberOfPages,              // NumberOfPages\r
                       &NewBackingStore,              // HostAddress\r
                       &NewBackingStoreDeviceAddress, // DeviceAddress\r
                       &NewBackingStoreMap            // Mapping\r
                       );\r
  if (EFI_ERROR (Status)) {\r
    goto DestroyHostResource;\r
  }\r
\r
  //\r
  // Attach backing store to the host resource.\r
  //\r
  Status = VirtioGpuResourceAttachBacking (\r
             VgpuGop->ParentBus,           // VgpuDev\r
             NewResourceId,                // ResourceId\r
             NewBackingStoreDeviceAddress, // BackingStoreDeviceAddress\r
             NewNumberOfPages              // NumberOfPages\r
             );\r
  if (EFI_ERROR (Status)) {\r
    goto UnmapAndFreeBackingStore;\r
  }\r
\r
  //\r
  // Point head (scanout) #0 to the host resource.\r
  //\r
  Status = VirtioGpuSetScanout (\r
             VgpuGop->ParentBus,                 // VgpuDev\r
             0,                                  // X\r
             0,                                  // Y\r
             GopModeInfo->HorizontalResolution,  // Width\r
             GopModeInfo->VerticalResolution,    // Height\r
             0,                                  // ScanoutId\r
             NewResourceId                       // ResourceId\r
             );\r
  if (EFI_ERROR (Status)) {\r
    goto DetachBackingStore;\r
  }\r
\r
  //\r
  // If this is not the first (i.e., internal) call, then we have to (a) flush\r
  // the new resource to head (scanout) #0, after having flipped the latter to\r
  // the former above, plus (b) release the old resources.\r
  //\r
  if (VgpuGop->ResourceId != 0) {\r
    Status = VirtioGpuResourceFlush (\r
               VgpuGop->ParentBus,                 // VgpuDev\r
               0,                                  // X\r
               0,                                  // Y\r
               GopModeInfo->HorizontalResolution,  // Width\r
               GopModeInfo->VerticalResolution,    // Height\r
               NewResourceId                       // ResourceId\r
               );\r
    if (EFI_ERROR (Status)) {\r
      //\r
      // Flip head (scanout) #0 back to the current resource. If this fails, we\r
      // cannot continue, as this error occurs on the error path and is\r
      // therefore non-recoverable.\r
      //\r
      Status2 = VirtioGpuSetScanout (\r
                  VgpuGop->ParentBus,                        // VgpuDev\r
                  0,                                         // X\r
                  0,                                         // Y\r
                  VgpuGop->GopModeInfo.HorizontalResolution, // Width\r
                  VgpuGop->GopModeInfo.VerticalResolution,   // Height\r
                  0,                                         // ScanoutId\r
                  VgpuGop->ResourceId                        // ResourceId\r
                  );\r
      ASSERT_EFI_ERROR (Status2);\r
      if (EFI_ERROR (Status2)) {\r
        CpuDeadLoop ();\r
      }\r
\r
      goto DetachBackingStore;\r
    }\r
\r
    //\r
    // Flush successful; release the old resources (without disabling head\r
    // (scanout) #0).\r
    //\r
    ReleaseGopResources (VgpuGop, FALSE /* DisableHead */);\r
  }\r
\r
  //\r
  // This is either the first (internal) call when we have no old resources\r
  // yet, or we've changed the mode successfully and released the old\r
  // resources.\r
  //\r
  ASSERT (VgpuGop->ResourceId == 0);\r
  ASSERT (VgpuGop->BackingStore == NULL);\r
\r
  VgpuGop->ResourceId      = NewResourceId;\r
  VgpuGop->BackingStore    = NewBackingStore;\r
  VgpuGop->NumberOfPages   = NewNumberOfPages;\r
  VgpuGop->BackingStoreMap = NewBackingStoreMap;\r
\r
  //\r
  // Populate Mode and ModeInfo (mutable fields only).\r
  //\r
  VgpuGop->GopMode.Mode = ModeNumber;\r
  CopyMem (&VgpuGop->GopModeInfo, GopModeInfo, sizeof VgpuGop->GopModeInfo);\r
  FreePool (GopModeInfo);\r
  return EFI_SUCCESS;\r
\r
DetachBackingStore:\r
  Status2 = VirtioGpuResourceDetachBacking (VgpuGop->ParentBus, NewResourceId);\r
  ASSERT_EFI_ERROR (Status2);\r
  if (EFI_ERROR (Status2)) {\r
    CpuDeadLoop ();\r
  }\r
\r
UnmapAndFreeBackingStore:\r
  VirtioGpuUnmapAndFreeBackingStore (\r
    VgpuGop->ParentBus, // VgpuDev\r
    NewNumberOfPages,   // NumberOfPages\r
    NewBackingStore,    // HostAddress\r
    NewBackingStoreMap  // Mapping\r
    );\r
\r
DestroyHostResource:\r
  Status2 = VirtioGpuResourceUnref (VgpuGop->ParentBus, NewResourceId);\r
  ASSERT_EFI_ERROR (Status2);\r
  if (EFI_ERROR (Status2)) {\r
    CpuDeadLoop ();\r
  }\r
\r
  FreePool (GopModeInfo);\r
  return Status;\r
}\r
\r
STATIC\r
EFI_STATUS\r
EFIAPI\r
GopBlt (\r
  IN  EFI_GRAPHICS_OUTPUT_PROTOCOL       *This,\r
  IN  EFI_GRAPHICS_OUTPUT_BLT_PIXEL      *BltBuffer    OPTIONAL,\r
  IN  EFI_GRAPHICS_OUTPUT_BLT_OPERATION  BltOperation,\r
  IN  UINTN                              SourceX,\r
  IN  UINTN                              SourceY,\r
  IN  UINTN                              DestinationX,\r
  IN  UINTN                              DestinationY,\r
  IN  UINTN                              Width,\r
  IN  UINTN                              Height,\r
  IN  UINTN                              Delta         OPTIONAL\r
  )\r
{\r
  VGPU_GOP    *VgpuGop;\r
  UINT32      CurrentHorizontal;\r
  UINT32      CurrentVertical;\r
  UINTN       SegmentSize;\r
  UINTN       Y;\r
  UINTN       ResourceOffset;\r
  EFI_STATUS  Status;\r
\r
  VgpuGop           = VGPU_GOP_FROM_GOP (This);\r
  CurrentHorizontal = VgpuGop->GopModeInfo.HorizontalResolution;\r
  CurrentVertical   = VgpuGop->GopModeInfo.VerticalResolution;\r
\r
  //\r
  // We can avoid pixel format conversion in the guest because the internal\r
  // representation of EFI_GRAPHICS_OUTPUT_BLT_PIXEL and that of\r
  // VirtioGpuFormatB8G8R8X8Unorm are identical.\r
  //\r
  SegmentSize = Width * sizeof (UINT32);\r
\r
  //\r
  // Delta is relevant for operations that read a rectangle from, or write a\r
  // rectangle to, BltBuffer.\r
  //\r
  // In these cases, Delta is the stride of BltBuffer, in bytes. If Delta is\r
  // zero, then Width is the entire width of BltBuffer, and the stride is\r
  // supposed to be calculated from Width.\r
  //\r
  if ((BltOperation == EfiBltVideoToBltBuffer) ||\r
      (BltOperation == EfiBltBufferToVideo))\r
  {\r
    if (Delta == 0) {\r
      Delta = SegmentSize;\r
    }\r
  }\r
\r
  //\r
  // For operations that write to the display, check if the destination fits\r
  // onto the display.\r
  //\r
  if ((BltOperation == EfiBltVideoFill) ||\r
      (BltOperation == EfiBltBufferToVideo) ||\r
      (BltOperation == EfiBltVideoToVideo))\r
  {\r
    if ((DestinationX > CurrentHorizontal) ||\r
        (Width > CurrentHorizontal - DestinationX) ||\r
        (DestinationY > CurrentVertical) ||\r
        (Height > CurrentVertical - DestinationY))\r
    {\r
      return EFI_INVALID_PARAMETER;\r
    }\r
  }\r
\r
  //\r
  // For operations that read from the display, check if the source fits onto\r
  // the display.\r
  //\r
  if ((BltOperation == EfiBltVideoToBltBuffer) ||\r
      (BltOperation == EfiBltVideoToVideo))\r
  {\r
    if ((SourceX > CurrentHorizontal) ||\r
        (Width > CurrentHorizontal - SourceX) ||\r
        (SourceY > CurrentVertical) ||\r
        (Height > CurrentVertical - SourceY))\r
    {\r
      return EFI_INVALID_PARAMETER;\r
    }\r
  }\r
\r
  //\r
  // Render the request. For requests that do not modify the display, there\r
  // won't be further steps.\r
  //\r
  switch (BltOperation) {\r
    case EfiBltVideoFill:\r
      //\r
      // Write data from the BltBuffer pixel (0, 0) directly to every pixel of\r
      // the video display rectangle (DestinationX, DestinationY) (DestinationX +\r
      // Width, DestinationY + Height). Only one pixel will be used from the\r
      // BltBuffer. Delta is NOT used.\r
      //\r
      for (Y = 0; Y < Height; ++Y) {\r
        SetMem32 (\r
          VgpuGop->BackingStore +\r
          (DestinationY + Y) * CurrentHorizontal + DestinationX,\r
          SegmentSize,\r
          *(UINT32 *)BltBuffer\r
          );\r
      }\r
\r
      break;\r
\r
    case EfiBltVideoToBltBuffer:\r
      //\r
      // Read data from the video display rectangle (SourceX, SourceY) (SourceX +\r
      // Width, SourceY + Height) and place it in the BltBuffer rectangle\r
      // (DestinationX, DestinationY ) (DestinationX + Width, DestinationY +\r
      // Height). If DestinationX or DestinationY is not zero then Delta must be\r
      // set to the length in bytes of a row in the BltBuffer.\r
      //\r
      for (Y = 0; Y < Height; ++Y) {\r
        CopyMem (\r
          (UINT8 *)BltBuffer +\r
          (DestinationY + Y) * Delta + DestinationX * sizeof *BltBuffer,\r
          VgpuGop->BackingStore +\r
          (SourceY + Y) * CurrentHorizontal + SourceX,\r
          SegmentSize\r
          );\r
      }\r
\r
      return EFI_SUCCESS;\r
\r
    case EfiBltBufferToVideo:\r
      //\r
      // Write data from the BltBuffer rectangle (SourceX, SourceY) (SourceX +\r
      // Width, SourceY + Height) directly to the video display rectangle\r
      // (DestinationX, DestinationY) (DestinationX + Width, DestinationY +\r
      // Height). If SourceX or SourceY is not zero then Delta must be set to the\r
      // length in bytes of a row in the BltBuffer.\r
      //\r
      for (Y = 0; Y < Height; ++Y) {\r
        CopyMem (\r
          VgpuGop->BackingStore +\r
          (DestinationY + Y) * CurrentHorizontal + DestinationX,\r
          (UINT8 *)BltBuffer +\r
          (SourceY + Y) * Delta + SourceX * sizeof *BltBuffer,\r
          SegmentSize\r
          );\r
      }\r
\r
      break;\r
\r
    case EfiBltVideoToVideo:\r
      //\r
      // Copy from the video display rectangle (SourceX, SourceY) (SourceX +\r
      // Width, SourceY + Height) to the video display rectangle (DestinationX,\r
      // DestinationY) (DestinationX + Width, DestinationY + Height). The\r
      // BltBuffer and Delta are not used in this mode.\r
      //\r
      // A single invocation of CopyMem() handles overlap between source and\r
      // destination (that is, within a single line), but for multiple\r
      // invocations, we must handle overlaps.\r
      //\r
      if (SourceY < DestinationY) {\r
        Y = Height;\r
        while (Y > 0) {\r
          --Y;\r
          CopyMem (\r
            VgpuGop->BackingStore +\r
            (DestinationY + Y) * CurrentHorizontal + DestinationX,\r
            VgpuGop->BackingStore +\r
            (SourceY + Y) * CurrentHorizontal + SourceX,\r
            SegmentSize\r
            );\r
        }\r
      } else {\r
        for (Y = 0; Y < Height; ++Y) {\r
          CopyMem (\r
            VgpuGop->BackingStore +\r
            (DestinationY + Y) * CurrentHorizontal + DestinationX,\r
            VgpuGop->BackingStore +\r
            (SourceY + Y) * CurrentHorizontal + SourceX,\r
            SegmentSize\r
            );\r
        }\r
      }\r
\r
      break;\r
\r
    default:\r
      return EFI_INVALID_PARAMETER;\r
  }\r
\r
  //\r
  // For operations that wrote to the display, submit the updated area to the\r
  // host -- update the host resource from guest memory.\r
  //\r
  ResourceOffset = sizeof (UINT32) * (DestinationY * CurrentHorizontal +\r
                                      DestinationX);\r
  Status = VirtioGpuTransferToHost2d (\r
             VgpuGop->ParentBus,   // VgpuDev\r
             (UINT32)DestinationX, // X\r
             (UINT32)DestinationY, // Y\r
             (UINT32)Width,        // Width\r
             (UINT32)Height,       // Height\r
             ResourceOffset,       // Offset\r
             VgpuGop->ResourceId   // ResourceId\r
             );\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  //\r
  // Flush the updated resource to the display.\r
  //\r
  Status = VirtioGpuResourceFlush (\r
             VgpuGop->ParentBus,   // VgpuDev\r
             (UINT32)DestinationX, // X\r
             (UINT32)DestinationY, // Y\r
             (UINT32)Width,        // Width\r
             (UINT32)Height,       // Height\r
             VgpuGop->ResourceId   // ResourceId\r
             );\r
  return Status;\r
}\r
\r
//\r
// Template for initializing VGPU_GOP.Gop.\r
//\r
CONST EFI_GRAPHICS_OUTPUT_PROTOCOL  mGopTemplate = {\r
  GopQueryMode,\r
  GopSetMode,\r
  GopBlt,\r
  NULL          // Mode, to be overwritten in the actual protocol instance\r
};\r