OvmfPkg/Bhyve/BhyveRfbDxe/GopScreen.c

   1 /*++ @file
   2
   3 Copyright (c) 2020, Rebecca Cran <rebecca@bsdio.com>
   4 Copyright (c) 2015, Nahanni Systems, Inc.
   5 Copyright (c) 2006 - 2018, Intel Corporation. All rights reserved.<BR>
   6 Portions copyright (c) 2010 - 2011, Apple Inc. All rights reserved.
   7
   8 SPDX-License-Identifier: BSD-2-Clause-Patent
   9
  10 Module Name:
  11
  12     EmuGopScreen.c
  13
  14 Abstract:
  15
  16   This file produces the graphics abstration of UGA. It is called by
  17   EmuGopDriver.c file which deals with the EFI 1.1 driver model.
  18   This file just does graphics.
  19
  20 **/
  21
  22 #include "Gop.h"
  23 #include <Library/FrameBufferBltLib.h>
  24
  25
  26 EFI_EVENT               mGopScreenExitBootServicesEvent;
  27
  28 GOP_MODE_DATA mGopModeData[] = {
  29     { 0,     0,    32, 0 },    // Filled in with user-spec'd resolution
  30     { 1024,  768,  32, 0 },
  31     { 800,   600,  32, 0 },
  32     { 640,   480,  32, 0 }
  33     };
  34
  35 STATIC
  36 VOID
  37 BhyveGopCompleteModeInfo (
  38   IN  GOP_MODE_DATA  *ModeData,
  39   OUT EFI_GRAPHICS_OUTPUT_MODE_INFORMATION  *Info
  40   )
  41 {
  42   Info->Version = 0;
  43   if (ModeData->ColorDepth == 8) {
  44     Info->PixelFormat = PixelBitMask;
  45     Info->PixelInformation.RedMask = PIXEL_RED_MASK;
  46     Info->PixelInformation.GreenMask = PIXEL_GREEN_MASK;
  47     Info->PixelInformation.BlueMask = PIXEL_BLUE_MASK;
  48     Info->PixelInformation.ReservedMask = 0;
  49   } else if (ModeData->ColorDepth == 24) {
  50     Info->PixelFormat = PixelBitMask;
  51     Info->PixelInformation.RedMask = PIXEL24_RED_MASK;
  52     Info->PixelInformation.GreenMask = PIXEL24_GREEN_MASK;
  53     Info->PixelInformation.BlueMask = PIXEL24_BLUE_MASK;
  54     Info->PixelInformation.ReservedMask = 0;
  55   } else if (ModeData->ColorDepth == 32) {
  56     DEBUG ((DEBUG_INFO, "%dx%d PixelBlueGreenRedReserved8BitPerColor\n",
  57      ModeData->HorizontalResolution, ModeData->VerticalResolution));
  58     Info->PixelFormat = PixelBlueGreenRedReserved8BitPerColor;
  59   }
  60   Info->PixelsPerScanLine = Info->HorizontalResolution;
  61 }
  62
  63
  64 /**
  65   Returns information for an available graphics mode that the graphics device
  66   and the set of active video output devices supports.
  67
  68   @param  This                  The EFI_GRAPHICS_OUTPUT_PROTOCOL instance.
  69   @param  ModeNumber            The mode number to return information on.
  70   @param  SizeOfInfo            A pointer to the size, in bytes, of the Info buffer.
  71   @param  Info                  A pointer to callee allocated buffer that returns information about ModeNumber.
  72
  73   @retval EFI_SUCCESS           Mode information returned.
  74   @retval EFI_BUFFER_TOO_SMALL  The Info buffer was too small.
  75   @retval EFI_DEVICE_ERROR      A hardware error occurred trying to retrieve the video mode.
  76   @retval EFI_NOT_STARTED       Video display is not initialized. Call SetMode ()
  77   @retval EFI_INVALID_PARAMETER One of the input args was NULL.
  78
  79 **/
  80 EFI_STATUS
  81 EFIAPI
  82 EmuGopQuerytMode (
  83   IN  EFI_GRAPHICS_OUTPUT_PROTOCOL          *This,
  84   IN  UINT32                                ModeNumber,
  85   OUT UINTN                                 *SizeOfInfo,
  86   OUT EFI_GRAPHICS_OUTPUT_MODE_INFORMATION  **Info
  87   )
  88 {
  89   GOP_PRIVATE_DATA  *Private;
  90   GOP_MODE_DATA     *ModeData;
  91
  92   Private = GOP_PRIVATE_DATA_FROM_THIS (This);
  93
  94   if (Info == NULL || SizeOfInfo == NULL || (UINTN) ModeNumber >= This->Mode->MaxMode) {
  95     return EFI_INVALID_PARAMETER;
  96   }
  97
  98   *Info = AllocatePool (sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION));
  99   if (*Info == NULL) {
 100     return EFI_OUT_OF_RESOURCES;
 101   }
 102
 103   *SizeOfInfo = sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION);
 104
 105   ModeData = &Private->ModeData[ModeNumber];
 106   (*Info)->Version = 0;
 107   (*Info)->HorizontalResolution = ModeData->HorizontalResolution;
 108   (*Info)->VerticalResolution   = ModeData->VerticalResolution;
 109   (*Info)->PixelFormat = PixelBitMask;
 110   (*Info)->PixelsPerScanLine = (*Info)->HorizontalResolution;
 111   BhyveGopCompleteModeInfo(ModeData, *Info);
 112   return EFI_SUCCESS;
 113 }
 114
 115
 116
 117 /**
 118   Set the video device into the specified mode and clears the visible portions of
 119   the output display to black.
 120
 121   @param  This              The EFI_GRAPHICS_OUTPUT_PROTOCOL instance.
 122   @param  ModeNumber        Abstraction that defines the current video mode.
 123
 124   @retval EFI_SUCCESS       The graphics mode specified by ModeNumber was selected.
 125   @retval EFI_DEVICE_ERROR  The device had an error and could not complete the request.
 126   @retval EFI_UNSUPPORTED   ModeNumber is not supported by this device.
 127
 128 **/
 129
 130 FRAME_BUFFER_CONFIGURE *fbconf;
 131
 132 EFI_STATUS
 133 EFIAPI
 134 EmuGopSetMode (
 135   IN  EFI_GRAPHICS_OUTPUT_PROTOCOL  *This,
 136   IN  UINT32                        ModeNumber
 137   )
 138 {
 139   GOP_PRIVATE_DATA                *Private;
 140   GOP_MODE_DATA                   *ModeData;
 141   EFI_GRAPHICS_OUTPUT_BLT_PIXEL   Fill;
 142   EFI_GRAPHICS_OUTPUT_MODE_INFORMATION  *Info;
 143
 144   UINTN confsize = 0;
 145   fbconf = NULL;
 146
 147   Private = GOP_PRIVATE_DATA_FROM_THIS (This);
 148
 149   if (ModeNumber >= This->Mode->MaxMode) {
 150     // Tell bhyve that we are switching out of vesa
 151     BhyveSetGraphicsMode(Private, 0, 0, 0);
 152     return EFI_UNSUPPORTED;
 153   }
 154
 155   DEBUG ((DEBUG_INFO, "BHYVE GopSetMode %d\n", ModeNumber));
 156
 157   ModeData = &Private->ModeData[ModeNumber];
 158   This->Mode->Mode = ModeNumber;
 159   Private->GraphicsOutput.Mode->Info->HorizontalResolution = ModeData->HorizontalResolution;
 160   Private->GraphicsOutput.Mode->Info->VerticalResolution = ModeData->VerticalResolution;
 161   Private->GraphicsOutput.Mode->Info->PixelsPerScanLine = ModeData->HorizontalResolution;
 162
 163   Info = This->Mode->Info;
 164   BhyveGopCompleteModeInfo(ModeData, Info);
 165
 166   This->Mode->Info->HorizontalResolution = ModeData->HorizontalResolution;
 167   This->Mode->Info->VerticalResolution = ModeData->VerticalResolution;
 168   This->Mode->SizeOfInfo = sizeof(EFI_GRAPHICS_OUTPUT_MODE_INFORMATION);
 169   This->Mode->FrameBufferBase = Private->GraphicsOutput.Mode->FrameBufferBase;
 170
 171   /*
 172   This->Mode->FrameBufferSize = Info->HorizontalResolution * Info->VerticalResolution
 173                                 * ((ModeData->ColorDepth + 7) / 8);
 174   */
 175   This->Mode->FrameBufferSize = Private->FbSize;
 176   DEBUG ((DEBUG_INFO, "BHYVE GOP FrameBufferBase: 0x%x, FrameBufferSize: 0x%x\n", This->Mode->FrameBufferBase, This->Mode->FrameBufferSize));
 177
 178   BhyveSetGraphicsMode(Private, (UINT16)ModeData->HorizontalResolution, (UINT16)ModeData->VerticalResolution, (UINT16)ModeData->ColorDepth);
 179
 180   RETURN_STATUS ret = FrameBufferBltConfigure (
 181     (VOID*)(UINTN) This->Mode->FrameBufferBase,
 182     This->Mode->Info, fbconf, &confsize
 183     );
 184   if (ret == EFI_BUFFER_TOO_SMALL || ret == EFI_INVALID_PARAMETER) {
 185           fbconf = AllocatePool(confsize);
 186           ret = FrameBufferBltConfigure(
 187                          (VOID*)(UINTN)This->Mode->FrameBufferBase,
 188                          This->Mode->Info, fbconf, &confsize);
 189           ASSERT(ret == EFI_SUCCESS);
 190   }
 191
 192   Fill.Red   = 0;
 193   Fill.Green = 0;
 194   Fill.Blue  = 0;
 195   This->Blt (
 196           This,
 197           &Fill,
 198           EfiBltVideoFill,
 199           0,
 200           0,
 201           0,
 202           0,
 203           ModeData->HorizontalResolution,
 204           ModeData->VerticalResolution,
 205           ModeData->HorizontalResolution * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL)
 206           );
 207   return EFI_SUCCESS;
 208 }
 209
 210
 211
 212 /**
 213   Blt a rectangle of pixels on the graphics screen. Blt stands for BLock Transfer.
 214
 215   @param  This         Protocol instance pointer.
 216   @param  BltBuffer    Buffer containing data to blit into video buffer. This
 217                        buffer has a size of Width*Height*sizeof(EFI_GRAPHICS_OUTPUT_BLT_PIXEL)
 218   @param  BltOperation Operation to perform on BlitBuffer and video memory
 219   @param  SourceX      X coordinate of source for the BltBuffer.
 220   @param  SourceY      Y coordinate of source for the BltBuffer.
 221   @param  DestinationX X coordinate of destination for the BltBuffer.
 222   @param  DestinationY Y coordinate of destination for the BltBuffer.
 223   @param  Width        Width of rectangle in BltBuffer in pixels.
 224   @param  Height       Hight of rectangle in BltBuffer in pixels.
 225   @param  Delta        OPTIONAL
 226
 227   @retval EFI_SUCCESS           The Blt operation completed.
 228   @retval EFI_INVALID_PARAMETER BltOperation is not valid.
 229   @retval EFI_DEVICE_ERROR      A hardware error occurred writting to the video buffer.
 230
 231 **/
 232 EFI_STATUS
 233 EFIAPI
 234 EmuGopBlt (
 235   IN  EFI_GRAPHICS_OUTPUT_PROTOCOL            *This,
 236   IN  EFI_GRAPHICS_OUTPUT_BLT_PIXEL           *BltBuffer    OPTIONAL,
 237   IN  EFI_GRAPHICS_OUTPUT_BLT_OPERATION       BltOperation,
 238   IN  UINTN                                   SourceX,
 239   IN  UINTN                                   SourceY,
 240   IN  UINTN                                   DestinationX,
 241   IN  UINTN                                   DestinationY,
 242   IN  UINTN                                   Width,
 243   IN  UINTN                                   Height,
 244   IN  UINTN                                   Delta         OPTIONAL
 245   )
 246 {
 247   EFI_TPL           OriginalTPL;
 248   EFI_STATUS        Status;
 249
 250   if ((UINT32)BltOperation >= EfiGraphicsOutputBltOperationMax) {
 251     return EFI_INVALID_PARAMETER;
 252   }
 253
 254   if (Width == 0 || Height == 0) {
 255     return EFI_INVALID_PARAMETER;
 256   }
 257
 258   //
 259   // We have to raise to TPL Notify, so we make an atomic write the frame buffer.
 260   // We would not want a timer based event (Cursor, ...) to come in while we are
 261   // doing this operation.
 262   //
 263   OriginalTPL = gBS->RaiseTPL (TPL_NOTIFY);
 264
 265   switch (BltOperation) {
 266   case EfiBltVideoToBltBuffer:
 267   case EfiBltBufferToVideo:
 268   case EfiBltVideoFill:
 269   case EfiBltVideoToVideo:
 270     Status = FrameBufferBlt (
 271      fbconf,
 272       BltBuffer,
 273       BltOperation,
 274       SourceX,
 275       SourceY,
 276       DestinationX,
 277       DestinationY,
 278       Width,
 279       Height,
 280       Delta
 281       );
 282     break;
 283
 284   default:
 285     Status = EFI_INVALID_PARAMETER;
 286     ASSERT (FALSE);
 287   }
 288
 289   gBS->RestoreTPL (OriginalTPL);
 290
 291   return Status;
 292 }
 293
 294
 295 //
 296 // Construction and Destruction functions
 297 //
 298
 299 EFI_STATUS
 300 EmuGopConstructor (
 301   GOP_PRIVATE_DATA    *Private
 302   )
 303 {
 304   // Set mode 0 to be the requested resolution
 305   mGopModeData[0].HorizontalResolution = PcdGet32 ( PcdVideoHorizontalResolution);
 306   mGopModeData[0].VerticalResolution = PcdGet32 ( PcdVideoVerticalResolution );
 307
 308   Private->ModeData = mGopModeData;
 309
 310   Private->GraphicsOutput.QueryMode      = EmuGopQuerytMode;
 311   Private->GraphicsOutput.SetMode        = EmuGopSetMode;
 312   Private->GraphicsOutput.Blt            = EmuGopBlt;
 313
 314   //
 315   // Allocate buffer for Graphics Output Protocol mode information
 316   //
 317   Private->GraphicsOutput.Mode = AllocatePool (sizeof (EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE));
 318   if (Private->GraphicsOutput.Mode == NULL) {
 319     return EFI_OUT_OF_RESOURCES;
 320   }
 321   Private->GraphicsOutput.Mode->Info = AllocatePool (sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION));
 322   if (Private->GraphicsOutput.Mode->Info == NULL) {
 323     return EFI_OUT_OF_RESOURCES;
 324   }
 325
 326
 327   DEBUG ((DEBUG_INFO, "BHYVE Gop Constructor\n"));
 328
 329   Private->GraphicsOutput.Mode->MaxMode = sizeof(mGopModeData) / sizeof(GOP_MODE_DATA);
 330   //
 331   // Till now, we have no idea about the window size.
 332   //
 333   Private->GraphicsOutput.Mode->Mode = GRAPHICS_OUTPUT_INVALID_MODE_NUMBER;
 334   Private->GraphicsOutput.Mode->Info->Version = 0;
 335   Private->GraphicsOutput.Mode->Info->HorizontalResolution = 0;
 336   Private->GraphicsOutput.Mode->Info->VerticalResolution = 0;
 337   Private->GraphicsOutput.Mode->Info->PixelFormat = PixelBitMask;
 338   Private->GraphicsOutput.Mode->SizeOfInfo = sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION);
 339   Private->GraphicsOutput.Mode->FrameBufferBase = (EFI_PHYSICAL_ADDRESS) Private->FbAddr;
 340   Private->GraphicsOutput.Mode->FrameBufferSize = Private->FbSize;
 341
 342   return EFI_SUCCESS;
 343 }
 344
 345
 346
 347 EFI_STATUS
 348 EmuGopDestructor (
 349   GOP_PRIVATE_DATA     *Private
 350   )
 351 {
 352   //
 353   // Free graphics output protocol occupied resource
 354   //
 355   if (Private->GraphicsOutput.Mode != NULL) {
 356     if (Private->GraphicsOutput.Mode->Info != NULL) {
 357       FreePool (Private->GraphicsOutput.Mode->Info);
 358     }
 359     FreePool (Private->GraphicsOutput.Mode);
 360     Private->GraphicsOutput.Mode = NULL;
 361   }
 362
 363   return EFI_SUCCESS;
 364 }
 365
 366
 367 VOID
 368 EFIAPI
 369 ShutdownGopEvent (
 370   IN EFI_EVENT  Event,
 371   IN VOID       *Context
 372   )
 373 /*++
 374
 375 Routine Description:
 376
 377   This is the UGA screen's callback notification function for exit-boot-services.
 378   All we do here is call EmuGopDestructor().
 379
 380 Arguments:
 381
 382   Event   - not used
 383   Context - pointer to the Private structure.
 384
 385 Returns:
 386
 387   None.
 388
 389 **/
 390 {
 391   EmuGopDestructor (Context);
 392 }