99b7db7cc05ae531af55548beceb4472132ded62
[mirror_edk2.git] / OvmfPkg / Library / PlatformBootManagerLib / BdsPlatform.c
1 /** @file
2 Platform BDS customizations.
3
4 Copyright (c) 2004 - 2016, Intel Corporation. All rights reserved.<BR>
5 This program and the accompanying materials are licensed and made available
6 under the terms and conditions of the BSD License which accompanies this
7 distribution. The full text of the license may be found at
8 http://opensource.org/licenses/bsd-license.php
9
10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, WITHOUT
11 WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
12
13 **/
14
15 #include "BdsPlatform.h"
16 #include <Guid/XenInfo.h>
17 #include <Guid/RootBridgesConnectedEventGroup.h>
18 #include <Protocol/FirmwareVolume2.h>
19
20
21 //
22 // Global data
23 //
24
25 VOID *mEfiDevPathNotifyReg;
26 EFI_EVENT mEfiDevPathEvent;
27 VOID *mEmuVariableEventReg;
28 EFI_EVENT mEmuVariableEvent;
29 BOOLEAN mDetectVgaOnly;
30 UINT16 mHostBridgeDevId;
31
32 //
33 // Table of host IRQs matching PCI IRQs A-D
34 // (for configuring PCI Interrupt Line register)
35 //
36 CONST UINT8 PciHostIrqs[] = {
37 0x0a, 0x0a, 0x0b, 0x0b
38 };
39
40 //
41 // Type definitions
42 //
43
44 typedef
45 EFI_STATUS
46 (EFIAPI *PROTOCOL_INSTANCE_CALLBACK)(
47 IN EFI_HANDLE Handle,
48 IN VOID *Instance,
49 IN VOID *Context
50 );
51
52 /**
53 @param[in] Handle - Handle of PCI device instance
54 @param[in] PciIo - PCI IO protocol instance
55 @param[in] Pci - PCI Header register block
56 **/
57 typedef
58 EFI_STATUS
59 (EFIAPI *VISIT_PCI_INSTANCE_CALLBACK)(
60 IN EFI_HANDLE Handle,
61 IN EFI_PCI_IO_PROTOCOL *PciIo,
62 IN PCI_TYPE00 *Pci
63 );
64
65
66 //
67 // Function prototypes
68 //
69
70 EFI_STATUS
71 VisitAllInstancesOfProtocol (
72 IN EFI_GUID *Id,
73 IN PROTOCOL_INSTANCE_CALLBACK CallBackFunction,
74 IN VOID *Context
75 );
76
77 EFI_STATUS
78 VisitAllPciInstancesOfProtocol (
79 IN VISIT_PCI_INSTANCE_CALLBACK CallBackFunction
80 );
81
82 VOID
83 InstallDevicePathCallback (
84 VOID
85 );
86
87 VOID
88 PlatformRegisterFvBootOption (
89 EFI_GUID *FileGuid,
90 CHAR16 *Description,
91 UINT32 Attributes
92 )
93 {
94 EFI_STATUS Status;
95 INTN OptionIndex;
96 EFI_BOOT_MANAGER_LOAD_OPTION NewOption;
97 EFI_BOOT_MANAGER_LOAD_OPTION *BootOptions;
98 UINTN BootOptionCount;
99 MEDIA_FW_VOL_FILEPATH_DEVICE_PATH FileNode;
100 EFI_LOADED_IMAGE_PROTOCOL *LoadedImage;
101 EFI_DEVICE_PATH_PROTOCOL *DevicePath;
102
103 Status = gBS->HandleProtocol (
104 gImageHandle,
105 &gEfiLoadedImageProtocolGuid,
106 (VOID **) &LoadedImage
107 );
108 ASSERT_EFI_ERROR (Status);
109
110 EfiInitializeFwVolDevicepathNode (&FileNode, FileGuid);
111 DevicePath = DevicePathFromHandle (LoadedImage->DeviceHandle);
112 ASSERT (DevicePath != NULL);
113 DevicePath = AppendDevicePathNode (
114 DevicePath,
115 (EFI_DEVICE_PATH_PROTOCOL *) &FileNode
116 );
117 ASSERT (DevicePath != NULL);
118
119 Status = EfiBootManagerInitializeLoadOption (
120 &NewOption,
121 LoadOptionNumberUnassigned,
122 LoadOptionTypeBoot,
123 Attributes,
124 Description,
125 DevicePath,
126 NULL,
127 0
128 );
129 ASSERT_EFI_ERROR (Status);
130 FreePool (DevicePath);
131
132 BootOptions = EfiBootManagerGetLoadOptions (
133 &BootOptionCount, LoadOptionTypeBoot
134 );
135
136 OptionIndex = EfiBootManagerFindLoadOption (
137 &NewOption, BootOptions, BootOptionCount
138 );
139
140 if (OptionIndex == -1) {
141 Status = EfiBootManagerAddLoadOptionVariable (&NewOption, MAX_UINTN);
142 ASSERT_EFI_ERROR (Status);
143 }
144 EfiBootManagerFreeLoadOption (&NewOption);
145 EfiBootManagerFreeLoadOptions (BootOptions, BootOptionCount);
146 }
147
148 /**
149 Remove all MemoryMapped(...)/FvFile(...) and Fv(...)/FvFile(...) boot options
150 whose device paths do not resolve exactly to an FvFile in the system.
151
152 This removes any boot options that point to binaries built into the firmware
153 and have become stale due to any of the following:
154 - DXEFV's base address or size changed (historical),
155 - DXEFV's FvNameGuid changed,
156 - the FILE_GUID of the pointed-to binary changed,
157 - the referenced binary is no longer built into the firmware.
158
159 EfiBootManagerFindLoadOption() used in PlatformRegisterFvBootOption() only
160 avoids exact duplicates.
161 **/
162 VOID
163 RemoveStaleFvFileOptions (
164 VOID
165 )
166 {
167 EFI_BOOT_MANAGER_LOAD_OPTION *BootOptions;
168 UINTN BootOptionCount;
169 UINTN Index;
170
171 BootOptions = EfiBootManagerGetLoadOptions (&BootOptionCount,
172 LoadOptionTypeBoot);
173
174 for (Index = 0; Index < BootOptionCount; ++Index) {
175 EFI_DEVICE_PATH_PROTOCOL *Node1, *Node2, *SearchNode;
176 EFI_STATUS Status;
177 EFI_HANDLE FvHandle;
178
179 //
180 // If the device path starts with neither MemoryMapped(...) nor Fv(...),
181 // then keep the boot option.
182 //
183 Node1 = BootOptions[Index].FilePath;
184 if (!(DevicePathType (Node1) == HARDWARE_DEVICE_PATH &&
185 DevicePathSubType (Node1) == HW_MEMMAP_DP) &&
186 !(DevicePathType (Node1) == MEDIA_DEVICE_PATH &&
187 DevicePathSubType (Node1) == MEDIA_PIWG_FW_VOL_DP)) {
188 continue;
189 }
190
191 //
192 // If the second device path node is not FvFile(...), then keep the boot
193 // option.
194 //
195 Node2 = NextDevicePathNode (Node1);
196 if (DevicePathType (Node2) != MEDIA_DEVICE_PATH ||
197 DevicePathSubType (Node2) != MEDIA_PIWG_FW_FILE_DP) {
198 continue;
199 }
200
201 //
202 // Locate the Firmware Volume2 protocol instance that is denoted by the
203 // boot option. If this lookup fails (i.e., the boot option references a
204 // firmware volume that doesn't exist), then we'll proceed to delete the
205 // boot option.
206 //
207 SearchNode = Node1;
208 Status = gBS->LocateDevicePath (&gEfiFirmwareVolume2ProtocolGuid,
209 &SearchNode, &FvHandle);
210
211 if (!EFI_ERROR (Status)) {
212 //
213 // The firmware volume was found; now let's see if it contains the FvFile
214 // identified by GUID.
215 //
216 EFI_FIRMWARE_VOLUME2_PROTOCOL *FvProtocol;
217 MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *FvFileNode;
218 UINTN BufferSize;
219 EFI_FV_FILETYPE FoundType;
220 EFI_FV_FILE_ATTRIBUTES FileAttributes;
221 UINT32 AuthenticationStatus;
222
223 Status = gBS->HandleProtocol (FvHandle, &gEfiFirmwareVolume2ProtocolGuid,
224 (VOID **)&FvProtocol);
225 ASSERT_EFI_ERROR (Status);
226
227 FvFileNode = (MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *)Node2;
228 //
229 // Buffer==NULL means we request metadata only: BufferSize, FoundType,
230 // FileAttributes.
231 //
232 Status = FvProtocol->ReadFile (
233 FvProtocol,
234 &FvFileNode->FvFileName, // NameGuid
235 NULL, // Buffer
236 &BufferSize,
237 &FoundType,
238 &FileAttributes,
239 &AuthenticationStatus
240 );
241 if (!EFI_ERROR (Status)) {
242 //
243 // The FvFile was found. Keep the boot option.
244 //
245 continue;
246 }
247 }
248
249 //
250 // Delete the boot option.
251 //
252 Status = EfiBootManagerDeleteLoadOptionVariable (
253 BootOptions[Index].OptionNumber, LoadOptionTypeBoot);
254 DEBUG_CODE (
255 CHAR16 *DevicePathString;
256
257 DevicePathString = ConvertDevicePathToText(BootOptions[Index].FilePath,
258 FALSE, FALSE);
259 DEBUG ((
260 EFI_ERROR (Status) ? EFI_D_WARN : EFI_D_VERBOSE,
261 "%a: removing stale Boot#%04x %s: %r\n",
262 __FUNCTION__,
263 (UINT32)BootOptions[Index].OptionNumber,
264 DevicePathString == NULL ? L"<unavailable>" : DevicePathString,
265 Status
266 ));
267 if (DevicePathString != NULL) {
268 FreePool (DevicePathString);
269 }
270 );
271 }
272
273 EfiBootManagerFreeLoadOptions (BootOptions, BootOptionCount);
274 }
275
276 VOID
277 PlatformRegisterOptionsAndKeys (
278 VOID
279 )
280 {
281 EFI_STATUS Status;
282 EFI_INPUT_KEY Enter;
283 EFI_INPUT_KEY F2;
284 EFI_INPUT_KEY Esc;
285 EFI_BOOT_MANAGER_LOAD_OPTION BootOption;
286
287 //
288 // Register ENTER as CONTINUE key
289 //
290 Enter.ScanCode = SCAN_NULL;
291 Enter.UnicodeChar = CHAR_CARRIAGE_RETURN;
292 Status = EfiBootManagerRegisterContinueKeyOption (0, &Enter, NULL);
293 ASSERT_EFI_ERROR (Status);
294
295 //
296 // Map F2 to Boot Manager Menu
297 //
298 F2.ScanCode = SCAN_F2;
299 F2.UnicodeChar = CHAR_NULL;
300 Esc.ScanCode = SCAN_ESC;
301 Esc.UnicodeChar = CHAR_NULL;
302 Status = EfiBootManagerGetBootManagerMenu (&BootOption);
303 ASSERT_EFI_ERROR (Status);
304 Status = EfiBootManagerAddKeyOptionVariable (
305 NULL, (UINT16) BootOption.OptionNumber, 0, &F2, NULL
306 );
307 ASSERT (Status == EFI_SUCCESS || Status == EFI_ALREADY_STARTED);
308 Status = EfiBootManagerAddKeyOptionVariable (
309 NULL, (UINT16) BootOption.OptionNumber, 0, &Esc, NULL
310 );
311 ASSERT (Status == EFI_SUCCESS || Status == EFI_ALREADY_STARTED);
312 }
313
314 EFI_STATUS
315 EFIAPI
316 ConnectRootBridge (
317 IN EFI_HANDLE RootBridgeHandle,
318 IN VOID *Instance,
319 IN VOID *Context
320 );
321
322 STATIC
323 VOID
324 SaveS3BootScript (
325 VOID
326 );
327
328 //
329 // BDS Platform Functions
330 //
331 VOID
332 EFIAPI
333 PlatformBootManagerBeforeConsole (
334 VOID
335 )
336 /*++
337
338 Routine Description:
339
340 Platform Bds init. Include the platform firmware vendor, revision
341 and so crc check.
342
343 Arguments:
344
345 Returns:
346
347 None.
348
349 --*/
350 {
351 EFI_HANDLE Handle;
352 EFI_STATUS Status;
353 RETURN_STATUS PcdStatus;
354
355 DEBUG ((EFI_D_INFO, "PlatformBootManagerBeforeConsole\n"));
356 InstallDevicePathCallback ();
357
358 VisitAllInstancesOfProtocol (&gEfiPciRootBridgeIoProtocolGuid,
359 ConnectRootBridge, NULL);
360
361 //
362 // Signal the ACPI platform driver that it can download QEMU ACPI tables.
363 //
364 EfiEventGroupSignal (&gRootBridgesConnectedEventGroupGuid);
365
366 //
367 // We can't signal End-of-Dxe earlier than this. Namely, End-of-Dxe triggers
368 // the preparation of S3 system information. That logic has a hard dependency
369 // on the presence of the FACS ACPI table. Since our ACPI tables are only
370 // installed after PCI enumeration completes, we must not trigger the S3 save
371 // earlier, hence we can't signal End-of-Dxe earlier.
372 //
373 EfiEventGroupSignal (&gEfiEndOfDxeEventGroupGuid);
374
375 if (QemuFwCfgS3Enabled ()) {
376 //
377 // Save the boot script too. Note that this will require us to emit the
378 // DxeSmmReadyToLock event just below, which in turn locks down SMM.
379 //
380 SaveS3BootScript ();
381 }
382
383 //
384 // Prevent further changes to LockBoxes or SMRAM.
385 //
386 Handle = NULL;
387 Status = gBS->InstallProtocolInterface (&Handle,
388 &gEfiDxeSmmReadyToLockProtocolGuid, EFI_NATIVE_INTERFACE,
389 NULL);
390 ASSERT_EFI_ERROR (Status);
391
392 //
393 // Dispatch deferred images after EndOfDxe event and ReadyToLock
394 // installation.
395 //
396 EfiBootManagerDispatchDeferredImages ();
397
398 PlatformInitializeConsole (gPlatformConsole);
399 PcdStatus = PcdSet16S (PcdPlatformBootTimeOut,
400 GetFrontPageTimeoutFromQemu ());
401 ASSERT_RETURN_ERROR (PcdStatus);
402
403 PlatformRegisterOptionsAndKeys ();
404 }
405
406
407 EFI_STATUS
408 EFIAPI
409 ConnectRootBridge (
410 IN EFI_HANDLE RootBridgeHandle,
411 IN VOID *Instance,
412 IN VOID *Context
413 )
414 {
415 EFI_STATUS Status;
416
417 //
418 // Make the PCI bus driver connect the root bridge, non-recursively. This
419 // will produce a number of child handles with PciIo on them.
420 //
421 Status = gBS->ConnectController (
422 RootBridgeHandle, // ControllerHandle
423 NULL, // DriverImageHandle
424 NULL, // RemainingDevicePath -- produce all
425 // children
426 FALSE // Recursive
427 );
428 return Status;
429 }
430
431
432 EFI_STATUS
433 PrepareLpcBridgeDevicePath (
434 IN EFI_HANDLE DeviceHandle
435 )
436 /*++
437
438 Routine Description:
439
440 Add IsaKeyboard to ConIn,
441 add IsaSerial to ConOut, ConIn, ErrOut.
442 LPC Bridge: 06 01 00
443
444 Arguments:
445
446 DeviceHandle - Handle of PCIIO protocol.
447
448 Returns:
449
450 EFI_SUCCESS - LPC bridge is added to ConOut, ConIn, and ErrOut.
451 EFI_STATUS - No LPC bridge is added.
452
453 --*/
454 {
455 EFI_STATUS Status;
456 EFI_DEVICE_PATH_PROTOCOL *DevicePath;
457 EFI_DEVICE_PATH_PROTOCOL *TempDevicePath;
458 CHAR16 *DevPathStr;
459
460 DevicePath = NULL;
461 Status = gBS->HandleProtocol (
462 DeviceHandle,
463 &gEfiDevicePathProtocolGuid,
464 (VOID*)&DevicePath
465 );
466 if (EFI_ERROR (Status)) {
467 return Status;
468 }
469 TempDevicePath = DevicePath;
470
471 //
472 // Register Keyboard
473 //
474 DevicePath = AppendDevicePathNode (DevicePath,
475 (EFI_DEVICE_PATH_PROTOCOL *)&gPnpPs2KeyboardDeviceNode);
476
477 EfiBootManagerUpdateConsoleVariable (ConIn, DevicePath, NULL);
478
479 //
480 // Register COM1
481 //
482 DevicePath = TempDevicePath;
483 gPnp16550ComPortDeviceNode.UID = 0;
484
485 DevicePath = AppendDevicePathNode (DevicePath,
486 (EFI_DEVICE_PATH_PROTOCOL *)&gPnp16550ComPortDeviceNode);
487 DevicePath = AppendDevicePathNode (DevicePath,
488 (EFI_DEVICE_PATH_PROTOCOL *)&gUartDeviceNode);
489 DevicePath = AppendDevicePathNode (DevicePath,
490 (EFI_DEVICE_PATH_PROTOCOL *)&gTerminalTypeDeviceNode);
491
492 //
493 // Print Device Path
494 //
495 DevPathStr = ConvertDevicePathToText (DevicePath, FALSE, FALSE);
496 if (DevPathStr != NULL) {
497 DEBUG((
498 EFI_D_INFO,
499 "BdsPlatform.c+%d: COM%d DevPath: %s\n",
500 __LINE__,
501 gPnp16550ComPortDeviceNode.UID + 1,
502 DevPathStr
503 ));
504 FreePool(DevPathStr);
505 }
506
507 EfiBootManagerUpdateConsoleVariable (ConOut, DevicePath, NULL);
508 EfiBootManagerUpdateConsoleVariable (ConIn, DevicePath, NULL);
509 EfiBootManagerUpdateConsoleVariable (ErrOut, DevicePath, NULL);
510
511 //
512 // Register COM2
513 //
514 DevicePath = TempDevicePath;
515 gPnp16550ComPortDeviceNode.UID = 1;
516
517 DevicePath = AppendDevicePathNode (DevicePath,
518 (EFI_DEVICE_PATH_PROTOCOL *)&gPnp16550ComPortDeviceNode);
519 DevicePath = AppendDevicePathNode (DevicePath,
520 (EFI_DEVICE_PATH_PROTOCOL *)&gUartDeviceNode);
521 DevicePath = AppendDevicePathNode (DevicePath,
522 (EFI_DEVICE_PATH_PROTOCOL *)&gTerminalTypeDeviceNode);
523
524 //
525 // Print Device Path
526 //
527 DevPathStr = ConvertDevicePathToText (DevicePath, FALSE, FALSE);
528 if (DevPathStr != NULL) {
529 DEBUG((
530 EFI_D_INFO,
531 "BdsPlatform.c+%d: COM%d DevPath: %s\n",
532 __LINE__,
533 gPnp16550ComPortDeviceNode.UID + 1,
534 DevPathStr
535 ));
536 FreePool(DevPathStr);
537 }
538
539 EfiBootManagerUpdateConsoleVariable (ConOut, DevicePath, NULL);
540 EfiBootManagerUpdateConsoleVariable (ConIn, DevicePath, NULL);
541 EfiBootManagerUpdateConsoleVariable (ErrOut, DevicePath, NULL);
542
543 return EFI_SUCCESS;
544 }
545
546 EFI_STATUS
547 GetGopDevicePath (
548 IN EFI_DEVICE_PATH_PROTOCOL *PciDevicePath,
549 OUT EFI_DEVICE_PATH_PROTOCOL **GopDevicePath
550 )
551 {
552 UINTN Index;
553 EFI_STATUS Status;
554 EFI_HANDLE PciDeviceHandle;
555 EFI_DEVICE_PATH_PROTOCOL *TempDevicePath;
556 EFI_DEVICE_PATH_PROTOCOL *TempPciDevicePath;
557 UINTN GopHandleCount;
558 EFI_HANDLE *GopHandleBuffer;
559
560 if (PciDevicePath == NULL || GopDevicePath == NULL) {
561 return EFI_INVALID_PARAMETER;
562 }
563
564 //
565 // Initialize the GopDevicePath to be PciDevicePath
566 //
567 *GopDevicePath = PciDevicePath;
568 TempPciDevicePath = PciDevicePath;
569
570 Status = gBS->LocateDevicePath (
571 &gEfiDevicePathProtocolGuid,
572 &TempPciDevicePath,
573 &PciDeviceHandle
574 );
575 if (EFI_ERROR (Status)) {
576 return Status;
577 }
578
579 //
580 // Try to connect this handle, so that GOP driver could start on this
581 // device and create child handles with GraphicsOutput Protocol installed
582 // on them, then we get device paths of these child handles and select
583 // them as possible console device.
584 //
585 gBS->ConnectController (PciDeviceHandle, NULL, NULL, FALSE);
586
587 Status = gBS->LocateHandleBuffer (
588 ByProtocol,
589 &gEfiGraphicsOutputProtocolGuid,
590 NULL,
591 &GopHandleCount,
592 &GopHandleBuffer
593 );
594 if (!EFI_ERROR (Status)) {
595 //
596 // Add all the child handles as possible Console Device
597 //
598 for (Index = 0; Index < GopHandleCount; Index++) {
599 Status = gBS->HandleProtocol (GopHandleBuffer[Index],
600 &gEfiDevicePathProtocolGuid, (VOID*)&TempDevicePath);
601 if (EFI_ERROR (Status)) {
602 continue;
603 }
604 if (CompareMem (
605 PciDevicePath,
606 TempDevicePath,
607 GetDevicePathSize (PciDevicePath) - END_DEVICE_PATH_LENGTH
608 ) == 0) {
609 //
610 // In current implementation, we only enable one of the child handles
611 // as console device, i.e. sotre one of the child handle's device
612 // path to variable "ConOut"
613 // In future, we could select all child handles to be console device
614 //
615
616 *GopDevicePath = TempDevicePath;
617
618 //
619 // Delete the PCI device's path that added by
620 // GetPlugInPciVgaDevicePath(). Add the integrity GOP device path.
621 //
622 EfiBootManagerUpdateConsoleVariable (ConOutDev, NULL, PciDevicePath);
623 EfiBootManagerUpdateConsoleVariable (ConOutDev, TempDevicePath, NULL);
624 }
625 }
626 gBS->FreePool (GopHandleBuffer);
627 }
628
629 return EFI_SUCCESS;
630 }
631
632 EFI_STATUS
633 PreparePciDisplayDevicePath (
634 IN EFI_HANDLE DeviceHandle
635 )
636 /*++
637
638 Routine Description:
639
640 Add PCI VGA to ConOut.
641 PCI VGA: 03 00 00
642
643 Arguments:
644
645 DeviceHandle - Handle of PCIIO protocol.
646
647 Returns:
648
649 EFI_SUCCESS - PCI VGA is added to ConOut.
650 EFI_STATUS - No PCI VGA device is added.
651
652 --*/
653 {
654 EFI_STATUS Status;
655 EFI_DEVICE_PATH_PROTOCOL *DevicePath;
656 EFI_DEVICE_PATH_PROTOCOL *GopDevicePath;
657
658 DevicePath = NULL;
659 GopDevicePath = NULL;
660 Status = gBS->HandleProtocol (
661 DeviceHandle,
662 &gEfiDevicePathProtocolGuid,
663 (VOID*)&DevicePath
664 );
665 if (EFI_ERROR (Status)) {
666 return Status;
667 }
668
669 GetGopDevicePath (DevicePath, &GopDevicePath);
670 DevicePath = GopDevicePath;
671
672 EfiBootManagerUpdateConsoleVariable (ConOut, DevicePath, NULL);
673
674 return EFI_SUCCESS;
675 }
676
677 EFI_STATUS
678 PreparePciSerialDevicePath (
679 IN EFI_HANDLE DeviceHandle
680 )
681 /*++
682
683 Routine Description:
684
685 Add PCI Serial to ConOut, ConIn, ErrOut.
686 PCI Serial: 07 00 02
687
688 Arguments:
689
690 DeviceHandle - Handle of PCIIO protocol.
691
692 Returns:
693
694 EFI_SUCCESS - PCI Serial is added to ConOut, ConIn, and ErrOut.
695 EFI_STATUS - No PCI Serial device is added.
696
697 --*/
698 {
699 EFI_STATUS Status;
700 EFI_DEVICE_PATH_PROTOCOL *DevicePath;
701
702 DevicePath = NULL;
703 Status = gBS->HandleProtocol (
704 DeviceHandle,
705 &gEfiDevicePathProtocolGuid,
706 (VOID*)&DevicePath
707 );
708 if (EFI_ERROR (Status)) {
709 return Status;
710 }
711
712 DevicePath = AppendDevicePathNode (DevicePath,
713 (EFI_DEVICE_PATH_PROTOCOL *)&gUartDeviceNode);
714 DevicePath = AppendDevicePathNode (DevicePath,
715 (EFI_DEVICE_PATH_PROTOCOL *)&gTerminalTypeDeviceNode);
716
717 EfiBootManagerUpdateConsoleVariable (ConOut, DevicePath, NULL);
718 EfiBootManagerUpdateConsoleVariable (ConIn, DevicePath, NULL);
719 EfiBootManagerUpdateConsoleVariable (ErrOut, DevicePath, NULL);
720
721 return EFI_SUCCESS;
722 }
723
724 EFI_STATUS
725 VisitAllInstancesOfProtocol (
726 IN EFI_GUID *Id,
727 IN PROTOCOL_INSTANCE_CALLBACK CallBackFunction,
728 IN VOID *Context
729 )
730 {
731 EFI_STATUS Status;
732 UINTN HandleCount;
733 EFI_HANDLE *HandleBuffer;
734 UINTN Index;
735 VOID *Instance;
736
737 //
738 // Start to check all the PciIo to find all possible device
739 //
740 HandleCount = 0;
741 HandleBuffer = NULL;
742 Status = gBS->LocateHandleBuffer (
743 ByProtocol,
744 Id,
745 NULL,
746 &HandleCount,
747 &HandleBuffer
748 );
749 if (EFI_ERROR (Status)) {
750 return Status;
751 }
752
753 for (Index = 0; Index < HandleCount; Index++) {
754 Status = gBS->HandleProtocol (HandleBuffer[Index], Id, &Instance);
755 if (EFI_ERROR (Status)) {
756 continue;
757 }
758
759 Status = (*CallBackFunction) (
760 HandleBuffer[Index],
761 Instance,
762 Context
763 );
764 }
765
766 gBS->FreePool (HandleBuffer);
767
768 return EFI_SUCCESS;
769 }
770
771
772 EFI_STATUS
773 EFIAPI
774 VisitingAPciInstance (
775 IN EFI_HANDLE Handle,
776 IN VOID *Instance,
777 IN VOID *Context
778 )
779 {
780 EFI_STATUS Status;
781 EFI_PCI_IO_PROTOCOL *PciIo;
782 PCI_TYPE00 Pci;
783
784 PciIo = (EFI_PCI_IO_PROTOCOL*) Instance;
785
786 //
787 // Check for all PCI device
788 //
789 Status = PciIo->Pci.Read (
790 PciIo,
791 EfiPciIoWidthUint32,
792 0,
793 sizeof (Pci) / sizeof (UINT32),
794 &Pci
795 );
796 if (EFI_ERROR (Status)) {
797 return Status;
798 }
799
800 return (*(VISIT_PCI_INSTANCE_CALLBACK)(UINTN) Context) (
801 Handle,
802 PciIo,
803 &Pci
804 );
805
806 }
807
808
809
810 EFI_STATUS
811 VisitAllPciInstances (
812 IN VISIT_PCI_INSTANCE_CALLBACK CallBackFunction
813 )
814 {
815 return VisitAllInstancesOfProtocol (
816 &gEfiPciIoProtocolGuid,
817 VisitingAPciInstance,
818 (VOID*)(UINTN) CallBackFunction
819 );
820 }
821
822
823 /**
824 Do platform specific PCI Device check and add them to
825 ConOut, ConIn, ErrOut.
826
827 @param[in] Handle - Handle of PCI device instance
828 @param[in] PciIo - PCI IO protocol instance
829 @param[in] Pci - PCI Header register block
830
831 @retval EFI_SUCCESS - PCI Device check and Console variable update
832 successfully.
833 @retval EFI_STATUS - PCI Device check or Console variable update fail.
834
835 **/
836 EFI_STATUS
837 EFIAPI
838 DetectAndPreparePlatformPciDevicePath (
839 IN EFI_HANDLE Handle,
840 IN EFI_PCI_IO_PROTOCOL *PciIo,
841 IN PCI_TYPE00 *Pci
842 )
843 {
844 EFI_STATUS Status;
845
846 Status = PciIo->Attributes (
847 PciIo,
848 EfiPciIoAttributeOperationEnable,
849 EFI_PCI_DEVICE_ENABLE,
850 NULL
851 );
852 ASSERT_EFI_ERROR (Status);
853
854 if (!mDetectVgaOnly) {
855 //
856 // Here we decide whether it is LPC Bridge
857 //
858 if ((IS_PCI_LPC (Pci)) ||
859 ((IS_PCI_ISA_PDECODE (Pci)) &&
860 (Pci->Hdr.VendorId == 0x8086) &&
861 (Pci->Hdr.DeviceId == 0x7000)
862 )
863 ) {
864 //
865 // Add IsaKeyboard to ConIn,
866 // add IsaSerial to ConOut, ConIn, ErrOut
867 //
868 DEBUG ((EFI_D_INFO, "Found LPC Bridge device\n"));
869 PrepareLpcBridgeDevicePath (Handle);
870 return EFI_SUCCESS;
871 }
872 //
873 // Here we decide which Serial device to enable in PCI bus
874 //
875 if (IS_PCI_16550SERIAL (Pci)) {
876 //
877 // Add them to ConOut, ConIn, ErrOut.
878 //
879 DEBUG ((EFI_D_INFO, "Found PCI 16550 SERIAL device\n"));
880 PreparePciSerialDevicePath (Handle);
881 return EFI_SUCCESS;
882 }
883 }
884
885 //
886 // Here we decide which display device to enable in PCI bus
887 //
888 if (IS_PCI_DISPLAY (Pci)) {
889 //
890 // Add them to ConOut.
891 //
892 DEBUG ((EFI_D_INFO, "Found PCI display device\n"));
893 PreparePciDisplayDevicePath (Handle);
894 return EFI_SUCCESS;
895 }
896
897 return Status;
898 }
899
900
901 /**
902 Do platform specific PCI Device check and add them to ConOut, ConIn, ErrOut
903
904 @param[in] DetectVgaOnly - Only detect VGA device if it's TRUE.
905
906 @retval EFI_SUCCESS - PCI Device check and Console variable update
907 successfully.
908 @retval EFI_STATUS - PCI Device check or Console variable update fail.
909
910 **/
911 EFI_STATUS
912 DetectAndPreparePlatformPciDevicePaths (
913 BOOLEAN DetectVgaOnly
914 )
915 {
916 mDetectVgaOnly = DetectVgaOnly;
917 return VisitAllPciInstances (DetectAndPreparePlatformPciDevicePath);
918 }
919
920
921 VOID
922 PlatformInitializeConsole (
923 IN PLATFORM_CONSOLE_CONNECT_ENTRY *PlatformConsole
924 )
925 /*++
926
927 Routine Description:
928
929 Connect the predefined platform default console device. Always try to find
930 and enable the vga device if have.
931
932 Arguments:
933
934 PlatformConsole - Predefined platform default console device array.
935 --*/
936 {
937 UINTN Index;
938 EFI_DEVICE_PATH_PROTOCOL *VarConout;
939 EFI_DEVICE_PATH_PROTOCOL *VarConin;
940
941 //
942 // Connect RootBridge
943 //
944 GetEfiGlobalVariable2 (EFI_CON_OUT_VARIABLE_NAME, (VOID **) &VarConout,
945 NULL);
946 GetEfiGlobalVariable2 (EFI_CON_IN_VARIABLE_NAME, (VOID **) &VarConin, NULL);
947
948 if (VarConout == NULL || VarConin == NULL) {
949 //
950 // Do platform specific PCI Device check and add them to ConOut, ConIn,
951 // ErrOut
952 //
953 DetectAndPreparePlatformPciDevicePaths (FALSE);
954
955 //
956 // Have chance to connect the platform default console,
957 // the platform default console is the minimum device group
958 // the platform should support
959 //
960 for (Index = 0; PlatformConsole[Index].DevicePath != NULL; ++Index) {
961 //
962 // Update the console variable with the connect type
963 //
964 if ((PlatformConsole[Index].ConnectType & CONSOLE_IN) == CONSOLE_IN) {
965 EfiBootManagerUpdateConsoleVariable (ConIn,
966 PlatformConsole[Index].DevicePath, NULL);
967 }
968 if ((PlatformConsole[Index].ConnectType & CONSOLE_OUT) == CONSOLE_OUT) {
969 EfiBootManagerUpdateConsoleVariable (ConOut,
970 PlatformConsole[Index].DevicePath, NULL);
971 }
972 if ((PlatformConsole[Index].ConnectType & STD_ERROR) == STD_ERROR) {
973 EfiBootManagerUpdateConsoleVariable (ErrOut,
974 PlatformConsole[Index].DevicePath, NULL);
975 }
976 }
977 } else {
978 //
979 // Only detect VGA device and add them to ConOut
980 //
981 DetectAndPreparePlatformPciDevicePaths (TRUE);
982 }
983 }
984
985
986 /**
987 Configure PCI Interrupt Line register for applicable devices
988 Ported from SeaBIOS, src/fw/pciinit.c, *_pci_slot_get_irq()
989
990 @param[in] Handle - Handle of PCI device instance
991 @param[in] PciIo - PCI IO protocol instance
992 @param[in] PciHdr - PCI Header register block
993
994 @retval EFI_SUCCESS - PCI Interrupt Line register configured successfully.
995
996 **/
997 EFI_STATUS
998 EFIAPI
999 SetPciIntLine (
1000 IN EFI_HANDLE Handle,
1001 IN EFI_PCI_IO_PROTOCOL *PciIo,
1002 IN PCI_TYPE00 *PciHdr
1003 )
1004 {
1005 EFI_DEVICE_PATH_PROTOCOL *DevPathNode;
1006 EFI_DEVICE_PATH_PROTOCOL *DevPath;
1007 UINTN RootSlot;
1008 UINTN Idx;
1009 UINT8 IrqLine;
1010 EFI_STATUS Status;
1011 UINT32 RootBusNumber;
1012
1013 Status = EFI_SUCCESS;
1014
1015 if (PciHdr->Device.InterruptPin != 0) {
1016
1017 DevPathNode = DevicePathFromHandle (Handle);
1018 ASSERT (DevPathNode != NULL);
1019 DevPath = DevPathNode;
1020
1021 RootBusNumber = 0;
1022 if (DevicePathType (DevPathNode) == ACPI_DEVICE_PATH &&
1023 DevicePathSubType (DevPathNode) == ACPI_DP &&
1024 ((ACPI_HID_DEVICE_PATH *)DevPathNode)->HID == EISA_PNP_ID(0x0A03)) {
1025 RootBusNumber = ((ACPI_HID_DEVICE_PATH *)DevPathNode)->UID;
1026 }
1027
1028 //
1029 // Compute index into PciHostIrqs[] table by walking
1030 // the device path and adding up all device numbers
1031 //
1032 Status = EFI_NOT_FOUND;
1033 RootSlot = 0;
1034 Idx = PciHdr->Device.InterruptPin - 1;
1035 while (!IsDevicePathEnd (DevPathNode)) {
1036 if (DevicePathType (DevPathNode) == HARDWARE_DEVICE_PATH &&
1037 DevicePathSubType (DevPathNode) == HW_PCI_DP) {
1038
1039 Idx += ((PCI_DEVICE_PATH *)DevPathNode)->Device;
1040
1041 //
1042 // Unlike SeaBIOS, which starts climbing from the leaf device
1043 // up toward the root, we traverse the device path starting at
1044 // the root moving toward the leaf node.
1045 // The slot number of the top-level parent bridge is needed for
1046 // Q35 cases with more than 24 slots on the root bus.
1047 //
1048 if (Status != EFI_SUCCESS) {
1049 Status = EFI_SUCCESS;
1050 RootSlot = ((PCI_DEVICE_PATH *)DevPathNode)->Device;
1051 }
1052 }
1053
1054 DevPathNode = NextDevicePathNode (DevPathNode);
1055 }
1056 if (EFI_ERROR (Status)) {
1057 return Status;
1058 }
1059 if (RootBusNumber == 0 && RootSlot == 0) {
1060 DEBUG((
1061 EFI_D_ERROR,
1062 "%a: PCI host bridge (00:00.0) should have no interrupts!\n",
1063 __FUNCTION__
1064 ));
1065 ASSERT (FALSE);
1066 }
1067
1068 //
1069 // Final PciHostIrqs[] index calculation depends on the platform
1070 // and should match SeaBIOS src/fw/pciinit.c *_pci_slot_get_irq()
1071 //
1072 switch (mHostBridgeDevId) {
1073 case INTEL_82441_DEVICE_ID:
1074 Idx -= 1;
1075 break;
1076 case INTEL_Q35_MCH_DEVICE_ID:
1077 //
1078 // SeaBIOS contains the following comment:
1079 // "Slots 0-24 rotate slot:pin mapping similar to piix above, but
1080 // with a different starting index - see q35-acpi-dsdt.dsl.
1081 //
1082 // Slots 25-31 all use LNKA mapping (or LNKE, but A:D = E:H)"
1083 //
1084 if (RootSlot > 24) {
1085 //
1086 // in this case, subtract back out RootSlot from Idx
1087 // (SeaBIOS never adds it to begin with, but that would make our
1088 // device path traversal loop above too awkward)
1089 //
1090 Idx -= RootSlot;
1091 }
1092 break;
1093 default:
1094 ASSERT (FALSE); // should never get here
1095 }
1096 Idx %= ARRAY_SIZE (PciHostIrqs);
1097 IrqLine = PciHostIrqs[Idx];
1098
1099 DEBUG_CODE_BEGIN ();
1100 {
1101 CHAR16 *DevPathString;
1102 STATIC CHAR16 Fallback[] = L"<failed to convert>";
1103 UINTN Segment, Bus, Device, Function;
1104
1105 DevPathString = ConvertDevicePathToText (DevPath, FALSE, FALSE);
1106 if (DevPathString == NULL) {
1107 DevPathString = Fallback;
1108 }
1109 Status = PciIo->GetLocation (PciIo, &Segment, &Bus, &Device, &Function);
1110 ASSERT_EFI_ERROR (Status);
1111
1112 DEBUG ((EFI_D_VERBOSE, "%a: [%02x:%02x.%x] %s -> 0x%02x\n", __FUNCTION__,
1113 (UINT32)Bus, (UINT32)Device, (UINT32)Function, DevPathString,
1114 IrqLine));
1115
1116 if (DevPathString != Fallback) {
1117 FreePool (DevPathString);
1118 }
1119 }
1120 DEBUG_CODE_END ();
1121
1122 //
1123 // Set PCI Interrupt Line register for this device to PciHostIrqs[Idx]
1124 //
1125 Status = PciIo->Pci.Write (
1126 PciIo,
1127 EfiPciIoWidthUint8,
1128 PCI_INT_LINE_OFFSET,
1129 1,
1130 &IrqLine
1131 );
1132 }
1133
1134 return Status;
1135 }
1136
1137
1138 VOID
1139 PciAcpiInitialization (
1140 )
1141 {
1142 UINTN Pmba;
1143
1144 //
1145 // Query Host Bridge DID to determine platform type
1146 //
1147 mHostBridgeDevId = PcdGet16 (PcdOvmfHostBridgePciDevId);
1148 switch (mHostBridgeDevId) {
1149 case INTEL_82441_DEVICE_ID:
1150 Pmba = POWER_MGMT_REGISTER_PIIX4 (PIIX4_PMBA);
1151 //
1152 // 00:01.0 ISA Bridge (PIIX4) LNK routing targets
1153 //
1154 PciWrite8 (PCI_LIB_ADDRESS (0, 1, 0, 0x60), 0x0b); // A
1155 PciWrite8 (PCI_LIB_ADDRESS (0, 1, 0, 0x61), 0x0b); // B
1156 PciWrite8 (PCI_LIB_ADDRESS (0, 1, 0, 0x62), 0x0a); // C
1157 PciWrite8 (PCI_LIB_ADDRESS (0, 1, 0, 0x63), 0x0a); // D
1158 break;
1159 case INTEL_Q35_MCH_DEVICE_ID:
1160 Pmba = POWER_MGMT_REGISTER_Q35 (ICH9_PMBASE);
1161 //
1162 // 00:1f.0 LPC Bridge (Q35) LNK routing targets
1163 //
1164 PciWrite8 (PCI_LIB_ADDRESS (0, 0x1f, 0, 0x60), 0x0a); // A
1165 PciWrite8 (PCI_LIB_ADDRESS (0, 0x1f, 0, 0x61), 0x0a); // B
1166 PciWrite8 (PCI_LIB_ADDRESS (0, 0x1f, 0, 0x62), 0x0b); // C
1167 PciWrite8 (PCI_LIB_ADDRESS (0, 0x1f, 0, 0x63), 0x0b); // D
1168 PciWrite8 (PCI_LIB_ADDRESS (0, 0x1f, 0, 0x68), 0x0a); // E
1169 PciWrite8 (PCI_LIB_ADDRESS (0, 0x1f, 0, 0x69), 0x0a); // F
1170 PciWrite8 (PCI_LIB_ADDRESS (0, 0x1f, 0, 0x6a), 0x0b); // G
1171 PciWrite8 (PCI_LIB_ADDRESS (0, 0x1f, 0, 0x6b), 0x0b); // H
1172 break;
1173 default:
1174 DEBUG ((EFI_D_ERROR, "%a: Unknown Host Bridge Device ID: 0x%04x\n",
1175 __FUNCTION__, mHostBridgeDevId));
1176 ASSERT (FALSE);
1177 return;
1178 }
1179
1180 //
1181 // Initialize PCI_INTERRUPT_LINE for applicable present PCI devices
1182 //
1183 VisitAllPciInstances (SetPciIntLine);
1184
1185 //
1186 // Set ACPI SCI_EN bit in PMCNTRL
1187 //
1188 IoOr16 ((PciRead32 (Pmba) & ~BIT0) + 4, BIT0);
1189 }
1190
1191 /**
1192 This function detects if OVMF is running on Xen.
1193
1194 **/
1195 STATIC
1196 BOOLEAN
1197 XenDetected (
1198 VOID
1199 )
1200 {
1201 EFI_HOB_GUID_TYPE *GuidHob;
1202 STATIC INTN FoundHob = -1;
1203
1204 if (FoundHob == 0) {
1205 return FALSE;
1206 } else if (FoundHob == 1) {
1207 return TRUE;
1208 }
1209
1210 //
1211 // See if a XenInfo HOB is available
1212 //
1213 GuidHob = GetFirstGuidHob (&gEfiXenInfoGuid);
1214 if (GuidHob == NULL) {
1215 FoundHob = 0;
1216 return FALSE;
1217 }
1218
1219 FoundHob = 1;
1220 return TRUE;
1221 }
1222
1223 EFI_STATUS
1224 EFIAPI
1225 ConnectRecursivelyIfPciMassStorage (
1226 IN EFI_HANDLE Handle,
1227 IN EFI_PCI_IO_PROTOCOL *Instance,
1228 IN PCI_TYPE00 *PciHeader
1229 )
1230 {
1231 EFI_STATUS Status;
1232 EFI_DEVICE_PATH_PROTOCOL *DevicePath;
1233 CHAR16 *DevPathStr;
1234
1235 //
1236 // Recognize PCI Mass Storage, and Xen PCI devices
1237 //
1238 if (IS_CLASS1 (PciHeader, PCI_CLASS_MASS_STORAGE) ||
1239 (XenDetected() && IS_CLASS2 (PciHeader, 0xFF, 0x80))) {
1240 DevicePath = NULL;
1241 Status = gBS->HandleProtocol (
1242 Handle,
1243 &gEfiDevicePathProtocolGuid,
1244 (VOID*)&DevicePath
1245 );
1246 if (EFI_ERROR (Status)) {
1247 return Status;
1248 }
1249
1250 //
1251 // Print Device Path
1252 //
1253 DevPathStr = ConvertDevicePathToText (DevicePath, FALSE, FALSE);
1254 if (DevPathStr != NULL) {
1255 DEBUG((
1256 EFI_D_INFO,
1257 "Found %s device: %s\n",
1258 (IS_CLASS1 (PciHeader, PCI_CLASS_MASS_STORAGE) ?
1259 L"Mass Storage" :
1260 L"Xen"
1261 ),
1262 DevPathStr
1263 ));
1264 FreePool(DevPathStr);
1265 }
1266
1267 Status = gBS->ConnectController (Handle, NULL, NULL, TRUE);
1268 if (EFI_ERROR (Status)) {
1269 return Status;
1270 }
1271
1272 }
1273
1274 return EFI_SUCCESS;
1275 }
1276
1277
1278 /**
1279 This notification function is invoked when the
1280 EMU Variable FVB has been changed.
1281
1282 @param Event The event that occurred
1283 @param Context For EFI compatibility. Not used.
1284
1285 **/
1286 VOID
1287 EFIAPI
1288 EmuVariablesUpdatedCallback (
1289 IN EFI_EVENT Event,
1290 IN VOID *Context
1291 )
1292 {
1293 DEBUG ((EFI_D_INFO, "EmuVariablesUpdatedCallback\n"));
1294 UpdateNvVarsOnFileSystem ();
1295 }
1296
1297
1298 EFI_STATUS
1299 EFIAPI
1300 VisitingFileSystemInstance (
1301 IN EFI_HANDLE Handle,
1302 IN VOID *Instance,
1303 IN VOID *Context
1304 )
1305 {
1306 EFI_STATUS Status;
1307 STATIC BOOLEAN ConnectedToFileSystem = FALSE;
1308 RETURN_STATUS PcdStatus;
1309
1310 if (ConnectedToFileSystem) {
1311 return EFI_ALREADY_STARTED;
1312 }
1313
1314 Status = ConnectNvVarsToFileSystem (Handle);
1315 if (EFI_ERROR (Status)) {
1316 return Status;
1317 }
1318
1319 ConnectedToFileSystem = TRUE;
1320 mEmuVariableEvent =
1321 EfiCreateProtocolNotifyEvent (
1322 &gEfiDevicePathProtocolGuid,
1323 TPL_CALLBACK,
1324 EmuVariablesUpdatedCallback,
1325 NULL,
1326 &mEmuVariableEventReg
1327 );
1328 PcdStatus = PcdSet64S (PcdEmuVariableEvent,
1329 (UINT64)(UINTN) mEmuVariableEvent);
1330 ASSERT_RETURN_ERROR (PcdStatus);
1331
1332 return EFI_SUCCESS;
1333 }
1334
1335
1336 VOID
1337 PlatformBdsRestoreNvVarsFromHardDisk (
1338 )
1339 {
1340 VisitAllPciInstances (ConnectRecursivelyIfPciMassStorage);
1341 VisitAllInstancesOfProtocol (
1342 &gEfiSimpleFileSystemProtocolGuid,
1343 VisitingFileSystemInstance,
1344 NULL
1345 );
1346
1347 }
1348
1349 VOID
1350 PlatformBdsConnectSequence (
1351 VOID
1352 )
1353 /*++
1354
1355 Routine Description:
1356
1357 Connect with predefined platform connect sequence,
1358 the OEM/IBV can customize with their own connect sequence.
1359
1360 Arguments:
1361
1362 None.
1363
1364 Returns:
1365
1366 None.
1367
1368 --*/
1369 {
1370 UINTN Index;
1371 RETURN_STATUS Status;
1372
1373 DEBUG ((EFI_D_INFO, "PlatformBdsConnectSequence\n"));
1374
1375 Index = 0;
1376
1377 //
1378 // Here we can get the customized platform connect sequence
1379 // Notes: we can connect with new variable which record the
1380 // last time boots connect device path sequence
1381 //
1382 while (gPlatformConnectSequence[Index] != NULL) {
1383 //
1384 // Build the platform boot option
1385 //
1386 EfiBootManagerConnectDevicePath (gPlatformConnectSequence[Index], NULL);
1387 Index++;
1388 }
1389
1390 Status = ConnectDevicesFromQemu ();
1391 if (RETURN_ERROR (Status)) {
1392 //
1393 // Just use the simple policy to connect all devices
1394 //
1395 DEBUG ((DEBUG_INFO, "EfiBootManagerConnectAll\n"));
1396 EfiBootManagerConnectAll ();
1397 }
1398
1399 PciAcpiInitialization ();
1400 }
1401
1402 /**
1403 Save the S3 boot script.
1404
1405 Note that DxeSmmReadyToLock must be signaled after this function returns;
1406 otherwise the script wouldn't be saved actually.
1407 **/
1408 STATIC
1409 VOID
1410 SaveS3BootScript (
1411 VOID
1412 )
1413 {
1414 EFI_STATUS Status;
1415 EFI_S3_SAVE_STATE_PROTOCOL *BootScript;
1416 STATIC CONST UINT8 Info[] = { 0xDE, 0xAD, 0xBE, 0xEF };
1417
1418 Status = gBS->LocateProtocol (&gEfiS3SaveStateProtocolGuid, NULL,
1419 (VOID **) &BootScript);
1420 ASSERT_EFI_ERROR (Status);
1421
1422 //
1423 // Despite the opcode documentation in the PI spec, the protocol
1424 // implementation embeds a deep copy of the info in the boot script, rather
1425 // than storing just a pointer to runtime or NVS storage.
1426 //
1427 Status = BootScript->Write(BootScript, EFI_BOOT_SCRIPT_INFORMATION_OPCODE,
1428 (UINT32) sizeof Info,
1429 (EFI_PHYSICAL_ADDRESS)(UINTN) &Info);
1430 ASSERT_EFI_ERROR (Status);
1431 }
1432
1433
1434 VOID
1435 EFIAPI
1436 PlatformBootManagerAfterConsole (
1437 VOID
1438 )
1439 /*++
1440
1441 Routine Description:
1442
1443 The function will execute with as the platform policy, current policy
1444 is driven by boot mode. IBV/OEM can customize this code for their specific
1445 policy action.
1446
1447 --*/
1448 {
1449 EFI_BOOT_MODE BootMode;
1450
1451 DEBUG ((EFI_D_INFO, "PlatformBootManagerAfterConsole\n"));
1452
1453 if (PcdGetBool (PcdOvmfFlashVariablesEnable)) {
1454 DEBUG ((EFI_D_INFO, "PlatformBdsPolicyBehavior: not restoring NvVars "
1455 "from disk since flash variables appear to be supported.\n"));
1456 } else {
1457 //
1458 // Try to restore variables from the hard disk early so
1459 // they can be used for the other BDS connect operations.
1460 //
1461 PlatformBdsRestoreNvVarsFromHardDisk ();
1462 }
1463
1464 //
1465 // Get current Boot Mode
1466 //
1467 BootMode = GetBootModeHob ();
1468 DEBUG ((DEBUG_INFO, "Boot Mode:%x\n", BootMode));
1469
1470 //
1471 // Go the different platform policy with different boot mode
1472 // Notes: this part code can be change with the table policy
1473 //
1474 ASSERT (BootMode == BOOT_WITH_FULL_CONFIGURATION);
1475
1476 //
1477 // Logo show
1478 //
1479 BootLogoEnableLogo ();
1480
1481 //
1482 // Perform some platform specific connect sequence
1483 //
1484 PlatformBdsConnectSequence ();
1485
1486 //
1487 // Process QEMU's -kernel command line option
1488 //
1489 TryRunningQemuKernel ();
1490
1491 EfiBootManagerRefreshAllBootOption ();
1492
1493 //
1494 // Register UEFI Shell
1495 //
1496 PlatformRegisterFvBootOption (
1497 PcdGetPtr (PcdShellFile), L"EFI Internal Shell", LOAD_OPTION_ACTIVE
1498 );
1499
1500 RemoveStaleFvFileOptions ();
1501 SetBootOrderFromQemu ();
1502 }
1503
1504 /**
1505 This notification function is invoked when an instance of the
1506 EFI_DEVICE_PATH_PROTOCOL is produced.
1507
1508 @param Event The event that occurred
1509 @param Context For EFI compatibility. Not used.
1510
1511 **/
1512 VOID
1513 EFIAPI
1514 NotifyDevPath (
1515 IN EFI_EVENT Event,
1516 IN VOID *Context
1517 )
1518 {
1519 EFI_HANDLE Handle;
1520 EFI_STATUS Status;
1521 UINTN BufferSize;
1522 EFI_DEVICE_PATH_PROTOCOL *DevPathNode;
1523 ATAPI_DEVICE_PATH *Atapi;
1524
1525 //
1526 // Examine all new handles
1527 //
1528 for (;;) {
1529 //
1530 // Get the next handle
1531 //
1532 BufferSize = sizeof (Handle);
1533 Status = gBS->LocateHandle (
1534 ByRegisterNotify,
1535 NULL,
1536 mEfiDevPathNotifyReg,
1537 &BufferSize,
1538 &Handle
1539 );
1540
1541 //
1542 // If not found, we're done
1543 //
1544 if (EFI_NOT_FOUND == Status) {
1545 break;
1546 }
1547
1548 if (EFI_ERROR (Status)) {
1549 continue;
1550 }
1551
1552 //
1553 // Get the DevicePath protocol on that handle
1554 //
1555 Status = gBS->HandleProtocol (Handle, &gEfiDevicePathProtocolGuid,
1556 (VOID **)&DevPathNode);
1557 ASSERT_EFI_ERROR (Status);
1558
1559 while (!IsDevicePathEnd (DevPathNode)) {
1560 //
1561 // Find the handler to dump this device path node
1562 //
1563 if (
1564 (DevicePathType(DevPathNode) == MESSAGING_DEVICE_PATH) &&
1565 (DevicePathSubType(DevPathNode) == MSG_ATAPI_DP)
1566 ) {
1567 Atapi = (ATAPI_DEVICE_PATH*) DevPathNode;
1568 PciOr16 (
1569 PCI_LIB_ADDRESS (
1570 0,
1571 1,
1572 1,
1573 (Atapi->PrimarySecondary == 1) ? 0x42: 0x40
1574 ),
1575 BIT15
1576 );
1577 }
1578
1579 //
1580 // Next device path node
1581 //
1582 DevPathNode = NextDevicePathNode (DevPathNode);
1583 }
1584 }
1585
1586 return;
1587 }
1588
1589
1590 VOID
1591 InstallDevicePathCallback (
1592 VOID
1593 )
1594 {
1595 DEBUG ((EFI_D_INFO, "Registered NotifyDevPath Event\n"));
1596 mEfiDevPathEvent = EfiCreateProtocolNotifyEvent (
1597 &gEfiDevicePathProtocolGuid,
1598 TPL_CALLBACK,
1599 NotifyDevPath,
1600 NULL,
1601 &mEfiDevPathNotifyReg
1602 );
1603 }
1604
1605 /**
1606 This function is called each second during the boot manager waits the
1607 timeout.
1608
1609 @param TimeoutRemain The remaining timeout.
1610 **/
1611 VOID
1612 EFIAPI
1613 PlatformBootManagerWaitCallback (
1614 UINT16 TimeoutRemain
1615 )
1616 {
1617 EFI_GRAPHICS_OUTPUT_BLT_PIXEL_UNION Black;
1618 EFI_GRAPHICS_OUTPUT_BLT_PIXEL_UNION White;
1619 UINT16 Timeout;
1620
1621 Timeout = PcdGet16 (PcdPlatformBootTimeOut);
1622
1623 Black.Raw = 0x00000000;
1624 White.Raw = 0x00FFFFFF;
1625
1626 BootLogoUpdateProgress (
1627 White.Pixel,
1628 Black.Pixel,
1629 L"Start boot option",
1630 White.Pixel,
1631 (Timeout - TimeoutRemain) * 100 / Timeout,
1632 0
1633 );
1634 }
1635