VirtualBox

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

Last change on this file since 79205 was 77662, checked in by vboxsync, 6 years ago

EFI: First step in UDK2018 merge. Does not build yet.
  • Property svn:eol-style set to native
File size: 28.0 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 - 2010, Intel Corporation. All rights reserved.<BR>
6
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
11
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.
14
15**/
16
17#include <IndustryStandard/VmwareSvga.h>
18#include <IndustryStandard/Acpi.h>
19#include "Qemu.h"
20#include "UnalignedIoInternal.h"
21
22EFI_DRIVER_BINDING_PROTOCOL gQemuVideoDriverBinding = {
23 QemuVideoControllerDriverSupported,
24 QemuVideoControllerDriverStart,
25 QemuVideoControllerDriverStop,
26 0x10,
27 NULL,
28 NULL
29};
30
31QEMU_VIDEO_CARD gQemuVideoCardList[] = {
32 {
33 CIRRUS_LOGIC_VENDOR_ID,
34 CIRRUS_LOGIC_5430_DEVICE_ID,
35 QEMU_VIDEO_CIRRUS_5430,
36 L"Cirrus 5430"
37 },{
38 CIRRUS_LOGIC_VENDOR_ID,
39 CIRRUS_LOGIC_5430_ALTERNATE_DEVICE_ID,
40 QEMU_VIDEO_CIRRUS_5430,
41 L"Cirrus 5430"
42 },{
43 CIRRUS_LOGIC_VENDOR_ID,
44 CIRRUS_LOGIC_5446_DEVICE_ID,
45 QEMU_VIDEO_CIRRUS_5446,
46 L"Cirrus 5446"
47 },{
48 0x1234,
49 0x1111,
50 QEMU_VIDEO_BOCHS_MMIO,
51 L"QEMU Standard VGA"
52 },{
53 0x1b36,
54 0x0100,
55 QEMU_VIDEO_BOCHS,
56 L"QEMU QXL VGA"
57 },{
58 0x1af4,
59 0x1050,
60 QEMU_VIDEO_BOCHS_MMIO,
61 L"QEMU VirtIO VGA"
62 },{
63 VMWARE_PCI_VENDOR_ID_VMWARE,
64 VMWARE_PCI_DEVICE_ID_VMWARE_SVGA2,
65 QEMU_VIDEO_VMWARE_SVGA,
66 L"QEMU VMWare SVGA"
67 },{
68 0 /* end of list */
69 }
70};
71
72static QEMU_VIDEO_CARD*
73QemuVideoDetect(
74 IN UINT16 VendorId,
75 IN UINT16 DeviceId
76 )
77{
78 UINTN Index = 0;
79
80 while (gQemuVideoCardList[Index].VendorId != 0) {
81 if (gQemuVideoCardList[Index].VendorId == VendorId &&
82 gQemuVideoCardList[Index].DeviceId == DeviceId) {
83 return gQemuVideoCardList + Index;
84 }
85 Index++;
86 }
87 return NULL;
88}
89
90/**
91 Check if this device is supported.
92
93 @param This The driver binding protocol.
94 @param Controller The controller handle to check.
95 @param RemainingDevicePath The remaining device path.
96
97 @retval EFI_SUCCESS The bus supports this controller.
98 @retval EFI_UNSUPPORTED This device isn't supported.
99
100**/
101EFI_STATUS
102EFIAPI
103QemuVideoControllerDriverSupported (
104 IN EFI_DRIVER_BINDING_PROTOCOL *This,
105 IN EFI_HANDLE Controller,
106 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
107 )
108{
109 EFI_STATUS Status;
110 EFI_PCI_IO_PROTOCOL *PciIo;
111 PCI_TYPE00 Pci;
112 QEMU_VIDEO_CARD *Card;
113
114 //
115 // Open the PCI I/O Protocol
116 //
117 Status = gBS->OpenProtocol (
118 Controller,
119 &gEfiPciIoProtocolGuid,
120 (VOID **) &PciIo,
121 This->DriverBindingHandle,
122 Controller,
123 EFI_OPEN_PROTOCOL_BY_DRIVER
124 );
125 if (EFI_ERROR (Status)) {
126 return Status;
127 }
128
129 //
130 // Read the PCI Configuration Header from the PCI Device
131 //
132 Status = PciIo->Pci.Read (
133 PciIo,
134 EfiPciIoWidthUint32,
135 0,
136 sizeof (Pci) / sizeof (UINT32),
137 &Pci
138 );
139 if (EFI_ERROR (Status)) {
140 goto Done;
141 }
142
143 Status = EFI_UNSUPPORTED;
144 if (!IS_PCI_VGA (&Pci)) {
145 goto Done;
146 }
147 Card = QemuVideoDetect(Pci.Hdr.VendorId, Pci.Hdr.DeviceId);
148 if (Card != NULL) {
149 DEBUG ((EFI_D_INFO, "QemuVideo: %s detected\n", Card->Name));
150 Status = EFI_SUCCESS;
151 }
152
153Done:
154 //
155 // Close the PCI I/O Protocol
156 //
157 gBS->CloseProtocol (
158 Controller,
159 &gEfiPciIoProtocolGuid,
160 This->DriverBindingHandle,
161 Controller
162 );
163
164 return Status;
165}
166
167/**
168 Start to process the controller.
169
170 @param This The USB bus driver binding instance.
171 @param Controller The controller to check.
172 @param RemainingDevicePath The remaining device patch.
173
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
176 bus.
177 @retval EFI_OUT_OF_RESOURCES Failed to allocate resources.
178
179**/
180EFI_STATUS
181EFIAPI
182QemuVideoControllerDriverStart (
183 IN EFI_DRIVER_BINDING_PROTOCOL *This,
184 IN EFI_HANDLE Controller,
185 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
186 )
187{
188 EFI_TPL OldTpl;
189 EFI_STATUS Status;
190 QEMU_VIDEO_PRIVATE_DATA *Private;
191 BOOLEAN IsQxl;
192 EFI_DEVICE_PATH_PROTOCOL *ParentDevicePath;
193 ACPI_ADR_DEVICE_PATH AcpiDeviceNode;
194 PCI_TYPE00 Pci;
195 QEMU_VIDEO_CARD *Card;
196 EFI_PCI_IO_PROTOCOL *ChildPciIo;
197
198 OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
199
200 //
201 // Allocate Private context data for GOP inteface.
202 //
203 Private = AllocateZeroPool (sizeof (QEMU_VIDEO_PRIVATE_DATA));
204 if (Private == NULL) {
205 Status = EFI_OUT_OF_RESOURCES;
206 goto RestoreTpl;
207 }
208
209 //
210 // Set up context record
211 //
212 Private->Signature = QEMU_VIDEO_PRIVATE_DATA_SIGNATURE;
213
214 //
215 // Open PCI I/O Protocol
216 //
217 Status = gBS->OpenProtocol (
218 Controller,
219 &gEfiPciIoProtocolGuid,
220 (VOID **) &Private->PciIo,
221 This->DriverBindingHandle,
222 Controller,
223 EFI_OPEN_PROTOCOL_BY_DRIVER
224 );
225 if (EFI_ERROR (Status)) {
226 goto FreePrivate;
227 }
228
229 //
230 // Read the PCI Configuration Header from the PCI Device
231 //
232 Status = Private->PciIo->Pci.Read (
233 Private->PciIo,
234 EfiPciIoWidthUint32,
235 0,
236 sizeof (Pci) / sizeof (UINT32),
237 &Pci
238 );
239 if (EFI_ERROR (Status)) {
240 goto ClosePciIo;
241 }
242
243 //
244 // Determine card variant.
245 //
246 Card = QemuVideoDetect(Pci.Hdr.VendorId, Pci.Hdr.DeviceId);
247 if (Card == NULL) {
248 Status = EFI_DEVICE_ERROR;
249 goto ClosePciIo;
250 }
251 Private->Variant = Card->Variant;
252 Private->FrameBufferVramBarIndex = PCI_BAR_IDX0;
253
254 //
255 // IsQxl is based on the detected Card->Variant, which at a later point might
256 // not match Private->Variant.
257 //
258 IsQxl = (BOOLEAN)(Card->Variant == QEMU_VIDEO_BOCHS);
259
260 //
261 // Save original PCI attributes
262 //
263 Status = Private->PciIo->Attributes (
264 Private->PciIo,
265 EfiPciIoAttributeOperationGet,
266 0,
267 &Private->OriginalPciAttributes
268 );
269
270 if (EFI_ERROR (Status)) {
271 goto ClosePciIo;
272 }
273
274 //
275 // Set new PCI attributes
276 //
277 Status = Private->PciIo->Attributes (
278 Private->PciIo,
279 EfiPciIoAttributeOperationEnable,
280 EFI_PCI_DEVICE_ENABLE | EFI_PCI_IO_ATTRIBUTE_VGA_MEMORY | EFI_PCI_IO_ATTRIBUTE_VGA_IO,
281 NULL
282 );
283 if (EFI_ERROR (Status)) {
284 goto ClosePciIo;
285 }
286
287 //
288 // Check whenever the qemu stdvga mmio bar is present (qemu 1.3+).
289 //
290 if (Private->Variant == QEMU_VIDEO_BOCHS_MMIO) {
291 EFI_ACPI_ADDRESS_SPACE_DESCRIPTOR *MmioDesc;
292
293 Status = Private->PciIo->GetBarAttributes (
294 Private->PciIo,
295 PCI_BAR_IDX2,
296 NULL,
297 (VOID**) &MmioDesc
298 );
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;
303 } else {
304 DEBUG ((EFI_D_INFO, "QemuVideo: Using mmio bar @ 0x%lx\n",
305 MmioDesc->AddrRangeMin));
306 }
307
308 if (!EFI_ERROR (Status)) {
309 FreePool (MmioDesc);
310 }
311 }
312
313 //
314 // Check if accessing the bochs interface works.
315 //
316 if (Private->Variant == QEMU_VIDEO_BOCHS_MMIO ||
317 Private->Variant == QEMU_VIDEO_BOCHS) {
318 UINT16 BochsId;
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;
324 }
325 }
326
327 //
328 // Check if accessing Vmware SVGA interface works
329 //
330 if (Private->Variant == QEMU_VIDEO_VMWARE_SVGA) {
331 EFI_ACPI_ADDRESS_SPACE_DESCRIPTOR *IoDesc;
332 UINT32 TargetId;
333 UINT32 SvgaIdRead;
334
335 IoDesc = NULL;
336 Status = Private->PciIo->GetBarAttributes (
337 Private->PciIo,
338 PCI_BAR_IDX0,
339 NULL,
340 (VOID**) &IoDesc
341 );
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) {
346 FreePool (IoDesc);
347 }
348 Status = EFI_DEVICE_ERROR;
349 goto RestoreAttributes;
350 }
351 Private->VmwareSvgaBasePort = (UINT16) IoDesc->AddrRangeMin;
352 FreePool (IoDesc);
353
354 TargetId = VMWARE_SVGA_ID_2;
355 while (TRUE) {
356 VmwareSvgaWrite (Private, VmwareSvgaRegId, TargetId);
357 SvgaIdRead = VmwareSvgaRead (Private, VmwareSvgaRegId);
358 if ((SvgaIdRead == TargetId) || (TargetId <= VMWARE_SVGA_ID_0)) {
359 break;
360 }
361 TargetId--;
362 }
363
364 if (SvgaIdRead != TargetId) {
365 DEBUG ((
366 DEBUG_ERROR,
367 "QemuVideo: QEMU_VIDEO_VMWARE_SVGA ID mismatch "
368 "(got 0x%x, base address 0x%x)\n",
369 SvgaIdRead,
370 Private->VmwareSvgaBasePort
371 ));
372 Status = EFI_DEVICE_ERROR;
373 goto RestoreAttributes;
374 }
375
376 Private->FrameBufferVramBarIndex = PCI_BAR_IDX1;
377 }
378
379 //
380 // Get ParentDevicePath
381 //
382 Status = gBS->HandleProtocol (
383 Controller,
384 &gEfiDevicePathProtocolGuid,
385 (VOID **) &ParentDevicePath
386 );
387 if (EFI_ERROR (Status)) {
388 goto RestoreAttributes;
389 }
390
391 //
392 // Set Gop Device Path
393 //
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));
399
400 Private->GopDevicePath = AppendDevicePathNode (
401 ParentDevicePath,
402 (EFI_DEVICE_PATH_PROTOCOL *) &AcpiDeviceNode
403 );
404 if (Private->GopDevicePath == NULL) {
405 Status = EFI_OUT_OF_RESOURCES;
406 goto RestoreAttributes;
407 }
408
409 //
410 // Create new child handle and install the device path protocol on it.
411 //
412 Status = gBS->InstallMultipleProtocolInterfaces (
413 &Private->Handle,
414 &gEfiDevicePathProtocolGuid,
415 Private->GopDevicePath,
416 NULL
417 );
418 if (EFI_ERROR (Status)) {
419 goto FreeGopDevicePath;
420 }
421
422 //
423 // Construct video mode buffer
424 //
425 switch (Private->Variant) {
426 case QEMU_VIDEO_CIRRUS_5430:
427 case QEMU_VIDEO_CIRRUS_5446:
428 Status = QemuVideoCirrusModeSetup (Private);
429 break;
430 case QEMU_VIDEO_BOCHS_MMIO:
431 case QEMU_VIDEO_BOCHS:
432 Status = QemuVideoBochsModeSetup (Private, IsQxl);
433 break;
434 case QEMU_VIDEO_VMWARE_SVGA:
435 Status = QemuVideoVmwareSvgaModeSetup (Private);
436 break;
437 default:
438 ASSERT (FALSE);
439 Status = EFI_DEVICE_ERROR;
440 break;
441 }
442 if (EFI_ERROR (Status)) {
443 goto UninstallGopDevicePath;
444 }
445
446 //
447 // Start the GOP software stack.
448 //
449 Status = QemuVideoGraphicsOutputConstructor (Private);
450 if (EFI_ERROR (Status)) {
451 goto FreeModeData;
452 }
453
454 Status = gBS->InstallMultipleProtocolInterfaces (
455 &Private->Handle,
456 &gEfiGraphicsOutputProtocolGuid,
457 &Private->GraphicsOutput,
458 NULL
459 );
460 if (EFI_ERROR (Status)) {
461 goto DestructQemuVideoGraphics;
462 }
463
464 //
465 // Reference parent handle from child handle.
466 //
467 Status = gBS->OpenProtocol (
468 Controller,
469 &gEfiPciIoProtocolGuid,
470 (VOID **) &ChildPciIo,
471 This->DriverBindingHandle,
472 Private->Handle,
473 EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
474 );
475 if (EFI_ERROR (Status)) {
476 goto UninstallGop;
477 }
478
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);
483 }
484#endif
485
486 gBS->RestoreTPL (OldTpl);
487 return EFI_SUCCESS;
488
489UninstallGop:
490 gBS->UninstallProtocolInterface (Private->Handle,
491 &gEfiGraphicsOutputProtocolGuid, &Private->GraphicsOutput);
492
493DestructQemuVideoGraphics:
494 QemuVideoGraphicsOutputDestructor (Private);
495
496FreeModeData:
497 FreePool (Private->ModeData);
498 if (Private->VmwareSvgaModeInfo != NULL) {
499 FreePool (Private->VmwareSvgaModeInfo);
500 }
501
502UninstallGopDevicePath:
503 gBS->UninstallProtocolInterface (Private->Handle,
504 &gEfiDevicePathProtocolGuid, Private->GopDevicePath);
505
506FreeGopDevicePath:
507 FreePool (Private->GopDevicePath);
508
509RestoreAttributes:
510 Private->PciIo->Attributes (Private->PciIo, EfiPciIoAttributeOperationSet,
511 Private->OriginalPciAttributes, NULL);
512
513ClosePciIo:
514 gBS->CloseProtocol (Controller, &gEfiPciIoProtocolGuid,
515 This->DriverBindingHandle, Controller);
516
517FreePrivate:
518 FreePool (Private);
519
520RestoreTpl:
521 gBS->RestoreTPL (OldTpl);
522
523 return Status;
524}
525
526/**
527 Stop this device
528
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.
534
535 @retval EFI_SUCCESS The controller or children are stopped.
536 @retval EFI_DEVICE_ERROR Failed to stop the driver.
537
538**/
539EFI_STATUS
540EFIAPI
541QemuVideoControllerDriverStop (
542 IN EFI_DRIVER_BINDING_PROTOCOL *This,
543 IN EFI_HANDLE Controller,
544 IN UINTN NumberOfChildren,
545 IN EFI_HANDLE *ChildHandleBuffer
546 )
547{
548 EFI_GRAPHICS_OUTPUT_PROTOCOL *GraphicsOutput;
549
550 EFI_STATUS Status;
551 QEMU_VIDEO_PRIVATE_DATA *Private;
552
553 if (NumberOfChildren == 0) {
554 //
555 // Close the PCI I/O Protocol
556 //
557 gBS->CloseProtocol (
558 Controller,
559 &gEfiPciIoProtocolGuid,
560 This->DriverBindingHandle,
561 Controller
562 );
563 return EFI_SUCCESS;
564 }
565
566 //
567 // free all resources for whose access we need the child handle, because the
568 // child handle is going away
569 //
570 ASSERT (NumberOfChildren == 1);
571 Status = gBS->OpenProtocol (
572 ChildHandleBuffer[0],
573 &gEfiGraphicsOutputProtocolGuid,
574 (VOID **) &GraphicsOutput,
575 This->DriverBindingHandle,
576 Controller,
577 EFI_OPEN_PROTOCOL_GET_PROTOCOL
578 );
579 if (EFI_ERROR (Status)) {
580 return Status;
581 }
582
583 //
584 // Get our private context information
585 //
586 Private = QEMU_VIDEO_PRIVATE_DATA_FROM_GRAPHICS_OUTPUT_THIS (GraphicsOutput);
587 ASSERT (Private->Handle == ChildHandleBuffer[0]);
588
589 QemuVideoGraphicsOutputDestructor (Private);
590 //
591 // Remove the GOP protocol interface from the system
592 //
593 Status = gBS->UninstallMultipleProtocolInterfaces (
594 Private->Handle,
595 &gEfiGraphicsOutputProtocolGuid,
596 &Private->GraphicsOutput,
597 NULL
598 );
599
600 if (EFI_ERROR (Status)) {
601 return Status;
602 }
603
604 //
605 // Restore original PCI attributes
606 //
607 Private->PciIo->Attributes (
608 Private->PciIo,
609 EfiPciIoAttributeOperationSet,
610 Private->OriginalPciAttributes,
611 NULL
612 );
613
614 gBS->CloseProtocol (
615 Controller,
616 &gEfiPciIoProtocolGuid,
617 This->DriverBindingHandle,
618 Private->Handle
619 );
620
621 FreePool (Private->ModeData);
622 if (Private->VmwareSvgaModeInfo != NULL) {
623 FreePool (Private->VmwareSvgaModeInfo);
624 }
625 gBS->UninstallProtocolInterface (Private->Handle,
626 &gEfiDevicePathProtocolGuid, Private->GopDevicePath);
627 FreePool (Private->GopDevicePath);
628
629 //
630 // Free our instance data
631 //
632 gBS->FreePool (Private);
633
634 return EFI_SUCCESS;
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
648outb (
649 QEMU_VIDEO_PRIVATE_DATA *Private,
650 UINTN Address,
651 UINT8 Data
652 )
653{
654 Private->PciIo->Io.Write (
655 Private->PciIo,
656 EfiPciIoWidthUint8,
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 @param Data TODO: add argument description
670
671 TODO: add return values
672
673**/
674VOID
675outw (
676 QEMU_VIDEO_PRIVATE_DATA *Private,
677 UINTN Address,
678 UINT16 Data
679 )
680{
681 Private->PciIo->Io.Write (
682 Private->PciIo,
683 EfiPciIoWidthUint16,
684 EFI_PCI_IO_PASS_THROUGH_BAR,
685 Address,
686 1,
687 &Data
688 );
689}
690
691/**
692 TODO: Add function description
693
694 @param Private TODO: add argument description
695 @param Address TODO: add argument description
696
697 TODO: add return values
698
699**/
700UINT8
701inb (
702 QEMU_VIDEO_PRIVATE_DATA *Private,
703 UINTN Address
704 )
705{
706 UINT8 Data;
707
708 Private->PciIo->Io.Read (
709 Private->PciIo,
710 EfiPciIoWidthUint8,
711 EFI_PCI_IO_PASS_THROUGH_BAR,
712 Address,
713 1,
714 &Data
715 );
716 return Data;
717}
718
719/**
720 TODO: Add function description
721
722 @param Private TODO: add argument description
723 @param Address TODO: add argument description
724
725 TODO: add return values
726
727**/
728UINT16
729inw (
730 QEMU_VIDEO_PRIVATE_DATA *Private,
731 UINTN Address
732 )
733{
734 UINT16 Data;
735
736 Private->PciIo->Io.Read (
737 Private->PciIo,
738 EfiPciIoWidthUint16,
739 EFI_PCI_IO_PASS_THROUGH_BAR,
740 Address,
741 1,
742 &Data
743 );
744 return Data;
745}
746
747/**
748 TODO: Add function description
749
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
755
756 TODO: add return values
757
758**/
759VOID
760SetPaletteColor (
761 QEMU_VIDEO_PRIVATE_DATA *Private,
762 UINTN Index,
763 UINT8 Red,
764 UINT8 Green,
765 UINT8 Blue
766 )
767{
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));
772}
773
774/**
775 TODO: Add function description
776
777 @param Private TODO: add argument description
778
779 TODO: add return values
780
781**/
782VOID
783SetDefaultPalette (
784 QEMU_VIDEO_PRIVATE_DATA *Private
785 )
786{
787 UINTN Index;
788 UINTN RedIndex;
789 UINTN GreenIndex;
790 UINTN BlueIndex;
791
792 Index = 0;
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));
797 Index++;
798 }
799 }
800 }
801}
802
803/**
804 TODO: Add function description
805
806 @param Private TODO: add argument description
807
808 TODO: add return values
809
810**/
811VOID
812ClearScreen (
813 QEMU_VIDEO_PRIVATE_DATA *Private
814 )
815{
816 UINT32 Color;
817
818 Color = 0;
819 Private->PciIo->Mem.Write (
820 Private->PciIo,
821 EfiPciIoWidthFillUint32,
822 Private->FrameBufferVramBarIndex,
823 0,
824 0x400000 >> 2,
825 &Color
826 );
827}
828
829/**
830 TODO: Add function description
831
832 @param Private TODO: add argument description
833
834 TODO: add return values
835
836**/
837VOID
838DrawLogo (
839 QEMU_VIDEO_PRIVATE_DATA *Private,
840 UINTN ScreenWidth,
841 UINTN ScreenHeight
842 )
843{
844}
845
846/**
847 TODO: Add function description
848
849 @param Private TODO: add argument description
850 @param ModeData TODO: add argument description
851
852 TODO: add return values
853
854**/
855VOID
856InitializeCirrusGraphicsMode (
857 QEMU_VIDEO_PRIVATE_DATA *Private,
858 QEMU_VIDEO_CIRRUS_MODES *ModeData
859 )
860{
861 UINT8 Byte;
862 UINTN Index;
863
864 outw (Private, SEQ_ADDRESS_REGISTER, 0x1206);
865 outw (Private, SEQ_ADDRESS_REGISTER, 0x0012);
866
867 for (Index = 0; Index < 15; Index++) {
868 outw (Private, SEQ_ADDRESS_REGISTER, ModeData->SeqSettings[Index]);
869 }
870
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);
875 }
876
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);
881
882 for (Index = 0; Index < 28; Index++) {
883 outw (Private, CRTC_ADDRESS_REGISTER, (UINT16) ((ModeData->CrtcSettings[Index] << 8) | Index));
884 }
885
886 for (Index = 0; Index < 9; Index++) {
887 outw (Private, GRAPH_ADDRESS_REGISTER, (UINT16) ((GraphicsController[Index] << 8) | Index));
888 }
889
890 inb (Private, INPUT_STATUS_1_REGISTER);
891
892 for (Index = 0; Index < 21; Index++) {
893 outb (Private, ATT_ADDRESS_REGISTER, (UINT8) Index);
894 outb (Private, ATT_ADDRESS_REGISTER, AttributeController[Index]);
895 }
896
897 outb (Private, ATT_ADDRESS_REGISTER, 0x20);
898
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);
903
904 SetDefaultPalette (Private);
905 ClearScreen (Private);
906}
907
908VOID
909BochsWrite (
910 QEMU_VIDEO_PRIVATE_DATA *Private,
911 UINT16 Reg,
912 UINT16 Data
913 )
914{
915 EFI_STATUS Status;
916
917 if (Private->Variant == QEMU_VIDEO_BOCHS_MMIO) {
918 Status = Private->PciIo->Mem.Write (
919 Private->PciIo,
920 EfiPciIoWidthUint16,
921 PCI_BAR_IDX2,
922 0x500 + (Reg << 1),
923 1,
924 &Data
925 );
926 ASSERT_EFI_ERROR (Status);
927 } else {
928 outw (Private, VBE_DISPI_IOPORT_INDEX, Reg);
929 outw (Private, VBE_DISPI_IOPORT_DATA, Data);
930 }
931}
932
933UINT16
934BochsRead (
935 QEMU_VIDEO_PRIVATE_DATA *Private,
936 UINT16 Reg
937 )
938{
939 EFI_STATUS Status;
940 UINT16 Data;
941
942 if (Private->Variant == QEMU_VIDEO_BOCHS_MMIO) {
943 Status = Private->PciIo->Mem.Read (
944 Private->PciIo,
945 EfiPciIoWidthUint16,
946 PCI_BAR_IDX2,
947 0x500 + (Reg << 1),
948 1,
949 &Data
950 );
951 ASSERT_EFI_ERROR (Status);
952 } else {
953 outw (Private, VBE_DISPI_IOPORT_INDEX, Reg);
954 Data = inw (Private, VBE_DISPI_IOPORT_DATA);
955 }
956 return Data;
957}
958
959VOID
960VmwareSvgaWrite (
961 QEMU_VIDEO_PRIVATE_DATA *Private,
962 UINT16 Register,
963 UINT32 Value
964 )
965{
966 UnalignedIoWrite32 (
967 Private->VmwareSvgaBasePort + VMWARE_SVGA_INDEX_PORT,
968 Register
969 );
970 UnalignedIoWrite32 (
971 Private->VmwareSvgaBasePort + VMWARE_SVGA_VALUE_PORT,
972 Value
973 );
974}
975
976UINT32
977VmwareSvgaRead (
978 QEMU_VIDEO_PRIVATE_DATA *Private,
979 UINT16 Register
980 )
981{
982 UnalignedIoWrite32 (
983 Private->VmwareSvgaBasePort + VMWARE_SVGA_INDEX_PORT,
984 Register
985 );
986 return UnalignedIoRead32 (
987 Private->VmwareSvgaBasePort + VMWARE_SVGA_VALUE_PORT
988 );
989}
990
991VOID
992VgaOutb (
993 QEMU_VIDEO_PRIVATE_DATA *Private,
994 UINTN Reg,
995 UINT8 Data
996 )
997{
998 EFI_STATUS Status;
999
1000 if (Private->Variant == QEMU_VIDEO_BOCHS_MMIO) {
1001 Status = Private->PciIo->Mem.Write (
1002 Private->PciIo,
1003 EfiPciIoWidthUint8,
1004 PCI_BAR_IDX2,
1005 0x400 - 0x3c0 + Reg,
1006 1,
1007 &Data
1008 );
1009 ASSERT_EFI_ERROR (Status);
1010 } else {
1011 outb (Private, Reg, Data);
1012 }
1013}
1014
1015VOID
1016InitializeBochsGraphicsMode (
1017 QEMU_VIDEO_PRIVATE_DATA *Private,
1018 QEMU_VIDEO_BOCHS_MODES *ModeData
1019 )
1020{
1021 DEBUG ((EFI_D_INFO, "InitializeBochsGraphicsMode: %dx%d @ %d\n",
1022 ModeData->Width, ModeData->Height, ModeData->ColorDepth));
1023
1024 /* unblank */
1025 VgaOutb (Private, ATT_ADDRESS_REGISTER, 0x20);
1026
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);
1031
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);
1037
1038 BochsWrite (Private, VBE_DISPI_INDEX_ENABLE,
1039 VBE_DISPI_ENABLED | VBE_DISPI_LFB_ENABLED);
1040
1041 SetDefaultPalette (Private);
1042 ClearScreen (Private);
1043}
1044
1045VOID
1046InitializeVmwareSvgaGraphicsMode (
1047 QEMU_VIDEO_PRIVATE_DATA *Private,
1048 QEMU_VIDEO_BOCHS_MODES *ModeData
1049 )
1050{
1051 UINT32 Capabilities;
1052
1053 VmwareSvgaWrite (Private, VmwareSvgaRegWidth, ModeData->Width);
1054 VmwareSvgaWrite (Private, VmwareSvgaRegHeight, ModeData->Height);
1055
1056 Capabilities = VmwareSvgaRead (
1057 Private,
1058 VmwareSvgaRegCapabilities
1059 );
1060 if ((Capabilities & VMWARE_SVGA_CAP_8BIT_EMULATION) != 0) {
1061 VmwareSvgaWrite (
1062 Private,
1063 VmwareSvgaRegBitsPerPixel,
1064 ModeData->ColorDepth
1065 );
1066 }
1067
1068 VmwareSvgaWrite (Private, VmwareSvgaRegEnable, 1);
1069
1070 SetDefaultPalette (Private);
1071 ClearScreen (Private);
1072}
1073
1074EFI_STATUS
1075EFIAPI
1076InitializeQemuVideo (
1077 IN EFI_HANDLE ImageHandle,
1078 IN EFI_SYSTEM_TABLE *SystemTable
1079 )
1080{
1081 EFI_STATUS Status;
1082
1083 Status = EfiLibInstallDriverBindingComponentName2 (
1084 ImageHandle,
1085 SystemTable,
1086 &gQemuVideoDriverBinding,
1087 ImageHandle,
1088 &gQemuVideoComponentName,
1089 &gQemuVideoComponentName2
1090 );
1091 ASSERT_EFI_ERROR (Status);
1092
1093 //
1094 // Install EFI Driver Supported EFI Version Protocol required for
1095 // EFI drivers that are on PCI and other plug in cards.
1096 //
1097 gQemuVideoDriverSupportedEfiVersion.FirmwareVersion = PcdGet32 (PcdDriverSupportedEfiVersion);
1098 Status = gBS->InstallMultipleProtocolInterfaces (
1099 &ImageHandle,
1100 &gEfiDriverSupportedEfiVersionProtocolGuid,
1101 &gQemuVideoDriverSupportedEfiVersion,
1102 NULL
1103 );
1104 ASSERT_EFI_ERROR (Status);
1105
1106 return Status;
1107}
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