OvmfPkg/QemuVideoDxe/Qemu.h

   1 /** @file
   2   QEMU Video Controller Driver
   3
   4   Copyright (c) 2006 - 2016, Intel Corporation. All rights reserved.<BR>
   5   This program and the accompanying materials
   6   are licensed and made available under the terms and conditions of the BSD License
   7   which accompanies this distribution.  The full text of the license may be found at
   8   http://opensource.org/licenses/bsd-license.php
   9
  10   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12
  13 **/
  14
  15 //
  16 // QEMU Video Controller Driver
  17 //
  18
  19 #ifndef _QEMU_H_
  20 #define _QEMU_H_
  21
  22
  23 #include <Uefi.h>
  24 #include <Protocol/GraphicsOutput.h>
  25 #include <Protocol/PciIo.h>
  26 #include <Protocol/DriverSupportedEfiVersion.h>
  27 #include <Protocol/DevicePath.h>
  28
  29 #include <Library/DebugLib.h>
  30 #include <Library/UefiDriverEntryPoint.h>
  31 #include <Library/UefiLib.h>
  32 #include <Library/PcdLib.h>
  33 #include <Library/MemoryAllocationLib.h>
  34 #include <Library/UefiBootServicesTableLib.h>
  35 #include <Library/BaseMemoryLib.h>
  36 #include <Library/DevicePathLib.h>
  37 #include <Library/TimerLib.h>
  38 #include <Library/FrameBufferBltLib.h>
  39
  40 #include <IndustryStandard/Pci.h>
  41 #include <IndustryStandard/Acpi.h>
  42
  43 //
  44 // QEMU Video PCI Configuration Header values
  45 //
  46 #define CIRRUS_LOGIC_VENDOR_ID                0x1013
  47 #define CIRRUS_LOGIC_5430_DEVICE_ID           0x00a8
  48 #define CIRRUS_LOGIC_5430_ALTERNATE_DEVICE_ID 0x00a0
  49 #define CIRRUS_LOGIC_5446_DEVICE_ID           0x00b8
  50
  51 //
  52 // QEMU Vide Graphical Mode Data
  53 //
  54 typedef struct {
  55   UINT32  InternalModeIndex; // points into card-specific mode table
  56   UINT32  HorizontalResolution;
  57   UINT32  VerticalResolution;
  58   UINT32  ColorDepth;
  59   UINT32  RefreshRate;
  60 } QEMU_VIDEO_MODE_DATA;
  61
  62 #define PIXEL_RED_SHIFT   0
  63 #define PIXEL_GREEN_SHIFT 3
  64 #define PIXEL_BLUE_SHIFT  6
  65
  66 #define PIXEL_RED_MASK    (BIT7 | BIT6 | BIT5)
  67 #define PIXEL_GREEN_MASK  (BIT4 | BIT3 | BIT2)
  68 #define PIXEL_BLUE_MASK   (BIT1 | BIT0)
  69
  70 #define PIXEL_TO_COLOR_BYTE(pixel, mask, shift) ((UINT8) ((pixel & mask) << shift))
  71 #define PIXEL_TO_RED_BYTE(pixel) PIXEL_TO_COLOR_BYTE(pixel, PIXEL_RED_MASK, PIXEL_RED_SHIFT)
  72 #define PIXEL_TO_GREEN_BYTE(pixel) PIXEL_TO_COLOR_BYTE(pixel, PIXEL_GREEN_MASK, PIXEL_GREEN_SHIFT)
  73 #define PIXEL_TO_BLUE_BYTE(pixel) PIXEL_TO_COLOR_BYTE(pixel, PIXEL_BLUE_MASK, PIXEL_BLUE_SHIFT)
  74
  75 #define RGB_BYTES_TO_PIXEL(Red, Green, Blue) \
  76   (UINT8) ( (((Red) >> PIXEL_RED_SHIFT) & PIXEL_RED_MASK) | \
  77             (((Green) >> PIXEL_GREEN_SHIFT) & PIXEL_GREEN_MASK) | \
  78             (((Blue) >> PIXEL_BLUE_SHIFT) & PIXEL_BLUE_MASK) )
  79
  80 #define PIXEL24_RED_MASK    0x00ff0000
  81 #define PIXEL24_GREEN_MASK  0x0000ff00
  82 #define PIXEL24_BLUE_MASK   0x000000ff
  83
  84 #define GRAPHICS_OUTPUT_INVALIDE_MODE_NUMBER  0xffff
  85
  86 //
  87 // QEMU Video Private Data Structure
  88 //
  89 #define QEMU_VIDEO_PRIVATE_DATA_SIGNATURE  SIGNATURE_32 ('Q', 'V', 'I', 'D')
  90
  91 typedef enum {
  92   QEMU_VIDEO_CIRRUS_5430 = 1,
  93   QEMU_VIDEO_CIRRUS_5446,
  94   QEMU_VIDEO_BOCHS,
  95   QEMU_VIDEO_BOCHS_MMIO,
  96 } QEMU_VIDEO_VARIANT;
  97
  98 typedef struct {
  99   UINT16                                VendorId;
 100   UINT16                                DeviceId;
 101   QEMU_VIDEO_VARIANT                    Variant;
 102   CHAR16                                *Name;
 103 } QEMU_VIDEO_CARD;
 104
 105 typedef struct {
 106   UINT64                                Signature;
 107   EFI_HANDLE                            Handle;
 108   EFI_PCI_IO_PROTOCOL                   *PciIo;
 109   UINT64                                OriginalPciAttributes;
 110   EFI_GRAPHICS_OUTPUT_PROTOCOL          GraphicsOutput;
 111   EFI_DEVICE_PATH_PROTOCOL              *GopDevicePath;
 112
 113   //
 114   // The next three fields match the client-visible
 115   // EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE.Mode and
 116   // EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE.MaxMode fields.
 117   //
 118   UINTN                                 CurrentMode;
 119   UINTN                                 MaxMode;
 120   QEMU_VIDEO_MODE_DATA                  *ModeData;
 121
 122   UINT8                                 *LineBuffer;
 123   QEMU_VIDEO_VARIANT                    Variant;
 124   FRAME_BUFFER_CONFIGURE                *FrameBufferBltConfigure;
 125   UINTN                                 FrameBufferBltConfigureSize;
 126 } QEMU_VIDEO_PRIVATE_DATA;
 127
 128 ///
 129 /// Card-specific Video Mode structures
 130 ///
 131 typedef struct {
 132   UINT32  Width;
 133   UINT32  Height;
 134   UINT32  ColorDepth;
 135   UINT32  RefreshRate;
 136   UINT8   *CrtcSettings;
 137   UINT16  *SeqSettings;
 138   UINT8   MiscSetting;
 139 } QEMU_VIDEO_CIRRUS_MODES;
 140
 141 typedef struct {
 142   UINT32  Width;
 143   UINT32  Height;
 144   UINT32  ColorDepth;
 145 } QEMU_VIDEO_BOCHS_MODES;
 146
 147 #define QEMU_VIDEO_PRIVATE_DATA_FROM_GRAPHICS_OUTPUT_THIS(a) \
 148   CR(a, QEMU_VIDEO_PRIVATE_DATA, GraphicsOutput, QEMU_VIDEO_PRIVATE_DATA_SIGNATURE)
 149
 150
 151 //
 152 // Global Variables
 153 //
 154 extern UINT8                                      AttributeController[];
 155 extern UINT8                                      GraphicsController[];
 156 extern UINT8                                      Crtc_640_480_256_60[];
 157 extern UINT16                                     Seq_640_480_256_60[];
 158 extern UINT8                                      Crtc_800_600_256_60[];
 159 extern UINT16                                     Seq_800_600_256_60[];
 160 extern UINT8                                      Crtc_1024_768_256_60[];
 161 extern UINT16                                     Seq_1024_768_256_60[];
 162 extern QEMU_VIDEO_CIRRUS_MODES                    QemuVideoCirrusModes[];
 163 extern QEMU_VIDEO_BOCHS_MODES                     QemuVideoBochsModes[];
 164 extern EFI_DRIVER_BINDING_PROTOCOL                gQemuVideoDriverBinding;
 165 extern EFI_COMPONENT_NAME_PROTOCOL                gQemuVideoComponentName;
 166 extern EFI_COMPONENT_NAME2_PROTOCOL               gQemuVideoComponentName2;
 167 extern EFI_DRIVER_SUPPORTED_EFI_VERSION_PROTOCOL  gQemuVideoDriverSupportedEfiVersion;
 168
 169 //
 170 // Io Registers defined by VGA
 171 //
 172 #define CRTC_ADDRESS_REGISTER   0x3d4
 173 #define CRTC_DATA_REGISTER      0x3d5
 174 #define SEQ_ADDRESS_REGISTER    0x3c4
 175 #define SEQ_DATA_REGISTER       0x3c5
 176 #define GRAPH_ADDRESS_REGISTER  0x3ce
 177 #define GRAPH_DATA_REGISTER     0x3cf
 178 #define ATT_ADDRESS_REGISTER    0x3c0
 179 #define MISC_OUTPUT_REGISTER    0x3c2
 180 #define INPUT_STATUS_1_REGISTER 0x3da
 181 #define DAC_PIXEL_MASK_REGISTER 0x3c6
 182 #define PALETTE_INDEX_REGISTER  0x3c8
 183 #define PALETTE_DATA_REGISTER   0x3c9
 184
 185 #define VBE_DISPI_IOPORT_INDEX           0x01CE
 186 #define VBE_DISPI_IOPORT_DATA            0x01D0
 187
 188 #define VBE_DISPI_INDEX_ID               0x0
 189 #define VBE_DISPI_INDEX_XRES             0x1
 190 #define VBE_DISPI_INDEX_YRES             0x2
 191 #define VBE_DISPI_INDEX_BPP              0x3
 192 #define VBE_DISPI_INDEX_ENABLE           0x4
 193 #define VBE_DISPI_INDEX_BANK             0x5
 194 #define VBE_DISPI_INDEX_VIRT_WIDTH       0x6
 195 #define VBE_DISPI_INDEX_VIRT_HEIGHT      0x7
 196 #define VBE_DISPI_INDEX_X_OFFSET         0x8
 197 #define VBE_DISPI_INDEX_Y_OFFSET         0x9
 198 #define VBE_DISPI_INDEX_VIDEO_MEMORY_64K 0xa
 199
 200 #define VBE_DISPI_ID0                    0xB0C0
 201 #define VBE_DISPI_ID1                    0xB0C1
 202 #define VBE_DISPI_ID2                    0xB0C2
 203 #define VBE_DISPI_ID3                    0xB0C3
 204 #define VBE_DISPI_ID4                    0xB0C4
 205 #define VBE_DISPI_ID5                    0xB0C5
 206
 207 #define VBE_DISPI_DISABLED               0x00
 208 #define VBE_DISPI_ENABLED                0x01
 209 #define VBE_DISPI_GETCAPS                0x02
 210 #define VBE_DISPI_8BIT_DAC               0x20
 211 #define VBE_DISPI_LFB_ENABLED            0x40
 212 #define VBE_DISPI_NOCLEARMEM             0x80
 213
 214 //
 215 // Graphics Output Hardware abstraction internal worker functions
 216 //
 217 EFI_STATUS
 218 QemuVideoGraphicsOutputConstructor (
 219   QEMU_VIDEO_PRIVATE_DATA  *Private
 220   );
 221
 222 EFI_STATUS
 223 QemuVideoGraphicsOutputDestructor (
 224   QEMU_VIDEO_PRIVATE_DATA  *Private
 225   );
 226
 227
 228 //
 229 // EFI_DRIVER_BINDING_PROTOCOL Protocol Interface
 230 //
 231 /**
 232   TODO: Add function description
 233
 234   @param  This TODO: add argument description
 235   @param  Controller TODO: add argument description
 236   @param  RemainingDevicePath TODO: add argument description
 237
 238   TODO: add return values
 239
 240 **/
 241 EFI_STATUS
 242 EFIAPI
 243 QemuVideoControllerDriverSupported (
 244   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
 245   IN EFI_HANDLE                   Controller,
 246   IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath
 247   );
 248
 249 /**
 250   TODO: Add function description
 251
 252   @param  This TODO: add argument description
 253   @param  Controller TODO: add argument description
 254   @param  RemainingDevicePath TODO: add argument description
 255
 256   TODO: add return values
 257
 258 **/
 259 EFI_STATUS
 260 EFIAPI
 261 QemuVideoControllerDriverStart (
 262   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
 263   IN EFI_HANDLE                   Controller,
 264   IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath
 265   );
 266
 267 /**
 268   TODO: Add function description
 269
 270   @param  This TODO: add argument description
 271   @param  Controller TODO: add argument description
 272   @param  NumberOfChildren TODO: add argument description
 273   @param  ChildHandleBuffer TODO: add argument description
 274
 275   TODO: add return values
 276
 277 **/
 278 EFI_STATUS
 279 EFIAPI
 280 QemuVideoControllerDriverStop (
 281   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
 282   IN EFI_HANDLE                   Controller,
 283   IN UINTN                        NumberOfChildren,
 284   IN EFI_HANDLE                   *ChildHandleBuffer
 285   );
 286
 287 //
 288 // EFI Component Name Functions
 289 //
 290 /**
 291   Retrieves a Unicode string that is the user readable name of the driver.
 292
 293   This function retrieves the user readable name of a driver in the form of a
 294   Unicode string. If the driver specified by This has a user readable name in
 295   the language specified by Language, then a pointer to the driver name is
 296   returned in DriverName, and EFI_SUCCESS is returned. If the driver specified
 297   by This does not support the language specified by Language,
 298   then EFI_UNSUPPORTED is returned.
 299
 300   @param  This[in]              A pointer to the EFI_COMPONENT_NAME2_PROTOCOL or
 301                                 EFI_COMPONENT_NAME_PROTOCOL instance.
 302
 303   @param  Language[in]          A pointer to a Null-terminated ASCII string
 304                                 array indicating the language. This is the
 305                                 language of the driver name that the caller is
 306                                 requesting, and it must match one of the
 307                                 languages specified in SupportedLanguages. The
 308                                 number of languages supported by a driver is up
 309                                 to the driver writer. Language is specified
 310                                 in RFC 4646 or ISO 639-2 language code format.
 311
 312   @param  DriverName[out]       A pointer to the Unicode string to return.
 313                                 This Unicode string is the name of the
 314                                 driver specified by This in the language
 315                                 specified by Language.
 316
 317   @retval EFI_SUCCESS           The Unicode string for the Driver specified by
 318                                 This and the language specified by Language was
 319                                 returned in DriverName.
 320
 321   @retval EFI_INVALID_PARAMETER Language is NULL.
 322
 323   @retval EFI_INVALID_PARAMETER DriverName is NULL.
 324
 325   @retval EFI_UNSUPPORTED       The driver specified by This does not support
 326                                 the language specified by Language.
 327
 328 **/
 329 EFI_STATUS
 330 EFIAPI
 331 QemuVideoComponentNameGetDriverName (
 332   IN  EFI_COMPONENT_NAME_PROTOCOL  *This,
 333   IN  CHAR8                        *Language,
 334   OUT CHAR16                       **DriverName
 335   );
 336
 337
 338 /**
 339   Retrieves a Unicode string that is the user readable name of the controller
 340   that is being managed by a driver.
 341
 342   This function retrieves the user readable name of the controller specified by
 343   ControllerHandle and ChildHandle in the form of a Unicode string. If the
 344   driver specified by This has a user readable name in the language specified by
 345   Language, then a pointer to the controller name is returned in ControllerName,
 346   and EFI_SUCCESS is returned.  If the driver specified by This is not currently
 347   managing the controller specified by ControllerHandle and ChildHandle,
 348   then EFI_UNSUPPORTED is returned.  If the driver specified by This does not
 349   support the language specified by Language, then EFI_UNSUPPORTED is returned.
 350
 351   @param  This[in]              A pointer to the EFI_COMPONENT_NAME2_PROTOCOL or
 352                                 EFI_COMPONENT_NAME_PROTOCOL instance.
 353
 354   @param  ControllerHandle[in]  The handle of a controller that the driver
 355                                 specified by This is managing.  This handle
 356                                 specifies the controller whose name is to be
 357                                 returned.
 358
 359   @param  ChildHandle[in]       The handle of the child controller to retrieve
 360                                 the name of.  This is an optional parameter that
 361                                 may be NULL.  It will be NULL for device
 362                                 drivers.  It will also be NULL for a bus drivers
 363                                 that wish to retrieve the name of the bus
 364                                 controller.  It will not be NULL for a bus
 365                                 driver that wishes to retrieve the name of a
 366                                 child controller.
 367
 368   @param  Language[in]          A pointer to a Null-terminated ASCII string
 369                                 array indicating the language.  This is the
 370                                 language of the driver name that the caller is
 371                                 requesting, and it must match one of the
 372                                 languages specified in SupportedLanguages. The
 373                                 number of languages supported by a driver is up
 374                                 to the driver writer. Language is specified in
 375                                 RFC 4646 or ISO 639-2 language code format.
 376
 377   @param  ControllerName[out]   A pointer to the Unicode string to return.
 378                                 This Unicode string is the name of the
 379                                 controller specified by ControllerHandle and
 380                                 ChildHandle in the language specified by
 381                                 Language from the point of view of the driver
 382                                 specified by This.
 383
 384   @retval EFI_SUCCESS           The Unicode string for the user readable name in
 385                                 the language specified by Language for the
 386                                 driver specified by This was returned in
 387                                 DriverName.
 388
 389   @retval EFI_INVALID_PARAMETER ControllerHandle is not a valid EFI_HANDLE.
 390
 391   @retval EFI_INVALID_PARAMETER ChildHandle is not NULL and it is not a valid
 392                                 EFI_HANDLE.
 393
 394   @retval EFI_INVALID_PARAMETER Language is NULL.
 395
 396   @retval EFI_INVALID_PARAMETER ControllerName is NULL.
 397
 398   @retval EFI_UNSUPPORTED       The driver specified by This is not currently
 399                                 managing the controller specified by
 400                                 ControllerHandle and ChildHandle.
 401
 402   @retval EFI_UNSUPPORTED       The driver specified by This does not support
 403                                 the language specified by Language.
 404
 405 **/
 406 EFI_STATUS
 407 EFIAPI
 408 QemuVideoComponentNameGetControllerName (
 409   IN  EFI_COMPONENT_NAME_PROTOCOL                     *This,
 410   IN  EFI_HANDLE                                      ControllerHandle,
 411   IN  EFI_HANDLE                                      ChildHandle        OPTIONAL,
 412   IN  CHAR8                                           *Language,
 413   OUT CHAR16                                          **ControllerName
 414   );
 415
 416
 417 //
 418 // Local Function Prototypes
 419 //
 420 VOID
 421 InitializeCirrusGraphicsMode (
 422   QEMU_VIDEO_PRIVATE_DATA  *Private,
 423   QEMU_VIDEO_CIRRUS_MODES  *ModeData
 424   );
 425
 426 VOID
 427 InitializeBochsGraphicsMode (
 428   QEMU_VIDEO_PRIVATE_DATA  *Private,
 429   QEMU_VIDEO_BOCHS_MODES   *ModeData
 430   );
 431
 432 VOID
 433 SetPaletteColor (
 434   QEMU_VIDEO_PRIVATE_DATA  *Private,
 435   UINTN                           Index,
 436   UINT8                           Red,
 437   UINT8                           Green,
 438   UINT8                           Blue
 439   );
 440
 441 VOID
 442 SetDefaultPalette (
 443   QEMU_VIDEO_PRIVATE_DATA  *Private
 444   );
 445
 446 VOID
 447 DrawLogo (
 448   QEMU_VIDEO_PRIVATE_DATA  *Private,
 449   UINTN                           ScreenWidth,
 450   UINTN                           ScreenHeight
 451   );
 452
 453 VOID
 454 outb (
 455   QEMU_VIDEO_PRIVATE_DATA  *Private,
 456   UINTN                           Address,
 457   UINT8                           Data
 458   );
 459
 460 VOID
 461 outw (
 462   QEMU_VIDEO_PRIVATE_DATA  *Private,
 463   UINTN                           Address,
 464   UINT16                          Data
 465   );
 466
 467 UINT8
 468 inb (
 469   QEMU_VIDEO_PRIVATE_DATA  *Private,
 470   UINTN                           Address
 471   );
 472
 473 UINT16
 474 inw (
 475   QEMU_VIDEO_PRIVATE_DATA  *Private,
 476   UINTN                           Address
 477   );
 478
 479 VOID
 480 BochsWrite (
 481   QEMU_VIDEO_PRIVATE_DATA  *Private,
 482   UINT16                   Reg,
 483   UINT16                   Data
 484   );
 485
 486 UINT16
 487 BochsRead (
 488   QEMU_VIDEO_PRIVATE_DATA  *Private,
 489   UINT16                   Reg
 490   );
 491
 492 VOID
 493 VgaOutb (
 494   QEMU_VIDEO_PRIVATE_DATA  *Private,
 495   UINTN                    Reg,
 496   UINT8                    Data
 497   );
 498
 499 EFI_STATUS
 500 QemuVideoCirrusModeSetup (
 501   QEMU_VIDEO_PRIVATE_DATA  *Private
 502   );
 503
 504 EFI_STATUS
 505 QemuVideoBochsModeSetup (
 506   QEMU_VIDEO_PRIVATE_DATA  *Private,
 507   BOOLEAN                  IsQxl
 508   );
 509
 510 VOID
 511 InstallVbeShim (
 512   IN CONST CHAR16         *CardName,
 513   IN EFI_PHYSICAL_ADDRESS FrameBufferBase
 514   );
 515 #endif