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.
17 #include <IndustryStandard/VmwareSvga.h>
18 #include <IndustryStandard/Acpi.h>
20 #include "UnalignedIoInternal.h"
22 EFI_DRIVER_BINDING_PROTOCOL gQemuVideoDriverBinding
= {
23 QemuVideoControllerDriverSupported
,
24 QemuVideoControllerDriverStart
,
25 QemuVideoControllerDriverStop
,
31 QEMU_VIDEO_CARD gQemuVideoCardList
[] = {
33 CIRRUS_LOGIC_VENDOR_ID
,
34 CIRRUS_LOGIC_5430_DEVICE_ID
,
35 QEMU_VIDEO_CIRRUS_5430
,
38 CIRRUS_LOGIC_VENDOR_ID
,
39 CIRRUS_LOGIC_5430_ALTERNATE_DEVICE_ID
,
40 QEMU_VIDEO_CIRRUS_5430
,
43 CIRRUS_LOGIC_VENDOR_ID
,
44 CIRRUS_LOGIC_5446_DEVICE_ID
,
45 QEMU_VIDEO_CIRRUS_5446
,
50 QEMU_VIDEO_BOCHS_MMIO
,
60 QEMU_VIDEO_BOCHS_MMIO
,
63 VMWARE_PCI_VENDOR_ID_VMWARE
,
64 VMWARE_PCI_DEVICE_ID_VMWARE_SVGA2
,
65 QEMU_VIDEO_VMWARE_SVGA
,
72 static QEMU_VIDEO_CARD
*
80 while (gQemuVideoCardList
[Index
].VendorId
!= 0) {
81 if (gQemuVideoCardList
[Index
].VendorId
== VendorId
&&
82 gQemuVideoCardList
[Index
].DeviceId
== DeviceId
) {
83 return gQemuVideoCardList
+ Index
;
91 Check if this device is supported.
93 @param This The driver binding protocol.
94 @param Controller The controller handle to check.
95 @param RemainingDevicePath The remaining device path.
97 @retval EFI_SUCCESS The bus supports this controller.
98 @retval EFI_UNSUPPORTED This device isn't supported.
103 QemuVideoControllerDriverSupported (
104 IN EFI_DRIVER_BINDING_PROTOCOL
*This
,
105 IN EFI_HANDLE Controller
,
106 IN EFI_DEVICE_PATH_PROTOCOL
*RemainingDevicePath
110 EFI_PCI_IO_PROTOCOL
*PciIo
;
112 QEMU_VIDEO_CARD
*Card
;
115 // Open the PCI I/O Protocol
117 Status
= gBS
->OpenProtocol (
119 &gEfiPciIoProtocolGuid
,
121 This
->DriverBindingHandle
,
123 EFI_OPEN_PROTOCOL_BY_DRIVER
125 if (EFI_ERROR (Status
)) {
130 // Read the PCI Configuration Header from the PCI Device
132 Status
= PciIo
->Pci
.Read (
136 sizeof (Pci
) / sizeof (UINT32
),
139 if (EFI_ERROR (Status
)) {
143 Status
= EFI_UNSUPPORTED
;
144 if (!IS_PCI_VGA (&Pci
)) {
147 Card
= QemuVideoDetect(Pci
.Hdr
.VendorId
, Pci
.Hdr
.DeviceId
);
149 DEBUG ((EFI_D_INFO
, "QemuVideo: %s detected\n", Card
->Name
));
150 Status
= EFI_SUCCESS
;
155 // Close the PCI I/O Protocol
159 &gEfiPciIoProtocolGuid
,
160 This
->DriverBindingHandle
,
168 Start to process the controller.
170 @param This The USB bus driver binding instance.
171 @param Controller The controller to check.
172 @param RemainingDevicePath The remaining device patch.
174 @retval EFI_SUCCESS The controller is controlled by the usb bus.
175 @retval EFI_ALREADY_STARTED The controller is already controlled by the usb
177 @retval EFI_OUT_OF_RESOURCES Failed to allocate resources.
182 QemuVideoControllerDriverStart (
183 IN EFI_DRIVER_BINDING_PROTOCOL
*This
,
184 IN EFI_HANDLE Controller
,
185 IN EFI_DEVICE_PATH_PROTOCOL
*RemainingDevicePath
190 QEMU_VIDEO_PRIVATE_DATA
*Private
;
192 EFI_DEVICE_PATH_PROTOCOL
*ParentDevicePath
;
193 ACPI_ADR_DEVICE_PATH AcpiDeviceNode
;
195 QEMU_VIDEO_CARD
*Card
;
196 EFI_PCI_IO_PROTOCOL
*ChildPciIo
;
198 OldTpl
= gBS
->RaiseTPL (TPL_CALLBACK
);
201 // Allocate Private context data for GOP inteface.
203 Private
= AllocateZeroPool (sizeof (QEMU_VIDEO_PRIVATE_DATA
));
204 if (Private
== NULL
) {
205 Status
= EFI_OUT_OF_RESOURCES
;
210 // Set up context record
212 Private
->Signature
= QEMU_VIDEO_PRIVATE_DATA_SIGNATURE
;
215 // Open PCI I/O Protocol
217 Status
= gBS
->OpenProtocol (
219 &gEfiPciIoProtocolGuid
,
220 (VOID
**) &Private
->PciIo
,
221 This
->DriverBindingHandle
,
223 EFI_OPEN_PROTOCOL_BY_DRIVER
225 if (EFI_ERROR (Status
)) {
230 // Read the PCI Configuration Header from the PCI Device
232 Status
= Private
->PciIo
->Pci
.Read (
236 sizeof (Pci
) / sizeof (UINT32
),
239 if (EFI_ERROR (Status
)) {
244 // Determine card variant.
246 Card
= QemuVideoDetect(Pci
.Hdr
.VendorId
, Pci
.Hdr
.DeviceId
);
248 Status
= EFI_DEVICE_ERROR
;
251 Private
->Variant
= Card
->Variant
;
252 Private
->FrameBufferVramBarIndex
= PCI_BAR_IDX0
;
255 // IsQxl is based on the detected Card->Variant, which at a later point might
256 // not match Private->Variant.
258 IsQxl
= (BOOLEAN
)(Card
->Variant
== QEMU_VIDEO_BOCHS
);
261 // Save original PCI attributes
263 Status
= Private
->PciIo
->Attributes (
265 EfiPciIoAttributeOperationGet
,
267 &Private
->OriginalPciAttributes
270 if (EFI_ERROR (Status
)) {
275 // Set new PCI attributes
277 Status
= Private
->PciIo
->Attributes (
279 EfiPciIoAttributeOperationEnable
,
280 EFI_PCI_DEVICE_ENABLE
| EFI_PCI_IO_ATTRIBUTE_VGA_MEMORY
| EFI_PCI_IO_ATTRIBUTE_VGA_IO
,
283 if (EFI_ERROR (Status
)) {
288 // Check whenever the qemu stdvga mmio bar is present (qemu 1.3+).
290 if (Private
->Variant
== QEMU_VIDEO_BOCHS_MMIO
) {
291 EFI_ACPI_ADDRESS_SPACE_DESCRIPTOR
*MmioDesc
;
293 Status
= Private
->PciIo
->GetBarAttributes (
299 if (EFI_ERROR (Status
) ||
300 MmioDesc
->ResType
!= ACPI_ADDRESS_SPACE_TYPE_MEM
) {
301 DEBUG ((EFI_D_INFO
, "QemuVideo: No mmio bar, fallback to port io\n"));
302 Private
->Variant
= QEMU_VIDEO_BOCHS
;
304 DEBUG ((EFI_D_INFO
, "QemuVideo: Using mmio bar @ 0x%lx\n",
305 MmioDesc
->AddrRangeMin
));
308 if (!EFI_ERROR (Status
)) {
314 // Check if accessing the bochs interface works.
316 if (Private
->Variant
== QEMU_VIDEO_BOCHS_MMIO
||
317 Private
->Variant
== QEMU_VIDEO_BOCHS
) {
319 BochsId
= BochsRead(Private
, VBE_DISPI_INDEX_ID
);
320 if ((BochsId
& 0xFFF0) != VBE_DISPI_ID0
) {
321 DEBUG ((EFI_D_INFO
, "QemuVideo: BochsID mismatch (got 0x%x)\n", BochsId
));
322 Status
= EFI_DEVICE_ERROR
;
323 goto RestoreAttributes
;
328 // Check if accessing Vmware SVGA interface works
330 if (Private
->Variant
== QEMU_VIDEO_VMWARE_SVGA
) {
331 EFI_ACPI_ADDRESS_SPACE_DESCRIPTOR
*IoDesc
;
336 Status
= Private
->PciIo
->GetBarAttributes (
342 if (EFI_ERROR (Status
) ||
343 IoDesc
->ResType
!= ACPI_ADDRESS_SPACE_TYPE_IO
||
344 IoDesc
->AddrRangeMin
> MAX_UINT16
+ 1 - (VMWARE_SVGA_VALUE_PORT
+ 4)) {
345 if (IoDesc
!= NULL
) {
348 Status
= EFI_DEVICE_ERROR
;
349 goto RestoreAttributes
;
351 Private
->VmwareSvgaBasePort
= (UINT16
) IoDesc
->AddrRangeMin
;
354 TargetId
= VMWARE_SVGA_ID_2
;
356 VmwareSvgaWrite (Private
, VmwareSvgaRegId
, TargetId
);
357 SvgaIdRead
= VmwareSvgaRead (Private
, VmwareSvgaRegId
);
358 if ((SvgaIdRead
== TargetId
) || (TargetId
<= VMWARE_SVGA_ID_0
)) {
364 if (SvgaIdRead
!= TargetId
) {
367 "QemuVideo: QEMU_VIDEO_VMWARE_SVGA ID mismatch "
368 "(got 0x%x, base address 0x%x)\n",
370 Private
->VmwareSvgaBasePort
372 Status
= EFI_DEVICE_ERROR
;
373 goto RestoreAttributes
;
376 Private
->FrameBufferVramBarIndex
= PCI_BAR_IDX1
;
380 // Get ParentDevicePath
382 Status
= gBS
->HandleProtocol (
384 &gEfiDevicePathProtocolGuid
,
385 (VOID
**) &ParentDevicePath
387 if (EFI_ERROR (Status
)) {
388 goto RestoreAttributes
;
392 // Set Gop Device Path
394 ZeroMem (&AcpiDeviceNode
, sizeof (ACPI_ADR_DEVICE_PATH
));
395 AcpiDeviceNode
.Header
.Type
= ACPI_DEVICE_PATH
;
396 AcpiDeviceNode
.Header
.SubType
= ACPI_ADR_DP
;
397 AcpiDeviceNode
.ADR
= ACPI_DISPLAY_ADR (1, 0, 0, 1, 0, ACPI_ADR_DISPLAY_TYPE_VGA
, 0, 0);
398 SetDevicePathNodeLength (&AcpiDeviceNode
.Header
, sizeof (ACPI_ADR_DEVICE_PATH
));
400 Private
->GopDevicePath
= AppendDevicePathNode (
402 (EFI_DEVICE_PATH_PROTOCOL
*) &AcpiDeviceNode
404 if (Private
->GopDevicePath
== NULL
) {
405 Status
= EFI_OUT_OF_RESOURCES
;
406 goto RestoreAttributes
;
410 // Create new child handle and install the device path protocol on it.
412 Status
= gBS
->InstallMultipleProtocolInterfaces (
414 &gEfiDevicePathProtocolGuid
,
415 Private
->GopDevicePath
,
418 if (EFI_ERROR (Status
)) {
419 goto FreeGopDevicePath
;
423 // Construct video mode buffer
425 switch (Private
->Variant
) {
426 case QEMU_VIDEO_CIRRUS_5430
:
427 case QEMU_VIDEO_CIRRUS_5446
:
428 Status
= QemuVideoCirrusModeSetup (Private
);
430 case QEMU_VIDEO_BOCHS_MMIO
:
431 case QEMU_VIDEO_BOCHS
:
432 Status
= QemuVideoBochsModeSetup (Private
, IsQxl
);
434 case QEMU_VIDEO_VMWARE_SVGA
:
435 Status
= QemuVideoVmwareSvgaModeSetup (Private
);
439 Status
= EFI_DEVICE_ERROR
;
442 if (EFI_ERROR (Status
)) {
443 goto UninstallGopDevicePath
;
447 // Start the GOP software stack.
449 Status
= QemuVideoGraphicsOutputConstructor (Private
);
450 if (EFI_ERROR (Status
)) {
454 Status
= gBS
->InstallMultipleProtocolInterfaces (
456 &gEfiGraphicsOutputProtocolGuid
,
457 &Private
->GraphicsOutput
,
460 if (EFI_ERROR (Status
)) {
461 goto DestructQemuVideoGraphics
;
465 // Reference parent handle from child handle.
467 Status
= gBS
->OpenProtocol (
469 &gEfiPciIoProtocolGuid
,
470 (VOID
**) &ChildPciIo
,
471 This
->DriverBindingHandle
,
473 EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
475 if (EFI_ERROR (Status
)) {
479 #if defined MDE_CPU_IA32 || defined MDE_CPU_X64
480 if (Private
->Variant
== QEMU_VIDEO_BOCHS_MMIO
||
481 Private
->Variant
== QEMU_VIDEO_BOCHS
) {
482 InstallVbeShim (Card
->Name
, Private
->GraphicsOutput
.Mode
->FrameBufferBase
);
486 gBS
->RestoreTPL (OldTpl
);
490 gBS
->UninstallProtocolInterface (Private
->Handle
,
491 &gEfiGraphicsOutputProtocolGuid
, &Private
->GraphicsOutput
);
493 DestructQemuVideoGraphics
:
494 QemuVideoGraphicsOutputDestructor (Private
);
497 FreePool (Private
->ModeData
);
498 if (Private
->VmwareSvgaModeInfo
!= NULL
) {
499 FreePool (Private
->VmwareSvgaModeInfo
);
502 UninstallGopDevicePath
:
503 gBS
->UninstallProtocolInterface (Private
->Handle
,
504 &gEfiDevicePathProtocolGuid
, Private
->GopDevicePath
);
507 FreePool (Private
->GopDevicePath
);
510 Private
->PciIo
->Attributes (Private
->PciIo
, EfiPciIoAttributeOperationSet
,
511 Private
->OriginalPciAttributes
, NULL
);
514 gBS
->CloseProtocol (Controller
, &gEfiPciIoProtocolGuid
,
515 This
->DriverBindingHandle
, Controller
);
521 gBS
->RestoreTPL (OldTpl
);
529 @param This The USB bus driver binding protocol.
530 @param Controller The controller to release.
531 @param NumberOfChildren The number of children of this device that
532 opened the controller BY_CHILD.
533 @param ChildHandleBuffer The array of child handle.
535 @retval EFI_SUCCESS The controller or children are stopped.
536 @retval EFI_DEVICE_ERROR Failed to stop the driver.
541 QemuVideoControllerDriverStop (
542 IN EFI_DRIVER_BINDING_PROTOCOL
*This
,
543 IN EFI_HANDLE Controller
,
544 IN UINTN NumberOfChildren
,
545 IN EFI_HANDLE
*ChildHandleBuffer
548 EFI_GRAPHICS_OUTPUT_PROTOCOL
*GraphicsOutput
;
551 QEMU_VIDEO_PRIVATE_DATA
*Private
;
553 if (NumberOfChildren
== 0) {
555 // Close the PCI I/O Protocol
559 &gEfiPciIoProtocolGuid
,
560 This
->DriverBindingHandle
,
567 // free all resources for whose access we need the child handle, because the
568 // child handle is going away
570 ASSERT (NumberOfChildren
== 1);
571 Status
= gBS
->OpenProtocol (
572 ChildHandleBuffer
[0],
573 &gEfiGraphicsOutputProtocolGuid
,
574 (VOID
**) &GraphicsOutput
,
575 This
->DriverBindingHandle
,
577 EFI_OPEN_PROTOCOL_GET_PROTOCOL
579 if (EFI_ERROR (Status
)) {
584 // Get our private context information
586 Private
= QEMU_VIDEO_PRIVATE_DATA_FROM_GRAPHICS_OUTPUT_THIS (GraphicsOutput
);
587 ASSERT (Private
->Handle
== ChildHandleBuffer
[0]);
589 QemuVideoGraphicsOutputDestructor (Private
);
591 // Remove the GOP protocol interface from the system
593 Status
= gBS
->UninstallMultipleProtocolInterfaces (
595 &gEfiGraphicsOutputProtocolGuid
,
596 &Private
->GraphicsOutput
,
600 if (EFI_ERROR (Status
)) {
605 // Restore original PCI attributes
607 Private
->PciIo
->Attributes (
609 EfiPciIoAttributeOperationSet
,
610 Private
->OriginalPciAttributes
,
616 &gEfiPciIoProtocolGuid
,
617 This
->DriverBindingHandle
,
621 FreePool (Private
->ModeData
);
622 if (Private
->VmwareSvgaModeInfo
!= NULL
) {
623 FreePool (Private
->VmwareSvgaModeInfo
);
625 gBS
->UninstallProtocolInterface (Private
->Handle
,
626 &gEfiDevicePathProtocolGuid
, Private
->GopDevicePath
);
627 FreePool (Private
->GopDevicePath
);
630 // Free our instance data
632 gBS
->FreePool (Private
);
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
669 @param Data TODO: add argument description
671 TODO: add return values
676 QEMU_VIDEO_PRIVATE_DATA
*Private
,
681 Private
->PciIo
->Io
.Write (
684 EFI_PCI_IO_PASS_THROUGH_BAR
,
692 TODO: Add function description
694 @param Private TODO: add argument description
695 @param Address TODO: add argument description
697 TODO: add return values
702 QEMU_VIDEO_PRIVATE_DATA
*Private
,
708 Private
->PciIo
->Io
.Read (
711 EFI_PCI_IO_PASS_THROUGH_BAR
,
720 TODO: Add function description
722 @param Private TODO: add argument description
723 @param Address TODO: add argument description
725 TODO: add return values
730 QEMU_VIDEO_PRIVATE_DATA
*Private
,
736 Private
->PciIo
->Io
.Read (
739 EFI_PCI_IO_PASS_THROUGH_BAR
,
748 TODO: Add function description
750 @param Private TODO: add argument description
751 @param Index TODO: add argument description
752 @param Red TODO: add argument description
753 @param Green TODO: add argument description
754 @param Blue TODO: add argument description
756 TODO: add return values
761 QEMU_VIDEO_PRIVATE_DATA
*Private
,
768 VgaOutb (Private
, PALETTE_INDEX_REGISTER
, (UINT8
) Index
);
769 VgaOutb (Private
, PALETTE_DATA_REGISTER
, (UINT8
) (Red
>> 2));
770 VgaOutb (Private
, PALETTE_DATA_REGISTER
, (UINT8
) (Green
>> 2));
771 VgaOutb (Private
, PALETTE_DATA_REGISTER
, (UINT8
) (Blue
>> 2));
775 TODO: Add function description
777 @param Private TODO: add argument description
779 TODO: add return values
784 QEMU_VIDEO_PRIVATE_DATA
*Private
793 for (RedIndex
= 0; RedIndex
< 8; RedIndex
++) {
794 for (GreenIndex
= 0; GreenIndex
< 8; GreenIndex
++) {
795 for (BlueIndex
= 0; BlueIndex
< 4; BlueIndex
++) {
796 SetPaletteColor (Private
, Index
, (UINT8
) (RedIndex
<< 5), (UINT8
) (GreenIndex
<< 5), (UINT8
) (BlueIndex
<< 6));
804 TODO: Add function description
806 @param Private TODO: add argument description
808 TODO: add return values
813 QEMU_VIDEO_PRIVATE_DATA
*Private
819 Private
->PciIo
->Mem
.Write (
821 EfiPciIoWidthFillUint32
,
822 Private
->FrameBufferVramBarIndex
,
830 TODO: Add function description
832 @param Private TODO: add argument description
834 TODO: add return values
839 QEMU_VIDEO_PRIVATE_DATA
*Private
,
847 TODO: Add function description
849 @param Private TODO: add argument description
850 @param ModeData TODO: add argument description
852 TODO: add return values
856 InitializeCirrusGraphicsMode (
857 QEMU_VIDEO_PRIVATE_DATA
*Private
,
858 QEMU_VIDEO_CIRRUS_MODES
*ModeData
864 outw (Private
, SEQ_ADDRESS_REGISTER
, 0x1206);
865 outw (Private
, SEQ_ADDRESS_REGISTER
, 0x0012);
867 for (Index
= 0; Index
< 15; Index
++) {
868 outw (Private
, SEQ_ADDRESS_REGISTER
, ModeData
->SeqSettings
[Index
]);
871 if (Private
->Variant
== QEMU_VIDEO_CIRRUS_5430
) {
872 outb (Private
, SEQ_ADDRESS_REGISTER
, 0x0f);
873 Byte
= (UINT8
) ((inb (Private
, SEQ_DATA_REGISTER
) & 0xc7) ^ 0x30);
874 outb (Private
, SEQ_DATA_REGISTER
, Byte
);
877 outb (Private
, MISC_OUTPUT_REGISTER
, ModeData
->MiscSetting
);
878 outw (Private
, GRAPH_ADDRESS_REGISTER
, 0x0506);
879 outw (Private
, SEQ_ADDRESS_REGISTER
, 0x0300);
880 outw (Private
, CRTC_ADDRESS_REGISTER
, 0x2011);
882 for (Index
= 0; Index
< 28; Index
++) {
883 outw (Private
, CRTC_ADDRESS_REGISTER
, (UINT16
) ((ModeData
->CrtcSettings
[Index
] << 8) | Index
));
886 for (Index
= 0; Index
< 9; Index
++) {
887 outw (Private
, GRAPH_ADDRESS_REGISTER
, (UINT16
) ((GraphicsController
[Index
] << 8) | Index
));
890 inb (Private
, INPUT_STATUS_1_REGISTER
);
892 for (Index
= 0; Index
< 21; Index
++) {
893 outb (Private
, ATT_ADDRESS_REGISTER
, (UINT8
) Index
);
894 outb (Private
, ATT_ADDRESS_REGISTER
, AttributeController
[Index
]);
897 outb (Private
, ATT_ADDRESS_REGISTER
, 0x20);
899 outw (Private
, GRAPH_ADDRESS_REGISTER
, 0x0009);
900 outw (Private
, GRAPH_ADDRESS_REGISTER
, 0x000a);
901 outw (Private
, GRAPH_ADDRESS_REGISTER
, 0x000b);
902 outb (Private
, DAC_PIXEL_MASK_REGISTER
, 0xff);
904 SetDefaultPalette (Private
);
905 ClearScreen (Private
);
910 QEMU_VIDEO_PRIVATE_DATA
*Private
,
917 if (Private
->Variant
== QEMU_VIDEO_BOCHS_MMIO
) {
918 Status
= Private
->PciIo
->Mem
.Write (
926 ASSERT_EFI_ERROR (Status
);
928 outw (Private
, VBE_DISPI_IOPORT_INDEX
, Reg
);
929 outw (Private
, VBE_DISPI_IOPORT_DATA
, Data
);
935 QEMU_VIDEO_PRIVATE_DATA
*Private
,
942 if (Private
->Variant
== QEMU_VIDEO_BOCHS_MMIO
) {
943 Status
= Private
->PciIo
->Mem
.Read (
951 ASSERT_EFI_ERROR (Status
);
953 outw (Private
, VBE_DISPI_IOPORT_INDEX
, Reg
);
954 Data
= inw (Private
, VBE_DISPI_IOPORT_DATA
);
961 QEMU_VIDEO_PRIVATE_DATA
*Private
,
967 Private
->VmwareSvgaBasePort
+ VMWARE_SVGA_INDEX_PORT
,
971 Private
->VmwareSvgaBasePort
+ VMWARE_SVGA_VALUE_PORT
,
978 QEMU_VIDEO_PRIVATE_DATA
*Private
,
983 Private
->VmwareSvgaBasePort
+ VMWARE_SVGA_INDEX_PORT
,
986 return UnalignedIoRead32 (
987 Private
->VmwareSvgaBasePort
+ VMWARE_SVGA_VALUE_PORT
993 QEMU_VIDEO_PRIVATE_DATA
*Private
,
1000 if (Private
->Variant
== QEMU_VIDEO_BOCHS_MMIO
) {
1001 Status
= Private
->PciIo
->Mem
.Write (
1005 0x400 - 0x3c0 + Reg
,
1009 ASSERT_EFI_ERROR (Status
);
1011 outb (Private
, Reg
, Data
);
1016 InitializeBochsGraphicsMode (
1017 QEMU_VIDEO_PRIVATE_DATA
*Private
,
1018 QEMU_VIDEO_BOCHS_MODES
*ModeData
1021 DEBUG ((EFI_D_INFO
, "InitializeBochsGraphicsMode: %dx%d @ %d\n",
1022 ModeData
->Width
, ModeData
->Height
, ModeData
->ColorDepth
));
1025 VgaOutb (Private
, ATT_ADDRESS_REGISTER
, 0x20);
1027 BochsWrite (Private
, VBE_DISPI_INDEX_ENABLE
, 0);
1028 BochsWrite (Private
, VBE_DISPI_INDEX_BANK
, 0);
1029 BochsWrite (Private
, VBE_DISPI_INDEX_X_OFFSET
, 0);
1030 BochsWrite (Private
, VBE_DISPI_INDEX_Y_OFFSET
, 0);
1032 BochsWrite (Private
, VBE_DISPI_INDEX_BPP
, (UINT16
) ModeData
->ColorDepth
);
1033 BochsWrite (Private
, VBE_DISPI_INDEX_XRES
, (UINT16
) ModeData
->Width
);
1034 BochsWrite (Private
, VBE_DISPI_INDEX_VIRT_WIDTH
, (UINT16
) ModeData
->Width
);
1035 BochsWrite (Private
, VBE_DISPI_INDEX_YRES
, (UINT16
) ModeData
->Height
);
1036 BochsWrite (Private
, VBE_DISPI_INDEX_VIRT_HEIGHT
, (UINT16
) ModeData
->Height
);
1038 BochsWrite (Private
, VBE_DISPI_INDEX_ENABLE
,
1039 VBE_DISPI_ENABLED
| VBE_DISPI_LFB_ENABLED
);
1041 SetDefaultPalette (Private
);
1042 ClearScreen (Private
);
1046 InitializeVmwareSvgaGraphicsMode (
1047 QEMU_VIDEO_PRIVATE_DATA
*Private
,
1048 QEMU_VIDEO_BOCHS_MODES
*ModeData
1051 UINT32 Capabilities
;
1053 VmwareSvgaWrite (Private
, VmwareSvgaRegWidth
, ModeData
->Width
);
1054 VmwareSvgaWrite (Private
, VmwareSvgaRegHeight
, ModeData
->Height
);
1056 Capabilities
= VmwareSvgaRead (
1058 VmwareSvgaRegCapabilities
1060 if ((Capabilities
& VMWARE_SVGA_CAP_8BIT_EMULATION
) != 0) {
1063 VmwareSvgaRegBitsPerPixel
,
1064 ModeData
->ColorDepth
1068 VmwareSvgaWrite (Private
, VmwareSvgaRegEnable
, 1);
1070 SetDefaultPalette (Private
);
1071 ClearScreen (Private
);
1076 InitializeQemuVideo (
1077 IN EFI_HANDLE ImageHandle
,
1078 IN EFI_SYSTEM_TABLE
*SystemTable
1083 Status
= EfiLibInstallDriverBindingComponentName2 (
1086 &gQemuVideoDriverBinding
,
1088 &gQemuVideoComponentName
,
1089 &gQemuVideoComponentName2
1091 ASSERT_EFI_ERROR (Status
);
1094 // Install EFI Driver Supported EFI Version Protocol required for
1095 // EFI drivers that are on PCI and other plug in cards.
1097 gQemuVideoDriverSupportedEfiVersion
.FirmwareVersion
= PcdGet32 (PcdDriverSupportedEfiVersion
);
1098 Status
= gBS
->InstallMultipleProtocolInterfaces (
1100 &gEfiDriverSupportedEfiVersionProtocolGuid
,
1101 &gQemuVideoDriverSupportedEfiVersion
,
1104 ASSERT_EFI_ERROR (Status
);