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 This program and the accompanying materials
8 are licensed and made available under the terms and conditions of the BSD License
9 which accompanies this distribution. The full text of the license may be found at
10 http://opensource.org/licenses/bsd-license.php
12 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
13 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
18 #include <IndustryStandard/Acpi.h>
20 EFI_DRIVER_BINDING_PROTOCOL gQemuVideoDriverBinding
= {
21 QemuVideoControllerDriverSupported
,
22 QemuVideoControllerDriverStart
,
23 QemuVideoControllerDriverStop
,
29 QEMU_VIDEO_CARD gQemuVideoCardList
[] = {
31 PCI_CLASS_DISPLAY_VGA
,
32 CIRRUS_LOGIC_VENDOR_ID
,
33 CIRRUS_LOGIC_5430_DEVICE_ID
,
34 QEMU_VIDEO_CIRRUS_5430
,
37 PCI_CLASS_DISPLAY_VGA
,
38 CIRRUS_LOGIC_VENDOR_ID
,
39 CIRRUS_LOGIC_5430_ALTERNATE_DEVICE_ID
,
40 QEMU_VIDEO_CIRRUS_5430
,
43 PCI_CLASS_DISPLAY_VGA
,
44 CIRRUS_LOGIC_VENDOR_ID
,
45 CIRRUS_LOGIC_5446_DEVICE_ID
,
46 QEMU_VIDEO_CIRRUS_5446
,
49 PCI_CLASS_DISPLAY_VGA
,
52 QEMU_VIDEO_BOCHS_MMIO
,
55 PCI_CLASS_DISPLAY_OTHER
,
58 QEMU_VIDEO_BOCHS_MMIO
,
59 L
"QEMU Standard VGA (secondary)"
61 PCI_CLASS_DISPLAY_VGA
,
67 PCI_CLASS_DISPLAY_VGA
,
70 QEMU_VIDEO_BOCHS_MMIO
,
73 PCI_CLASS_DISPLAY_VGA
,
76 QEMU_VIDEO_VMWARE_SVGA
,
83 static QEMU_VIDEO_CARD
*
92 while (gQemuVideoCardList
[Index
].VendorId
!= 0) {
93 if (gQemuVideoCardList
[Index
].SubClass
== SubClass
&&
94 gQemuVideoCardList
[Index
].VendorId
== VendorId
&&
95 gQemuVideoCardList
[Index
].DeviceId
== DeviceId
) {
96 return gQemuVideoCardList
+ Index
;
104 Check if this device is supported.
106 @param This The driver binding protocol.
107 @param Controller The controller handle to check.
108 @param RemainingDevicePath The remaining device path.
110 @retval EFI_SUCCESS The bus supports this controller.
111 @retval EFI_UNSUPPORTED This device isn't supported.
116 QemuVideoControllerDriverSupported (
117 IN EFI_DRIVER_BINDING_PROTOCOL
*This
,
118 IN EFI_HANDLE Controller
,
119 IN EFI_DEVICE_PATH_PROTOCOL
*RemainingDevicePath
123 EFI_PCI_IO_PROTOCOL
*PciIo
;
125 QEMU_VIDEO_CARD
*Card
;
128 // Open the PCI I/O Protocol
130 Status
= gBS
->OpenProtocol (
132 &gEfiPciIoProtocolGuid
,
134 This
->DriverBindingHandle
,
136 EFI_OPEN_PROTOCOL_BY_DRIVER
138 if (EFI_ERROR (Status
)) {
143 // Read the PCI Configuration Header from the PCI Device
145 Status
= PciIo
->Pci
.Read (
149 sizeof (Pci
) / sizeof (UINT32
),
152 if (EFI_ERROR (Status
)) {
156 Status
= EFI_UNSUPPORTED
;
157 if (!IS_PCI_DISPLAY (&Pci
)) {
160 Card
= QemuVideoDetect(Pci
.Hdr
.ClassCode
[1], Pci
.Hdr
.VendorId
, Pci
.Hdr
.DeviceId
);
162 DEBUG ((EFI_D_INFO
, "QemuVideo: %s detected\n", Card
->Name
));
163 Status
= EFI_SUCCESS
;
168 // Close the PCI I/O Protocol
172 &gEfiPciIoProtocolGuid
,
173 This
->DriverBindingHandle
,
181 Start to process the controller.
183 @param This The USB bus driver binding instance.
184 @param Controller The controller to check.
185 @param RemainingDevicePath The remaining device patch.
187 @retval EFI_SUCCESS The controller is controlled by the usb bus.
188 @retval EFI_ALREADY_STARTED The controller is already controlled by the usb
190 @retval EFI_OUT_OF_RESOURCES Failed to allocate resources.
195 QemuVideoControllerDriverStart (
196 IN EFI_DRIVER_BINDING_PROTOCOL
*This
,
197 IN EFI_HANDLE Controller
,
198 IN EFI_DEVICE_PATH_PROTOCOL
*RemainingDevicePath
203 QEMU_VIDEO_PRIVATE_DATA
*Private
;
205 EFI_DEVICE_PATH_PROTOCOL
*ParentDevicePath
;
206 ACPI_ADR_DEVICE_PATH AcpiDeviceNode
;
208 QEMU_VIDEO_CARD
*Card
;
209 EFI_PCI_IO_PROTOCOL
*ChildPciIo
;
211 OldTpl
= gBS
->RaiseTPL (TPL_CALLBACK
);
214 // Allocate Private context data for GOP inteface.
216 Private
= AllocateZeroPool (sizeof (QEMU_VIDEO_PRIVATE_DATA
));
217 if (Private
== NULL
) {
218 Status
= EFI_OUT_OF_RESOURCES
;
223 // Set up context record
225 Private
->Signature
= QEMU_VIDEO_PRIVATE_DATA_SIGNATURE
;
228 // Open PCI I/O Protocol
230 Status
= gBS
->OpenProtocol (
232 &gEfiPciIoProtocolGuid
,
233 (VOID
**) &Private
->PciIo
,
234 This
->DriverBindingHandle
,
236 EFI_OPEN_PROTOCOL_BY_DRIVER
238 if (EFI_ERROR (Status
)) {
243 // Read the PCI Configuration Header from the PCI Device
245 Status
= Private
->PciIo
->Pci
.Read (
249 sizeof (Pci
) / sizeof (UINT32
),
252 if (EFI_ERROR (Status
)) {
257 // Determine card variant.
259 Card
= QemuVideoDetect(Pci
.Hdr
.ClassCode
[1], Pci
.Hdr
.VendorId
, Pci
.Hdr
.DeviceId
);
261 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 // Set new PCI attributes
289 Status
= Private
->PciIo
->Attributes (
291 EfiPciIoAttributeOperationEnable
,
292 EFI_PCI_DEVICE_ENABLE
| EFI_PCI_IO_ATTRIBUTE_VGA_MEMORY
| EFI_PCI_IO_ATTRIBUTE_VGA_IO
,
295 if (EFI_ERROR (Status
)) {
300 // Check whenever the qemu stdvga mmio bar is present (qemu 1.3+).
302 if (Private
->Variant
== QEMU_VIDEO_BOCHS_MMIO
) {
303 EFI_ACPI_ADDRESS_SPACE_DESCRIPTOR
*MmioDesc
;
305 Status
= Private
->PciIo
->GetBarAttributes (
311 if (EFI_ERROR (Status
) ||
312 MmioDesc
->ResType
!= ACPI_ADDRESS_SPACE_TYPE_MEM
) {
313 DEBUG ((EFI_D_INFO
, "QemuVideo: No mmio bar, fallback to port io\n"));
314 Private
->Variant
= QEMU_VIDEO_BOCHS
;
316 DEBUG ((EFI_D_INFO
, "QemuVideo: Using mmio bar @ 0x%lx\n",
317 MmioDesc
->AddrRangeMin
));
320 if (!EFI_ERROR (Status
)) {
326 // VMWare SVGA is handled like Bochs (with port IO only).
328 if (Private
->Variant
== QEMU_VIDEO_VMWARE_SVGA
) {
329 Private
->Variant
= QEMU_VIDEO_BOCHS
;
330 Private
->FrameBufferVramBarIndex
= PCI_BAR_IDX1
;
334 // Check if accessing the bochs interface works.
336 if (Private
->Variant
== QEMU_VIDEO_BOCHS_MMIO
||
337 Private
->Variant
== QEMU_VIDEO_BOCHS
) {
339 BochsId
= BochsRead(Private
, VBE_DISPI_INDEX_ID
);
340 if ((BochsId
& 0xFFF0) != VBE_DISPI_ID0
) {
341 DEBUG ((EFI_D_INFO
, "QemuVideo: BochsID mismatch (got 0x%x)\n", BochsId
));
342 Status
= EFI_DEVICE_ERROR
;
343 goto RestoreAttributes
;
348 // Get ParentDevicePath
350 Status
= gBS
->HandleProtocol (
352 &gEfiDevicePathProtocolGuid
,
353 (VOID
**) &ParentDevicePath
355 if (EFI_ERROR (Status
)) {
356 goto RestoreAttributes
;
360 // Set Gop Device Path
362 ZeroMem (&AcpiDeviceNode
, sizeof (ACPI_ADR_DEVICE_PATH
));
363 AcpiDeviceNode
.Header
.Type
= ACPI_DEVICE_PATH
;
364 AcpiDeviceNode
.Header
.SubType
= ACPI_ADR_DP
;
365 AcpiDeviceNode
.ADR
= ACPI_DISPLAY_ADR (1, 0, 0, 1, 0, ACPI_ADR_DISPLAY_TYPE_VGA
, 0, 0);
366 SetDevicePathNodeLength (&AcpiDeviceNode
.Header
, sizeof (ACPI_ADR_DEVICE_PATH
));
368 Private
->GopDevicePath
= AppendDevicePathNode (
370 (EFI_DEVICE_PATH_PROTOCOL
*) &AcpiDeviceNode
372 if (Private
->GopDevicePath
== NULL
) {
373 Status
= EFI_OUT_OF_RESOURCES
;
374 goto RestoreAttributes
;
378 // Create new child handle and install the device path protocol on it.
380 Status
= gBS
->InstallMultipleProtocolInterfaces (
382 &gEfiDevicePathProtocolGuid
,
383 Private
->GopDevicePath
,
386 if (EFI_ERROR (Status
)) {
387 goto FreeGopDevicePath
;
391 // Construct video mode buffer
393 switch (Private
->Variant
) {
394 case QEMU_VIDEO_CIRRUS_5430
:
395 case QEMU_VIDEO_CIRRUS_5446
:
396 Status
= QemuVideoCirrusModeSetup (Private
);
398 case QEMU_VIDEO_BOCHS_MMIO
:
399 case QEMU_VIDEO_BOCHS
:
400 Status
= QemuVideoBochsModeSetup (Private
, IsQxl
);
404 Status
= EFI_DEVICE_ERROR
;
407 if (EFI_ERROR (Status
)) {
408 goto UninstallGopDevicePath
;
412 // Start the GOP software stack.
414 Status
= QemuVideoGraphicsOutputConstructor (Private
);
415 if (EFI_ERROR (Status
)) {
419 Status
= gBS
->InstallMultipleProtocolInterfaces (
421 &gEfiGraphicsOutputProtocolGuid
,
422 &Private
->GraphicsOutput
,
425 if (EFI_ERROR (Status
)) {
426 goto DestructQemuVideoGraphics
;
430 // Reference parent handle from child handle.
432 Status
= gBS
->OpenProtocol (
434 &gEfiPciIoProtocolGuid
,
435 (VOID
**) &ChildPciIo
,
436 This
->DriverBindingHandle
,
438 EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
440 if (EFI_ERROR (Status
)) {
444 #if defined MDE_CPU_IA32 || defined MDE_CPU_X64
445 if (Private
->Variant
== QEMU_VIDEO_BOCHS_MMIO
||
446 Private
->Variant
== QEMU_VIDEO_BOCHS
) {
447 InstallVbeShim (Card
->Name
, Private
->GraphicsOutput
.Mode
->FrameBufferBase
);
451 gBS
->RestoreTPL (OldTpl
);
455 gBS
->UninstallProtocolInterface (Private
->Handle
,
456 &gEfiGraphicsOutputProtocolGuid
, &Private
->GraphicsOutput
);
458 DestructQemuVideoGraphics
:
459 QemuVideoGraphicsOutputDestructor (Private
);
462 FreePool (Private
->ModeData
);
464 UninstallGopDevicePath
:
465 gBS
->UninstallProtocolInterface (Private
->Handle
,
466 &gEfiDevicePathProtocolGuid
, Private
->GopDevicePath
);
469 FreePool (Private
->GopDevicePath
);
472 Private
->PciIo
->Attributes (Private
->PciIo
, EfiPciIoAttributeOperationSet
,
473 Private
->OriginalPciAttributes
, NULL
);
476 gBS
->CloseProtocol (Controller
, &gEfiPciIoProtocolGuid
,
477 This
->DriverBindingHandle
, Controller
);
483 gBS
->RestoreTPL (OldTpl
);
491 @param This The USB bus driver binding protocol.
492 @param Controller The controller to release.
493 @param NumberOfChildren The number of children of this device that
494 opened the controller BY_CHILD.
495 @param ChildHandleBuffer The array of child handle.
497 @retval EFI_SUCCESS The controller or children are stopped.
498 @retval EFI_DEVICE_ERROR Failed to stop the driver.
503 QemuVideoControllerDriverStop (
504 IN EFI_DRIVER_BINDING_PROTOCOL
*This
,
505 IN EFI_HANDLE Controller
,
506 IN UINTN NumberOfChildren
,
507 IN EFI_HANDLE
*ChildHandleBuffer
510 EFI_GRAPHICS_OUTPUT_PROTOCOL
*GraphicsOutput
;
513 QEMU_VIDEO_PRIVATE_DATA
*Private
;
515 if (NumberOfChildren
== 0) {
517 // Close the PCI I/O Protocol
521 &gEfiPciIoProtocolGuid
,
522 This
->DriverBindingHandle
,
529 // free all resources for whose access we need the child handle, because the
530 // child handle is going away
532 ASSERT (NumberOfChildren
== 1);
533 Status
= gBS
->OpenProtocol (
534 ChildHandleBuffer
[0],
535 &gEfiGraphicsOutputProtocolGuid
,
536 (VOID
**) &GraphicsOutput
,
537 This
->DriverBindingHandle
,
539 EFI_OPEN_PROTOCOL_GET_PROTOCOL
541 if (EFI_ERROR (Status
)) {
546 // Get our private context information
548 Private
= QEMU_VIDEO_PRIVATE_DATA_FROM_GRAPHICS_OUTPUT_THIS (GraphicsOutput
);
549 ASSERT (Private
->Handle
== ChildHandleBuffer
[0]);
551 QemuVideoGraphicsOutputDestructor (Private
);
553 // Remove the GOP protocol interface from the system
555 Status
= gBS
->UninstallMultipleProtocolInterfaces (
557 &gEfiGraphicsOutputProtocolGuid
,
558 &Private
->GraphicsOutput
,
562 if (EFI_ERROR (Status
)) {
567 // Restore original PCI attributes
569 Private
->PciIo
->Attributes (
571 EfiPciIoAttributeOperationSet
,
572 Private
->OriginalPciAttributes
,
578 &gEfiPciIoProtocolGuid
,
579 This
->DriverBindingHandle
,
583 FreePool (Private
->ModeData
);
584 gBS
->UninstallProtocolInterface (Private
->Handle
,
585 &gEfiDevicePathProtocolGuid
, Private
->GopDevicePath
);
586 FreePool (Private
->GopDevicePath
);
589 // Free our instance data
591 gBS
->FreePool (Private
);
597 TODO: Add function description
599 @param Private TODO: add argument description
600 @param Address TODO: add argument description
601 @param Data TODO: add argument description
603 TODO: add return values
608 QEMU_VIDEO_PRIVATE_DATA
*Private
,
613 Private
->PciIo
->Io
.Write (
616 EFI_PCI_IO_PASS_THROUGH_BAR
,
624 TODO: Add function description
626 @param Private TODO: add argument description
627 @param Address TODO: add argument description
628 @param Data TODO: add argument description
630 TODO: add return values
635 QEMU_VIDEO_PRIVATE_DATA
*Private
,
640 Private
->PciIo
->Io
.Write (
643 EFI_PCI_IO_PASS_THROUGH_BAR
,
651 TODO: Add function description
653 @param Private TODO: add argument description
654 @param Address TODO: add argument description
656 TODO: add return values
661 QEMU_VIDEO_PRIVATE_DATA
*Private
,
667 Private
->PciIo
->Io
.Read (
670 EFI_PCI_IO_PASS_THROUGH_BAR
,
679 TODO: Add function description
681 @param Private TODO: add argument description
682 @param Address TODO: add argument description
684 TODO: add return values
689 QEMU_VIDEO_PRIVATE_DATA
*Private
,
695 Private
->PciIo
->Io
.Read (
698 EFI_PCI_IO_PASS_THROUGH_BAR
,
707 TODO: Add function description
709 @param Private TODO: add argument description
710 @param Index TODO: add argument description
711 @param Red TODO: add argument description
712 @param Green TODO: add argument description
713 @param Blue TODO: add argument description
715 TODO: add return values
720 QEMU_VIDEO_PRIVATE_DATA
*Private
,
727 VgaOutb (Private
, PALETTE_INDEX_REGISTER
, (UINT8
) Index
);
728 VgaOutb (Private
, PALETTE_DATA_REGISTER
, (UINT8
) (Red
>> 2));
729 VgaOutb (Private
, PALETTE_DATA_REGISTER
, (UINT8
) (Green
>> 2));
730 VgaOutb (Private
, PALETTE_DATA_REGISTER
, (UINT8
) (Blue
>> 2));
734 TODO: Add function description
736 @param Private TODO: add argument description
738 TODO: add return values
743 QEMU_VIDEO_PRIVATE_DATA
*Private
752 for (RedIndex
= 0; RedIndex
< 8; RedIndex
++) {
753 for (GreenIndex
= 0; GreenIndex
< 8; GreenIndex
++) {
754 for (BlueIndex
= 0; BlueIndex
< 4; BlueIndex
++) {
755 SetPaletteColor (Private
, Index
, (UINT8
) (RedIndex
<< 5), (UINT8
) (GreenIndex
<< 5), (UINT8
) (BlueIndex
<< 6));
763 TODO: Add function description
765 @param Private TODO: add argument description
767 TODO: add return values
772 QEMU_VIDEO_PRIVATE_DATA
*Private
778 Private
->PciIo
->Mem
.Write (
780 EfiPciIoWidthFillUint32
,
781 Private
->FrameBufferVramBarIndex
,
789 TODO: Add function description
791 @param Private TODO: add argument description
793 TODO: add return values
798 QEMU_VIDEO_PRIVATE_DATA
*Private
,
806 TODO: Add function description
808 @param Private TODO: add argument description
809 @param ModeData TODO: add argument description
811 TODO: add return values
815 InitializeCirrusGraphicsMode (
816 QEMU_VIDEO_PRIVATE_DATA
*Private
,
817 QEMU_VIDEO_CIRRUS_MODES
*ModeData
823 outw (Private
, SEQ_ADDRESS_REGISTER
, 0x1206);
824 outw (Private
, SEQ_ADDRESS_REGISTER
, 0x0012);
826 for (Index
= 0; Index
< 15; Index
++) {
827 outw (Private
, SEQ_ADDRESS_REGISTER
, ModeData
->SeqSettings
[Index
]);
830 if (Private
->Variant
== QEMU_VIDEO_CIRRUS_5430
) {
831 outb (Private
, SEQ_ADDRESS_REGISTER
, 0x0f);
832 Byte
= (UINT8
) ((inb (Private
, SEQ_DATA_REGISTER
) & 0xc7) ^ 0x30);
833 outb (Private
, SEQ_DATA_REGISTER
, Byte
);
836 outb (Private
, MISC_OUTPUT_REGISTER
, ModeData
->MiscSetting
);
837 outw (Private
, GRAPH_ADDRESS_REGISTER
, 0x0506);
838 outw (Private
, SEQ_ADDRESS_REGISTER
, 0x0300);
839 outw (Private
, CRTC_ADDRESS_REGISTER
, 0x2011);
841 for (Index
= 0; Index
< 28; Index
++) {
842 outw (Private
, CRTC_ADDRESS_REGISTER
, (UINT16
) ((ModeData
->CrtcSettings
[Index
] << 8) | Index
));
845 for (Index
= 0; Index
< 9; Index
++) {
846 outw (Private
, GRAPH_ADDRESS_REGISTER
, (UINT16
) ((GraphicsController
[Index
] << 8) | Index
));
849 inb (Private
, INPUT_STATUS_1_REGISTER
);
851 for (Index
= 0; Index
< 21; Index
++) {
852 outb (Private
, ATT_ADDRESS_REGISTER
, (UINT8
) Index
);
853 outb (Private
, ATT_ADDRESS_REGISTER
, AttributeController
[Index
]);
856 outb (Private
, ATT_ADDRESS_REGISTER
, 0x20);
858 outw (Private
, GRAPH_ADDRESS_REGISTER
, 0x0009);
859 outw (Private
, GRAPH_ADDRESS_REGISTER
, 0x000a);
860 outw (Private
, GRAPH_ADDRESS_REGISTER
, 0x000b);
861 outb (Private
, DAC_PIXEL_MASK_REGISTER
, 0xff);
863 SetDefaultPalette (Private
);
864 ClearScreen (Private
);
869 QEMU_VIDEO_PRIVATE_DATA
*Private
,
876 if (Private
->Variant
== QEMU_VIDEO_BOCHS_MMIO
) {
877 Status
= Private
->PciIo
->Mem
.Write (
885 ASSERT_EFI_ERROR (Status
);
887 outw (Private
, VBE_DISPI_IOPORT_INDEX
, Reg
);
888 outw (Private
, VBE_DISPI_IOPORT_DATA
, Data
);
894 QEMU_VIDEO_PRIVATE_DATA
*Private
,
901 if (Private
->Variant
== QEMU_VIDEO_BOCHS_MMIO
) {
902 Status
= Private
->PciIo
->Mem
.Read (
910 ASSERT_EFI_ERROR (Status
);
912 outw (Private
, VBE_DISPI_IOPORT_INDEX
, Reg
);
913 Data
= inw (Private
, VBE_DISPI_IOPORT_DATA
);
920 QEMU_VIDEO_PRIVATE_DATA
*Private
,
927 if (Private
->Variant
== QEMU_VIDEO_BOCHS_MMIO
) {
928 Status
= Private
->PciIo
->Mem
.Write (
936 ASSERT_EFI_ERROR (Status
);
938 outb (Private
, Reg
, Data
);
943 InitializeBochsGraphicsMode (
944 QEMU_VIDEO_PRIVATE_DATA
*Private
,
945 QEMU_VIDEO_BOCHS_MODES
*ModeData
948 DEBUG ((EFI_D_INFO
, "InitializeBochsGraphicsMode: %dx%d @ %d\n",
949 ModeData
->Width
, ModeData
->Height
, ModeData
->ColorDepth
));
952 VgaOutb (Private
, ATT_ADDRESS_REGISTER
, 0x20);
954 BochsWrite (Private
, VBE_DISPI_INDEX_ENABLE
, 0);
955 BochsWrite (Private
, VBE_DISPI_INDEX_BANK
, 0);
956 BochsWrite (Private
, VBE_DISPI_INDEX_X_OFFSET
, 0);
957 BochsWrite (Private
, VBE_DISPI_INDEX_Y_OFFSET
, 0);
959 BochsWrite (Private
, VBE_DISPI_INDEX_BPP
, (UINT16
) ModeData
->ColorDepth
);
960 BochsWrite (Private
, VBE_DISPI_INDEX_XRES
, (UINT16
) ModeData
->Width
);
961 BochsWrite (Private
, VBE_DISPI_INDEX_VIRT_WIDTH
, (UINT16
) ModeData
->Width
);
962 BochsWrite (Private
, VBE_DISPI_INDEX_YRES
, (UINT16
) ModeData
->Height
);
963 BochsWrite (Private
, VBE_DISPI_INDEX_VIRT_HEIGHT
, (UINT16
) ModeData
->Height
);
965 BochsWrite (Private
, VBE_DISPI_INDEX_ENABLE
,
966 VBE_DISPI_ENABLED
| VBE_DISPI_LFB_ENABLED
);
968 SetDefaultPalette (Private
);
969 ClearScreen (Private
);
974 InitializeQemuVideo (
975 IN EFI_HANDLE ImageHandle
,
976 IN EFI_SYSTEM_TABLE
*SystemTable
981 Status
= EfiLibInstallDriverBindingComponentName2 (
984 &gQemuVideoDriverBinding
,
986 &gQemuVideoComponentName
,
987 &gQemuVideoComponentName2
989 ASSERT_EFI_ERROR (Status
);
992 // Install EFI Driver Supported EFI Version Protocol required for
993 // EFI drivers that are on PCI and other plug in cards.
995 gQemuVideoDriverSupportedEfiVersion
.FirmwareVersion
= PcdGet32 (PcdDriverSupportedEfiVersion
);
996 Status
= gBS
->InstallMultipleProtocolInterfaces (
998 &gEfiDriverSupportedEfiVersionProtocolGuid
,
999 &gQemuVideoDriverSupportedEfiVersion
,
1002 ASSERT_EFI_ERROR (Status
);