2 This driver is a sample implementation of the Graphics Output Protocol for
3 the QEMU (Cirrus Logic 5446) video controller.
5 Copyright (c) 2006 - 2019, Intel Corporation. All rights reserved.<BR>
7 SPDX-License-Identifier: BSD-2-Clause-Patent
12 #include <IndustryStandard/Acpi.h>
14 EFI_DRIVER_BINDING_PROTOCOL gQemuVideoDriverBinding
= {
15 QemuVideoControllerDriverSupported
,
16 QemuVideoControllerDriverStart
,
17 QemuVideoControllerDriverStop
,
23 QEMU_VIDEO_CARD gQemuVideoCardList
[] = {
25 PCI_CLASS_DISPLAY_VGA
,
26 CIRRUS_LOGIC_VENDOR_ID
,
27 CIRRUS_LOGIC_5430_DEVICE_ID
,
28 QEMU_VIDEO_CIRRUS_5430
,
31 PCI_CLASS_DISPLAY_VGA
,
32 CIRRUS_LOGIC_VENDOR_ID
,
33 CIRRUS_LOGIC_5430_ALTERNATE_DEVICE_ID
,
34 QEMU_VIDEO_CIRRUS_5430
,
37 PCI_CLASS_DISPLAY_VGA
,
38 CIRRUS_LOGIC_VENDOR_ID
,
39 CIRRUS_LOGIC_5446_DEVICE_ID
,
40 QEMU_VIDEO_CIRRUS_5446
,
43 PCI_CLASS_DISPLAY_VGA
,
46 QEMU_VIDEO_BOCHS_MMIO
,
49 PCI_CLASS_DISPLAY_OTHER
,
52 QEMU_VIDEO_BOCHS_MMIO
,
53 L
"QEMU Standard VGA (secondary)"
55 PCI_CLASS_DISPLAY_VGA
,
61 PCI_CLASS_DISPLAY_VGA
,
64 QEMU_VIDEO_BOCHS_MMIO
,
67 PCI_CLASS_DISPLAY_VGA
,
70 QEMU_VIDEO_VMWARE_SVGA
,
77 static QEMU_VIDEO_CARD
*
86 while (gQemuVideoCardList
[Index
].VendorId
!= 0) {
87 if (gQemuVideoCardList
[Index
].SubClass
== SubClass
&&
88 gQemuVideoCardList
[Index
].VendorId
== VendorId
&&
89 gQemuVideoCardList
[Index
].DeviceId
== DeviceId
) {
90 return gQemuVideoCardList
+ Index
;
98 Check if this device is supported.
100 @param This The driver binding protocol.
101 @param Controller The controller handle to check.
102 @param RemainingDevicePath The remaining device path.
104 @retval EFI_SUCCESS The bus supports this controller.
105 @retval EFI_UNSUPPORTED This device isn't supported.
110 QemuVideoControllerDriverSupported (
111 IN EFI_DRIVER_BINDING_PROTOCOL
*This
,
112 IN EFI_HANDLE Controller
,
113 IN EFI_DEVICE_PATH_PROTOCOL
*RemainingDevicePath
117 EFI_PCI_IO_PROTOCOL
*PciIo
;
119 QEMU_VIDEO_CARD
*Card
;
122 // Open the PCI I/O Protocol
124 Status
= gBS
->OpenProtocol (
126 &gEfiPciIoProtocolGuid
,
128 This
->DriverBindingHandle
,
130 EFI_OPEN_PROTOCOL_BY_DRIVER
132 if (EFI_ERROR (Status
)) {
137 // Read the PCI Configuration Header from the PCI Device
139 Status
= PciIo
->Pci
.Read (
143 sizeof (Pci
) / sizeof (UINT32
),
146 if (EFI_ERROR (Status
)) {
150 Status
= EFI_UNSUPPORTED
;
151 if (!IS_PCI_DISPLAY (&Pci
)) {
154 Card
= QemuVideoDetect(Pci
.Hdr
.ClassCode
[1], Pci
.Hdr
.VendorId
, Pci
.Hdr
.DeviceId
);
156 DEBUG ((EFI_D_INFO
, "QemuVideo: %s detected\n", Card
->Name
));
157 Status
= EFI_SUCCESS
;
162 // Close the PCI I/O Protocol
166 &gEfiPciIoProtocolGuid
,
167 This
->DriverBindingHandle
,
175 Start to process the controller.
177 @param This The USB bus driver binding instance.
178 @param Controller The controller to check.
179 @param RemainingDevicePath The remaining device patch.
181 @retval EFI_SUCCESS The controller is controlled by the usb bus.
182 @retval EFI_ALREADY_STARTED The controller is already controlled by the usb
184 @retval EFI_OUT_OF_RESOURCES Failed to allocate resources.
189 QemuVideoControllerDriverStart (
190 IN EFI_DRIVER_BINDING_PROTOCOL
*This
,
191 IN EFI_HANDLE Controller
,
192 IN EFI_DEVICE_PATH_PROTOCOL
*RemainingDevicePath
197 QEMU_VIDEO_PRIVATE_DATA
*Private
;
199 EFI_DEVICE_PATH_PROTOCOL
*ParentDevicePath
;
200 ACPI_ADR_DEVICE_PATH AcpiDeviceNode
;
202 QEMU_VIDEO_CARD
*Card
;
203 EFI_PCI_IO_PROTOCOL
*ChildPciIo
;
204 UINT64 SupportedVgaIo
;
206 OldTpl
= gBS
->RaiseTPL (TPL_CALLBACK
);
209 // Allocate Private context data for GOP interface.
211 Private
= AllocateZeroPool (sizeof (QEMU_VIDEO_PRIVATE_DATA
));
212 if (Private
== NULL
) {
213 Status
= EFI_OUT_OF_RESOURCES
;
218 // Set up context record
220 Private
->Signature
= QEMU_VIDEO_PRIVATE_DATA_SIGNATURE
;
223 // Open PCI I/O Protocol
225 Status
= gBS
->OpenProtocol (
227 &gEfiPciIoProtocolGuid
,
228 (VOID
**) &Private
->PciIo
,
229 This
->DriverBindingHandle
,
231 EFI_OPEN_PROTOCOL_BY_DRIVER
233 if (EFI_ERROR (Status
)) {
238 // Read the PCI Configuration Header from the PCI Device
240 Status
= Private
->PciIo
->Pci
.Read (
244 sizeof (Pci
) / sizeof (UINT32
),
247 if (EFI_ERROR (Status
)) {
252 // Determine card variant.
254 Card
= QemuVideoDetect(Pci
.Hdr
.ClassCode
[1], Pci
.Hdr
.VendorId
, Pci
.Hdr
.DeviceId
);
256 Status
= EFI_DEVICE_ERROR
;
259 Private
->Variant
= Card
->Variant
;
262 // IsQxl is based on the detected Card->Variant, which at a later point might
263 // not match Private->Variant.
265 IsQxl
= (BOOLEAN
)(Card
->Variant
== QEMU_VIDEO_BOCHS
);
268 // Save original PCI attributes
270 Status
= Private
->PciIo
->Attributes (
272 EfiPciIoAttributeOperationGet
,
274 &Private
->OriginalPciAttributes
277 if (EFI_ERROR (Status
)) {
282 // Get supported PCI attributes
284 Status
= Private
->PciIo
->Attributes (
286 EfiPciIoAttributeOperationSupported
,
290 if (EFI_ERROR (Status
)) {
294 SupportedVgaIo
&= (UINT64
)(EFI_PCI_IO_ATTRIBUTE_VGA_IO
| EFI_PCI_IO_ATTRIBUTE_VGA_IO_16
);
295 if (SupportedVgaIo
== 0 && IS_PCI_VGA (&Pci
)) {
296 Status
= EFI_UNSUPPORTED
;
301 // Set new PCI attributes
303 Status
= Private
->PciIo
->Attributes (
305 EfiPciIoAttributeOperationEnable
,
306 EFI_PCI_DEVICE_ENABLE
| EFI_PCI_IO_ATTRIBUTE_VGA_MEMORY
| SupportedVgaIo
,
309 if (EFI_ERROR (Status
)) {
314 // Check whenever the qemu stdvga mmio bar is present (qemu 1.3+).
316 if (Private
->Variant
== QEMU_VIDEO_BOCHS_MMIO
) {
317 EFI_ACPI_ADDRESS_SPACE_DESCRIPTOR
*MmioDesc
;
319 Status
= Private
->PciIo
->GetBarAttributes (
325 if (EFI_ERROR (Status
) ||
326 MmioDesc
->ResType
!= ACPI_ADDRESS_SPACE_TYPE_MEM
) {
327 DEBUG ((EFI_D_INFO
, "QemuVideo: No mmio bar, fallback to port io\n"));
328 Private
->Variant
= QEMU_VIDEO_BOCHS
;
330 DEBUG ((EFI_D_INFO
, "QemuVideo: Using mmio bar @ 0x%lx\n",
331 MmioDesc
->AddrRangeMin
));
334 if (!EFI_ERROR (Status
)) {
340 // VMWare SVGA is handled like Bochs (with port IO only).
342 if (Private
->Variant
== QEMU_VIDEO_VMWARE_SVGA
) {
343 Private
->Variant
= QEMU_VIDEO_BOCHS
;
344 Private
->FrameBufferVramBarIndex
= PCI_BAR_IDX1
;
348 // Check if accessing the bochs interface works.
350 if (Private
->Variant
== QEMU_VIDEO_BOCHS_MMIO
||
351 Private
->Variant
== QEMU_VIDEO_BOCHS
) {
353 BochsId
= BochsRead(Private
, VBE_DISPI_INDEX_ID
);
354 if ((BochsId
& 0xFFF0) != VBE_DISPI_ID0
) {
355 DEBUG ((EFI_D_INFO
, "QemuVideo: BochsID mismatch (got 0x%x)\n", BochsId
));
356 Status
= EFI_DEVICE_ERROR
;
357 goto RestoreAttributes
;
362 // Get ParentDevicePath
364 Status
= gBS
->HandleProtocol (
366 &gEfiDevicePathProtocolGuid
,
367 (VOID
**) &ParentDevicePath
369 if (EFI_ERROR (Status
)) {
370 goto RestoreAttributes
;
374 // Set Gop Device Path
376 ZeroMem (&AcpiDeviceNode
, sizeof (ACPI_ADR_DEVICE_PATH
));
377 AcpiDeviceNode
.Header
.Type
= ACPI_DEVICE_PATH
;
378 AcpiDeviceNode
.Header
.SubType
= ACPI_ADR_DP
;
379 AcpiDeviceNode
.ADR
= ACPI_DISPLAY_ADR (1, 0, 0, 1, 0, ACPI_ADR_DISPLAY_TYPE_VGA
, 0, 0);
380 SetDevicePathNodeLength (&AcpiDeviceNode
.Header
, sizeof (ACPI_ADR_DEVICE_PATH
));
382 Private
->GopDevicePath
= AppendDevicePathNode (
384 (EFI_DEVICE_PATH_PROTOCOL
*) &AcpiDeviceNode
386 if (Private
->GopDevicePath
== NULL
) {
387 Status
= EFI_OUT_OF_RESOURCES
;
388 goto RestoreAttributes
;
392 // Create new child handle and install the device path protocol on it.
394 Status
= gBS
->InstallMultipleProtocolInterfaces (
396 &gEfiDevicePathProtocolGuid
,
397 Private
->GopDevicePath
,
400 if (EFI_ERROR (Status
)) {
401 goto FreeGopDevicePath
;
405 // Construct video mode buffer
407 switch (Private
->Variant
) {
408 case QEMU_VIDEO_CIRRUS_5430
:
409 case QEMU_VIDEO_CIRRUS_5446
:
410 Status
= QemuVideoCirrusModeSetup (Private
);
412 case QEMU_VIDEO_BOCHS_MMIO
:
413 case QEMU_VIDEO_BOCHS
:
414 Status
= QemuVideoBochsModeSetup (Private
, IsQxl
);
418 Status
= EFI_DEVICE_ERROR
;
421 if (EFI_ERROR (Status
)) {
422 goto UninstallGopDevicePath
;
426 // Start the GOP software stack.
428 Status
= QemuVideoGraphicsOutputConstructor (Private
);
429 if (EFI_ERROR (Status
)) {
433 Status
= gBS
->InstallMultipleProtocolInterfaces (
435 &gEfiGraphicsOutputProtocolGuid
,
436 &Private
->GraphicsOutput
,
439 if (EFI_ERROR (Status
)) {
440 goto DestructQemuVideoGraphics
;
444 // Reference parent handle from child handle.
446 Status
= gBS
->OpenProtocol (
448 &gEfiPciIoProtocolGuid
,
449 (VOID
**) &ChildPciIo
,
450 This
->DriverBindingHandle
,
452 EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
454 if (EFI_ERROR (Status
)) {
458 #if defined MDE_CPU_IA32 || defined MDE_CPU_X64
459 if (Private
->Variant
== QEMU_VIDEO_BOCHS_MMIO
||
460 Private
->Variant
== QEMU_VIDEO_BOCHS
) {
461 InstallVbeShim (Card
->Name
, Private
->GraphicsOutput
.Mode
->FrameBufferBase
);
465 gBS
->RestoreTPL (OldTpl
);
469 gBS
->UninstallProtocolInterface (Private
->Handle
,
470 &gEfiGraphicsOutputProtocolGuid
, &Private
->GraphicsOutput
);
472 DestructQemuVideoGraphics
:
473 QemuVideoGraphicsOutputDestructor (Private
);
476 FreePool (Private
->ModeData
);
478 UninstallGopDevicePath
:
479 gBS
->UninstallProtocolInterface (Private
->Handle
,
480 &gEfiDevicePathProtocolGuid
, Private
->GopDevicePath
);
483 FreePool (Private
->GopDevicePath
);
486 Private
->PciIo
->Attributes (Private
->PciIo
, EfiPciIoAttributeOperationSet
,
487 Private
->OriginalPciAttributes
, NULL
);
490 gBS
->CloseProtocol (Controller
, &gEfiPciIoProtocolGuid
,
491 This
->DriverBindingHandle
, Controller
);
497 gBS
->RestoreTPL (OldTpl
);
505 @param This The USB bus driver binding protocol.
506 @param Controller The controller to release.
507 @param NumberOfChildren The number of children of this device that
508 opened the controller BY_CHILD.
509 @param ChildHandleBuffer The array of child handle.
511 @retval EFI_SUCCESS The controller or children are stopped.
512 @retval EFI_DEVICE_ERROR Failed to stop the driver.
517 QemuVideoControllerDriverStop (
518 IN EFI_DRIVER_BINDING_PROTOCOL
*This
,
519 IN EFI_HANDLE Controller
,
520 IN UINTN NumberOfChildren
,
521 IN EFI_HANDLE
*ChildHandleBuffer
524 EFI_GRAPHICS_OUTPUT_PROTOCOL
*GraphicsOutput
;
527 QEMU_VIDEO_PRIVATE_DATA
*Private
;
529 if (NumberOfChildren
== 0) {
531 // Close the PCI I/O Protocol
535 &gEfiPciIoProtocolGuid
,
536 This
->DriverBindingHandle
,
543 // free all resources for whose access we need the child handle, because the
544 // child handle is going away
546 ASSERT (NumberOfChildren
== 1);
547 Status
= gBS
->OpenProtocol (
548 ChildHandleBuffer
[0],
549 &gEfiGraphicsOutputProtocolGuid
,
550 (VOID
**) &GraphicsOutput
,
551 This
->DriverBindingHandle
,
553 EFI_OPEN_PROTOCOL_GET_PROTOCOL
555 if (EFI_ERROR (Status
)) {
560 // Get our private context information
562 Private
= QEMU_VIDEO_PRIVATE_DATA_FROM_GRAPHICS_OUTPUT_THIS (GraphicsOutput
);
563 ASSERT (Private
->Handle
== ChildHandleBuffer
[0]);
565 QemuVideoGraphicsOutputDestructor (Private
);
567 // Remove the GOP protocol interface from the system
569 Status
= gBS
->UninstallMultipleProtocolInterfaces (
571 &gEfiGraphicsOutputProtocolGuid
,
572 &Private
->GraphicsOutput
,
576 if (EFI_ERROR (Status
)) {
581 // Restore original PCI attributes
583 Private
->PciIo
->Attributes (
585 EfiPciIoAttributeOperationSet
,
586 Private
->OriginalPciAttributes
,
592 &gEfiPciIoProtocolGuid
,
593 This
->DriverBindingHandle
,
597 FreePool (Private
->ModeData
);
598 gBS
->UninstallProtocolInterface (Private
->Handle
,
599 &gEfiDevicePathProtocolGuid
, Private
->GopDevicePath
);
600 FreePool (Private
->GopDevicePath
);
603 // Free our instance data
605 gBS
->FreePool (Private
);
611 TODO: Add function description
613 @param Private TODO: add argument description
614 @param Address TODO: add argument description
615 @param Data TODO: add argument description
617 TODO: add return values
622 QEMU_VIDEO_PRIVATE_DATA
*Private
,
627 Private
->PciIo
->Io
.Write (
630 EFI_PCI_IO_PASS_THROUGH_BAR
,
638 TODO: Add function description
640 @param Private TODO: add argument description
641 @param Address TODO: add argument description
642 @param Data TODO: add argument description
644 TODO: add return values
649 QEMU_VIDEO_PRIVATE_DATA
*Private
,
654 Private
->PciIo
->Io
.Write (
657 EFI_PCI_IO_PASS_THROUGH_BAR
,
665 TODO: Add function description
667 @param Private TODO: add argument description
668 @param Address TODO: add argument description
670 TODO: add return values
675 QEMU_VIDEO_PRIVATE_DATA
*Private
,
681 Private
->PciIo
->Io
.Read (
684 EFI_PCI_IO_PASS_THROUGH_BAR
,
693 TODO: Add function description
695 @param Private TODO: add argument description
696 @param Address TODO: add argument description
698 TODO: add return values
703 QEMU_VIDEO_PRIVATE_DATA
*Private
,
709 Private
->PciIo
->Io
.Read (
712 EFI_PCI_IO_PASS_THROUGH_BAR
,
721 TODO: Add function description
723 @param Private TODO: add argument description
724 @param Index TODO: add argument description
725 @param Red TODO: add argument description
726 @param Green TODO: add argument description
727 @param Blue TODO: add argument description
729 TODO: add return values
734 QEMU_VIDEO_PRIVATE_DATA
*Private
,
741 VgaOutb (Private
, PALETTE_INDEX_REGISTER
, (UINT8
) Index
);
742 VgaOutb (Private
, PALETTE_DATA_REGISTER
, (UINT8
) (Red
>> 2));
743 VgaOutb (Private
, PALETTE_DATA_REGISTER
, (UINT8
) (Green
>> 2));
744 VgaOutb (Private
, PALETTE_DATA_REGISTER
, (UINT8
) (Blue
>> 2));
748 TODO: Add function description
750 @param Private TODO: add argument description
752 TODO: add return values
757 QEMU_VIDEO_PRIVATE_DATA
*Private
766 for (RedIndex
= 0; RedIndex
< 8; RedIndex
++) {
767 for (GreenIndex
= 0; GreenIndex
< 8; GreenIndex
++) {
768 for (BlueIndex
= 0; BlueIndex
< 4; BlueIndex
++) {
769 SetPaletteColor (Private
, Index
, (UINT8
) (RedIndex
<< 5), (UINT8
) (GreenIndex
<< 5), (UINT8
) (BlueIndex
<< 6));
777 TODO: Add function description
779 @param Private TODO: add argument description
781 TODO: add return values
786 QEMU_VIDEO_PRIVATE_DATA
*Private
792 Private
->PciIo
->Mem
.Write (
794 EfiPciIoWidthFillUint32
,
795 Private
->FrameBufferVramBarIndex
,
803 TODO: Add function description
805 @param Private TODO: add argument description
807 TODO: add return values
812 QEMU_VIDEO_PRIVATE_DATA
*Private
,
820 TODO: Add function description
822 @param Private TODO: add argument description
823 @param ModeData TODO: add argument description
825 TODO: add return values
829 InitializeCirrusGraphicsMode (
830 QEMU_VIDEO_PRIVATE_DATA
*Private
,
831 QEMU_VIDEO_CIRRUS_MODES
*ModeData
837 outw (Private
, SEQ_ADDRESS_REGISTER
, 0x1206);
838 outw (Private
, SEQ_ADDRESS_REGISTER
, 0x0012);
840 for (Index
= 0; Index
< 15; Index
++) {
841 outw (Private
, SEQ_ADDRESS_REGISTER
, ModeData
->SeqSettings
[Index
]);
844 if (Private
->Variant
== QEMU_VIDEO_CIRRUS_5430
) {
845 outb (Private
, SEQ_ADDRESS_REGISTER
, 0x0f);
846 Byte
= (UINT8
) ((inb (Private
, SEQ_DATA_REGISTER
) & 0xc7) ^ 0x30);
847 outb (Private
, SEQ_DATA_REGISTER
, Byte
);
850 outb (Private
, MISC_OUTPUT_REGISTER
, ModeData
->MiscSetting
);
851 outw (Private
, GRAPH_ADDRESS_REGISTER
, 0x0506);
852 outw (Private
, SEQ_ADDRESS_REGISTER
, 0x0300);
853 outw (Private
, CRTC_ADDRESS_REGISTER
, 0x2011);
855 for (Index
= 0; Index
< 28; Index
++) {
856 outw (Private
, CRTC_ADDRESS_REGISTER
, (UINT16
) ((ModeData
->CrtcSettings
[Index
] << 8) | Index
));
859 for (Index
= 0; Index
< 9; Index
++) {
860 outw (Private
, GRAPH_ADDRESS_REGISTER
, (UINT16
) ((GraphicsController
[Index
] << 8) | Index
));
863 inb (Private
, INPUT_STATUS_1_REGISTER
);
865 for (Index
= 0; Index
< 21; Index
++) {
866 outb (Private
, ATT_ADDRESS_REGISTER
, (UINT8
) Index
);
867 outb (Private
, ATT_ADDRESS_REGISTER
, AttributeController
[Index
]);
870 outb (Private
, ATT_ADDRESS_REGISTER
, 0x20);
872 outw (Private
, GRAPH_ADDRESS_REGISTER
, 0x0009);
873 outw (Private
, GRAPH_ADDRESS_REGISTER
, 0x000a);
874 outw (Private
, GRAPH_ADDRESS_REGISTER
, 0x000b);
875 outb (Private
, DAC_PIXEL_MASK_REGISTER
, 0xff);
877 SetDefaultPalette (Private
);
878 ClearScreen (Private
);
883 QEMU_VIDEO_PRIVATE_DATA
*Private
,
890 if (Private
->Variant
== QEMU_VIDEO_BOCHS_MMIO
) {
891 Status
= Private
->PciIo
->Mem
.Write (
899 ASSERT_EFI_ERROR (Status
);
901 outw (Private
, VBE_DISPI_IOPORT_INDEX
, Reg
);
902 outw (Private
, VBE_DISPI_IOPORT_DATA
, Data
);
908 QEMU_VIDEO_PRIVATE_DATA
*Private
,
915 if (Private
->Variant
== QEMU_VIDEO_BOCHS_MMIO
) {
916 Status
= Private
->PciIo
->Mem
.Read (
924 ASSERT_EFI_ERROR (Status
);
926 outw (Private
, VBE_DISPI_IOPORT_INDEX
, Reg
);
927 Data
= inw (Private
, VBE_DISPI_IOPORT_DATA
);
934 QEMU_VIDEO_PRIVATE_DATA
*Private
,
941 if (Private
->Variant
== QEMU_VIDEO_BOCHS_MMIO
) {
942 Status
= Private
->PciIo
->Mem
.Write (
950 ASSERT_EFI_ERROR (Status
);
952 outb (Private
, Reg
, Data
);
957 InitializeBochsGraphicsMode (
958 QEMU_VIDEO_PRIVATE_DATA
*Private
,
959 QEMU_VIDEO_BOCHS_MODES
*ModeData
962 DEBUG ((EFI_D_INFO
, "InitializeBochsGraphicsMode: %dx%d @ %d\n",
963 ModeData
->Width
, ModeData
->Height
, ModeData
->ColorDepth
));
966 VgaOutb (Private
, ATT_ADDRESS_REGISTER
, 0x20);
968 BochsWrite (Private
, VBE_DISPI_INDEX_ENABLE
, 0);
969 BochsWrite (Private
, VBE_DISPI_INDEX_BANK
, 0);
970 BochsWrite (Private
, VBE_DISPI_INDEX_X_OFFSET
, 0);
971 BochsWrite (Private
, VBE_DISPI_INDEX_Y_OFFSET
, 0);
973 BochsWrite (Private
, VBE_DISPI_INDEX_BPP
, (UINT16
) ModeData
->ColorDepth
);
974 BochsWrite (Private
, VBE_DISPI_INDEX_XRES
, (UINT16
) ModeData
->Width
);
975 BochsWrite (Private
, VBE_DISPI_INDEX_VIRT_WIDTH
, (UINT16
) ModeData
->Width
);
976 BochsWrite (Private
, VBE_DISPI_INDEX_YRES
, (UINT16
) ModeData
->Height
);
977 BochsWrite (Private
, VBE_DISPI_INDEX_VIRT_HEIGHT
, (UINT16
) ModeData
->Height
);
979 BochsWrite (Private
, VBE_DISPI_INDEX_ENABLE
,
980 VBE_DISPI_ENABLED
| VBE_DISPI_LFB_ENABLED
);
982 SetDefaultPalette (Private
);
983 ClearScreen (Private
);
988 InitializeQemuVideo (
989 IN EFI_HANDLE ImageHandle
,
990 IN EFI_SYSTEM_TABLE
*SystemTable
995 Status
= EfiLibInstallDriverBindingComponentName2 (
998 &gQemuVideoDriverBinding
,
1000 &gQemuVideoComponentName
,
1001 &gQemuVideoComponentName2
1003 ASSERT_EFI_ERROR (Status
);