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 - 2010, 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
;
205 OldTpl
= gBS
->RaiseTPL (TPL_CALLBACK
);
208 // Allocate Private context data for GOP inteface.
210 Private
= AllocateZeroPool (sizeof (QEMU_VIDEO_PRIVATE_DATA
));
211 if (Private
== NULL
) {
212 Status
= EFI_OUT_OF_RESOURCES
;
217 // Set up context record
219 Private
->Signature
= QEMU_VIDEO_PRIVATE_DATA_SIGNATURE
;
222 // Open PCI I/O Protocol
224 Status
= gBS
->OpenProtocol (
226 &gEfiPciIoProtocolGuid
,
227 (VOID
**) &Private
->PciIo
,
228 This
->DriverBindingHandle
,
230 EFI_OPEN_PROTOCOL_BY_DRIVER
232 if (EFI_ERROR (Status
)) {
237 // Read the PCI Configuration Header from the PCI Device
239 Status
= Private
->PciIo
->Pci
.Read (
243 sizeof (Pci
) / sizeof (UINT32
),
246 if (EFI_ERROR (Status
)) {
251 // Determine card variant.
253 Card
= QemuVideoDetect(Pci
.Hdr
.ClassCode
[1], Pci
.Hdr
.VendorId
, Pci
.Hdr
.DeviceId
);
255 Status
= EFI_DEVICE_ERROR
;
258 Private
->Variant
= Card
->Variant
;
261 // IsQxl is based on the detected Card->Variant, which at a later point might
262 // not match Private->Variant.
264 IsQxl
= (BOOLEAN
)(Card
->Variant
== QEMU_VIDEO_BOCHS
);
267 // Save original PCI attributes
269 Status
= Private
->PciIo
->Attributes (
271 EfiPciIoAttributeOperationGet
,
273 &Private
->OriginalPciAttributes
276 if (EFI_ERROR (Status
)) {
281 // Set new PCI attributes
283 Status
= Private
->PciIo
->Attributes (
285 EfiPciIoAttributeOperationEnable
,
286 EFI_PCI_DEVICE_ENABLE
| EFI_PCI_IO_ATTRIBUTE_VGA_MEMORY
| EFI_PCI_IO_ATTRIBUTE_VGA_IO
,
289 if (EFI_ERROR (Status
)) {
294 // Check whenever the qemu stdvga mmio bar is present (qemu 1.3+).
296 if (Private
->Variant
== QEMU_VIDEO_BOCHS_MMIO
) {
297 EFI_ACPI_ADDRESS_SPACE_DESCRIPTOR
*MmioDesc
;
299 Status
= Private
->PciIo
->GetBarAttributes (
305 if (EFI_ERROR (Status
) ||
306 MmioDesc
->ResType
!= ACPI_ADDRESS_SPACE_TYPE_MEM
) {
307 DEBUG ((EFI_D_INFO
, "QemuVideo: No mmio bar, fallback to port io\n"));
308 Private
->Variant
= QEMU_VIDEO_BOCHS
;
310 DEBUG ((EFI_D_INFO
, "QemuVideo: Using mmio bar @ 0x%lx\n",
311 MmioDesc
->AddrRangeMin
));
314 if (!EFI_ERROR (Status
)) {
320 // VMWare SVGA is handled like Bochs (with port IO only).
322 if (Private
->Variant
== QEMU_VIDEO_VMWARE_SVGA
) {
323 Private
->Variant
= QEMU_VIDEO_BOCHS
;
324 Private
->FrameBufferVramBarIndex
= PCI_BAR_IDX1
;
328 // Check if accessing the bochs interface works.
330 if (Private
->Variant
== QEMU_VIDEO_BOCHS_MMIO
||
331 Private
->Variant
== QEMU_VIDEO_BOCHS
) {
333 BochsId
= BochsRead(Private
, VBE_DISPI_INDEX_ID
);
334 if ((BochsId
& 0xFFF0) != VBE_DISPI_ID0
) {
335 DEBUG ((EFI_D_INFO
, "QemuVideo: BochsID mismatch (got 0x%x)\n", BochsId
));
336 Status
= EFI_DEVICE_ERROR
;
337 goto RestoreAttributes
;
342 // Get ParentDevicePath
344 Status
= gBS
->HandleProtocol (
346 &gEfiDevicePathProtocolGuid
,
347 (VOID
**) &ParentDevicePath
349 if (EFI_ERROR (Status
)) {
350 goto RestoreAttributes
;
354 // Set Gop Device Path
356 ZeroMem (&AcpiDeviceNode
, sizeof (ACPI_ADR_DEVICE_PATH
));
357 AcpiDeviceNode
.Header
.Type
= ACPI_DEVICE_PATH
;
358 AcpiDeviceNode
.Header
.SubType
= ACPI_ADR_DP
;
359 AcpiDeviceNode
.ADR
= ACPI_DISPLAY_ADR (1, 0, 0, 1, 0, ACPI_ADR_DISPLAY_TYPE_VGA
, 0, 0);
360 SetDevicePathNodeLength (&AcpiDeviceNode
.Header
, sizeof (ACPI_ADR_DEVICE_PATH
));
362 Private
->GopDevicePath
= AppendDevicePathNode (
364 (EFI_DEVICE_PATH_PROTOCOL
*) &AcpiDeviceNode
366 if (Private
->GopDevicePath
== NULL
) {
367 Status
= EFI_OUT_OF_RESOURCES
;
368 goto RestoreAttributes
;
372 // Create new child handle and install the device path protocol on it.
374 Status
= gBS
->InstallMultipleProtocolInterfaces (
376 &gEfiDevicePathProtocolGuid
,
377 Private
->GopDevicePath
,
380 if (EFI_ERROR (Status
)) {
381 goto FreeGopDevicePath
;
385 // Construct video mode buffer
387 switch (Private
->Variant
) {
388 case QEMU_VIDEO_CIRRUS_5430
:
389 case QEMU_VIDEO_CIRRUS_5446
:
390 Status
= QemuVideoCirrusModeSetup (Private
);
392 case QEMU_VIDEO_BOCHS_MMIO
:
393 case QEMU_VIDEO_BOCHS
:
394 Status
= QemuVideoBochsModeSetup (Private
, IsQxl
);
398 Status
= EFI_DEVICE_ERROR
;
401 if (EFI_ERROR (Status
)) {
402 goto UninstallGopDevicePath
;
406 // Start the GOP software stack.
408 Status
= QemuVideoGraphicsOutputConstructor (Private
);
409 if (EFI_ERROR (Status
)) {
413 Status
= gBS
->InstallMultipleProtocolInterfaces (
415 &gEfiGraphicsOutputProtocolGuid
,
416 &Private
->GraphicsOutput
,
419 if (EFI_ERROR (Status
)) {
420 goto DestructQemuVideoGraphics
;
424 // Reference parent handle from child handle.
426 Status
= gBS
->OpenProtocol (
428 &gEfiPciIoProtocolGuid
,
429 (VOID
**) &ChildPciIo
,
430 This
->DriverBindingHandle
,
432 EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
434 if (EFI_ERROR (Status
)) {
438 #if defined MDE_CPU_IA32 || defined MDE_CPU_X64
439 if (Private
->Variant
== QEMU_VIDEO_BOCHS_MMIO
||
440 Private
->Variant
== QEMU_VIDEO_BOCHS
) {
441 InstallVbeShim (Card
->Name
, Private
->GraphicsOutput
.Mode
->FrameBufferBase
);
445 gBS
->RestoreTPL (OldTpl
);
449 gBS
->UninstallProtocolInterface (Private
->Handle
,
450 &gEfiGraphicsOutputProtocolGuid
, &Private
->GraphicsOutput
);
452 DestructQemuVideoGraphics
:
453 QemuVideoGraphicsOutputDestructor (Private
);
456 FreePool (Private
->ModeData
);
458 UninstallGopDevicePath
:
459 gBS
->UninstallProtocolInterface (Private
->Handle
,
460 &gEfiDevicePathProtocolGuid
, Private
->GopDevicePath
);
463 FreePool (Private
->GopDevicePath
);
466 Private
->PciIo
->Attributes (Private
->PciIo
, EfiPciIoAttributeOperationSet
,
467 Private
->OriginalPciAttributes
, NULL
);
470 gBS
->CloseProtocol (Controller
, &gEfiPciIoProtocolGuid
,
471 This
->DriverBindingHandle
, Controller
);
477 gBS
->RestoreTPL (OldTpl
);
485 @param This The USB bus driver binding protocol.
486 @param Controller The controller to release.
487 @param NumberOfChildren The number of children of this device that
488 opened the controller BY_CHILD.
489 @param ChildHandleBuffer The array of child handle.
491 @retval EFI_SUCCESS The controller or children are stopped.
492 @retval EFI_DEVICE_ERROR Failed to stop the driver.
497 QemuVideoControllerDriverStop (
498 IN EFI_DRIVER_BINDING_PROTOCOL
*This
,
499 IN EFI_HANDLE Controller
,
500 IN UINTN NumberOfChildren
,
501 IN EFI_HANDLE
*ChildHandleBuffer
504 EFI_GRAPHICS_OUTPUT_PROTOCOL
*GraphicsOutput
;
507 QEMU_VIDEO_PRIVATE_DATA
*Private
;
509 if (NumberOfChildren
== 0) {
511 // Close the PCI I/O Protocol
515 &gEfiPciIoProtocolGuid
,
516 This
->DriverBindingHandle
,
523 // free all resources for whose access we need the child handle, because the
524 // child handle is going away
526 ASSERT (NumberOfChildren
== 1);
527 Status
= gBS
->OpenProtocol (
528 ChildHandleBuffer
[0],
529 &gEfiGraphicsOutputProtocolGuid
,
530 (VOID
**) &GraphicsOutput
,
531 This
->DriverBindingHandle
,
533 EFI_OPEN_PROTOCOL_GET_PROTOCOL
535 if (EFI_ERROR (Status
)) {
540 // Get our private context information
542 Private
= QEMU_VIDEO_PRIVATE_DATA_FROM_GRAPHICS_OUTPUT_THIS (GraphicsOutput
);
543 ASSERT (Private
->Handle
== ChildHandleBuffer
[0]);
545 QemuVideoGraphicsOutputDestructor (Private
);
547 // Remove the GOP protocol interface from the system
549 Status
= gBS
->UninstallMultipleProtocolInterfaces (
551 &gEfiGraphicsOutputProtocolGuid
,
552 &Private
->GraphicsOutput
,
556 if (EFI_ERROR (Status
)) {
561 // Restore original PCI attributes
563 Private
->PciIo
->Attributes (
565 EfiPciIoAttributeOperationSet
,
566 Private
->OriginalPciAttributes
,
572 &gEfiPciIoProtocolGuid
,
573 This
->DriverBindingHandle
,
577 FreePool (Private
->ModeData
);
578 gBS
->UninstallProtocolInterface (Private
->Handle
,
579 &gEfiDevicePathProtocolGuid
, Private
->GopDevicePath
);
580 FreePool (Private
->GopDevicePath
);
583 // Free our instance data
585 gBS
->FreePool (Private
);
591 TODO: Add function description
593 @param Private TODO: add argument description
594 @param Address TODO: add argument description
595 @param Data TODO: add argument description
597 TODO: add return values
602 QEMU_VIDEO_PRIVATE_DATA
*Private
,
607 Private
->PciIo
->Io
.Write (
610 EFI_PCI_IO_PASS_THROUGH_BAR
,
618 TODO: Add function description
620 @param Private TODO: add argument description
621 @param Address TODO: add argument description
622 @param Data TODO: add argument description
624 TODO: add return values
629 QEMU_VIDEO_PRIVATE_DATA
*Private
,
634 Private
->PciIo
->Io
.Write (
637 EFI_PCI_IO_PASS_THROUGH_BAR
,
645 TODO: Add function description
647 @param Private TODO: add argument description
648 @param Address TODO: add argument description
650 TODO: add return values
655 QEMU_VIDEO_PRIVATE_DATA
*Private
,
661 Private
->PciIo
->Io
.Read (
664 EFI_PCI_IO_PASS_THROUGH_BAR
,
673 TODO: Add function description
675 @param Private TODO: add argument description
676 @param Address TODO: add argument description
678 TODO: add return values
683 QEMU_VIDEO_PRIVATE_DATA
*Private
,
689 Private
->PciIo
->Io
.Read (
692 EFI_PCI_IO_PASS_THROUGH_BAR
,
701 TODO: Add function description
703 @param Private TODO: add argument description
704 @param Index TODO: add argument description
705 @param Red TODO: add argument description
706 @param Green TODO: add argument description
707 @param Blue TODO: add argument description
709 TODO: add return values
714 QEMU_VIDEO_PRIVATE_DATA
*Private
,
721 VgaOutb (Private
, PALETTE_INDEX_REGISTER
, (UINT8
) Index
);
722 VgaOutb (Private
, PALETTE_DATA_REGISTER
, (UINT8
) (Red
>> 2));
723 VgaOutb (Private
, PALETTE_DATA_REGISTER
, (UINT8
) (Green
>> 2));
724 VgaOutb (Private
, PALETTE_DATA_REGISTER
, (UINT8
) (Blue
>> 2));
728 TODO: Add function description
730 @param Private TODO: add argument description
732 TODO: add return values
737 QEMU_VIDEO_PRIVATE_DATA
*Private
746 for (RedIndex
= 0; RedIndex
< 8; RedIndex
++) {
747 for (GreenIndex
= 0; GreenIndex
< 8; GreenIndex
++) {
748 for (BlueIndex
= 0; BlueIndex
< 4; BlueIndex
++) {
749 SetPaletteColor (Private
, Index
, (UINT8
) (RedIndex
<< 5), (UINT8
) (GreenIndex
<< 5), (UINT8
) (BlueIndex
<< 6));
757 TODO: Add function description
759 @param Private TODO: add argument description
761 TODO: add return values
766 QEMU_VIDEO_PRIVATE_DATA
*Private
772 Private
->PciIo
->Mem
.Write (
774 EfiPciIoWidthFillUint32
,
775 Private
->FrameBufferVramBarIndex
,
783 TODO: Add function description
785 @param Private TODO: add argument description
787 TODO: add return values
792 QEMU_VIDEO_PRIVATE_DATA
*Private
,
800 TODO: Add function description
802 @param Private TODO: add argument description
803 @param ModeData TODO: add argument description
805 TODO: add return values
809 InitializeCirrusGraphicsMode (
810 QEMU_VIDEO_PRIVATE_DATA
*Private
,
811 QEMU_VIDEO_CIRRUS_MODES
*ModeData
817 outw (Private
, SEQ_ADDRESS_REGISTER
, 0x1206);
818 outw (Private
, SEQ_ADDRESS_REGISTER
, 0x0012);
820 for (Index
= 0; Index
< 15; Index
++) {
821 outw (Private
, SEQ_ADDRESS_REGISTER
, ModeData
->SeqSettings
[Index
]);
824 if (Private
->Variant
== QEMU_VIDEO_CIRRUS_5430
) {
825 outb (Private
, SEQ_ADDRESS_REGISTER
, 0x0f);
826 Byte
= (UINT8
) ((inb (Private
, SEQ_DATA_REGISTER
) & 0xc7) ^ 0x30);
827 outb (Private
, SEQ_DATA_REGISTER
, Byte
);
830 outb (Private
, MISC_OUTPUT_REGISTER
, ModeData
->MiscSetting
);
831 outw (Private
, GRAPH_ADDRESS_REGISTER
, 0x0506);
832 outw (Private
, SEQ_ADDRESS_REGISTER
, 0x0300);
833 outw (Private
, CRTC_ADDRESS_REGISTER
, 0x2011);
835 for (Index
= 0; Index
< 28; Index
++) {
836 outw (Private
, CRTC_ADDRESS_REGISTER
, (UINT16
) ((ModeData
->CrtcSettings
[Index
] << 8) | Index
));
839 for (Index
= 0; Index
< 9; Index
++) {
840 outw (Private
, GRAPH_ADDRESS_REGISTER
, (UINT16
) ((GraphicsController
[Index
] << 8) | Index
));
843 inb (Private
, INPUT_STATUS_1_REGISTER
);
845 for (Index
= 0; Index
< 21; Index
++) {
846 outb (Private
, ATT_ADDRESS_REGISTER
, (UINT8
) Index
);
847 outb (Private
, ATT_ADDRESS_REGISTER
, AttributeController
[Index
]);
850 outb (Private
, ATT_ADDRESS_REGISTER
, 0x20);
852 outw (Private
, GRAPH_ADDRESS_REGISTER
, 0x0009);
853 outw (Private
, GRAPH_ADDRESS_REGISTER
, 0x000a);
854 outw (Private
, GRAPH_ADDRESS_REGISTER
, 0x000b);
855 outb (Private
, DAC_PIXEL_MASK_REGISTER
, 0xff);
857 SetDefaultPalette (Private
);
858 ClearScreen (Private
);
863 QEMU_VIDEO_PRIVATE_DATA
*Private
,
870 if (Private
->Variant
== QEMU_VIDEO_BOCHS_MMIO
) {
871 Status
= Private
->PciIo
->Mem
.Write (
879 ASSERT_EFI_ERROR (Status
);
881 outw (Private
, VBE_DISPI_IOPORT_INDEX
, Reg
);
882 outw (Private
, VBE_DISPI_IOPORT_DATA
, Data
);
888 QEMU_VIDEO_PRIVATE_DATA
*Private
,
895 if (Private
->Variant
== QEMU_VIDEO_BOCHS_MMIO
) {
896 Status
= Private
->PciIo
->Mem
.Read (
904 ASSERT_EFI_ERROR (Status
);
906 outw (Private
, VBE_DISPI_IOPORT_INDEX
, Reg
);
907 Data
= inw (Private
, VBE_DISPI_IOPORT_DATA
);
914 QEMU_VIDEO_PRIVATE_DATA
*Private
,
921 if (Private
->Variant
== QEMU_VIDEO_BOCHS_MMIO
) {
922 Status
= Private
->PciIo
->Mem
.Write (
930 ASSERT_EFI_ERROR (Status
);
932 outb (Private
, Reg
, Data
);
937 InitializeBochsGraphicsMode (
938 QEMU_VIDEO_PRIVATE_DATA
*Private
,
939 QEMU_VIDEO_BOCHS_MODES
*ModeData
942 DEBUG ((EFI_D_INFO
, "InitializeBochsGraphicsMode: %dx%d @ %d\n",
943 ModeData
->Width
, ModeData
->Height
, ModeData
->ColorDepth
));
946 VgaOutb (Private
, ATT_ADDRESS_REGISTER
, 0x20);
948 BochsWrite (Private
, VBE_DISPI_INDEX_ENABLE
, 0);
949 BochsWrite (Private
, VBE_DISPI_INDEX_BANK
, 0);
950 BochsWrite (Private
, VBE_DISPI_INDEX_X_OFFSET
, 0);
951 BochsWrite (Private
, VBE_DISPI_INDEX_Y_OFFSET
, 0);
953 BochsWrite (Private
, VBE_DISPI_INDEX_BPP
, (UINT16
) ModeData
->ColorDepth
);
954 BochsWrite (Private
, VBE_DISPI_INDEX_XRES
, (UINT16
) ModeData
->Width
);
955 BochsWrite (Private
, VBE_DISPI_INDEX_VIRT_WIDTH
, (UINT16
) ModeData
->Width
);
956 BochsWrite (Private
, VBE_DISPI_INDEX_YRES
, (UINT16
) ModeData
->Height
);
957 BochsWrite (Private
, VBE_DISPI_INDEX_VIRT_HEIGHT
, (UINT16
) ModeData
->Height
);
959 BochsWrite (Private
, VBE_DISPI_INDEX_ENABLE
,
960 VBE_DISPI_ENABLED
| VBE_DISPI_LFB_ENABLED
);
962 SetDefaultPalette (Private
);
963 ClearScreen (Private
);
968 InitializeQemuVideo (
969 IN EFI_HANDLE ImageHandle
,
970 IN EFI_SYSTEM_TABLE
*SystemTable
975 Status
= EfiLibInstallDriverBindingComponentName2 (
978 &gQemuVideoDriverBinding
,
980 &gQemuVideoComponentName
,
981 &gQemuVideoComponentName2
983 ASSERT_EFI_ERROR (Status
);
986 // Install EFI Driver Supported EFI Version Protocol required for
987 // EFI drivers that are on PCI and other plug in cards.
989 gQemuVideoDriverSupportedEfiVersion
.FirmwareVersion
= PcdGet32 (PcdDriverSupportedEfiVersion
);
990 Status
= gBS
->InstallMultipleProtocolInterfaces (
992 &gEfiDriverSupportedEfiVersionProtocolGuid
,
993 &gQemuVideoDriverSupportedEfiVersion
,
996 ASSERT_EFI_ERROR (Status
);