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 CIRRUS_LOGIC_VENDOR_ID
,
32 CIRRUS_LOGIC_5430_DEVICE_ID
,
33 QEMU_VIDEO_CIRRUS_5430
,
36 CIRRUS_LOGIC_VENDOR_ID
,
37 CIRRUS_LOGIC_5430_ALTERNATE_DEVICE_ID
,
38 QEMU_VIDEO_CIRRUS_5430
,
41 CIRRUS_LOGIC_VENDOR_ID
,
42 CIRRUS_LOGIC_5446_DEVICE_ID
,
43 QEMU_VIDEO_CIRRUS_5446
,
48 QEMU_VIDEO_BOCHS_MMIO
,
60 static QEMU_VIDEO_CARD
*
68 while (gQemuVideoCardList
[Index
].VendorId
!= 0) {
69 if (gQemuVideoCardList
[Index
].VendorId
== VendorId
&&
70 gQemuVideoCardList
[Index
].DeviceId
== DeviceId
) {
71 return gQemuVideoCardList
+ Index
;
79 Check if this device is supported.
81 @param This The driver binding protocol.
82 @param Controller The controller handle to check.
83 @param RemainingDevicePath The remaining device path.
85 @retval EFI_SUCCESS The bus supports this controller.
86 @retval EFI_UNSUPPORTED This device isn't supported.
91 QemuVideoControllerDriverSupported (
92 IN EFI_DRIVER_BINDING_PROTOCOL
*This
,
93 IN EFI_HANDLE Controller
,
94 IN EFI_DEVICE_PATH_PROTOCOL
*RemainingDevicePath
98 EFI_PCI_IO_PROTOCOL
*PciIo
;
100 QEMU_VIDEO_CARD
*Card
;
103 // Open the PCI I/O Protocol
105 Status
= gBS
->OpenProtocol (
107 &gEfiPciIoProtocolGuid
,
109 This
->DriverBindingHandle
,
111 EFI_OPEN_PROTOCOL_BY_DRIVER
113 if (EFI_ERROR (Status
)) {
118 // Read the PCI Configuration Header from the PCI Device
120 Status
= PciIo
->Pci
.Read (
124 sizeof (Pci
) / sizeof (UINT32
),
127 if (EFI_ERROR (Status
)) {
131 Status
= EFI_UNSUPPORTED
;
132 Card
= QemuVideoDetect(Pci
.Hdr
.VendorId
, Pci
.Hdr
.DeviceId
);
134 DEBUG ((EFI_D_INFO
, "QemuVideo: %s detected\n", Card
->Name
));
135 Status
= EFI_SUCCESS
;
140 // Close the PCI I/O Protocol
144 &gEfiPciIoProtocolGuid
,
145 This
->DriverBindingHandle
,
153 Start to process the controller.
155 @param This The USB bus driver binding instance.
156 @param Controller The controller to check.
157 @param RemainingDevicePath The remaining device patch.
159 @retval EFI_SUCCESS The controller is controlled by the usb bus.
160 @retval EFI_ALREADY_STARTED The controller is already controlled by the usb
162 @retval EFI_OUT_OF_RESOURCES Failed to allocate resources.
167 QemuVideoControllerDriverStart (
168 IN EFI_DRIVER_BINDING_PROTOCOL
*This
,
169 IN EFI_HANDLE Controller
,
170 IN EFI_DEVICE_PATH_PROTOCOL
*RemainingDevicePath
175 QEMU_VIDEO_PRIVATE_DATA
*Private
;
177 EFI_DEVICE_PATH_PROTOCOL
*ParentDevicePath
;
178 ACPI_ADR_DEVICE_PATH AcpiDeviceNode
;
180 QEMU_VIDEO_CARD
*Card
;
181 EFI_PCI_IO_PROTOCOL
*ChildPciIo
;
183 OldTpl
= gBS
->RaiseTPL (TPL_CALLBACK
);
186 // Allocate Private context data for GOP inteface.
188 Private
= AllocateZeroPool (sizeof (QEMU_VIDEO_PRIVATE_DATA
));
189 if (Private
== NULL
) {
190 Status
= EFI_OUT_OF_RESOURCES
;
195 // Set up context record
197 Private
->Signature
= QEMU_VIDEO_PRIVATE_DATA_SIGNATURE
;
200 // Open PCI I/O Protocol
202 Status
= gBS
->OpenProtocol (
204 &gEfiPciIoProtocolGuid
,
205 (VOID
**) &Private
->PciIo
,
206 This
->DriverBindingHandle
,
208 EFI_OPEN_PROTOCOL_BY_DRIVER
210 if (EFI_ERROR (Status
)) {
215 // Read the PCI Configuration Header from the PCI Device
217 Status
= Private
->PciIo
->Pci
.Read (
221 sizeof (Pci
) / sizeof (UINT32
),
224 if (EFI_ERROR (Status
)) {
229 // Determine card variant.
231 Card
= QemuVideoDetect(Pci
.Hdr
.VendorId
, Pci
.Hdr
.DeviceId
);
233 Status
= EFI_DEVICE_ERROR
;
236 Private
->Variant
= Card
->Variant
;
239 // IsQxl is based on the detected Card->Variant, which at a later point might
240 // not match Private->Variant.
242 IsQxl
= (BOOLEAN
)(Card
->Variant
== QEMU_VIDEO_BOCHS
);
245 // Save original PCI attributes
247 Status
= Private
->PciIo
->Attributes (
249 EfiPciIoAttributeOperationGet
,
251 &Private
->OriginalPciAttributes
254 if (EFI_ERROR (Status
)) {
259 // Set new PCI attributes
261 Status
= Private
->PciIo
->Attributes (
263 EfiPciIoAttributeOperationEnable
,
264 EFI_PCI_DEVICE_ENABLE
| EFI_PCI_IO_ATTRIBUTE_VGA_MEMORY
| EFI_PCI_IO_ATTRIBUTE_VGA_IO
,
267 if (EFI_ERROR (Status
)) {
272 // Check whenever the qemu stdvga mmio bar is present (qemu 1.3+).
274 if (Private
->Variant
== QEMU_VIDEO_BOCHS_MMIO
) {
275 EFI_ACPI_ADDRESS_SPACE_DESCRIPTOR
*MmioDesc
;
277 Status
= Private
->PciIo
->GetBarAttributes (
283 if (EFI_ERROR (Status
) ||
284 MmioDesc
->ResType
!= ACPI_ADDRESS_SPACE_TYPE_MEM
) {
285 DEBUG ((EFI_D_INFO
, "QemuVideo: No mmio bar, fallback to port io\n"));
286 Private
->Variant
= QEMU_VIDEO_BOCHS
;
288 DEBUG ((EFI_D_INFO
, "QemuVideo: Using mmio bar @ 0x%lx\n",
289 MmioDesc
->AddrRangeMin
));
292 if (!EFI_ERROR (Status
)) {
298 // Check if accessing the bochs interface works.
300 if (Private
->Variant
== QEMU_VIDEO_BOCHS_MMIO
||
301 Private
->Variant
== QEMU_VIDEO_BOCHS
) {
303 BochsId
= BochsRead(Private
, VBE_DISPI_INDEX_ID
);
304 if ((BochsId
& 0xFFF0) != VBE_DISPI_ID0
) {
305 DEBUG ((EFI_D_INFO
, "QemuVideo: BochsID mismatch (got 0x%x)\n", BochsId
));
306 Status
= EFI_DEVICE_ERROR
;
307 goto RestoreAttributes
;
312 // Get ParentDevicePath
314 Status
= gBS
->HandleProtocol (
316 &gEfiDevicePathProtocolGuid
,
317 (VOID
**) &ParentDevicePath
319 if (EFI_ERROR (Status
)) {
320 goto RestoreAttributes
;
324 // Set Gop Device Path
326 ZeroMem (&AcpiDeviceNode
, sizeof (ACPI_ADR_DEVICE_PATH
));
327 AcpiDeviceNode
.Header
.Type
= ACPI_DEVICE_PATH
;
328 AcpiDeviceNode
.Header
.SubType
= ACPI_ADR_DP
;
329 AcpiDeviceNode
.ADR
= ACPI_DISPLAY_ADR (1, 0, 0, 1, 0, ACPI_ADR_DISPLAY_TYPE_VGA
, 0, 0);
330 SetDevicePathNodeLength (&AcpiDeviceNode
.Header
, sizeof (ACPI_ADR_DEVICE_PATH
));
332 Private
->GopDevicePath
= AppendDevicePathNode (
334 (EFI_DEVICE_PATH_PROTOCOL
*) &AcpiDeviceNode
336 if (Private
->GopDevicePath
== NULL
) {
337 Status
= EFI_OUT_OF_RESOURCES
;
338 goto RestoreAttributes
;
342 // Create new child handle and install the device path protocol on it.
344 Status
= gBS
->InstallMultipleProtocolInterfaces (
346 &gEfiDevicePathProtocolGuid
,
347 Private
->GopDevicePath
,
350 if (EFI_ERROR (Status
)) {
351 goto FreeGopDevicePath
;
355 // Construct video mode buffer
357 switch (Private
->Variant
) {
358 case QEMU_VIDEO_CIRRUS_5430
:
359 case QEMU_VIDEO_CIRRUS_5446
:
360 Status
= QemuVideoCirrusModeSetup (Private
);
362 case QEMU_VIDEO_BOCHS_MMIO
:
363 case QEMU_VIDEO_BOCHS
:
364 Status
= QemuVideoBochsModeSetup (Private
, IsQxl
);
368 Status
= EFI_DEVICE_ERROR
;
371 if (EFI_ERROR (Status
)) {
372 goto UninstallGopDevicePath
;
376 // Start the GOP software stack.
378 Status
= QemuVideoGraphicsOutputConstructor (Private
);
379 if (EFI_ERROR (Status
)) {
383 Status
= gBS
->InstallMultipleProtocolInterfaces (
385 &gEfiGraphicsOutputProtocolGuid
,
386 &Private
->GraphicsOutput
,
389 if (EFI_ERROR (Status
)) {
390 goto DestructQemuVideoGraphics
;
394 // Reference parent handle from child handle.
396 Status
= gBS
->OpenProtocol (
398 &gEfiPciIoProtocolGuid
,
399 (VOID
**) &ChildPciIo
,
400 This
->DriverBindingHandle
,
402 EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
404 if (EFI_ERROR (Status
)) {
408 if (Private
->Variant
== QEMU_VIDEO_BOCHS_MMIO
||
409 Private
->Variant
== QEMU_VIDEO_BOCHS
) {
410 InstallVbeShim (Card
->Name
, Private
->GraphicsOutput
.Mode
->FrameBufferBase
);
413 gBS
->RestoreTPL (OldTpl
);
417 gBS
->UninstallProtocolInterface (Private
->Handle
,
418 &gEfiGraphicsOutputProtocolGuid
, &Private
->GraphicsOutput
);
420 DestructQemuVideoGraphics
:
421 QemuVideoGraphicsOutputDestructor (Private
);
424 FreePool (Private
->ModeData
);
426 UninstallGopDevicePath
:
427 gBS
->UninstallProtocolInterface (Private
->Handle
,
428 &gEfiDevicePathProtocolGuid
, Private
->GopDevicePath
);
431 FreePool (Private
->GopDevicePath
);
434 Private
->PciIo
->Attributes (Private
->PciIo
, EfiPciIoAttributeOperationSet
,
435 Private
->OriginalPciAttributes
, NULL
);
438 gBS
->CloseProtocol (Controller
, &gEfiPciIoProtocolGuid
,
439 This
->DriverBindingHandle
, Controller
);
445 gBS
->RestoreTPL (OldTpl
);
453 @param This The USB bus driver binding protocol.
454 @param Controller The controller to release.
455 @param NumberOfChildren The number of children of this device that
456 opened the controller BY_CHILD.
457 @param ChildHandleBuffer The array of child handle.
459 @retval EFI_SUCCESS The controller or children are stopped.
460 @retval EFI_DEVICE_ERROR Failed to stop the driver.
465 QemuVideoControllerDriverStop (
466 IN EFI_DRIVER_BINDING_PROTOCOL
*This
,
467 IN EFI_HANDLE Controller
,
468 IN UINTN NumberOfChildren
,
469 IN EFI_HANDLE
*ChildHandleBuffer
472 EFI_GRAPHICS_OUTPUT_PROTOCOL
*GraphicsOutput
;
475 QEMU_VIDEO_PRIVATE_DATA
*Private
;
477 if (NumberOfChildren
== 0) {
479 // Close the PCI I/O Protocol
483 &gEfiPciIoProtocolGuid
,
484 This
->DriverBindingHandle
,
491 // free all resources for whose access we need the child handle, because the
492 // child handle is going away
494 ASSERT (NumberOfChildren
== 1);
495 Status
= gBS
->OpenProtocol (
496 ChildHandleBuffer
[0],
497 &gEfiGraphicsOutputProtocolGuid
,
498 (VOID
**) &GraphicsOutput
,
499 This
->DriverBindingHandle
,
501 EFI_OPEN_PROTOCOL_GET_PROTOCOL
503 if (EFI_ERROR (Status
)) {
508 // Get our private context information
510 Private
= QEMU_VIDEO_PRIVATE_DATA_FROM_GRAPHICS_OUTPUT_THIS (GraphicsOutput
);
511 ASSERT (Private
->Handle
== ChildHandleBuffer
[0]);
513 QemuVideoGraphicsOutputDestructor (Private
);
515 // Remove the GOP protocol interface from the system
517 Status
= gBS
->UninstallMultipleProtocolInterfaces (
519 &gEfiGraphicsOutputProtocolGuid
,
520 &Private
->GraphicsOutput
,
524 if (EFI_ERROR (Status
)) {
529 // Restore original PCI attributes
531 Private
->PciIo
->Attributes (
533 EfiPciIoAttributeOperationSet
,
534 Private
->OriginalPciAttributes
,
540 &gEfiPciIoProtocolGuid
,
541 This
->DriverBindingHandle
,
545 FreePool (Private
->ModeData
);
546 gBS
->UninstallProtocolInterface (Private
->Handle
,
547 &gEfiDevicePathProtocolGuid
, Private
->GopDevicePath
);
548 FreePool (Private
->GopDevicePath
);
551 // Free our instance data
553 gBS
->FreePool (Private
);
559 TODO: Add function description
561 @param Private TODO: add argument description
562 @param Address TODO: add argument description
563 @param Data TODO: add argument description
565 TODO: add return values
570 QEMU_VIDEO_PRIVATE_DATA
*Private
,
575 Private
->PciIo
->Io
.Write (
578 EFI_PCI_IO_PASS_THROUGH_BAR
,
586 TODO: Add function description
588 @param Private TODO: add argument description
589 @param Address TODO: add argument description
590 @param Data TODO: add argument description
592 TODO: add return values
597 QEMU_VIDEO_PRIVATE_DATA
*Private
,
602 Private
->PciIo
->Io
.Write (
605 EFI_PCI_IO_PASS_THROUGH_BAR
,
613 TODO: Add function description
615 @param Private TODO: add argument description
616 @param Address TODO: add argument description
618 TODO: add return values
623 QEMU_VIDEO_PRIVATE_DATA
*Private
,
629 Private
->PciIo
->Io
.Read (
632 EFI_PCI_IO_PASS_THROUGH_BAR
,
641 TODO: Add function description
643 @param Private TODO: add argument description
644 @param Address TODO: add argument description
646 TODO: add return values
651 QEMU_VIDEO_PRIVATE_DATA
*Private
,
657 Private
->PciIo
->Io
.Read (
660 EFI_PCI_IO_PASS_THROUGH_BAR
,
669 TODO: Add function description
671 @param Private TODO: add argument description
672 @param Index TODO: add argument description
673 @param Red TODO: add argument description
674 @param Green TODO: add argument description
675 @param Blue TODO: add argument description
677 TODO: add return values
682 QEMU_VIDEO_PRIVATE_DATA
*Private
,
689 VgaOutb (Private
, PALETTE_INDEX_REGISTER
, (UINT8
) Index
);
690 VgaOutb (Private
, PALETTE_DATA_REGISTER
, (UINT8
) (Red
>> 2));
691 VgaOutb (Private
, PALETTE_DATA_REGISTER
, (UINT8
) (Green
>> 2));
692 VgaOutb (Private
, PALETTE_DATA_REGISTER
, (UINT8
) (Blue
>> 2));
696 TODO: Add function description
698 @param Private TODO: add argument description
700 TODO: add return values
705 QEMU_VIDEO_PRIVATE_DATA
*Private
714 for (RedIndex
= 0; RedIndex
< 8; RedIndex
++) {
715 for (GreenIndex
= 0; GreenIndex
< 8; GreenIndex
++) {
716 for (BlueIndex
= 0; BlueIndex
< 4; BlueIndex
++) {
717 SetPaletteColor (Private
, Index
, (UINT8
) (RedIndex
<< 5), (UINT8
) (GreenIndex
<< 5), (UINT8
) (BlueIndex
<< 6));
725 TODO: Add function description
727 @param Private TODO: add argument description
729 TODO: add return values
734 QEMU_VIDEO_PRIVATE_DATA
*Private
740 Private
->PciIo
->Mem
.Write (
742 EfiPciIoWidthFillUint32
,
751 TODO: Add function description
753 @param Private TODO: add argument description
755 TODO: add return values
760 QEMU_VIDEO_PRIVATE_DATA
*Private
,
768 TODO: Add function description
770 @param Private TODO: add argument description
771 @param ModeData TODO: add argument description
773 TODO: add return values
777 InitializeCirrusGraphicsMode (
778 QEMU_VIDEO_PRIVATE_DATA
*Private
,
779 QEMU_VIDEO_CIRRUS_MODES
*ModeData
785 outw (Private
, SEQ_ADDRESS_REGISTER
, 0x1206);
786 outw (Private
, SEQ_ADDRESS_REGISTER
, 0x0012);
788 for (Index
= 0; Index
< 15; Index
++) {
789 outw (Private
, SEQ_ADDRESS_REGISTER
, ModeData
->SeqSettings
[Index
]);
792 if (Private
->Variant
== QEMU_VIDEO_CIRRUS_5430
) {
793 outb (Private
, SEQ_ADDRESS_REGISTER
, 0x0f);
794 Byte
= (UINT8
) ((inb (Private
, SEQ_DATA_REGISTER
) & 0xc7) ^ 0x30);
795 outb (Private
, SEQ_DATA_REGISTER
, Byte
);
798 outb (Private
, MISC_OUTPUT_REGISTER
, ModeData
->MiscSetting
);
799 outw (Private
, GRAPH_ADDRESS_REGISTER
, 0x0506);
800 outw (Private
, SEQ_ADDRESS_REGISTER
, 0x0300);
801 outw (Private
, CRTC_ADDRESS_REGISTER
, 0x2011);
803 for (Index
= 0; Index
< 28; Index
++) {
804 outw (Private
, CRTC_ADDRESS_REGISTER
, (UINT16
) ((ModeData
->CrtcSettings
[Index
] << 8) | Index
));
807 for (Index
= 0; Index
< 9; Index
++) {
808 outw (Private
, GRAPH_ADDRESS_REGISTER
, (UINT16
) ((GraphicsController
[Index
] << 8) | Index
));
811 inb (Private
, INPUT_STATUS_1_REGISTER
);
813 for (Index
= 0; Index
< 21; Index
++) {
814 outb (Private
, ATT_ADDRESS_REGISTER
, (UINT8
) Index
);
815 outb (Private
, ATT_ADDRESS_REGISTER
, AttributeController
[Index
]);
818 outb (Private
, ATT_ADDRESS_REGISTER
, 0x20);
820 outw (Private
, GRAPH_ADDRESS_REGISTER
, 0x0009);
821 outw (Private
, GRAPH_ADDRESS_REGISTER
, 0x000a);
822 outw (Private
, GRAPH_ADDRESS_REGISTER
, 0x000b);
823 outb (Private
, DAC_PIXEL_MASK_REGISTER
, 0xff);
825 SetDefaultPalette (Private
);
826 ClearScreen (Private
);
831 QEMU_VIDEO_PRIVATE_DATA
*Private
,
838 if (Private
->Variant
== QEMU_VIDEO_BOCHS_MMIO
) {
839 Status
= Private
->PciIo
->Mem
.Write (
847 ASSERT_EFI_ERROR (Status
);
849 outw (Private
, VBE_DISPI_IOPORT_INDEX
, Reg
);
850 outw (Private
, VBE_DISPI_IOPORT_DATA
, Data
);
856 QEMU_VIDEO_PRIVATE_DATA
*Private
,
863 if (Private
->Variant
== QEMU_VIDEO_BOCHS_MMIO
) {
864 Status
= Private
->PciIo
->Mem
.Read (
872 ASSERT_EFI_ERROR (Status
);
874 outw (Private
, VBE_DISPI_IOPORT_INDEX
, Reg
);
875 Data
= inw (Private
, VBE_DISPI_IOPORT_DATA
);
882 QEMU_VIDEO_PRIVATE_DATA
*Private
,
889 if (Private
->Variant
== QEMU_VIDEO_BOCHS_MMIO
) {
890 Status
= Private
->PciIo
->Mem
.Write (
898 ASSERT_EFI_ERROR (Status
);
900 outb (Private
, Reg
, Data
);
905 InitializeBochsGraphicsMode (
906 QEMU_VIDEO_PRIVATE_DATA
*Private
,
907 QEMU_VIDEO_BOCHS_MODES
*ModeData
910 DEBUG ((EFI_D_INFO
, "InitializeBochsGraphicsMode: %dx%d @ %d\n",
911 ModeData
->Width
, ModeData
->Height
, ModeData
->ColorDepth
));
914 VgaOutb (Private
, ATT_ADDRESS_REGISTER
, 0x20);
916 BochsWrite (Private
, VBE_DISPI_INDEX_ENABLE
, 0);
917 BochsWrite (Private
, VBE_DISPI_INDEX_BANK
, 0);
918 BochsWrite (Private
, VBE_DISPI_INDEX_X_OFFSET
, 0);
919 BochsWrite (Private
, VBE_DISPI_INDEX_Y_OFFSET
, 0);
921 BochsWrite (Private
, VBE_DISPI_INDEX_BPP
, (UINT16
) ModeData
->ColorDepth
);
922 BochsWrite (Private
, VBE_DISPI_INDEX_XRES
, (UINT16
) ModeData
->Width
);
923 BochsWrite (Private
, VBE_DISPI_INDEX_VIRT_WIDTH
, (UINT16
) ModeData
->Width
);
924 BochsWrite (Private
, VBE_DISPI_INDEX_YRES
, (UINT16
) ModeData
->Height
);
925 BochsWrite (Private
, VBE_DISPI_INDEX_VIRT_HEIGHT
, (UINT16
) ModeData
->Height
);
927 BochsWrite (Private
, VBE_DISPI_INDEX_ENABLE
,
928 VBE_DISPI_ENABLED
| VBE_DISPI_LFB_ENABLED
);
930 SetDefaultPalette (Private
);
931 ClearScreen (Private
);
936 InitializeQemuVideo (
937 IN EFI_HANDLE ImageHandle
,
938 IN EFI_SYSTEM_TABLE
*SystemTable
943 Status
= EfiLibInstallDriverBindingComponentName2 (
946 &gQemuVideoDriverBinding
,
948 &gQemuVideoComponentName
,
949 &gQemuVideoComponentName2
951 ASSERT_EFI_ERROR (Status
);
954 // Install EFI Driver Supported EFI Version Protocol required for
955 // EFI drivers that are on PCI and other plug in cards.
957 gQemuVideoDriverSupportedEfiVersion
.FirmwareVersion
= PcdGet32 (PcdDriverSupportedEfiVersion
);
958 Status
= gBS
->InstallMultipleProtocolInterfaces (
960 &gEfiDriverSupportedEfiVersionProtocolGuid
,
961 &gQemuVideoDriverSupportedEfiVersion
,
964 ASSERT_EFI_ERROR (Status
);