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
))
91 return gQemuVideoCardList
+ Index
;
101 Check if this device is supported.
103 @param This The driver binding protocol.
104 @param Controller The controller handle to check.
105 @param RemainingDevicePath The remaining device path.
107 @retval EFI_SUCCESS The bus supports this controller.
108 @retval EFI_UNSUPPORTED This device isn't supported.
113 QemuVideoControllerDriverSupported (
114 IN EFI_DRIVER_BINDING_PROTOCOL
*This
,
115 IN EFI_HANDLE Controller
,
116 IN EFI_DEVICE_PATH_PROTOCOL
*RemainingDevicePath
120 EFI_PCI_IO_PROTOCOL
*PciIo
;
122 QEMU_VIDEO_CARD
*Card
;
125 // Open the PCI I/O Protocol
127 Status
= gBS
->OpenProtocol (
129 &gEfiPciIoProtocolGuid
,
131 This
->DriverBindingHandle
,
133 EFI_OPEN_PROTOCOL_BY_DRIVER
135 if (EFI_ERROR (Status
)) {
140 // Read the PCI Configuration Header from the PCI Device
142 Status
= PciIo
->Pci
.Read (
146 sizeof (Pci
) / sizeof (UINT32
),
149 if (EFI_ERROR (Status
)) {
153 Status
= EFI_UNSUPPORTED
;
154 if (!IS_PCI_DISPLAY (&Pci
)) {
158 Card
= QemuVideoDetect (Pci
.Hdr
.ClassCode
[1], Pci
.Hdr
.VendorId
, Pci
.Hdr
.DeviceId
);
160 DEBUG ((DEBUG_INFO
, "QemuVideo: %s detected\n", Card
->Name
));
161 Status
= EFI_SUCCESS
;
166 // Close the PCI I/O Protocol
170 &gEfiPciIoProtocolGuid
,
171 This
->DriverBindingHandle
,
179 Start to process the controller.
181 @param This The USB bus driver binding instance.
182 @param Controller The controller to check.
183 @param RemainingDevicePath The remaining device patch.
185 @retval EFI_SUCCESS The controller is controlled by the usb bus.
186 @retval EFI_ALREADY_STARTED The controller is already controlled by the usb
188 @retval EFI_OUT_OF_RESOURCES Failed to allocate resources.
193 QemuVideoControllerDriverStart (
194 IN EFI_DRIVER_BINDING_PROTOCOL
*This
,
195 IN EFI_HANDLE Controller
,
196 IN EFI_DEVICE_PATH_PROTOCOL
*RemainingDevicePath
201 QEMU_VIDEO_PRIVATE_DATA
*Private
;
203 EFI_DEVICE_PATH_PROTOCOL
*ParentDevicePath
;
204 ACPI_ADR_DEVICE_PATH AcpiDeviceNode
;
206 QEMU_VIDEO_CARD
*Card
;
207 EFI_PCI_IO_PROTOCOL
*ChildPciIo
;
208 UINT64 SupportedVgaIo
;
210 OldTpl
= gBS
->RaiseTPL (TPL_CALLBACK
);
213 // Allocate Private context data for GOP interface.
215 Private
= AllocateZeroPool (sizeof (QEMU_VIDEO_PRIVATE_DATA
));
216 if (Private
== NULL
) {
217 Status
= EFI_OUT_OF_RESOURCES
;
222 // Set up context record
224 Private
->Signature
= QEMU_VIDEO_PRIVATE_DATA_SIGNATURE
;
227 // Open PCI I/O Protocol
229 Status
= gBS
->OpenProtocol (
231 &gEfiPciIoProtocolGuid
,
232 (VOID
**)&Private
->PciIo
,
233 This
->DriverBindingHandle
,
235 EFI_OPEN_PROTOCOL_BY_DRIVER
237 if (EFI_ERROR (Status
)) {
242 // Read the PCI Configuration Header from the PCI Device
244 Status
= Private
->PciIo
->Pci
.Read (
248 sizeof (Pci
) / sizeof (UINT32
),
251 if (EFI_ERROR (Status
)) {
256 // Determine card variant.
258 Card
= QemuVideoDetect (Pci
.Hdr
.ClassCode
[1], Pci
.Hdr
.VendorId
, Pci
.Hdr
.DeviceId
);
260 Status
= EFI_DEVICE_ERROR
;
264 Private
->Variant
= Card
->Variant
;
267 // IsQxl is based on the detected Card->Variant, which at a later point might
268 // not match Private->Variant.
270 IsQxl
= (BOOLEAN
)(Card
->Variant
== QEMU_VIDEO_BOCHS
);
273 // Save original PCI attributes
275 Status
= Private
->PciIo
->Attributes (
277 EfiPciIoAttributeOperationGet
,
279 &Private
->OriginalPciAttributes
282 if (EFI_ERROR (Status
)) {
287 // Get supported PCI attributes
289 Status
= Private
->PciIo
->Attributes (
291 EfiPciIoAttributeOperationSupported
,
295 if (EFI_ERROR (Status
)) {
299 SupportedVgaIo
&= (UINT64
)(EFI_PCI_IO_ATTRIBUTE_VGA_IO
| EFI_PCI_IO_ATTRIBUTE_VGA_IO_16
);
300 if ((SupportedVgaIo
== 0) && IS_PCI_VGA (&Pci
)) {
301 Status
= EFI_UNSUPPORTED
;
306 // Set new PCI attributes
308 Status
= Private
->PciIo
->Attributes (
310 EfiPciIoAttributeOperationEnable
,
311 EFI_PCI_DEVICE_ENABLE
| EFI_PCI_IO_ATTRIBUTE_VGA_MEMORY
| SupportedVgaIo
,
314 if (EFI_ERROR (Status
)) {
319 // Check whenever the qemu stdvga mmio bar is present (qemu 1.3+).
321 if (Private
->Variant
== QEMU_VIDEO_BOCHS_MMIO
) {
322 EFI_ACPI_ADDRESS_SPACE_DESCRIPTOR
*MmioDesc
;
324 Status
= Private
->PciIo
->GetBarAttributes (
330 if (EFI_ERROR (Status
) ||
331 (MmioDesc
->ResType
!= ACPI_ADDRESS_SPACE_TYPE_MEM
))
333 DEBUG ((DEBUG_INFO
, "QemuVideo: No mmio bar, fallback to port io\n"));
334 Private
->Variant
= QEMU_VIDEO_BOCHS
;
338 "QemuVideo: Using mmio bar @ 0x%lx\n",
339 MmioDesc
->AddrRangeMin
343 if (!EFI_ERROR (Status
)) {
349 // VMWare SVGA is handled like Bochs (with port IO only).
351 if (Private
->Variant
== QEMU_VIDEO_VMWARE_SVGA
) {
352 Private
->Variant
= QEMU_VIDEO_BOCHS
;
353 Private
->FrameBufferVramBarIndex
= PCI_BAR_IDX1
;
357 // Check if accessing the bochs interface works.
359 if ((Private
->Variant
== QEMU_VIDEO_BOCHS_MMIO
) ||
360 (Private
->Variant
== QEMU_VIDEO_BOCHS
))
363 BochsId
= BochsRead (Private
, VBE_DISPI_INDEX_ID
);
364 if ((BochsId
& 0xFFF0) != VBE_DISPI_ID0
) {
365 DEBUG ((DEBUG_INFO
, "QemuVideo: BochsID mismatch (got 0x%x)\n", BochsId
));
366 Status
= EFI_DEVICE_ERROR
;
367 goto RestoreAttributes
;
372 // Get ParentDevicePath
374 Status
= gBS
->HandleProtocol (
376 &gEfiDevicePathProtocolGuid
,
377 (VOID
**)&ParentDevicePath
379 if (EFI_ERROR (Status
)) {
380 goto RestoreAttributes
;
384 // Set Gop Device Path
386 ZeroMem (&AcpiDeviceNode
, sizeof (ACPI_ADR_DEVICE_PATH
));
387 AcpiDeviceNode
.Header
.Type
= ACPI_DEVICE_PATH
;
388 AcpiDeviceNode
.Header
.SubType
= ACPI_ADR_DP
;
389 AcpiDeviceNode
.ADR
= ACPI_DISPLAY_ADR (1, 0, 0, 1, 0, ACPI_ADR_DISPLAY_TYPE_VGA
, 0, 0);
390 SetDevicePathNodeLength (&AcpiDeviceNode
.Header
, sizeof (ACPI_ADR_DEVICE_PATH
));
392 Private
->GopDevicePath
= AppendDevicePathNode (
394 (EFI_DEVICE_PATH_PROTOCOL
*)&AcpiDeviceNode
396 if (Private
->GopDevicePath
== NULL
) {
397 Status
= EFI_OUT_OF_RESOURCES
;
398 goto RestoreAttributes
;
402 // Create new child handle and install the device path protocol on it.
404 Status
= gBS
->InstallMultipleProtocolInterfaces (
406 &gEfiDevicePathProtocolGuid
,
407 Private
->GopDevicePath
,
410 if (EFI_ERROR (Status
)) {
411 goto FreeGopDevicePath
;
415 // Construct video mode buffer
417 switch (Private
->Variant
) {
418 case QEMU_VIDEO_CIRRUS_5430
:
419 case QEMU_VIDEO_CIRRUS_5446
:
420 Status
= QemuVideoCirrusModeSetup (Private
);
422 case QEMU_VIDEO_BOCHS_MMIO
:
423 case QEMU_VIDEO_BOCHS
:
424 Status
= QemuVideoBochsModeSetup (Private
, IsQxl
);
428 Status
= EFI_DEVICE_ERROR
;
432 if (EFI_ERROR (Status
)) {
433 goto UninstallGopDevicePath
;
437 // Start the GOP software stack.
439 Status
= QemuVideoGraphicsOutputConstructor (Private
);
440 if (EFI_ERROR (Status
)) {
444 Status
= gBS
->InstallMultipleProtocolInterfaces (
446 &gEfiGraphicsOutputProtocolGuid
,
447 &Private
->GraphicsOutput
,
450 if (EFI_ERROR (Status
)) {
451 goto DestructQemuVideoGraphics
;
455 // Reference parent handle from child handle.
457 Status
= gBS
->OpenProtocol (
459 &gEfiPciIoProtocolGuid
,
460 (VOID
**)&ChildPciIo
,
461 This
->DriverBindingHandle
,
463 EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
465 if (EFI_ERROR (Status
)) {
469 #if defined MDE_CPU_IA32 || defined MDE_CPU_X64
470 if ((Private
->Variant
== QEMU_VIDEO_BOCHS_MMIO
) ||
471 (Private
->Variant
== QEMU_VIDEO_BOCHS
))
473 InstallVbeShim (Card
->Name
, Private
->GraphicsOutput
.Mode
->FrameBufferBase
);
478 gBS
->RestoreTPL (OldTpl
);
482 gBS
->UninstallProtocolInterface (
484 &gEfiGraphicsOutputProtocolGuid
,
485 &Private
->GraphicsOutput
488 DestructQemuVideoGraphics
:
489 QemuVideoGraphicsOutputDestructor (Private
);
492 FreePool (Private
->ModeData
);
494 UninstallGopDevicePath
:
495 gBS
->UninstallProtocolInterface (
497 &gEfiDevicePathProtocolGuid
,
498 Private
->GopDevicePath
502 FreePool (Private
->GopDevicePath
);
505 Private
->PciIo
->Attributes (
507 EfiPciIoAttributeOperationSet
,
508 Private
->OriginalPciAttributes
,
515 &gEfiPciIoProtocolGuid
,
516 This
->DriverBindingHandle
,
524 gBS
->RestoreTPL (OldTpl
);
532 @param This The USB bus driver binding protocol.
533 @param Controller The controller to release.
534 @param NumberOfChildren The number of children of this device that
535 opened the controller BY_CHILD.
536 @param ChildHandleBuffer The array of child handle.
538 @retval EFI_SUCCESS The controller or children are stopped.
539 @retval EFI_DEVICE_ERROR Failed to stop the driver.
544 QemuVideoControllerDriverStop (
545 IN EFI_DRIVER_BINDING_PROTOCOL
*This
,
546 IN EFI_HANDLE Controller
,
547 IN UINTN NumberOfChildren
,
548 IN EFI_HANDLE
*ChildHandleBuffer
551 EFI_GRAPHICS_OUTPUT_PROTOCOL
*GraphicsOutput
;
554 QEMU_VIDEO_PRIVATE_DATA
*Private
;
556 if (NumberOfChildren
== 0) {
558 // Close the PCI I/O Protocol
562 &gEfiPciIoProtocolGuid
,
563 This
->DriverBindingHandle
,
570 // free all resources for whose access we need the child handle, because the
571 // child handle is going away
573 ASSERT (NumberOfChildren
== 1);
574 Status
= gBS
->OpenProtocol (
575 ChildHandleBuffer
[0],
576 &gEfiGraphicsOutputProtocolGuid
,
577 (VOID
**)&GraphicsOutput
,
578 This
->DriverBindingHandle
,
580 EFI_OPEN_PROTOCOL_GET_PROTOCOL
582 if (EFI_ERROR (Status
)) {
587 // Get our private context information
589 Private
= QEMU_VIDEO_PRIVATE_DATA_FROM_GRAPHICS_OUTPUT_THIS (GraphicsOutput
);
590 ASSERT (Private
->Handle
== ChildHandleBuffer
[0]);
592 QemuVideoGraphicsOutputDestructor (Private
);
594 // Remove the GOP protocol interface from the system
596 Status
= gBS
->UninstallMultipleProtocolInterfaces (
598 &gEfiGraphicsOutputProtocolGuid
,
599 &Private
->GraphicsOutput
,
603 if (EFI_ERROR (Status
)) {
608 // Restore original PCI attributes
610 Private
->PciIo
->Attributes (
612 EfiPciIoAttributeOperationSet
,
613 Private
->OriginalPciAttributes
,
619 &gEfiPciIoProtocolGuid
,
620 This
->DriverBindingHandle
,
624 FreePool (Private
->ModeData
);
625 gBS
->UninstallProtocolInterface (
627 &gEfiDevicePathProtocolGuid
,
628 Private
->GopDevicePath
630 FreePool (Private
->GopDevicePath
);
633 // Free our instance data
635 gBS
->FreePool (Private
);
641 TODO: Add function description
643 @param Private TODO: add argument description
644 @param Address TODO: add argument description
645 @param Data TODO: add argument description
647 TODO: add return values
652 QEMU_VIDEO_PRIVATE_DATA
*Private
,
657 Private
->PciIo
->Io
.Write (
660 EFI_PCI_IO_PASS_THROUGH_BAR
,
668 TODO: Add function description
670 @param Private TODO: add argument description
671 @param Address TODO: add argument description
672 @param Data TODO: add argument description
674 TODO: add return values
679 QEMU_VIDEO_PRIVATE_DATA
*Private
,
684 Private
->PciIo
->Io
.Write (
687 EFI_PCI_IO_PASS_THROUGH_BAR
,
695 TODO: Add function description
697 @param Private TODO: add argument description
698 @param Address TODO: add argument description
700 TODO: add return values
705 QEMU_VIDEO_PRIVATE_DATA
*Private
,
711 Private
->PciIo
->Io
.Read (
714 EFI_PCI_IO_PASS_THROUGH_BAR
,
723 TODO: Add function description
725 @param Private TODO: add argument description
726 @param Address TODO: add argument description
728 TODO: add return values
733 QEMU_VIDEO_PRIVATE_DATA
*Private
,
739 Private
->PciIo
->Io
.Read (
742 EFI_PCI_IO_PASS_THROUGH_BAR
,
751 TODO: Add function description
753 @param Private TODO: add argument description
754 @param Index TODO: add argument description
755 @param Red TODO: add argument description
756 @param Green TODO: add argument description
757 @param Blue TODO: add argument description
759 TODO: add return values
764 QEMU_VIDEO_PRIVATE_DATA
*Private
,
771 VgaOutb (Private
, PALETTE_INDEX_REGISTER
, (UINT8
)Index
);
772 VgaOutb (Private
, PALETTE_DATA_REGISTER
, (UINT8
)(Red
>> 2));
773 VgaOutb (Private
, PALETTE_DATA_REGISTER
, (UINT8
)(Green
>> 2));
774 VgaOutb (Private
, PALETTE_DATA_REGISTER
, (UINT8
)(Blue
>> 2));
778 TODO: Add function description
780 @param Private TODO: add argument description
782 TODO: add return values
787 QEMU_VIDEO_PRIVATE_DATA
*Private
796 for (RedIndex
= 0; RedIndex
< 8; RedIndex
++) {
797 for (GreenIndex
= 0; GreenIndex
< 8; GreenIndex
++) {
798 for (BlueIndex
= 0; BlueIndex
< 4; BlueIndex
++) {
799 SetPaletteColor (Private
, Index
, (UINT8
)(RedIndex
<< 5), (UINT8
)(GreenIndex
<< 5), (UINT8
)(BlueIndex
<< 6));
807 TODO: Add function description
809 @param Private TODO: add argument description
811 TODO: add return values
816 QEMU_VIDEO_PRIVATE_DATA
*Private
822 Private
->PciIo
->Mem
.Write (
824 EfiPciIoWidthFillUint32
,
825 Private
->FrameBufferVramBarIndex
,
833 TODO: Add function description
835 @param Private TODO: add argument description
837 TODO: add return values
842 QEMU_VIDEO_PRIVATE_DATA
*Private
,
850 TODO: Add function description
852 @param Private TODO: add argument description
853 @param ModeData TODO: add argument description
855 TODO: add return values
859 InitializeCirrusGraphicsMode (
860 QEMU_VIDEO_PRIVATE_DATA
*Private
,
861 QEMU_VIDEO_CIRRUS_MODES
*ModeData
867 outw (Private
, SEQ_ADDRESS_REGISTER
, 0x1206);
868 outw (Private
, SEQ_ADDRESS_REGISTER
, 0x0012);
870 for (Index
= 0; Index
< 15; Index
++) {
871 outw (Private
, SEQ_ADDRESS_REGISTER
, ModeData
->SeqSettings
[Index
]);
874 if (Private
->Variant
== QEMU_VIDEO_CIRRUS_5430
) {
875 outb (Private
, SEQ_ADDRESS_REGISTER
, 0x0f);
876 Byte
= (UINT8
)((inb (Private
, SEQ_DATA_REGISTER
) & 0xc7) ^ 0x30);
877 outb (Private
, SEQ_DATA_REGISTER
, Byte
);
880 outb (Private
, MISC_OUTPUT_REGISTER
, ModeData
->MiscSetting
);
881 outw (Private
, GRAPH_ADDRESS_REGISTER
, 0x0506);
882 outw (Private
, SEQ_ADDRESS_REGISTER
, 0x0300);
883 outw (Private
, CRTC_ADDRESS_REGISTER
, 0x2011);
885 for (Index
= 0; Index
< 28; Index
++) {
886 outw (Private
, CRTC_ADDRESS_REGISTER
, (UINT16
)((ModeData
->CrtcSettings
[Index
] << 8) | Index
));
889 for (Index
= 0; Index
< 9; Index
++) {
890 outw (Private
, GRAPH_ADDRESS_REGISTER
, (UINT16
)((GraphicsController
[Index
] << 8) | Index
));
893 inb (Private
, INPUT_STATUS_1_REGISTER
);
895 for (Index
= 0; Index
< 21; Index
++) {
896 outb (Private
, ATT_ADDRESS_REGISTER
, (UINT8
)Index
);
897 outb (Private
, ATT_ADDRESS_REGISTER
, AttributeController
[Index
]);
900 outb (Private
, ATT_ADDRESS_REGISTER
, 0x20);
902 outw (Private
, GRAPH_ADDRESS_REGISTER
, 0x0009);
903 outw (Private
, GRAPH_ADDRESS_REGISTER
, 0x000a);
904 outw (Private
, GRAPH_ADDRESS_REGISTER
, 0x000b);
905 outb (Private
, DAC_PIXEL_MASK_REGISTER
, 0xff);
907 SetDefaultPalette (Private
);
908 ClearScreen (Private
);
913 QEMU_VIDEO_PRIVATE_DATA
*Private
,
920 if (Private
->Variant
== QEMU_VIDEO_BOCHS_MMIO
) {
921 Status
= Private
->PciIo
->Mem
.Write (
929 ASSERT_EFI_ERROR (Status
);
931 outw (Private
, VBE_DISPI_IOPORT_INDEX
, Reg
);
932 outw (Private
, VBE_DISPI_IOPORT_DATA
, Data
);
938 QEMU_VIDEO_PRIVATE_DATA
*Private
,
945 if (Private
->Variant
== QEMU_VIDEO_BOCHS_MMIO
) {
946 Status
= Private
->PciIo
->Mem
.Read (
954 ASSERT_EFI_ERROR (Status
);
956 outw (Private
, VBE_DISPI_IOPORT_INDEX
, Reg
);
957 Data
= inw (Private
, VBE_DISPI_IOPORT_DATA
);
965 QEMU_VIDEO_PRIVATE_DATA
*Private
,
972 if (Private
->Variant
== QEMU_VIDEO_BOCHS_MMIO
) {
973 Status
= Private
->PciIo
->Mem
.Write (
981 ASSERT_EFI_ERROR (Status
);
983 outb (Private
, Reg
, Data
);
988 InitializeBochsGraphicsMode (
989 QEMU_VIDEO_PRIVATE_DATA
*Private
,
990 QEMU_VIDEO_MODE_DATA
*ModeData
995 "InitializeBochsGraphicsMode: %dx%d @ %d\n",
996 ModeData
->HorizontalResolution
,
997 ModeData
->VerticalResolution
,
1002 VgaOutb (Private
, ATT_ADDRESS_REGISTER
, 0x20);
1004 BochsWrite (Private
, VBE_DISPI_INDEX_ENABLE
, 0);
1005 BochsWrite (Private
, VBE_DISPI_INDEX_BANK
, 0);
1006 BochsWrite (Private
, VBE_DISPI_INDEX_X_OFFSET
, 0);
1007 BochsWrite (Private
, VBE_DISPI_INDEX_Y_OFFSET
, 0);
1009 BochsWrite (Private
, VBE_DISPI_INDEX_BPP
, (UINT16
)ModeData
->ColorDepth
);
1010 BochsWrite (Private
, VBE_DISPI_INDEX_XRES
, (UINT16
)ModeData
->HorizontalResolution
);
1011 BochsWrite (Private
, VBE_DISPI_INDEX_VIRT_WIDTH
, (UINT16
)ModeData
->HorizontalResolution
);
1012 BochsWrite (Private
, VBE_DISPI_INDEX_YRES
, (UINT16
)ModeData
->VerticalResolution
);
1013 BochsWrite (Private
, VBE_DISPI_INDEX_VIRT_HEIGHT
, (UINT16
)ModeData
->VerticalResolution
);
1017 VBE_DISPI_INDEX_ENABLE
,
1018 VBE_DISPI_ENABLED
| VBE_DISPI_LFB_ENABLED
1021 SetDefaultPalette (Private
);
1022 ClearScreen (Private
);
1027 InitializeQemuVideo (
1028 IN EFI_HANDLE ImageHandle
,
1029 IN EFI_SYSTEM_TABLE
*SystemTable
1034 Status
= EfiLibInstallDriverBindingComponentName2 (
1037 &gQemuVideoDriverBinding
,
1039 &gQemuVideoComponentName
,
1040 &gQemuVideoComponentName2
1042 ASSERT_EFI_ERROR (Status
);