VirtualBox

source: vbox/trunk/src/VBox/Devices/EFI/FirmwareNew/OvmfPkg/QemuVideoDxe/Driver.c@ 99396

Last change on this file since 99396 was 85718, checked in by vboxsync, 4 years ago

Devices/EFI: Merge edk-stable202005 and make it build, bugref:4643
  • Property svn:eol-style set to native
File size: 25.1 KB
Line 
1/** @file
2 This driver is a sample implementation of the Graphics Output Protocol for
3 the QEMU (Cirrus Logic 5446) video controller.
4
5 Copyright (c) 2006 - 2019, Intel Corporation. All rights reserved.<BR>
6
7 SPDX-License-Identifier: BSD-2-Clause-Patent
8
9**/
10
11#include "Qemu.h"
12#include <IndustryStandard/Acpi.h>
13
14EFI_DRIVER_BINDING_PROTOCOL gQemuVideoDriverBinding = {
15 QemuVideoControllerDriverSupported,
16 QemuVideoControllerDriverStart,
17 QemuVideoControllerDriverStop,
18 0x10,
19 NULL,
20 NULL
21};
22
23QEMU_VIDEO_CARD gQemuVideoCardList[] = {
24 {
25 PCI_CLASS_DISPLAY_VGA,
26 CIRRUS_LOGIC_VENDOR_ID,
27 CIRRUS_LOGIC_5430_DEVICE_ID,
28 QEMU_VIDEO_CIRRUS_5430,
29 L"Cirrus 5430"
30 },{
31 PCI_CLASS_DISPLAY_VGA,
32 CIRRUS_LOGIC_VENDOR_ID,
33 CIRRUS_LOGIC_5430_ALTERNATE_DEVICE_ID,
34 QEMU_VIDEO_CIRRUS_5430,
35 L"Cirrus 5430"
36 },{
37 PCI_CLASS_DISPLAY_VGA,
38 CIRRUS_LOGIC_VENDOR_ID,
39 CIRRUS_LOGIC_5446_DEVICE_ID,
40 QEMU_VIDEO_CIRRUS_5446,
41 L"Cirrus 5446"
42 },{
43 PCI_CLASS_DISPLAY_VGA,
44 0x1234,
45 0x1111,
46 QEMU_VIDEO_BOCHS_MMIO,
47 L"QEMU Standard VGA"
48 },{
49 PCI_CLASS_DISPLAY_OTHER,
50 0x1234,
51 0x1111,
52 QEMU_VIDEO_BOCHS_MMIO,
53 L"QEMU Standard VGA (secondary)"
54 },{
55 PCI_CLASS_DISPLAY_VGA,
56 0x1b36,
57 0x0100,
58 QEMU_VIDEO_BOCHS,
59 L"QEMU QXL VGA"
60 },{
61 PCI_CLASS_DISPLAY_VGA,
62 0x1af4,
63 0x1050,
64 QEMU_VIDEO_BOCHS_MMIO,
65 L"QEMU VirtIO VGA"
66 },{
67 PCI_CLASS_DISPLAY_VGA,
68 0x15ad,
69 0x0405,
70 QEMU_VIDEO_VMWARE_SVGA,
71 L"QEMU VMWare SVGA"
72 },{
73 0 /* end of list */
74 }
75};
76
77static QEMU_VIDEO_CARD*
78QemuVideoDetect(
79 IN UINT8 SubClass,
80 IN UINT16 VendorId,
81 IN UINT16 DeviceId
82 )
83{
84 UINTN Index = 0;
85
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;
91 }
92 Index++;
93 }
94 return NULL;
95}
96
97/**
98 Check if this device is supported.
99
100 @param This The driver binding protocol.
101 @param Controller The controller handle to check.
102 @param RemainingDevicePath The remaining device path.
103
104 @retval EFI_SUCCESS The bus supports this controller.
105 @retval EFI_UNSUPPORTED This device isn't supported.
106
107**/
108EFI_STATUS
109EFIAPI
110QemuVideoControllerDriverSupported (
111 IN EFI_DRIVER_BINDING_PROTOCOL *This,
112 IN EFI_HANDLE Controller,
113 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
114 )
115{
116 EFI_STATUS Status;
117 EFI_PCI_IO_PROTOCOL *PciIo;
118 PCI_TYPE00 Pci;
119 QEMU_VIDEO_CARD *Card;
120
121 //
122 // Open the PCI I/O Protocol
123 //
124 Status = gBS->OpenProtocol (
125 Controller,
126 &gEfiPciIoProtocolGuid,
127 (VOID **) &PciIo,
128 This->DriverBindingHandle,
129 Controller,
130 EFI_OPEN_PROTOCOL_BY_DRIVER
131 );
132 if (EFI_ERROR (Status)) {
133 return Status;
134 }
135
136 //
137 // Read the PCI Configuration Header from the PCI Device
138 //
139 Status = PciIo->Pci.Read (
140 PciIo,
141 EfiPciIoWidthUint32,
142 0,
143 sizeof (Pci) / sizeof (UINT32),
144 &Pci
145 );
146 if (EFI_ERROR (Status)) {
147 goto Done;
148 }
149
150 Status = EFI_UNSUPPORTED;
151 if (!IS_PCI_DISPLAY (&Pci)) {
152 goto Done;
153 }
154 Card = QemuVideoDetect(Pci.Hdr.ClassCode[1], Pci.Hdr.VendorId, Pci.Hdr.DeviceId);
155 if (Card != NULL) {
156 DEBUG ((DEBUG_INFO, "QemuVideo: %s detected\n", Card->Name));
157 Status = EFI_SUCCESS;
158 }
159
160Done:
161 //
162 // Close the PCI I/O Protocol
163 //
164 gBS->CloseProtocol (
165 Controller,
166 &gEfiPciIoProtocolGuid,
167 This->DriverBindingHandle,
168 Controller
169 );
170
171 return Status;
172}
173
174/**
175 Start to process the controller.
176
177 @param This The USB bus driver binding instance.
178 @param Controller The controller to check.
179 @param RemainingDevicePath The remaining device patch.
180
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
183 bus.
184 @retval EFI_OUT_OF_RESOURCES Failed to allocate resources.
185
186**/
187EFI_STATUS
188EFIAPI
189QemuVideoControllerDriverStart (
190 IN EFI_DRIVER_BINDING_PROTOCOL *This,
191 IN EFI_HANDLE Controller,
192 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
193 )
194{
195 EFI_TPL OldTpl;
196 EFI_STATUS Status;
197 QEMU_VIDEO_PRIVATE_DATA *Private;
198 BOOLEAN IsQxl;
199 EFI_DEVICE_PATH_PROTOCOL *ParentDevicePath;
200 ACPI_ADR_DEVICE_PATH AcpiDeviceNode;
201 PCI_TYPE00 Pci;
202 QEMU_VIDEO_CARD *Card;
203 EFI_PCI_IO_PROTOCOL *ChildPciIo;
204 UINT64 SupportedVgaIo;
205
206 OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
207
208 //
209 // Allocate Private context data for GOP interface.
210 //
211 Private = AllocateZeroPool (sizeof (QEMU_VIDEO_PRIVATE_DATA));
212 if (Private == NULL) {
213 Status = EFI_OUT_OF_RESOURCES;
214 goto RestoreTpl;
215 }
216
217 //
218 // Set up context record
219 //
220 Private->Signature = QEMU_VIDEO_PRIVATE_DATA_SIGNATURE;
221
222 //
223 // Open PCI I/O Protocol
224 //
225 Status = gBS->OpenProtocol (
226 Controller,
227 &gEfiPciIoProtocolGuid,
228 (VOID **) &Private->PciIo,
229 This->DriverBindingHandle,
230 Controller,
231 EFI_OPEN_PROTOCOL_BY_DRIVER
232 );
233 if (EFI_ERROR (Status)) {
234 goto FreePrivate;
235 }
236
237 //
238 // Read the PCI Configuration Header from the PCI Device
239 //
240 Status = Private->PciIo->Pci.Read (
241 Private->PciIo,
242 EfiPciIoWidthUint32,
243 0,
244 sizeof (Pci) / sizeof (UINT32),
245 &Pci
246 );
247 if (EFI_ERROR (Status)) {
248 goto ClosePciIo;
249 }
250
251 //
252 // Determine card variant.
253 //
254 Card = QemuVideoDetect(Pci.Hdr.ClassCode[1], Pci.Hdr.VendorId, Pci.Hdr.DeviceId);
255 if (Card == NULL) {
256 Status = EFI_DEVICE_ERROR;
257 goto ClosePciIo;
258 }
259 Private->Variant = Card->Variant;
260
261 //
262 // IsQxl is based on the detected Card->Variant, which at a later point might
263 // not match Private->Variant.
264 //
265 IsQxl = (BOOLEAN)(Card->Variant == QEMU_VIDEO_BOCHS);
266
267 //
268 // Save original PCI attributes
269 //
270 Status = Private->PciIo->Attributes (
271 Private->PciIo,
272 EfiPciIoAttributeOperationGet,
273 0,
274 &Private->OriginalPciAttributes
275 );
276
277 if (EFI_ERROR (Status)) {
278 goto ClosePciIo;
279 }
280
281 //
282 // Get supported PCI attributes
283 //
284 Status = Private->PciIo->Attributes (
285 Private->PciIo,
286 EfiPciIoAttributeOperationSupported,
287 0,
288 &SupportedVgaIo
289 );
290 if (EFI_ERROR (Status)) {
291 goto ClosePciIo;
292 }
293
294 SupportedVgaIo &= (UINT64)(EFI_PCI_IO_ATTRIBUTE_VGA_IO | EFI_PCI_IO_ATTRIBUTE_VGA_IO_16);
295 if (SupportedVgaIo == 0 && IS_PCI_VGA (&Pci)) {
296 Status = EFI_UNSUPPORTED;
297 goto ClosePciIo;
298 }
299
300 //
301 // Set new PCI attributes
302 //
303 Status = Private->PciIo->Attributes (
304 Private->PciIo,
305 EfiPciIoAttributeOperationEnable,
306 EFI_PCI_DEVICE_ENABLE | EFI_PCI_IO_ATTRIBUTE_VGA_MEMORY | SupportedVgaIo,
307 NULL
308 );
309 if (EFI_ERROR (Status)) {
310 goto ClosePciIo;
311 }
312
313 //
314 // Check whenever the qemu stdvga mmio bar is present (qemu 1.3+).
315 //
316 if (Private->Variant == QEMU_VIDEO_BOCHS_MMIO) {
317 EFI_ACPI_ADDRESS_SPACE_DESCRIPTOR *MmioDesc;
318
319 Status = Private->PciIo->GetBarAttributes (
320 Private->PciIo,
321 PCI_BAR_IDX2,
322 NULL,
323 (VOID**) &MmioDesc
324 );
325 if (EFI_ERROR (Status) ||
326 MmioDesc->ResType != ACPI_ADDRESS_SPACE_TYPE_MEM) {
327 DEBUG ((DEBUG_INFO, "QemuVideo: No mmio bar, fallback to port io\n"));
328 Private->Variant = QEMU_VIDEO_BOCHS;
329 } else {
330 DEBUG ((DEBUG_INFO, "QemuVideo: Using mmio bar @ 0x%lx\n",
331 MmioDesc->AddrRangeMin));
332 }
333
334 if (!EFI_ERROR (Status)) {
335 FreePool (MmioDesc);
336 }
337 }
338
339 //
340 // VMWare SVGA is handled like Bochs (with port IO only).
341 //
342 if (Private->Variant == QEMU_VIDEO_VMWARE_SVGA) {
343 Private->Variant = QEMU_VIDEO_BOCHS;
344 Private->FrameBufferVramBarIndex = PCI_BAR_IDX1;
345 }
346
347 //
348 // Check if accessing the bochs interface works.
349 //
350 if (Private->Variant == QEMU_VIDEO_BOCHS_MMIO ||
351 Private->Variant == QEMU_VIDEO_BOCHS) {
352 UINT16 BochsId;
353 BochsId = BochsRead(Private, VBE_DISPI_INDEX_ID);
354 if ((BochsId & 0xFFF0) != VBE_DISPI_ID0) {
355 DEBUG ((DEBUG_INFO, "QemuVideo: BochsID mismatch (got 0x%x)\n", BochsId));
356 Status = EFI_DEVICE_ERROR;
357 goto RestoreAttributes;
358 }
359 }
360
361 //
362 // Get ParentDevicePath
363 //
364 Status = gBS->HandleProtocol (
365 Controller,
366 &gEfiDevicePathProtocolGuid,
367 (VOID **) &ParentDevicePath
368 );
369 if (EFI_ERROR (Status)) {
370 goto RestoreAttributes;
371 }
372
373 //
374 // Set Gop Device Path
375 //
376 ZeroMem (&AcpiDeviceNode, sizeof (ACPI_ADR_DEVICE_PATH));
377 AcpiDeviceNode.Header.Type = ACPI_DEVICE_PATH;
378 AcpiDeviceNode.Header.SubType = ACPI_ADR_DP;
379 AcpiDeviceNode.ADR = ACPI_DISPLAY_ADR (1, 0, 0, 1, 0, ACPI_ADR_DISPLAY_TYPE_VGA, 0, 0);
380 SetDevicePathNodeLength (&AcpiDeviceNode.Header, sizeof (ACPI_ADR_DEVICE_PATH));
381
382 Private->GopDevicePath = AppendDevicePathNode (
383 ParentDevicePath,
384 (EFI_DEVICE_PATH_PROTOCOL *) &AcpiDeviceNode
385 );
386 if (Private->GopDevicePath == NULL) {
387 Status = EFI_OUT_OF_RESOURCES;
388 goto RestoreAttributes;
389 }
390
391 //
392 // Create new child handle and install the device path protocol on it.
393 //
394 Status = gBS->InstallMultipleProtocolInterfaces (
395 &Private->Handle,
396 &gEfiDevicePathProtocolGuid,
397 Private->GopDevicePath,
398 NULL
399 );
400 if (EFI_ERROR (Status)) {
401 goto FreeGopDevicePath;
402 }
403
404 //
405 // Construct video mode buffer
406 //
407 switch (Private->Variant) {
408 case QEMU_VIDEO_CIRRUS_5430:
409 case QEMU_VIDEO_CIRRUS_5446:
410 Status = QemuVideoCirrusModeSetup (Private);
411 break;
412 case QEMU_VIDEO_BOCHS_MMIO:
413 case QEMU_VIDEO_BOCHS:
414 Status = QemuVideoBochsModeSetup (Private, IsQxl);
415 break;
416 default:
417 ASSERT (FALSE);
418 Status = EFI_DEVICE_ERROR;
419 break;
420 }
421 if (EFI_ERROR (Status)) {
422 goto UninstallGopDevicePath;
423 }
424
425 //
426 // Start the GOP software stack.
427 //
428 Status = QemuVideoGraphicsOutputConstructor (Private);
429 if (EFI_ERROR (Status)) {
430 goto FreeModeData;
431 }
432
433 Status = gBS->InstallMultipleProtocolInterfaces (
434 &Private->Handle,
435 &gEfiGraphicsOutputProtocolGuid,
436 &Private->GraphicsOutput,
437 NULL
438 );
439 if (EFI_ERROR (Status)) {
440 goto DestructQemuVideoGraphics;
441 }
442
443 //
444 // Reference parent handle from child handle.
445 //
446 Status = gBS->OpenProtocol (
447 Controller,
448 &gEfiPciIoProtocolGuid,
449 (VOID **) &ChildPciIo,
450 This->DriverBindingHandle,
451 Private->Handle,
452 EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
453 );
454 if (EFI_ERROR (Status)) {
455 goto UninstallGop;
456 }
457
458#if defined MDE_CPU_IA32 || defined MDE_CPU_X64
459 if (Private->Variant == QEMU_VIDEO_BOCHS_MMIO ||
460 Private->Variant == QEMU_VIDEO_BOCHS) {
461 InstallVbeShim (Card->Name, Private->GraphicsOutput.Mode->FrameBufferBase);
462 }
463#endif
464
465 gBS->RestoreTPL (OldTpl);
466 return EFI_SUCCESS;
467
468UninstallGop:
469 gBS->UninstallProtocolInterface (Private->Handle,
470 &gEfiGraphicsOutputProtocolGuid, &Private->GraphicsOutput);
471
472DestructQemuVideoGraphics:
473 QemuVideoGraphicsOutputDestructor (Private);
474
475FreeModeData:
476 FreePool (Private->ModeData);
477
478UninstallGopDevicePath:
479 gBS->UninstallProtocolInterface (Private->Handle,
480 &gEfiDevicePathProtocolGuid, Private->GopDevicePath);
481
482FreeGopDevicePath:
483 FreePool (Private->GopDevicePath);
484
485RestoreAttributes:
486 Private->PciIo->Attributes (Private->PciIo, EfiPciIoAttributeOperationSet,
487 Private->OriginalPciAttributes, NULL);
488
489ClosePciIo:
490 gBS->CloseProtocol (Controller, &gEfiPciIoProtocolGuid,
491 This->DriverBindingHandle, Controller);
492
493FreePrivate:
494 FreePool (Private);
495
496RestoreTpl:
497 gBS->RestoreTPL (OldTpl);
498
499 return Status;
500}
501
502/**
503 Stop this device
504
505 @param This The USB bus driver binding protocol.
506 @param Controller The controller to release.
507 @param NumberOfChildren The number of children of this device that
508 opened the controller BY_CHILD.
509 @param ChildHandleBuffer The array of child handle.
510
511 @retval EFI_SUCCESS The controller or children are stopped.
512 @retval EFI_DEVICE_ERROR Failed to stop the driver.
513
514**/
515EFI_STATUS
516EFIAPI
517QemuVideoControllerDriverStop (
518 IN EFI_DRIVER_BINDING_PROTOCOL *This,
519 IN EFI_HANDLE Controller,
520 IN UINTN NumberOfChildren,
521 IN EFI_HANDLE *ChildHandleBuffer
522 )
523{
524 EFI_GRAPHICS_OUTPUT_PROTOCOL *GraphicsOutput;
525
526 EFI_STATUS Status;
527 QEMU_VIDEO_PRIVATE_DATA *Private;
528
529 if (NumberOfChildren == 0) {
530 //
531 // Close the PCI I/O Protocol
532 //
533 gBS->CloseProtocol (
534 Controller,
535 &gEfiPciIoProtocolGuid,
536 This->DriverBindingHandle,
537 Controller
538 );
539 return EFI_SUCCESS;
540 }
541
542 //
543 // free all resources for whose access we need the child handle, because the
544 // child handle is going away
545 //
546 ASSERT (NumberOfChildren == 1);
547 Status = gBS->OpenProtocol (
548 ChildHandleBuffer[0],
549 &gEfiGraphicsOutputProtocolGuid,
550 (VOID **) &GraphicsOutput,
551 This->DriverBindingHandle,
552 Controller,
553 EFI_OPEN_PROTOCOL_GET_PROTOCOL
554 );
555 if (EFI_ERROR (Status)) {
556 return Status;
557 }
558
559 //
560 // Get our private context information
561 //
562 Private = QEMU_VIDEO_PRIVATE_DATA_FROM_GRAPHICS_OUTPUT_THIS (GraphicsOutput);
563 ASSERT (Private->Handle == ChildHandleBuffer[0]);
564
565 QemuVideoGraphicsOutputDestructor (Private);
566 //
567 // Remove the GOP protocol interface from the system
568 //
569 Status = gBS->UninstallMultipleProtocolInterfaces (
570 Private->Handle,
571 &gEfiGraphicsOutputProtocolGuid,
572 &Private->GraphicsOutput,
573 NULL
574 );
575
576 if (EFI_ERROR (Status)) {
577 return Status;
578 }
579
580 //
581 // Restore original PCI attributes
582 //
583 Private->PciIo->Attributes (
584 Private->PciIo,
585 EfiPciIoAttributeOperationSet,
586 Private->OriginalPciAttributes,
587 NULL
588 );
589
590 gBS->CloseProtocol (
591 Controller,
592 &gEfiPciIoProtocolGuid,
593 This->DriverBindingHandle,
594 Private->Handle
595 );
596
597 FreePool (Private->ModeData);
598 gBS->UninstallProtocolInterface (Private->Handle,
599 &gEfiDevicePathProtocolGuid, Private->GopDevicePath);
600 FreePool (Private->GopDevicePath);
601
602 //
603 // Free our instance data
604 //
605 gBS->FreePool (Private);
606
607 return EFI_SUCCESS;
608}
609
610/**
611 TODO: Add function description
612
613 @param Private TODO: add argument description
614 @param Address TODO: add argument description
615 @param Data TODO: add argument description
616
617 TODO: add return values
618
619**/
620VOID
621outb (
622 QEMU_VIDEO_PRIVATE_DATA *Private,
623 UINTN Address,
624 UINT8 Data
625 )
626{
627 Private->PciIo->Io.Write (
628 Private->PciIo,
629 EfiPciIoWidthUint8,
630 EFI_PCI_IO_PASS_THROUGH_BAR,
631 Address,
632 1,
633 &Data
634 );
635}
636
637/**
638 TODO: Add function description
639
640 @param Private TODO: add argument description
641 @param Address TODO: add argument description
642 @param Data TODO: add argument description
643
644 TODO: add return values
645
646**/
647VOID
648outw (
649 QEMU_VIDEO_PRIVATE_DATA *Private,
650 UINTN Address,
651 UINT16 Data
652 )
653{
654 Private->PciIo->Io.Write (
655 Private->PciIo,
656 EfiPciIoWidthUint16,
657 EFI_PCI_IO_PASS_THROUGH_BAR,
658 Address,
659 1,
660 &Data
661 );
662}
663
664/**
665 TODO: Add function description
666
667 @param Private TODO: add argument description
668 @param Address TODO: add argument description
669
670 TODO: add return values
671
672**/
673UINT8
674inb (
675 QEMU_VIDEO_PRIVATE_DATA *Private,
676 UINTN Address
677 )
678{
679 UINT8 Data;
680
681 Private->PciIo->Io.Read (
682 Private->PciIo,
683 EfiPciIoWidthUint8,
684 EFI_PCI_IO_PASS_THROUGH_BAR,
685 Address,
686 1,
687 &Data
688 );
689 return Data;
690}
691
692/**
693 TODO: Add function description
694
695 @param Private TODO: add argument description
696 @param Address TODO: add argument description
697
698 TODO: add return values
699
700**/
701UINT16
702inw (
703 QEMU_VIDEO_PRIVATE_DATA *Private,
704 UINTN Address
705 )
706{
707 UINT16 Data;
708
709 Private->PciIo->Io.Read (
710 Private->PciIo,
711 EfiPciIoWidthUint16,
712 EFI_PCI_IO_PASS_THROUGH_BAR,
713 Address,
714 1,
715 &Data
716 );
717 return Data;
718}
719
720/**
721 TODO: Add function description
722
723 @param Private TODO: add argument description
724 @param Index TODO: add argument description
725 @param Red TODO: add argument description
726 @param Green TODO: add argument description
727 @param Blue TODO: add argument description
728
729 TODO: add return values
730
731**/
732VOID
733SetPaletteColor (
734 QEMU_VIDEO_PRIVATE_DATA *Private,
735 UINTN Index,
736 UINT8 Red,
737 UINT8 Green,
738 UINT8 Blue
739 )
740{
741 VgaOutb (Private, PALETTE_INDEX_REGISTER, (UINT8) Index);
742 VgaOutb (Private, PALETTE_DATA_REGISTER, (UINT8) (Red >> 2));
743 VgaOutb (Private, PALETTE_DATA_REGISTER, (UINT8) (Green >> 2));
744 VgaOutb (Private, PALETTE_DATA_REGISTER, (UINT8) (Blue >> 2));
745}
746
747/**
748 TODO: Add function description
749
750 @param Private TODO: add argument description
751
752 TODO: add return values
753
754**/
755VOID
756SetDefaultPalette (
757 QEMU_VIDEO_PRIVATE_DATA *Private
758 )
759{
760 UINTN Index;
761 UINTN RedIndex;
762 UINTN GreenIndex;
763 UINTN BlueIndex;
764
765 Index = 0;
766 for (RedIndex = 0; RedIndex < 8; RedIndex++) {
767 for (GreenIndex = 0; GreenIndex < 8; GreenIndex++) {
768 for (BlueIndex = 0; BlueIndex < 4; BlueIndex++) {
769 SetPaletteColor (Private, Index, (UINT8) (RedIndex << 5), (UINT8) (GreenIndex << 5), (UINT8) (BlueIndex << 6));
770 Index++;
771 }
772 }
773 }
774}
775
776/**
777 TODO: Add function description
778
779 @param Private TODO: add argument description
780
781 TODO: add return values
782
783**/
784VOID
785ClearScreen (
786 QEMU_VIDEO_PRIVATE_DATA *Private
787 )
788{
789 UINT32 Color;
790
791 Color = 0;
792 Private->PciIo->Mem.Write (
793 Private->PciIo,
794 EfiPciIoWidthFillUint32,
795 Private->FrameBufferVramBarIndex,
796 0,
797 0x400000 >> 2,
798 &Color
799 );
800}
801
802/**
803 TODO: Add function description
804
805 @param Private TODO: add argument description
806
807 TODO: add return values
808
809**/
810VOID
811DrawLogo (
812 QEMU_VIDEO_PRIVATE_DATA *Private,
813 UINTN ScreenWidth,
814 UINTN ScreenHeight
815 )
816{
817}
818
819/**
820 TODO: Add function description
821
822 @param Private TODO: add argument description
823 @param ModeData TODO: add argument description
824
825 TODO: add return values
826
827**/
828VOID
829InitializeCirrusGraphicsMode (
830 QEMU_VIDEO_PRIVATE_DATA *Private,
831 QEMU_VIDEO_CIRRUS_MODES *ModeData
832 )
833{
834 UINT8 Byte;
835 UINTN Index;
836
837 outw (Private, SEQ_ADDRESS_REGISTER, 0x1206);
838 outw (Private, SEQ_ADDRESS_REGISTER, 0x0012);
839
840 for (Index = 0; Index < 15; Index++) {
841 outw (Private, SEQ_ADDRESS_REGISTER, ModeData->SeqSettings[Index]);
842 }
843
844 if (Private->Variant == QEMU_VIDEO_CIRRUS_5430) {
845 outb (Private, SEQ_ADDRESS_REGISTER, 0x0f);
846 Byte = (UINT8) ((inb (Private, SEQ_DATA_REGISTER) & 0xc7) ^ 0x30);
847 outb (Private, SEQ_DATA_REGISTER, Byte);
848 }
849
850 outb (Private, MISC_OUTPUT_REGISTER, ModeData->MiscSetting);
851 outw (Private, GRAPH_ADDRESS_REGISTER, 0x0506);
852 outw (Private, SEQ_ADDRESS_REGISTER, 0x0300);
853 outw (Private, CRTC_ADDRESS_REGISTER, 0x2011);
854
855 for (Index = 0; Index < 28; Index++) {
856 outw (Private, CRTC_ADDRESS_REGISTER, (UINT16) ((ModeData->CrtcSettings[Index] << 8) | Index));
857 }
858
859 for (Index = 0; Index < 9; Index++) {
860 outw (Private, GRAPH_ADDRESS_REGISTER, (UINT16) ((GraphicsController[Index] << 8) | Index));
861 }
862
863 inb (Private, INPUT_STATUS_1_REGISTER);
864
865 for (Index = 0; Index < 21; Index++) {
866 outb (Private, ATT_ADDRESS_REGISTER, (UINT8) Index);
867 outb (Private, ATT_ADDRESS_REGISTER, AttributeController[Index]);
868 }
869
870 outb (Private, ATT_ADDRESS_REGISTER, 0x20);
871
872 outw (Private, GRAPH_ADDRESS_REGISTER, 0x0009);
873 outw (Private, GRAPH_ADDRESS_REGISTER, 0x000a);
874 outw (Private, GRAPH_ADDRESS_REGISTER, 0x000b);
875 outb (Private, DAC_PIXEL_MASK_REGISTER, 0xff);
876
877 SetDefaultPalette (Private);
878 ClearScreen (Private);
879}
880
881VOID
882BochsWrite (
883 QEMU_VIDEO_PRIVATE_DATA *Private,
884 UINT16 Reg,
885 UINT16 Data
886 )
887{
888 EFI_STATUS Status;
889
890 if (Private->Variant == QEMU_VIDEO_BOCHS_MMIO) {
891 Status = Private->PciIo->Mem.Write (
892 Private->PciIo,
893 EfiPciIoWidthUint16,
894 PCI_BAR_IDX2,
895 0x500 + (Reg << 1),
896 1,
897 &Data
898 );
899 ASSERT_EFI_ERROR (Status);
900 } else {
901 outw (Private, VBE_DISPI_IOPORT_INDEX, Reg);
902 outw (Private, VBE_DISPI_IOPORT_DATA, Data);
903 }
904}
905
906UINT16
907BochsRead (
908 QEMU_VIDEO_PRIVATE_DATA *Private,
909 UINT16 Reg
910 )
911{
912 EFI_STATUS Status;
913 UINT16 Data;
914
915 if (Private->Variant == QEMU_VIDEO_BOCHS_MMIO) {
916 Status = Private->PciIo->Mem.Read (
917 Private->PciIo,
918 EfiPciIoWidthUint16,
919 PCI_BAR_IDX2,
920 0x500 + (Reg << 1),
921 1,
922 &Data
923 );
924 ASSERT_EFI_ERROR (Status);
925 } else {
926 outw (Private, VBE_DISPI_IOPORT_INDEX, Reg);
927 Data = inw (Private, VBE_DISPI_IOPORT_DATA);
928 }
929 return Data;
930}
931
932VOID
933VgaOutb (
934 QEMU_VIDEO_PRIVATE_DATA *Private,
935 UINTN Reg,
936 UINT8 Data
937 )
938{
939 EFI_STATUS Status;
940
941 if (Private->Variant == QEMU_VIDEO_BOCHS_MMIO) {
942 Status = Private->PciIo->Mem.Write (
943 Private->PciIo,
944 EfiPciIoWidthUint8,
945 PCI_BAR_IDX2,
946 0x400 - 0x3c0 + Reg,
947 1,
948 &Data
949 );
950 ASSERT_EFI_ERROR (Status);
951 } else {
952 outb (Private, Reg, Data);
953 }
954}
955
956VOID
957InitializeBochsGraphicsMode (
958 QEMU_VIDEO_PRIVATE_DATA *Private,
959 QEMU_VIDEO_BOCHS_MODES *ModeData
960 )
961{
962 DEBUG ((DEBUG_INFO, "InitializeBochsGraphicsMode: %dx%d @ %d\n",
963 ModeData->Width, ModeData->Height, ModeData->ColorDepth));
964
965 /* unblank */
966 VgaOutb (Private, ATT_ADDRESS_REGISTER, 0x20);
967
968 BochsWrite (Private, VBE_DISPI_INDEX_ENABLE, 0);
969 BochsWrite (Private, VBE_DISPI_INDEX_BANK, 0);
970 BochsWrite (Private, VBE_DISPI_INDEX_X_OFFSET, 0);
971 BochsWrite (Private, VBE_DISPI_INDEX_Y_OFFSET, 0);
972
973 BochsWrite (Private, VBE_DISPI_INDEX_BPP, (UINT16) ModeData->ColorDepth);
974 BochsWrite (Private, VBE_DISPI_INDEX_XRES, (UINT16) ModeData->Width);
975 BochsWrite (Private, VBE_DISPI_INDEX_VIRT_WIDTH, (UINT16) ModeData->Width);
976 BochsWrite (Private, VBE_DISPI_INDEX_YRES, (UINT16) ModeData->Height);
977 BochsWrite (Private, VBE_DISPI_INDEX_VIRT_HEIGHT, (UINT16) ModeData->Height);
978
979 BochsWrite (Private, VBE_DISPI_INDEX_ENABLE,
980 VBE_DISPI_ENABLED | VBE_DISPI_LFB_ENABLED);
981
982 SetDefaultPalette (Private);
983 ClearScreen (Private);
984}
985
986EFI_STATUS
987EFIAPI
988InitializeQemuVideo (
989 IN EFI_HANDLE ImageHandle,
990 IN EFI_SYSTEM_TABLE *SystemTable
991 )
992{
993 EFI_STATUS Status;
994
995 Status = EfiLibInstallDriverBindingComponentName2 (
996 ImageHandle,
997 SystemTable,
998 &gQemuVideoDriverBinding,
999 ImageHandle,
1000 &gQemuVideoComponentName,
1001 &gQemuVideoComponentName2
1002 );
1003 ASSERT_EFI_ERROR (Status);
1004
1005 return Status;
1006}
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette