Pkg-Module: CorebootPayloadPkg
[mirror_edk2.git] / CorebootPayloadPkg / FbGop / FbGop.c
1 /** @file
2 ConsoleOut Routines that speak VGA.
3
4 Copyright (c) 2007 - 2013, Intel Corporation. All rights reserved.<BR>
5
6 This program and the accompanying materials
7 are licensed and made available under the terms and conditions
8 of the BSD License which accompanies this distribution. The
9 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 "FbGop.h"
18
19 EFI_PIXEL_BITMASK mPixelBitMask = {0x0000FF, 0x00FF00, 0xFF0000, 0x000000};
20
21 //
22 // Save controller attributes during first start
23 //
24 UINT64 mOriginalPciAttributes;
25 BOOLEAN mPciAttributesSaved = FALSE;
26
27
28 //
29 // EFI Driver Binding Protocol Instance
30 //
31 EFI_DRIVER_BINDING_PROTOCOL gFbGopDriverBinding = {
32 FbGopDriverBindingSupported,
33 FbGopDriverBindingStart,
34 FbGopDriverBindingStop,
35 0x3,
36 NULL,
37 NULL
38 };
39
40 //
41 // Native resolution in EDID DetailedTiming[0]
42 //
43 UINT32 mNativeModeHorizontal;
44 UINT32 mNativeModeVertical;
45
46 /**
47 Supported.
48
49 @param This Pointer to driver binding protocol
50 @param Controller Controller handle to connect
51 @param RemainingDevicePath A pointer to the remaining portion of a device
52 path
53
54 @retval EFI_STATUS EFI_SUCCESS:This controller can be managed by this
55 driver, Otherwise, this controller cannot be
56 managed by this driver
57
58 **/
59 EFI_STATUS
60 EFIAPI
61 FbGopDriverBindingSupported (
62 IN EFI_DRIVER_BINDING_PROTOCOL *This,
63 IN EFI_HANDLE Controller,
64 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
65 )
66 {
67 EFI_STATUS Status;
68 EFI_PCI_IO_PROTOCOL *PciIo;
69 PCI_TYPE00 Pci;
70 EFI_DEV_PATH *Node;
71
72 //
73 // Open the IO Abstraction(s) needed to perform the supported test
74 //
75 Status = gBS->OpenProtocol (
76 Controller,
77 &gEfiPciIoProtocolGuid,
78 (VOID **) &PciIo,
79 This->DriverBindingHandle,
80 Controller,
81 EFI_OPEN_PROTOCOL_BY_DRIVER
82 );
83 if (EFI_ERROR (Status)) {
84 return Status;
85 }
86
87 //
88 // See if this is a PCI Graphics Controller by looking at the Command register and
89 // Class Code Register
90 //
91 Status = PciIo->Pci.Read (
92 PciIo,
93 EfiPciIoWidthUint32,
94 0,
95 sizeof (Pci) / sizeof (UINT32),
96 &Pci
97 );
98 if (EFI_ERROR (Status)) {
99 Status = EFI_UNSUPPORTED;
100 goto Done;
101 }
102
103 Status = EFI_UNSUPPORTED;
104 if (Pci.Hdr.ClassCode[2] == 0x03 || (Pci.Hdr.ClassCode[2] == 0x00 && Pci.Hdr.ClassCode[1] == 0x01)) {
105
106 Status = EFI_SUCCESS;
107 //
108 // If this is a graphics controller,
109 // go further check RemainingDevicePath validation
110 //
111 if (RemainingDevicePath != NULL) {
112 Node = (EFI_DEV_PATH *) RemainingDevicePath;
113 //
114 // Check if RemainingDevicePath is the End of Device Path Node,
115 // if yes, return EFI_SUCCESS
116 //
117 if (!IsDevicePathEnd (Node)) {
118 //
119 // If RemainingDevicePath isn't the End of Device Path Node,
120 // check its validation
121 //
122 if (Node->DevPath.Type != ACPI_DEVICE_PATH ||
123 Node->DevPath.SubType != ACPI_ADR_DP ||
124 DevicePathNodeLength(&Node->DevPath) < sizeof(ACPI_ADR_DEVICE_PATH)) {
125 Status = EFI_UNSUPPORTED;
126 }
127 }
128 }
129 }
130
131 Done:
132 gBS->CloseProtocol (
133 Controller,
134 &gEfiPciIoProtocolGuid,
135 This->DriverBindingHandle,
136 Controller
137 );
138
139 return Status;
140 }
141
142
143 /**
144 Install Graphics Output Protocol onto VGA device handles.
145
146 @param This Pointer to driver binding protocol
147 @param Controller Controller handle to connect
148 @param RemainingDevicePath A pointer to the remaining portion of a device
149 path
150
151 @return EFI_STATUS
152
153 **/
154 EFI_STATUS
155 EFIAPI
156 FbGopDriverBindingStart (
157 IN EFI_DRIVER_BINDING_PROTOCOL *This,
158 IN EFI_HANDLE Controller,
159 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
160 )
161 {
162 EFI_STATUS Status;
163 EFI_DEVICE_PATH_PROTOCOL *ParentDevicePath;
164 EFI_PCI_IO_PROTOCOL *PciIo;
165 UINT64 Supports;
166
167 DEBUG ((EFI_D_INFO, "GOP START\n"));
168
169 //
170 // Initialize local variables
171 //
172 PciIo = NULL;
173 ParentDevicePath = NULL;
174
175 //
176 // Prepare for status code
177 //
178 Status = gBS->HandleProtocol (
179 Controller,
180 &gEfiDevicePathProtocolGuid,
181 (VOID **) &ParentDevicePath
182 );
183 if (EFI_ERROR (Status)) {
184 return Status;
185 }
186
187 //
188 // Open the IO Abstraction(s) needed
189 //
190 Status = gBS->OpenProtocol (
191 Controller,
192 &gEfiPciIoProtocolGuid,
193 (VOID **) &PciIo,
194 This->DriverBindingHandle,
195 Controller,
196 EFI_OPEN_PROTOCOL_BY_DRIVER
197 );
198 if (EFI_ERROR (Status) && (Status != EFI_ALREADY_STARTED)) {
199 return Status;
200 }
201
202 //
203 // Save original PCI attributes
204 //
205 if (!mPciAttributesSaved) {
206 Status = PciIo->Attributes (
207 PciIo,
208 EfiPciIoAttributeOperationGet,
209 0,
210 &mOriginalPciAttributes
211 );
212
213 if (EFI_ERROR (Status)) {
214 goto Done;
215 }
216 mPciAttributesSaved = TRUE;
217 }
218
219 //
220 // Get supported PCI attributes
221 //
222 Status = PciIo->Attributes (
223 PciIo,
224 EfiPciIoAttributeOperationSupported,
225 0,
226 &Supports
227 );
228 if (EFI_ERROR (Status)) {
229 goto Done;
230 }
231
232 Supports &= (EFI_PCI_IO_ATTRIBUTE_VGA_IO | EFI_PCI_IO_ATTRIBUTE_VGA_IO_16);
233 if (Supports == 0 || Supports == (EFI_PCI_IO_ATTRIBUTE_VGA_IO | EFI_PCI_IO_ATTRIBUTE_VGA_IO_16)) {
234 Status = EFI_UNSUPPORTED;
235 goto Done;
236 }
237
238 REPORT_STATUS_CODE_WITH_DEVICE_PATH (
239 EFI_PROGRESS_CODE,
240 EFI_PERIPHERAL_LOCAL_CONSOLE | EFI_P_PC_ENABLE,
241 ParentDevicePath
242 );
243 //
244 // Enable the device and make sure VGA cycles are being forwarded to this VGA device
245 //
246 Status = PciIo->Attributes (
247 PciIo,
248 EfiPciIoAttributeOperationEnable,
249 EFI_PCI_DEVICE_ENABLE,
250 NULL
251 );
252 if (EFI_ERROR (Status)) {
253 REPORT_STATUS_CODE_WITH_DEVICE_PATH (
254 EFI_ERROR_CODE | EFI_ERROR_MINOR,
255 EFI_PERIPHERAL_LOCAL_CONSOLE | EFI_P_EC_RESOURCE_CONFLICT,
256 ParentDevicePath
257 );
258 goto Done;
259 }
260
261 if (RemainingDevicePath != NULL) {
262 if (IsDevicePathEnd (RemainingDevicePath)) {
263 //
264 // If RemainingDevicePath is the End of Device Path Node,
265 // don't create any child device and return EFI_SUCESS
266 Status = EFI_SUCCESS;
267 goto Done;
268 }
269 }
270
271 //
272 // Create child handle and install GraphicsOutputProtocol on it
273 //
274 Status = FbGopChildHandleInstall (
275 This,
276 Controller,
277 PciIo,
278 NULL,
279 ParentDevicePath,
280 RemainingDevicePath
281 );
282
283 Done:
284 if ((EFI_ERROR (Status)) && (Status != EFI_ALREADY_STARTED)) {
285
286 REPORT_STATUS_CODE_WITH_DEVICE_PATH (
287 EFI_PROGRESS_CODE,
288 EFI_PERIPHERAL_LOCAL_CONSOLE | EFI_P_PC_DISABLE,
289 ParentDevicePath
290 );
291
292 REPORT_STATUS_CODE_WITH_DEVICE_PATH (
293 EFI_PROGRESS_CODE,
294 EFI_PERIPHERAL_LOCAL_CONSOLE | EFI_P_EC_NOT_DETECTED,
295 ParentDevicePath
296 );
297 if (!HasChildHandle (Controller)) {
298 if (mPciAttributesSaved) {
299 //
300 // Restore original PCI attributes
301 //
302 PciIo->Attributes (
303 PciIo,
304 EfiPciIoAttributeOperationSet,
305 mOriginalPciAttributes,
306 NULL
307 );
308 }
309 }
310 //
311 // Release PCI I/O Protocols on the controller handle.
312 //
313 gBS->CloseProtocol (
314 Controller,
315 &gEfiPciIoProtocolGuid,
316 This->DriverBindingHandle,
317 Controller
318 );
319 }
320
321 return Status;
322 }
323
324
325 /**
326 Stop.
327
328 @param This Pointer to driver binding protocol
329 @param Controller Controller handle to connect
330 @param NumberOfChildren Number of children handle created by this driver
331 @param ChildHandleBuffer Buffer containing child handle created
332
333 @retval EFI_SUCCESS Driver disconnected successfully from controller
334 @retval EFI_UNSUPPORTED Cannot find FB_VIDEO_DEV structure
335
336 **/
337 EFI_STATUS
338 EFIAPI
339 FbGopDriverBindingStop (
340 IN EFI_DRIVER_BINDING_PROTOCOL *This,
341 IN EFI_HANDLE Controller,
342 IN UINTN NumberOfChildren,
343 IN EFI_HANDLE *ChildHandleBuffer
344 )
345 {
346 EFI_STATUS Status;
347 BOOLEAN AllChildrenStopped;
348 UINTN Index;
349 EFI_PCI_IO_PROTOCOL *PciIo;
350
351 AllChildrenStopped = TRUE;
352
353 if (NumberOfChildren == 0) {
354 //
355 // Close PCI I/O protocol on the controller handle
356 //
357 gBS->CloseProtocol (
358 Controller,
359 &gEfiPciIoProtocolGuid,
360 This->DriverBindingHandle,
361 Controller
362 );
363
364 return EFI_SUCCESS;
365 }
366
367 for (Index = 0; Index < NumberOfChildren; Index++) {
368
369 Status = EFI_SUCCESS;
370
371 FbGopChildHandleUninstall (This, Controller, ChildHandleBuffer[Index]);
372
373 if (EFI_ERROR (Status)) {
374 AllChildrenStopped = FALSE;
375 }
376 }
377
378 if (!AllChildrenStopped) {
379 return EFI_DEVICE_ERROR;
380 }
381
382 if (!HasChildHandle (Controller)) {
383 if (mPciAttributesSaved) {
384 Status = gBS->HandleProtocol (
385 Controller,
386 &gEfiPciIoProtocolGuid,
387 (VOID **) &PciIo
388 );
389 ASSERT_EFI_ERROR (Status);
390
391 //
392 // Restore original PCI attributes
393 //
394 Status = PciIo->Attributes (
395 PciIo,
396 EfiPciIoAttributeOperationSet,
397 mOriginalPciAttributes,
398 NULL
399 );
400 ASSERT_EFI_ERROR (Status);
401 }
402 }
403
404
405 return EFI_SUCCESS;
406 }
407
408
409 /**
410 Install child handles if the Handle supports MBR format.
411
412 @param This Calling context.
413 @param ParentHandle Parent Handle
414 @param ParentPciIo Parent PciIo interface
415 @param ParentLegacyBios Parent LegacyBios interface
416 @param ParentDevicePath Parent Device Path
417 @param RemainingDevicePath Remaining Device Path
418
419 @retval EFI_SUCCESS If a child handle was added
420 @retval other A child handle was not added
421
422 **/
423 EFI_STATUS
424 FbGopChildHandleInstall (
425 IN EFI_DRIVER_BINDING_PROTOCOL *This,
426 IN EFI_HANDLE ParentHandle,
427 IN EFI_PCI_IO_PROTOCOL *ParentPciIo,
428 IN VOID *ParentLegacyBios,
429 IN EFI_DEVICE_PATH_PROTOCOL *ParentDevicePath,
430 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
431 )
432 {
433 EFI_STATUS Status;
434 FB_VIDEO_DEV *FbGopPrivate;
435 PCI_TYPE00 Pci;
436 ACPI_ADR_DEVICE_PATH AcpiDeviceNode;
437 BOOLEAN ProtocolInstalled;
438
439 //
440 // Allocate the private device structure for video device
441 //
442 FbGopPrivate = (FB_VIDEO_DEV *) AllocateZeroPool (
443 sizeof (FB_VIDEO_DEV)
444 );
445 if (NULL == FbGopPrivate) {
446 Status = EFI_OUT_OF_RESOURCES;
447 goto Done;
448 }
449
450 //
451 // See if this is a VGA compatible controller or not
452 //
453 Status = ParentPciIo->Pci.Read (
454 ParentPciIo,
455 EfiPciIoWidthUint32,
456 0,
457 sizeof (Pci) / sizeof (UINT32),
458 &Pci
459 );
460 if (EFI_ERROR (Status)) {
461 REPORT_STATUS_CODE_WITH_DEVICE_PATH (
462 EFI_ERROR_CODE | EFI_ERROR_MINOR,
463 EFI_PERIPHERAL_LOCAL_CONSOLE | EFI_P_EC_CONTROLLER_ERROR,
464 ParentDevicePath
465 );
466 goto Done;
467 }
468
469 //
470 // Initialize the child private structure
471 //
472 FbGopPrivate->Signature = FB_VIDEO_DEV_SIGNATURE;
473
474 //
475 // Fill in Graphics Output specific mode structures
476 //
477 FbGopPrivate->ModeData = NULL;
478
479 FbGopPrivate->VbeFrameBuffer = NULL;
480
481 FbGopPrivate->EdidDiscovered.SizeOfEdid = 0;
482 FbGopPrivate->EdidDiscovered.Edid = NULL;
483 FbGopPrivate->EdidActive.SizeOfEdid = 0;
484 FbGopPrivate->EdidActive.Edid = NULL;
485
486 //
487 // Fill in the Graphics Output Protocol
488 //
489 FbGopPrivate->GraphicsOutput.QueryMode = FbGopGraphicsOutputQueryMode;
490 FbGopPrivate->GraphicsOutput.SetMode = FbGopGraphicsOutputSetMode;
491
492
493 //
494 // Allocate buffer for Graphics Output Protocol mode information
495 //
496 FbGopPrivate->GraphicsOutput.Mode = (EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE *) AllocatePool (
497 sizeof (EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE)
498 );
499 if (NULL == FbGopPrivate->GraphicsOutput.Mode) {
500 Status = EFI_OUT_OF_RESOURCES;
501 goto Done;
502 }
503
504 FbGopPrivate->GraphicsOutput.Mode->Info = (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION *) AllocatePool (
505 sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION)
506 );
507 if (NULL == FbGopPrivate->GraphicsOutput.Mode->Info) {
508 Status = EFI_OUT_OF_RESOURCES;
509 goto Done;
510 }
511
512 //
513 // Set Gop Device Path, here RemainingDevicePath will not be one End of Device Path Node.
514 //
515 if ((RemainingDevicePath == NULL) || (!IsDevicePathEnd (RemainingDevicePath))) {
516 if (RemainingDevicePath == NULL) {
517 ZeroMem (&AcpiDeviceNode, sizeof (ACPI_ADR_DEVICE_PATH));
518 AcpiDeviceNode.Header.Type = ACPI_DEVICE_PATH;
519 AcpiDeviceNode.Header.SubType = ACPI_ADR_DP;
520 AcpiDeviceNode.ADR = ACPI_DISPLAY_ADR (1, 0, 0, 1, 0, ACPI_ADR_DISPLAY_TYPE_VGA, 0, 0);
521 SetDevicePathNodeLength (&AcpiDeviceNode.Header, sizeof (ACPI_ADR_DEVICE_PATH));
522
523 FbGopPrivate->GopDevicePath = AppendDevicePathNode (
524 ParentDevicePath,
525 (EFI_DEVICE_PATH_PROTOCOL *) &AcpiDeviceNode
526 );
527 } else {
528 FbGopPrivate->GopDevicePath = AppendDevicePathNode (ParentDevicePath, RemainingDevicePath);
529 }
530
531 //
532 // Creat child handle and device path protocol firstly
533 //
534 FbGopPrivate->Handle = NULL;
535 Status = gBS->InstallMultipleProtocolInterfaces (
536 &FbGopPrivate->Handle,
537 &gEfiDevicePathProtocolGuid,
538 FbGopPrivate->GopDevicePath,
539 NULL
540 );
541 if (EFI_ERROR (Status)) {
542 goto Done;
543 }
544 }
545
546 //
547 // When check for VBE, PCI I/O protocol is needed, so use parent's protocol interface temporally
548 //
549 FbGopPrivate->PciIo = ParentPciIo;
550
551 //
552 // Check for VESA BIOS Extensions for modes that are compatible with Graphics Output
553 //
554 Status = FbGopCheckForVbe (FbGopPrivate);
555 DEBUG ((EFI_D_INFO, "FbGopCheckForVbe - %r\n", Status));
556
557 if (EFI_ERROR (Status)) {
558 Status = EFI_UNSUPPORTED;
559 //goto Done;
560 }
561
562 ProtocolInstalled = FALSE;
563
564 //
565 // Creat child handle and install Graphics Output Protocol,EDID Discovered/Active Protocol
566 //
567 Status = gBS->InstallMultipleProtocolInterfaces (
568 &FbGopPrivate->Handle,
569 &gEfiGraphicsOutputProtocolGuid,
570 &FbGopPrivate->GraphicsOutput,
571 &gEfiEdidDiscoveredProtocolGuid,
572 &FbGopPrivate->EdidDiscovered,
573 &gEfiEdidActiveProtocolGuid,
574 &FbGopPrivate->EdidActive,
575 NULL
576 );
577
578 if (!EFI_ERROR (Status)) {
579 //
580 // Open the Parent Handle for the child
581 //
582 Status = gBS->OpenProtocol (
583 ParentHandle,
584 &gEfiPciIoProtocolGuid,
585 (VOID **) &FbGopPrivate->PciIo,
586 This->DriverBindingHandle,
587 FbGopPrivate->Handle,
588 EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
589 );
590 if (EFI_ERROR (Status)) {
591 goto Done;
592 }
593 ProtocolInstalled = TRUE;
594 }
595
596 Done:
597 if (EFI_ERROR (Status)) {
598 //
599 // Free private data structure
600 //
601 FbGopDeviceReleaseResource (FbGopPrivate);
602 }
603
604 return Status;
605 }
606
607
608 /**
609 Deregister an video child handle and free resources.
610
611 @param This Protocol instance pointer.
612 @param Controller Video controller handle
613 @param Handle Video child handle
614
615 @return EFI_STATUS
616
617 **/
618 EFI_STATUS
619 FbGopChildHandleUninstall (
620 EFI_DRIVER_BINDING_PROTOCOL *This,
621 EFI_HANDLE Controller,
622 EFI_HANDLE Handle
623 )
624 {
625 EFI_STATUS Status;
626 EFI_GRAPHICS_OUTPUT_PROTOCOL *GraphicsOutput;
627 FB_VIDEO_DEV *FbGopPrivate;
628 EFI_PCI_IO_PROTOCOL *PciIo;
629
630 FbGopPrivate = NULL;
631 GraphicsOutput = NULL;
632 PciIo = NULL;
633 Status = EFI_UNSUPPORTED;
634
635 Status = gBS->OpenProtocol (
636 Handle,
637 &gEfiGraphicsOutputProtocolGuid,
638 (VOID **) &GraphicsOutput,
639 This->DriverBindingHandle,
640 Handle,
641 EFI_OPEN_PROTOCOL_GET_PROTOCOL
642 );
643 if (!EFI_ERROR (Status)) {
644 FbGopPrivate = FB_VIDEO_DEV_FROM_GRAPHICS_OUTPUT_THIS (GraphicsOutput);
645 }
646
647 if (FbGopPrivate == NULL) {
648 return EFI_UNSUPPORTED;
649 }
650
651 //
652 // Close PCI I/O protocol that opened by child handle
653 //
654 Status = gBS->CloseProtocol (
655 Controller,
656 &gEfiPciIoProtocolGuid,
657 This->DriverBindingHandle,
658 Handle
659 );
660
661 //
662 // Uninstall protocols on child handle
663 //
664 Status = gBS->UninstallMultipleProtocolInterfaces (
665 FbGopPrivate->Handle,
666 &gEfiDevicePathProtocolGuid,
667 FbGopPrivate->GopDevicePath,
668 &gEfiGraphicsOutputProtocolGuid,
669 &FbGopPrivate->GraphicsOutput,
670 NULL
671 );
672
673 if (EFI_ERROR (Status)) {
674 gBS->OpenProtocol (
675 Controller,
676 &gEfiPciIoProtocolGuid,
677 (VOID **) &PciIo,
678 This->DriverBindingHandle,
679 Handle,
680 EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
681 );
682 return Status;
683 }
684
685 //
686 // Release all allocated resources
687 //
688 FbGopDeviceReleaseResource (FbGopPrivate);
689
690 return EFI_SUCCESS;
691 }
692
693
694 /**
695 Release resource for biso video instance.
696
697 @param FbGopPrivate Video child device private data structure
698
699 **/
700 VOID
701 FbGopDeviceReleaseResource (
702 FB_VIDEO_DEV *FbGopPrivate
703 )
704 {
705 if (FbGopPrivate == NULL) {
706 return ;
707 }
708
709 //
710 // Release all the resourses occupied by the FB_VIDEO_DEV
711 //
712
713 //
714 // Free VBE Frame Buffer
715 //
716 if (FbGopPrivate->VbeFrameBuffer != NULL) {
717 FreePool (FbGopPrivate->VbeFrameBuffer);
718 }
719
720 //
721 // Free mode data
722 //
723 if (FbGopPrivate->ModeData != NULL) {
724 FreePool (FbGopPrivate->ModeData);
725 }
726
727 //
728 // Free graphics output protocol occupied resource
729 //
730 if (FbGopPrivate->GraphicsOutput.Mode != NULL) {
731 if (FbGopPrivate->GraphicsOutput.Mode->Info != NULL) {
732 FreePool (FbGopPrivate->GraphicsOutput.Mode->Info);
733 FbGopPrivate->GraphicsOutput.Mode->Info = NULL;
734 }
735 FreePool (FbGopPrivate->GraphicsOutput.Mode);
736 FbGopPrivate->GraphicsOutput.Mode = NULL;
737 }
738
739 if (FbGopPrivate->GopDevicePath!= NULL) {
740 FreePool (FbGopPrivate->GopDevicePath);
741 }
742
743 FreePool (FbGopPrivate);
744
745 return ;
746 }
747
748
749
750 /**
751 Check if all video child handles have been uninstalled.
752
753 @param Controller Video controller handle
754
755 @return TRUE Child handles exist.
756 @return FALSE All video child handles have been uninstalled.
757
758 **/
759 BOOLEAN
760 HasChildHandle (
761 IN EFI_HANDLE Controller
762 )
763 {
764 UINTN Index;
765 EFI_OPEN_PROTOCOL_INFORMATION_ENTRY *OpenInfoBuffer;
766 UINTN EntryCount;
767 BOOLEAN HasChild;
768 EFI_STATUS Status;
769
770 EntryCount = 0;
771 HasChild = FALSE;
772 Status = gBS->OpenProtocolInformation (
773 Controller,
774 &gEfiPciIoProtocolGuid,
775 &OpenInfoBuffer,
776 &EntryCount
777 );
778 for (Index = 0; Index < EntryCount; Index++) {
779 if ((OpenInfoBuffer[Index].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {
780 HasChild = TRUE;
781 }
782 }
783
784 return HasChild;
785 }
786
787 /**
788 Check for VBE device.
789
790 @param FbGopPrivate Pointer to FB_VIDEO_DEV structure
791
792 @retval EFI_SUCCESS VBE device found
793
794 **/
795 EFI_STATUS
796 FbGopCheckForVbe (
797 IN OUT FB_VIDEO_DEV *FbGopPrivate
798 )
799 {
800 EFI_STATUS Status;
801 FB_VIDEO_MODE_DATA *ModeBuffer;
802 FB_VIDEO_MODE_DATA *CurrentModeData;
803 UINTN ModeNumber;
804 UINTN BitsPerPixel;
805 UINTN BytesPerScanLine;
806 UINT32 HorizontalResolution;
807 UINT32 VerticalResolution;
808 EFI_GRAPHICS_OUTPUT_BLT_PIXEL *VbeFrameBuffer;
809 EFI_HOB_GUID_TYPE *GuidHob;
810 FRAME_BUFFER_INFO *pFbInfo;
811
812 Status = EFI_SUCCESS;
813 //
814 // Find the frame buffer information guid hob
815 //
816 GuidHob = GetFirstGuidHob (&gUefiFrameBufferInfoGuid);
817 ASSERT (GuidHob != NULL);
818 pFbInfo = (FRAME_BUFFER_INFO *)GET_GUID_HOB_DATA (GuidHob);
819
820 //
821 // Add mode to the list of available modes
822 //
823 VbeFrameBuffer = NULL;
824 ModeBuffer = NULL;
825
826 ModeNumber = 1;
827 BitsPerPixel = pFbInfo->BitsPerPixel;
828 HorizontalResolution = pFbInfo->HorizontalResolution;
829 VerticalResolution = pFbInfo->VerticalResolution;
830 BytesPerScanLine = HorizontalResolution * (BitsPerPixel / 8);
831
832 ModeBuffer = (FB_VIDEO_MODE_DATA *) AllocatePool (
833 ModeNumber * sizeof (FB_VIDEO_MODE_DATA)
834 );
835 if (NULL == ModeBuffer) {
836 Status = EFI_OUT_OF_RESOURCES;
837 goto Done;
838 }
839
840 VbeFrameBuffer =
841 (EFI_GRAPHICS_OUTPUT_BLT_PIXEL *) AllocatePool (
842 BytesPerScanLine * VerticalResolution
843 );
844 if (NULL == VbeFrameBuffer) {
845 Status = EFI_OUT_OF_RESOURCES;
846 goto Done;
847 }
848
849 if (FbGopPrivate->ModeData != NULL) {
850 FreePool (FbGopPrivate->ModeData);
851 }
852
853 if (FbGopPrivate->VbeFrameBuffer != NULL) {
854 FreePool (FbGopPrivate->VbeFrameBuffer);
855 }
856
857 CurrentModeData = &ModeBuffer[ModeNumber - 1];
858 CurrentModeData->BytesPerScanLine = (UINT16)BytesPerScanLine;
859
860 CurrentModeData->Red = *(FB_VIDEO_COLOR_PLACEMENT *)&(pFbInfo->Red);
861 CurrentModeData->Blue = *(FB_VIDEO_COLOR_PLACEMENT *)&(pFbInfo->Blue);
862 CurrentModeData->Green = *(FB_VIDEO_COLOR_PLACEMENT *)&(pFbInfo->Green);
863 CurrentModeData->Reserved = *(FB_VIDEO_COLOR_PLACEMENT *)&(pFbInfo->Reserved);
864
865 CurrentModeData->BitsPerPixel = (UINT32)BitsPerPixel;
866 CurrentModeData->HorizontalResolution = HorizontalResolution;
867 CurrentModeData->VerticalResolution = VerticalResolution;
868 CurrentModeData->FrameBufferSize = CurrentModeData->BytesPerScanLine * CurrentModeData->VerticalResolution;
869 CurrentModeData->LinearFrameBuffer = (VOID *) (UINTN) pFbInfo->LinearFrameBuffer;
870 CurrentModeData->VbeModeNumber = 0;
871 CurrentModeData->ColorDepth = 32;
872 CurrentModeData->RefreshRate = 60;
873
874 CurrentModeData->PixelFormat = PixelBitMask;
875 if ((CurrentModeData->BitsPerPixel == 32) &&
876 (CurrentModeData->Red.Mask == 0xff) && (CurrentModeData->Green.Mask == 0xff) && (CurrentModeData->Blue.Mask == 0xff)) {
877 if ((CurrentModeData->Red.Position == 0) && (CurrentModeData->Green.Position == 8) && (CurrentModeData->Blue.Position == 16)) {
878 CurrentModeData->PixelFormat = PixelRedGreenBlueReserved8BitPerColor;
879 } else if ((CurrentModeData->Blue.Position == 0) && (CurrentModeData->Green.Position == 8) && (CurrentModeData->Red.Position == 16)) {
880 CurrentModeData->PixelFormat = PixelBlueGreenRedReserved8BitPerColor;
881 }
882 }
883
884 CopyMem (&(CurrentModeData->PixelBitMask), &mPixelBitMask, sizeof (EFI_PIXEL_BITMASK));
885
886 FbGopPrivate->ModeData = ModeBuffer;
887 FbGopPrivate->VbeFrameBuffer = VbeFrameBuffer;
888
889 //
890 // Assign Gop's Blt function
891 //
892 FbGopPrivate->GraphicsOutput.Blt = FbGopGraphicsOutputVbeBlt;
893
894 FbGopPrivate->GraphicsOutput.Mode->MaxMode = 1;
895 FbGopPrivate->GraphicsOutput.Mode->Mode = 0;
896 FbGopPrivate->GraphicsOutput.Mode->Info->Version = 0;
897 FbGopPrivate->GraphicsOutput.Mode->Info->HorizontalResolution = HorizontalResolution;
898 FbGopPrivate->GraphicsOutput.Mode->Info->VerticalResolution = VerticalResolution;
899 FbGopPrivate->GraphicsOutput.Mode->Info->PixelFormat = CurrentModeData->PixelFormat;
900 CopyMem (&(FbGopPrivate->GraphicsOutput.Mode->Info->PixelInformation), &mPixelBitMask, sizeof (EFI_PIXEL_BITMASK));
901 FbGopPrivate->GraphicsOutput.Mode->Info->PixelsPerScanLine = HorizontalResolution;
902 FbGopPrivate->GraphicsOutput.Mode->SizeOfInfo = sizeof(EFI_GRAPHICS_OUTPUT_MODE_INFORMATION);
903 FbGopPrivate->GraphicsOutput.Mode->FrameBufferBase = (EFI_PHYSICAL_ADDRESS) (UINTN) CurrentModeData->LinearFrameBuffer;
904 FbGopPrivate->GraphicsOutput.Mode->FrameBufferSize = CurrentModeData->FrameBufferSize;
905
906 //
907 // Find the best mode to initialize
908 //
909
910 Done:
911 //
912 // If there was an error, then free the mode structure
913 //
914 if (EFI_ERROR (Status)) {
915
916 if (VbeFrameBuffer != NULL) {
917 FreePool (VbeFrameBuffer);
918 }
919
920 if (ModeBuffer != NULL) {
921 FreePool (ModeBuffer);
922 }
923 }
924
925 return Status;
926 }
927
928
929 //
930 // Graphics Output Protocol Member Functions for VESA BIOS Extensions
931 //
932
933 /**
934 Graphics Output protocol interface to get video mode.
935
936 @param This Protocol instance pointer.
937 @param ModeNumber The mode number to return information on.
938 @param SizeOfInfo A pointer to the size, in bytes, of the Info
939 buffer.
940 @param Info Caller allocated buffer that returns information
941 about ModeNumber.
942
943 @retval EFI_SUCCESS Mode information returned.
944 @retval EFI_DEVICE_ERROR A hardware error occurred trying to retrieve the
945 video mode.
946 @retval EFI_NOT_STARTED Video display is not initialized. Call SetMode ()
947 @retval EFI_INVALID_PARAMETER One of the input args was NULL.
948
949 **/
950 EFI_STATUS
951 EFIAPI
952 FbGopGraphicsOutputQueryMode (
953 IN EFI_GRAPHICS_OUTPUT_PROTOCOL *This,
954 IN UINT32 ModeNumber,
955 OUT UINTN *SizeOfInfo,
956 OUT EFI_GRAPHICS_OUTPUT_MODE_INFORMATION **Info
957 )
958 {
959 FB_VIDEO_DEV *FbGopPrivate;
960 FB_VIDEO_MODE_DATA *ModeData;
961
962 FbGopPrivate = FB_VIDEO_DEV_FROM_GRAPHICS_OUTPUT_THIS (This);
963
964 if (This == NULL || Info == NULL || SizeOfInfo == NULL || ModeNumber >= This->Mode->MaxMode) {
965 return EFI_INVALID_PARAMETER;
966 }
967
968 *Info = (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION *) AllocatePool (
969 sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION)
970 );
971 if (NULL == *Info) {
972 return EFI_OUT_OF_RESOURCES;
973 }
974
975 *SizeOfInfo = sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION);
976
977 ModeData = &FbGopPrivate->ModeData[ModeNumber];
978 (*Info)->Version = 0;
979 (*Info)->HorizontalResolution = ModeData->HorizontalResolution;
980 (*Info)->VerticalResolution = ModeData->VerticalResolution;
981 (*Info)->PixelFormat = ModeData->PixelFormat;
982 CopyMem (&((*Info)->PixelInformation), &(ModeData->PixelBitMask), sizeof(ModeData->PixelBitMask));
983
984 (*Info)->PixelsPerScanLine = (ModeData->BytesPerScanLine * 8) / ModeData->BitsPerPixel;
985
986 return EFI_SUCCESS;
987 }
988
989 /**
990 Graphics Output protocol interface to set video mode.
991
992 @param This Protocol instance pointer.
993 @param ModeNumber The mode number to be set.
994
995 @retval EFI_SUCCESS Graphics mode was changed.
996 @retval EFI_DEVICE_ERROR The device had an error and could not complete the
997 request.
998 @retval EFI_UNSUPPORTED ModeNumber is not supported by this device.
999
1000 **/
1001 EFI_STATUS
1002 EFIAPI
1003 FbGopGraphicsOutputSetMode (
1004 IN EFI_GRAPHICS_OUTPUT_PROTOCOL * This,
1005 IN UINT32 ModeNumber
1006 )
1007 {
1008 FB_VIDEO_DEV *FbGopPrivate;
1009 FB_VIDEO_MODE_DATA *ModeData;
1010 EFI_GRAPHICS_OUTPUT_BLT_PIXEL Background;
1011
1012 if (This == NULL) {
1013 return EFI_INVALID_PARAMETER;
1014 }
1015
1016 FbGopPrivate = FB_VIDEO_DEV_FROM_GRAPHICS_OUTPUT_THIS (This);
1017
1018 ModeData = &FbGopPrivate->ModeData[ModeNumber];
1019
1020 if (ModeNumber >= This->Mode->MaxMode) {
1021 return EFI_UNSUPPORTED;
1022 }
1023
1024 if (ModeNumber == This->Mode->Mode) {
1025 //
1026 // Clear screen to black
1027 //
1028 ZeroMem (&Background, sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL));
1029 FbGopGraphicsOutputVbeBlt (
1030 This,
1031 &Background,
1032 EfiBltVideoFill,
1033 0,
1034 0,
1035 0,
1036 0,
1037 ModeData->HorizontalResolution,
1038 ModeData->VerticalResolution,
1039 0
1040 );
1041 return EFI_SUCCESS;
1042 } else {
1043 return EFI_UNSUPPORTED;
1044 }
1045
1046 }
1047
1048 /**
1049 Update physical frame buffer, copy 4 bytes block, then copy remaining bytes.
1050
1051 @param PciIo The pointer of EFI_PCI_IO_PROTOCOL
1052 @param VbeBuffer The data to transfer to screen
1053 @param MemAddress Physical frame buffer base address
1054 @param DestinationX The X coordinate of the destination for BltOperation
1055 @param DestinationY The Y coordinate of the destination for BltOperation
1056 @param TotalBytes The total bytes of copy
1057 @param VbePixelWidth Bytes per pixel
1058 @param BytesPerScanLine Bytes per scan line
1059
1060 **/
1061 VOID
1062 CopyVideoBuffer (
1063 IN EFI_PCI_IO_PROTOCOL *PciIo,
1064 IN UINT8 *VbeBuffer,
1065 IN VOID *MemAddress,
1066 IN UINTN DestinationX,
1067 IN UINTN DestinationY,
1068 IN UINTN TotalBytes,
1069 IN UINT32 VbePixelWidth,
1070 IN UINTN BytesPerScanLine
1071 )
1072 {
1073 UINTN FrameBufferAddr;
1074 UINTN CopyBlockNum;
1075 UINTN RemainingBytes;
1076 UINTN UnalignedBytes;
1077 EFI_STATUS Status;
1078
1079 FrameBufferAddr = (UINTN) MemAddress + (DestinationY * BytesPerScanLine) + DestinationX * VbePixelWidth;
1080
1081 //
1082 // If TotalBytes is less than 4 bytes, only start byte copy.
1083 //
1084 if (TotalBytes < 4) {
1085 Status = PciIo->Mem.Write (
1086 PciIo,
1087 EfiPciIoWidthUint8,
1088 EFI_PCI_IO_PASS_THROUGH_BAR,
1089 (UINT64) FrameBufferAddr,
1090 TotalBytes,
1091 VbeBuffer
1092 );
1093 ASSERT_EFI_ERROR (Status);
1094 return;
1095 }
1096
1097 //
1098 // If VbeBuffer is not 4-byte aligned, start byte copy.
1099 //
1100 UnalignedBytes = (4 - ((UINTN) VbeBuffer & 0x3)) & 0x3;
1101
1102 if (UnalignedBytes != 0) {
1103 Status = PciIo->Mem.Write (
1104 PciIo,
1105 EfiPciIoWidthUint8,
1106 EFI_PCI_IO_PASS_THROUGH_BAR,
1107 (UINT64) FrameBufferAddr,
1108 UnalignedBytes,
1109 VbeBuffer
1110 );
1111 ASSERT_EFI_ERROR (Status);
1112 FrameBufferAddr += UnalignedBytes;
1113 VbeBuffer += UnalignedBytes;
1114 }
1115
1116 //
1117 // Calculate 4-byte block count and remaining bytes.
1118 //
1119 CopyBlockNum = (TotalBytes - UnalignedBytes) >> 2;
1120 RemainingBytes = (TotalBytes - UnalignedBytes) & 3;
1121
1122 //
1123 // Copy 4-byte block and remaining bytes to physical frame buffer.
1124 //
1125 if (CopyBlockNum != 0) {
1126 Status = PciIo->Mem.Write (
1127 PciIo,
1128 EfiPciIoWidthUint32,
1129 EFI_PCI_IO_PASS_THROUGH_BAR,
1130 (UINT64) FrameBufferAddr,
1131 CopyBlockNum,
1132 VbeBuffer
1133 );
1134 ASSERT_EFI_ERROR (Status);
1135 }
1136
1137 if (RemainingBytes != 0) {
1138 FrameBufferAddr += (CopyBlockNum << 2);
1139 VbeBuffer += (CopyBlockNum << 2);
1140 Status = PciIo->Mem.Write (
1141 PciIo,
1142 EfiPciIoWidthUint8,
1143 EFI_PCI_IO_PASS_THROUGH_BAR,
1144 (UINT64) FrameBufferAddr,
1145 RemainingBytes,
1146 VbeBuffer
1147 );
1148 ASSERT_EFI_ERROR (Status);
1149 }
1150 }
1151
1152 /**
1153 Worker function to block transfer for VBE device.
1154
1155 @param FbGopPrivate Instance of FB_VIDEO_DEV
1156 @param BltBuffer The data to transfer to screen
1157 @param BltOperation The operation to perform
1158 @param SourceX The X coordinate of the source for BltOperation
1159 @param SourceY The Y coordinate of the source for BltOperation
1160 @param DestinationX The X coordinate of the destination for
1161 BltOperation
1162 @param DestinationY The Y coordinate of the destination for
1163 BltOperation
1164 @param Width The width of a rectangle in the blt rectangle in
1165 pixels
1166 @param Height The height of a rectangle in the blt rectangle in
1167 pixels
1168 @param Delta Not used for EfiBltVideoFill and
1169 EfiBltVideoToVideo operation. If a Delta of 0 is
1170 used, the entire BltBuffer will be operated on. If
1171 a subrectangle of the BltBuffer is used, then
1172 Delta represents the number of bytes in a row of
1173 the BltBuffer.
1174 @param Mode Mode data.
1175
1176 @retval EFI_INVALID_PARAMETER Invalid parameter passed in
1177 @retval EFI_SUCCESS Blt operation success
1178
1179 **/
1180 EFI_STATUS
1181 FbGopVbeBltWorker (
1182 IN FB_VIDEO_DEV *FbGopPrivate,
1183 IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL *BltBuffer, OPTIONAL
1184 IN EFI_GRAPHICS_OUTPUT_BLT_OPERATION BltOperation,
1185 IN UINTN SourceX,
1186 IN UINTN SourceY,
1187 IN UINTN DestinationX,
1188 IN UINTN DestinationY,
1189 IN UINTN Width,
1190 IN UINTN Height,
1191 IN UINTN Delta,
1192 IN FB_VIDEO_MODE_DATA *Mode
1193 )
1194 {
1195 EFI_PCI_IO_PROTOCOL *PciIo;
1196 EFI_TPL OriginalTPL;
1197 UINTN DstY;
1198 UINTN SrcY;
1199 UINTN DstX;
1200 EFI_GRAPHICS_OUTPUT_BLT_PIXEL *Blt;
1201 VOID *MemAddress;
1202 EFI_GRAPHICS_OUTPUT_BLT_PIXEL *VbeFrameBuffer;
1203 UINTN BytesPerScanLine;
1204 UINTN Index;
1205 UINT8 *VbeBuffer;
1206 UINT8 *VbeBuffer1;
1207 UINT8 *BltUint8;
1208 UINT32 VbePixelWidth;
1209 UINT32 Pixel;
1210 UINTN TotalBytes;
1211
1212 PciIo = FbGopPrivate->PciIo;
1213
1214 VbeFrameBuffer = FbGopPrivate->VbeFrameBuffer;
1215 MemAddress = Mode->LinearFrameBuffer;
1216 BytesPerScanLine = Mode->BytesPerScanLine;
1217 VbePixelWidth = Mode->BitsPerPixel / 8;
1218 BltUint8 = (UINT8 *) BltBuffer;
1219 TotalBytes = Width * VbePixelWidth;
1220
1221 if (((UINTN) BltOperation) >= EfiGraphicsOutputBltOperationMax) {
1222 return EFI_INVALID_PARAMETER;
1223 }
1224
1225 if (Width == 0 || Height == 0) {
1226 return EFI_INVALID_PARAMETER;
1227 }
1228 //
1229 // We need to fill the Virtual Screen buffer with the blt data.
1230 // The virtual screen is upside down, as the first row is the bootom row of
1231 // the image.
1232 //
1233 if (BltOperation == EfiBltVideoToBltBuffer) {
1234 //
1235 // Video to BltBuffer: Source is Video, destination is BltBuffer
1236 //
1237 if (SourceY + Height > Mode->VerticalResolution) {
1238 return EFI_INVALID_PARAMETER;
1239 }
1240
1241 if (SourceX + Width > Mode->HorizontalResolution) {
1242 return EFI_INVALID_PARAMETER;
1243 }
1244 } else {
1245 //
1246 // BltBuffer to Video: Source is BltBuffer, destination is Video
1247 //
1248 if (DestinationY + Height > Mode->VerticalResolution) {
1249 return EFI_INVALID_PARAMETER;
1250 }
1251
1252 if (DestinationX + Width > Mode->HorizontalResolution) {
1253 return EFI_INVALID_PARAMETER;
1254 }
1255 }
1256 //
1257 // If Delta is zero, then the entire BltBuffer is being used, so Delta
1258 // is the number of bytes in each row of BltBuffer. Since BltBuffer is Width pixels size,
1259 // the number of bytes in each row can be computed.
1260 //
1261 if (Delta == 0) {
1262 Delta = Width * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL);
1263 }
1264 //
1265 // We have to raise to TPL Notify, so we make an atomic write the frame buffer.
1266 // We would not want a timer based event (Cursor, ...) to come in while we are
1267 // doing this operation.
1268 //
1269 OriginalTPL = gBS->RaiseTPL (TPL_NOTIFY);
1270
1271 switch (BltOperation) {
1272 case EfiBltVideoToBltBuffer:
1273 for (SrcY = SourceY, DstY = DestinationY; DstY < (Height + DestinationY); SrcY++, DstY++) {
1274 Blt = (EFI_GRAPHICS_OUTPUT_BLT_PIXEL *) (BltUint8 + DstY * Delta + DestinationX * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL));
1275 //
1276 // Shuffle the packed bytes in the hardware buffer to match EFI_GRAPHICS_OUTPUT_BLT_PIXEL
1277 //
1278 VbeBuffer = ((UINT8 *) VbeFrameBuffer + (SrcY * BytesPerScanLine + SourceX * VbePixelWidth));
1279 for (DstX = DestinationX; DstX < (Width + DestinationX); DstX++) {
1280 Pixel = VbeBuffer[0] | VbeBuffer[1] << 8 | VbeBuffer[2] << 16 | VbeBuffer[3] << 24;
1281 Blt->Red = (UINT8) ((Pixel >> Mode->Red.Position) & Mode->Red.Mask);
1282 Blt->Blue = (UINT8) ((Pixel >> Mode->Blue.Position) & Mode->Blue.Mask);
1283 Blt->Green = (UINT8) ((Pixel >> Mode->Green.Position) & Mode->Green.Mask);
1284 Blt->Reserved = 0;
1285 Blt++;
1286 VbeBuffer += VbePixelWidth;
1287 }
1288
1289 }
1290 break;
1291
1292 case EfiBltVideoToVideo:
1293 for (Index = 0; Index < Height; Index++) {
1294 if (DestinationY <= SourceY) {
1295 SrcY = SourceY + Index;
1296 DstY = DestinationY + Index;
1297 } else {
1298 SrcY = SourceY + Height - Index - 1;
1299 DstY = DestinationY + Height - Index - 1;
1300 }
1301
1302 VbeBuffer = ((UINT8 *) VbeFrameBuffer + DstY * BytesPerScanLine + DestinationX * VbePixelWidth);
1303 VbeBuffer1 = ((UINT8 *) VbeFrameBuffer + SrcY * BytesPerScanLine + SourceX * VbePixelWidth);
1304
1305 gBS->CopyMem (
1306 VbeBuffer,
1307 VbeBuffer1,
1308 TotalBytes
1309 );
1310
1311 //
1312 // Update physical frame buffer.
1313 //
1314 CopyVideoBuffer (
1315 PciIo,
1316 VbeBuffer,
1317 MemAddress,
1318 DestinationX,
1319 DstY,
1320 TotalBytes,
1321 VbePixelWidth,
1322 BytesPerScanLine
1323 );
1324 }
1325 break;
1326
1327 case EfiBltVideoFill:
1328 VbeBuffer = (UINT8 *) ((UINTN) VbeFrameBuffer + (DestinationY * BytesPerScanLine) + DestinationX * VbePixelWidth);
1329 Blt = (EFI_GRAPHICS_OUTPUT_BLT_PIXEL *) BltUint8;
1330 //
1331 // Shuffle the RGB fields in EFI_GRAPHICS_OUTPUT_BLT_PIXEL to match the hardware buffer
1332 //
1333 Pixel = ((Blt->Red & Mode->Red.Mask) << Mode->Red.Position) |
1334 (
1335 (Blt->Green & Mode->Green.Mask) <<
1336 Mode->Green.Position
1337 ) |
1338 ((Blt->Blue & Mode->Blue.Mask) << Mode->Blue.Position);
1339
1340 for (Index = 0; Index < Width; Index++) {
1341 gBS->CopyMem (
1342 VbeBuffer,
1343 &Pixel,
1344 VbePixelWidth
1345 );
1346 VbeBuffer += VbePixelWidth;
1347 }
1348
1349 VbeBuffer = (UINT8 *) ((UINTN) VbeFrameBuffer + (DestinationY * BytesPerScanLine) + DestinationX * VbePixelWidth);
1350 for (DstY = DestinationY + 1; DstY < (Height + DestinationY); DstY++) {
1351 gBS->CopyMem (
1352 (VOID *) ((UINTN) VbeFrameBuffer + (DstY * BytesPerScanLine) + DestinationX * VbePixelWidth),
1353 VbeBuffer,
1354 TotalBytes
1355 );
1356 }
1357
1358 for (DstY = DestinationY; DstY < (Height + DestinationY); DstY++) {
1359 //
1360 // Update physical frame buffer.
1361 //
1362 CopyVideoBuffer (
1363 PciIo,
1364 VbeBuffer,
1365 MemAddress,
1366 DestinationX,
1367 DstY,
1368 TotalBytes,
1369 VbePixelWidth,
1370 BytesPerScanLine
1371 );
1372 }
1373 break;
1374
1375 case EfiBltBufferToVideo:
1376 for (SrcY = SourceY, DstY = DestinationY; SrcY < (Height + SourceY); SrcY++, DstY++) {
1377 Blt = (EFI_GRAPHICS_OUTPUT_BLT_PIXEL *) (BltUint8 + (SrcY * Delta) + (SourceX) * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL));
1378 VbeBuffer = ((UINT8 *) VbeFrameBuffer + (DstY * BytesPerScanLine + DestinationX * VbePixelWidth));
1379 for (DstX = DestinationX; DstX < (Width + DestinationX); DstX++) {
1380 //
1381 // Shuffle the RGB fields in EFI_GRAPHICS_OUTPUT_BLT_PIXEL to match the hardware buffer
1382 //
1383 Pixel = ((Blt->Red & Mode->Red.Mask) << Mode->Red.Position) |
1384 ((Blt->Green & Mode->Green.Mask) << Mode->Green.Position) |
1385 ((Blt->Blue & Mode->Blue.Mask) << Mode->Blue.Position);
1386 gBS->CopyMem (
1387 VbeBuffer,
1388 &Pixel,
1389 VbePixelWidth
1390 );
1391 Blt++;
1392 VbeBuffer += VbePixelWidth;
1393 }
1394
1395 VbeBuffer = ((UINT8 *) VbeFrameBuffer + (DstY * BytesPerScanLine + DestinationX * VbePixelWidth));
1396
1397 //
1398 // Update physical frame buffer.
1399 //
1400 CopyVideoBuffer (
1401 PciIo,
1402 VbeBuffer,
1403 MemAddress,
1404 DestinationX,
1405 DstY,
1406 TotalBytes,
1407 VbePixelWidth,
1408 BytesPerScanLine
1409 );
1410 }
1411 break;
1412
1413 default: ;
1414 }
1415
1416 gBS->RestoreTPL (OriginalTPL);
1417
1418 return EFI_SUCCESS;
1419 }
1420
1421 /**
1422 Graphics Output protocol instance to block transfer for VBE device.
1423
1424 @param This Pointer to Graphics Output protocol instance
1425 @param BltBuffer The data to transfer to screen
1426 @param BltOperation The operation to perform
1427 @param SourceX The X coordinate of the source for BltOperation
1428 @param SourceY The Y coordinate of the source for BltOperation
1429 @param DestinationX The X coordinate of the destination for
1430 BltOperation
1431 @param DestinationY The Y coordinate of the destination for
1432 BltOperation
1433 @param Width The width of a rectangle in the blt rectangle in
1434 pixels
1435 @param Height The height of a rectangle in the blt rectangle in
1436 pixels
1437 @param Delta Not used for EfiBltVideoFill and
1438 EfiBltVideoToVideo operation. If a Delta of 0 is
1439 used, the entire BltBuffer will be operated on. If
1440 a subrectangle of the BltBuffer is used, then
1441 Delta represents the number of bytes in a row of
1442 the BltBuffer.
1443
1444 @retval EFI_INVALID_PARAMETER Invalid parameter passed in
1445 @retval EFI_SUCCESS Blt operation success
1446
1447 **/
1448 EFI_STATUS
1449 EFIAPI
1450 FbGopGraphicsOutputVbeBlt (
1451 IN EFI_GRAPHICS_OUTPUT_PROTOCOL *This,
1452 IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL *BltBuffer, OPTIONAL
1453 IN EFI_GRAPHICS_OUTPUT_BLT_OPERATION BltOperation,
1454 IN UINTN SourceX,
1455 IN UINTN SourceY,
1456 IN UINTN DestinationX,
1457 IN UINTN DestinationY,
1458 IN UINTN Width,
1459 IN UINTN Height,
1460 IN UINTN Delta
1461 )
1462 {
1463 FB_VIDEO_DEV *FbGopPrivate;
1464 FB_VIDEO_MODE_DATA *Mode;
1465
1466 if (This == NULL) {
1467 return EFI_INVALID_PARAMETER;
1468 }
1469
1470 FbGopPrivate = FB_VIDEO_DEV_FROM_GRAPHICS_OUTPUT_THIS (This);
1471 Mode = &FbGopPrivate->ModeData[This->Mode->Mode];
1472
1473 return FbGopVbeBltWorker (
1474 FbGopPrivate,
1475 BltBuffer,
1476 BltOperation,
1477 SourceX,
1478 SourceY,
1479 DestinationX,
1480 DestinationY,
1481 Width,
1482 Height,
1483 Delta,
1484 Mode
1485 );
1486 }
1487
1488
1489 /**
1490 The user Entry Point for module UefiFbGop. The user code starts with this function.
1491
1492 @param[in] ImageHandle The firmware allocated handle for the EFI image.
1493 @param[in] SystemTable A pointer to the EFI System Table.
1494
1495 @retval EFI_SUCCESS The entry point is executed successfully.
1496 @retval other Some error occurs when executing this entry point.
1497
1498 **/
1499 EFI_STATUS
1500 EFIAPI
1501 FbGopEntryPoint(
1502 IN EFI_HANDLE ImageHandle,
1503 IN EFI_SYSTEM_TABLE *SystemTable
1504 )
1505 {
1506 EFI_STATUS Status;
1507 EFI_HOB_GUID_TYPE *GuidHob;
1508
1509 //
1510 // Find the frame buffer information guid hob
1511 //
1512 GuidHob = GetFirstGuidHob (&gUefiFrameBufferInfoGuid);
1513 if (GuidHob != NULL) {
1514 //
1515 // Install driver model protocol(s).
1516 //
1517 Status = EfiLibInstallDriverBindingComponentName2 (
1518 ImageHandle,
1519 SystemTable,
1520 &gFbGopDriverBinding,
1521 ImageHandle,
1522 &gFbGopComponentName,
1523 &gFbGopComponentName2
1524 );
1525 ASSERT_EFI_ERROR (Status);
1526 } else {
1527 DEBUG ((EFI_D_ERROR, "No FrameBuffer information from coreboot. NO GOP driver !!!\n"));
1528 Status = EFI_ABORTED;
1529 }
1530 return Status;
1531 }
1532