]> git.proxmox.com Git - mirror_edk2.git/blob - UefiCpuPkg/Universal/Acpi/S3Resume2Pei/S3Resume.c
projects / mirror_edk2.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
UefiCpuPkg: Add S3Resume2Pei PEIM
[mirror_edk2.git] / UefiCpuPkg / Universal / Acpi / S3Resume2Pei / S3Resume.c
1 /** @file
2 This module produces the EFI_PEI_S3_RESUME_PPI.
3 This module works with StandAloneBootScriptExecutor to S3 resume to OS.
4 This module will excute the boot script saved during last boot and after that,
5 control is passed to OS waking up handler.
6
7 Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
8
9 This program and the accompanying materials
10 are licensed and made available under the terms and conditions
11 of the BSD License which accompanies this distribution. The
12 full text of the license may be found at
13 http://opensource.org/licenses/bsd-license.php
14
15 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
16 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
17
18 **/
19
20 #include <PiPei.h>
21
22 #include <Guid/AcpiS3Context.h>
23 #include <Guid/BootScriptExecutorVariable.h>
24 #include <Guid/Performance.h>
25 #include <Ppi/ReadOnlyVariable2.h>
26 #include <Ppi/S3Resume2.h>
27 #include <Ppi/SmmAccess.h>
28 #include <Ppi/PostBootScriptTable.h>
29 #include <Ppi/EndOfPeiPhase.h>
30
31 #include <Library/DebugLib.h>
32 #include <Library/BaseLib.h>
33 #include <Library/TimerLib.h>
34 #include <Library/PeimEntryPoint.h>
35 #include <Library/PeiServicesLib.h>
36 #include <Library/HobLib.h>
37 #include <Library/PerformanceLib.h>
38 #include <Library/PeiServicesTablePointerLib.h>
39 #include <Library/IoLib.h>
40 #include <Library/BaseMemoryLib.h>
41 #include <Library/MemoryAllocationLib.h>
42 #include <Library/PcdLib.h>
43 #include <Library/DebugAgentLib.h>
44 #include <Library/LocalApicLib.h>
45 #include <Library/ReportStatusCodeLib.h>
46 #include <Library/PrintLib.h>
47 #include <Library/LockBoxLib.h>
48 #include <IndustryStandard/Acpi.h>
49
50 #pragma pack(1)
51 typedef union {
52 struct {
53 UINT32 LimitLow : 16;
54 UINT32 BaseLow : 16;
55 UINT32 BaseMid : 8;
56 UINT32 Type : 4;
57 UINT32 System : 1;
58 UINT32 Dpl : 2;
59 UINT32 Present : 1;
60 UINT32 LimitHigh : 4;
61 UINT32 Software : 1;
62 UINT32 Reserved : 1;
63 UINT32 DefaultSize : 1;
64 UINT32 Granularity : 1;
65 UINT32 BaseHigh : 8;
66 } Bits;
67 UINT64 Uint64;
68 } IA32_GDT;
69
70 //
71 // Page-Map Level-4 Offset (PML4) and
72 // Page-Directory-Pointer Offset (PDPE) entries 4K & 2MB
73 //
74 typedef union {
75 struct {
76 UINT64 Present:1; // 0 = Not present in memory, 1 = Present in memory
77 UINT64 ReadWrite:1; // 0 = Read-Only, 1= Read/Write
78 UINT64 UserSupervisor:1; // 0 = Supervisor, 1=User
79 UINT64 WriteThrough:1; // 0 = Write-Back caching, 1=Write-Through caching
80 UINT64 CacheDisabled:1; // 0 = Cached, 1=Non-Cached
81 UINT64 Accessed:1; // 0 = Not accessed, 1 = Accessed (set by CPU)
82 UINT64 Reserved:1; // Reserved
83 UINT64 MustBeZero:2; // Must Be Zero
84 UINT64 Available:3; // Available for use by system software
85 UINT64 PageTableBaseAddress:40; // Page Table Base Address
86 UINT64 AvabilableHigh:11; // Available for use by system software
87 UINT64 Nx:1; // No Execute bit
88 } Bits;
89 UINT64 Uint64;
90 } PAGE_MAP_AND_DIRECTORY_POINTER;
91
92 //
93 // Page Table Entry 2MB
94 //
95 typedef union {
96 struct {
97 UINT64 Present:1; // 0 = Not present in memory, 1 = Present in memory
98 UINT64 ReadWrite:1; // 0 = Read-Only, 1= Read/Write
99 UINT64 UserSupervisor:1; // 0 = Supervisor, 1=User
100 UINT64 WriteThrough:1; // 0 = Write-Back caching, 1=Write-Through caching
101 UINT64 CacheDisabled:1; // 0 = Cached, 1=Non-Cached
102 UINT64 Accessed:1; // 0 = Not accessed, 1 = Accessed (set by CPU)
103 UINT64 Dirty:1; // 0 = Not Dirty, 1 = written by processor on access to page
104 UINT64 MustBe1:1; // Must be 1
105 UINT64 Global:1; // 0 = Not global page, 1 = global page TLB not cleared on CR3 write
106 UINT64 Available:3; // Available for use by system software
107 UINT64 PAT:1; //
108 UINT64 MustBeZero:8; // Must be zero;
109 UINT64 PageTableBaseAddress:31; // Page Table Base Address
110 UINT64 AvabilableHigh:11; // Available for use by system software
111 UINT64 Nx:1; // 0 = Execute Code, 1 = No Code Execution
112 } Bits;
113 UINT64 Uint64;
114 } PAGE_TABLE_ENTRY;
115
116 #pragma pack()
117
118 //
119 // Function prototypes
120 //
121 /**
122 a ASM function to transfer control to OS.
123
124 @param S3WakingVector The S3 waking up vector saved in ACPI Facs table
125 @param AcpiLowMemoryBase a buffer under 1M which could be used during the transfer
126 **/
127 typedef
128 VOID
129 (EFIAPI *ASM_TRANSFER_CONTROL) (
130 IN UINT32 S3WakingVector,
131 IN UINT32 AcpiLowMemoryBase
132 );
133
134 /**
135 Restores the platform to its preboot configuration for an S3 resume and
136 jumps to the OS waking vector.
137
138 This function will restore the platform to its pre-boot configuration that was
139 pre-stored in the boot script table and transfer control to OS waking vector.
140 Upon invocation, this function is responsible for locating the following
141 information before jumping to OS waking vector:
142 - ACPI tables
143 - boot script table
144 - any other information that it needs
145
146 The S3RestoreConfig() function then executes the pre-stored boot script table
147 and transitions the platform to the pre-boot state. The boot script is recorded
148 during regular boot using the EFI_S3_SAVE_STATE_PROTOCOL.Write() and
149 EFI_S3_SMM_SAVE_STATE_PROTOCOL.Write() functions. Finally, this function
150 transfers control to the OS waking vector. If the OS supports only a real-mode
151 waking vector, this function will switch from flat mode to real mode before
152 jumping to the waking vector. If all platform pre-boot configurations are
153 successfully restored and all other necessary information is ready, this
154 function will never return and instead will directly jump to the OS waking
155 vector. If this function returns, it indicates that the attempt to resume
156 from the ACPI S3 sleep state failed.
157
158 @param[in] This Pointer to this instance of the PEI_S3_RESUME_PPI
159
160 @retval EFI_ABORTED Execution of the S3 resume boot script table failed.
161 @retval EFI_NOT_FOUND Some necessary information that is used for the S3
162 resume boot path could not be located.
163
164 **/
165 EFI_STATUS
166 EFIAPI
167 S3RestoreConfig2 (
168 IN EFI_PEI_S3_RESUME2_PPI *This
169 );
170
171 //
172 // Globals
173 //
174 EFI_PEI_S3_RESUME2_PPI mS3ResumePpi = { S3RestoreConfig2 };
175
176 EFI_PEI_PPI_DESCRIPTOR mPpiList = {
177 (EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST),
178 &gEfiPeiS3Resume2PpiGuid,
179 &mS3ResumePpi
180 };
181
182 EFI_PEI_PPI_DESCRIPTOR mPpiListPostScriptTable = {
183 (EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST),
184 &gPeiPostScriptTablePpiGuid,
185 0
186 };
187
188 EFI_PEI_PPI_DESCRIPTOR mPpiListEndOfPeiTable = {
189 (EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST),
190 &gEfiEndOfPeiSignalPpiGuid,
191 0
192 };
193
194 //
195 // Global Descriptor Table (GDT)
196 //
197 GLOBAL_REMOVE_IF_UNREFERENCED IA32_GDT mGdtEntries[] = {
198 /* selector { Global Segment Descriptor } */
199 /* 0x00 */ {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
200 /* 0x08 */ {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
201 /* 0x10 */ {{0xFFFF, 0, 0, 0xB, 1, 0, 1, 0xF, 0, 0, 1, 1, 0}},
202 /* 0x18 */ {{0xFFFF, 0, 0, 0x3, 1, 0, 1, 0xF, 0, 0, 1, 1, 0}},
203 /* 0x20 */ {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
204 /* 0x28 */ {{0xFFFF, 0, 0, 0xB, 1, 0, 1, 0xF, 0, 0, 0, 1, 0}},
205 /* 0x30 */ {{0xFFFF, 0, 0, 0x3, 1, 0, 1, 0xF, 0, 0, 0, 1, 0}},
206 /* 0x38 */ {{0xFFFF, 0, 0, 0xB, 1, 0, 1, 0xF, 0, 1, 0, 1, 0}},
207 /* 0x40 */ {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
208 };
209
210 //
211 // IA32 Gdt register
212 //
213 GLOBAL_REMOVE_IF_UNREFERENCED CONST IA32_DESCRIPTOR mGdt = {
214 sizeof (mGdtEntries) - 1,
215 (UINTN) mGdtEntries
216 };
217
218 /**
219 Performance measure function to get S3 detailed performance data.
220
221 This function will getS3 detailed performance data and saved in pre-reserved ACPI memory.
222 **/
223 VOID
224 WriteToOsS3PerformanceData (
225 VOID
226 )
227 {
228 EFI_STATUS Status;
229 EFI_PHYSICAL_ADDRESS mAcpiLowMemoryBase;
230 PERF_HEADER *PerfHeader;
231 PERF_DATA *PerfData;
232 UINT64 Ticker;
233 UINTN Index;
234 EFI_PEI_READ_ONLY_VARIABLE2_PPI *VariableServices;
235 UINTN VarSize;
236 UINTN LogEntryKey;
237 CONST VOID *Handle;
238 CONST CHAR8 *Token;
239 CONST CHAR8 *Module;
240 UINT64 StartTicker;
241 UINT64 EndTicker;
242 UINT64 StartValue;
243 UINT64 EndValue;
244 BOOLEAN CountUp;
245 UINT64 Freq;
246
247 //
248 // Retrive time stamp count as early as possilbe
249 //
250 Ticker = GetPerformanceCounter ();
251
252 Freq = GetPerformanceCounterProperties (&StartValue, &EndValue);
253
254 Freq = DivU64x32 (Freq, 1000);
255
256 Status = PeiServicesLocatePpi (
257 &gEfiPeiReadOnlyVariable2PpiGuid,
258 0,
259 NULL,
260 (VOID **) &VariableServices
261 );
262 ASSERT_EFI_ERROR (Status);
263
264 VarSize = sizeof (EFI_PHYSICAL_ADDRESS);
265 Status = VariableServices->GetVariable (
266 VariableServices,
267 L"PerfDataMemAddr",
268 &gPerformanceProtocolGuid,
269 NULL,
270 &VarSize,
271 &mAcpiLowMemoryBase
272 );
273 if (EFI_ERROR (Status)) {
274 DEBUG ((EFI_D_ERROR, "Fail to retrieve variable to log S3 performance data \n"));
275 return;
276 }
277
278 PerfHeader = (PERF_HEADER *) (UINTN) mAcpiLowMemoryBase;
279
280 if (PerfHeader->Signiture != PERFORMANCE_SIGNATURE) {
281 DEBUG ((EFI_D_ERROR, "Performance data in ACPI memory get corrupted! \n"));
282 return;
283 }
284
285 //
286 // Record total S3 resume time.
287 //
288 if (EndValue >= StartValue) {
289 PerfHeader->S3Resume = Ticker - StartValue;
290 CountUp = TRUE;
291 } else {
292 PerfHeader->S3Resume = StartValue - Ticker;
293 CountUp = FALSE;
294 }
295
296 //
297 // Get S3 detailed performance data
298 //
299 Index = 0;
300 LogEntryKey = 0;
301 while ((LogEntryKey = GetPerformanceMeasurement (
302 LogEntryKey,
303 &Handle,
304 &Token,
305 &Module,
306 &StartTicker,
307 &EndTicker)) != 0) {
308 if (EndTicker != 0) {
309 PerfData = &PerfHeader->S3Entry[Index];
310
311 //
312 // Use File Handle to specify the different performance log for PEIM.
313 // File Handle is the base address of PEIM FFS file.
314 //
315 if ((AsciiStrnCmp (Token, "PEIM", PEI_PERFORMANCE_STRING_SIZE) == 0) && (Handle != NULL)) {
316 AsciiSPrint (PerfData->Token, PERF_TOKEN_LENGTH, "0x%11p", Handle);
317 } else {
318 AsciiStrnCpy (PerfData->Token, Token, PERF_TOKEN_LENGTH);
319 }
320 if (StartTicker == 1) {
321 StartTicker = StartValue;
322 }
323 if (EndTicker == 1) {
324 EndTicker = StartValue;
325 }
326 Ticker = CountUp? (EndTicker - StartTicker) : (StartTicker - EndTicker);
327 PerfData->Duration = (UINT32) DivU64x32 (Ticker, (UINT32) Freq);
328
329 //
330 // Only Record > 1ms performance data so that more big performance can be recorded.
331 //
332 if ((Ticker > Freq) && (++Index >= PERF_PEI_ENTRY_MAX_NUM)) {
333 //
334 // Reach the maximum number of PEI performance log entries.
335 //
336 break;
337 }
338 }
339 }
340 PerfHeader->S3EntryNum = (UINT32) Index;
341 }
342
343 /**
344 Jump to OS waking vector.
345 The function will install boot script done PPI, report S3 resume status code, and then jump to OS waking vector.
346
347 @param AcpiS3Context a pointer to a structure of ACPI_S3_CONTEXT
348 @param PeiS3ResumeState a pointer to a structure of PEI_S3_RESUME_STATE
349 **/
350 VOID
351 EFIAPI
352 S3ResumeBootOs (
353 IN ACPI_S3_CONTEXT *AcpiS3Context,
354 IN PEI_S3_RESUME_STATE *PeiS3ResumeState
355 )
356 {
357 EFI_STATUS Status;
358 EFI_ACPI_4_0_FIRMWARE_ACPI_CONTROL_STRUCTURE *Facs;
359 ASM_TRANSFER_CONTROL AsmTransferControl;
360 UINTN TempStackTop;
361 UINTN TempStack[0x10];
362
363 //
364 // Restore IDT
365 //
366 AsmWriteIdtr (&PeiS3ResumeState->Idtr);
367
368 //
369 // Install BootScriptDonePpi
370 //
371 Status = PeiServicesInstallPpi (&mPpiListPostScriptTable);
372 ASSERT_EFI_ERROR (Status);
373
374 //
375 // Get ACPI Table Address
376 //
377 Facs = (EFI_ACPI_4_0_FIRMWARE_ACPI_CONTROL_STRUCTURE *) ((UINTN) (AcpiS3Context->AcpiFacsTable));
378
379 if ((Facs == NULL) ||
380 (Facs->Signature != EFI_ACPI_4_0_FIRMWARE_ACPI_CONTROL_STRUCTURE_SIGNATURE) ||
381 ((Facs->FirmwareWakingVector == 0) && (Facs->XFirmwareWakingVector == 0)) ) {
382 CpuDeadLoop ();
383 return ;
384 }
385
386 //
387 // report status code on S3 resume
388 //
389 REPORT_STATUS_CODE (EFI_PROGRESS_CODE, EFI_SOFTWARE_PEI_MODULE | EFI_SW_PEI_PC_OS_WAKE);
390
391 //
392 // Install EndOfPeiPpi
393 //
394 Status = PeiServicesInstallPpi (&mPpiListEndOfPeiTable);
395 ASSERT_EFI_ERROR (Status);
396
397 PERF_CODE (
398 WriteToOsS3PerformanceData ();
399 );
400
401 AsmTransferControl = (ASM_TRANSFER_CONTROL)(UINTN)PeiS3ResumeState->AsmTransferControl;
402 if (Facs->XFirmwareWakingVector != 0) {
403 //
404 // Switch to native waking vector
405 //
406 TempStackTop = (UINTN)&TempStack + sizeof(TempStack);
407 if ((Facs->Version == EFI_ACPI_4_0_FIRMWARE_ACPI_CONTROL_STRUCTURE_VERSION) &&
408 ((Facs->Flags & EFI_ACPI_4_0_64BIT_WAKE_SUPPORTED_F) != 0) &&
409 ((Facs->Flags & EFI_ACPI_4_0_OSPM_64BIT_WAKE__F) != 0)) {
410 //
411 // X64 long mode waking vector
412 //
413 DEBUG (( EFI_D_ERROR, "Transfer to 64bit OS waking vector - %x\r\n", (UINTN)Facs->XFirmwareWakingVector));
414 if (FeaturePcdGet (PcdDxeIplSwitchToLongMode)) {
415 AsmEnablePaging64 (
416 0x38,
417 Facs->XFirmwareWakingVector,
418 0,
419 0,
420 (UINT64)(UINTN)TempStackTop
421 );
422 } else {
423 DEBUG (( EFI_D_ERROR, "Unsupported for 32bit DXE transfer to 64bit OS waking vector!\r\n"));
424 ASSERT (FALSE);
425 }
426 } else {
427 //
428 // IA32 protected mode waking vector (Page disabled)
429 //
430 DEBUG (( EFI_D_ERROR, "Transfer to 32bit OS waking vector - %x\r\n", (UINTN)Facs->XFirmwareWakingVector));
431 SwitchStack (
432 (SWITCH_STACK_ENTRY_POINT) (UINTN) Facs->XFirmwareWakingVector,
433 NULL,
434 NULL,
435 (VOID *)(UINTN)TempStackTop
436 );
437 }
438 } else {
439 //
440 // 16bit Realmode waking vector
441 //
442 DEBUG (( EFI_D_ERROR, "Transfer to 16bit OS waking vector - %x\r\n", (UINTN)Facs->FirmwareWakingVector));
443 AsmTransferControl (Facs->FirmwareWakingVector, 0x0);
444 }
445
446 //
447 // Never run to here
448 //
449 CpuDeadLoop();
450 }
451
452 /**
453 Restore S3 page table because we do not trust ACPINvs content.
454 If BootScriptExector driver will not run in 64-bit mode, this function will do nothing.
455
456 @param S3NvsPageTableAddress PageTableAddress in ACPINvs
457 **/
458 VOID
459 RestoreS3PageTables (
460 IN UINTN S3NvsPageTableAddress
461 )
462 {
463 if (FeaturePcdGet (PcdDxeIplSwitchToLongMode)) {
464 UINT32 RegEax;
465 UINT8 PhysicalAddressBits;
466 EFI_PHYSICAL_ADDRESS PageAddress;
467 UINTN IndexOfPml4Entries;
468 UINTN IndexOfPdpEntries;
469 UINTN IndexOfPageDirectoryEntries;
470 UINT64 NumberOfPml4EntriesNeeded;
471 UINT64 NumberOfPdpEntriesNeeded;
472 PAGE_MAP_AND_DIRECTORY_POINTER *PageMapLevel4Entry;
473 PAGE_MAP_AND_DIRECTORY_POINTER *PageMap;
474 PAGE_MAP_AND_DIRECTORY_POINTER *PageDirectoryPointerEntry;
475 PAGE_TABLE_ENTRY *PageDirectoryEntry;
476
477 //
478 // NOTE: We have to ASSUME the page table generation format, because we do not know whole page table information.
479 // The whole page table is too large to be saved in SMRAM.
480 //
481 // The assumption is : whole page table is allocated in CONTINOUS memory and CR3 points to TOP page.
482 //
483 DEBUG ((EFI_D_ERROR, "S3NvsPageTableAddress - %x\n", S3NvsPageTableAddress));
484
485 //
486 // By architecture only one PageMapLevel4 exists - so lets allocate storgage for it.
487 //
488 PageMap = (PAGE_MAP_AND_DIRECTORY_POINTER *)S3NvsPageTableAddress;
489 S3NvsPageTableAddress += SIZE_4KB;
490
491 //
492 // Get physical address bits supported.
493 //
494 AsmCpuid (0x80000000, &RegEax, NULL, NULL, NULL);
495 if (RegEax >= 0x80000008) {
496 AsmCpuid (0x80000008, &RegEax, NULL, NULL, NULL);
497 PhysicalAddressBits = (UINT8) RegEax;
498 } else {
499 PhysicalAddressBits = 36;
500 }
501
502 //
503 // Calculate the table entries needed.
504 //
505 if (PhysicalAddressBits <= 39) {
506 NumberOfPml4EntriesNeeded = 1;
507 NumberOfPdpEntriesNeeded = LShiftU64 (1, (PhysicalAddressBits - 30));
508 } else {
509 NumberOfPml4EntriesNeeded = LShiftU64 (1, (PhysicalAddressBits - 39));
510 NumberOfPdpEntriesNeeded = 512;
511 }
512
513 PageMapLevel4Entry = PageMap;
514 PageAddress = 0;
515 for (IndexOfPml4Entries = 0; IndexOfPml4Entries < NumberOfPml4EntriesNeeded; IndexOfPml4Entries++, PageMapLevel4Entry++) {
516 //
517 // Each PML4 entry points to a page of Page Directory Pointer entires.
518 // So lets allocate space for them and fill them in in the IndexOfPdpEntries loop.
519 //
520 PageDirectoryPointerEntry = (PAGE_MAP_AND_DIRECTORY_POINTER *)S3NvsPageTableAddress;
521 S3NvsPageTableAddress += SIZE_4KB;
522
523 //
524 // Make a PML4 Entry
525 //
526 PageMapLevel4Entry->Uint64 = (UINT64)(UINTN)PageDirectoryPointerEntry;
527 PageMapLevel4Entry->Bits.ReadWrite = 1;
528 PageMapLevel4Entry->Bits.Present = 1;
529
530 for (IndexOfPdpEntries = 0; IndexOfPdpEntries < NumberOfPdpEntriesNeeded; IndexOfPdpEntries++, PageDirectoryPointerEntry++) {
531 //
532 // Each Directory Pointer entries points to a page of Page Directory entires.
533 // So allocate space for them and fill them in in the IndexOfPageDirectoryEntries loop.
534 //
535 PageDirectoryEntry = (PAGE_TABLE_ENTRY *)S3NvsPageTableAddress;
536 S3NvsPageTableAddress += SIZE_4KB;
537
538 //
539 // Fill in a Page Directory Pointer Entries
540 //
541 PageDirectoryPointerEntry->Uint64 = (UINT64)(UINTN)PageDirectoryEntry;
542 PageDirectoryPointerEntry->Bits.ReadWrite = 1;
543 PageDirectoryPointerEntry->Bits.Present = 1;
544
545 for (IndexOfPageDirectoryEntries = 0; IndexOfPageDirectoryEntries < 512; IndexOfPageDirectoryEntries++, PageDirectoryEntry++, PageAddress += SIZE_2MB) {
546 //
547 // Fill in the Page Directory entries
548 //
549 PageDirectoryEntry->Uint64 = (UINT64)PageAddress;
550 PageDirectoryEntry->Bits.ReadWrite = 1;
551 PageDirectoryEntry->Bits.Present = 1;
552 PageDirectoryEntry->Bits.MustBe1 = 1;
553 }
554 }
555 }
556 return ;
557 } else {
558 //
559 // If DXE is running 32-bit mode, no need to establish page table.
560 //
561 return ;
562 }
563 }
564
565 /**
566 Jump to boot script executor driver.
567
568 The function will close and lock SMRAM and then jump to boot script execute driver to executing S3 boot script table.
569
570 @param AcpiS3Context a pointer to a structure of ACPI_S3_CONTEXT
571 @param EfiBootScriptExecutorVariable The function entry to executing S3 boot Script table. This function is build in
572 boot script execute driver
573 **/
574 VOID
575 EFIAPI
576 S3ResumeExecuteBootScript (
577 IN ACPI_S3_CONTEXT *AcpiS3Context,
578 IN BOOT_SCRIPT_EXECUTOR_VARIABLE *EfiBootScriptExecutorVariable
579 )
580 {
581 EFI_STATUS Status;
582 PEI_SMM_ACCESS_PPI *SmmAccess;
583 UINTN Index;
584 VOID *GuidHob;
585 IA32_DESCRIPTOR *IdtDescriptor;
586 VOID *IdtBuffer;
587 PEI_S3_RESUME_STATE *PeiS3ResumeState;
588
589 DEBUG ((EFI_D_ERROR, "S3ResumeExecuteBootScript()\n"));
590
591 //
592 // Attempt to use content from SMRAM first
593 //
594 GuidHob = GetFirstGuidHob (&gEfiAcpiVariableGuid);
595 if (GuidHob != NULL) {
596 //
597 // Last step for SMM - send SMI for initialization
598 //
599
600 //
601 // Send SMI to APs
602 //
603 SendSmiIpiAllExcludingSelf ();
604 //
605 // Send SMI to BSP
606 //
607 SendSmiIpi (GetApicId ());
608
609 Status = PeiServicesLocatePpi (
610 &gPeiSmmAccessPpiGuid,
611 0,
612 NULL,
613 (VOID **) &SmmAccess
614 );
615
616 DEBUG ((EFI_D_ERROR, "Close all SMRAM regions before executing boot script\n"));
617
618 for (Index = 0, Status = EFI_SUCCESS; !EFI_ERROR (Status); Index++) {
619 Status = SmmAccess->Close ((EFI_PEI_SERVICES **)GetPeiServicesTablePointer (), SmmAccess, Index);
620 }
621
622 DEBUG ((EFI_D_ERROR, "Lock all SMRAM regions before executing boot script\n"));
623
624 for (Index = 0, Status = EFI_SUCCESS; !EFI_ERROR (Status); Index++) {
625 Status = SmmAccess->Lock ((EFI_PEI_SERVICES **)GetPeiServicesTablePointer (), SmmAccess, Index);
626 }
627 }
628
629 if (FeaturePcdGet (PcdDxeIplSwitchToLongMode)) {
630 //
631 // Need reconstruct page table here, since we do not trust ACPINvs.
632 //
633 RestoreS3PageTables ((UINTN)AcpiS3Context->S3NvsPageTableAddress);
634 AsmWriteCr3 ((UINTN)AcpiS3Context->S3NvsPageTableAddress);
635 }
636
637 if (FeaturePcdGet (PcdFrameworkCompatibilitySupport)) {
638 //
639 // On some platform, such as ECP, a dispatch node in boot script table may execute a 32-bit PEIM which may need PeiServices
640 // pointer. So PeiServices need preserve in (IDTBase- sizeof (UINTN)).
641 //
642 IdtDescriptor = (IA32_DESCRIPTOR *) (UINTN) (AcpiS3Context->IdtrProfile);
643 //
644 // Make sure the newly allcated IDT align with 16-bytes
645 //
646 IdtBuffer = AllocatePages (EFI_SIZE_TO_PAGES((IdtDescriptor->Limit + 1) + 16));
647 ASSERT (IdtBuffer != NULL);
648 CopyMem ((VOID*)((UINT8*)IdtBuffer + 16),(VOID*)(IdtDescriptor->Base), (IdtDescriptor->Limit + 1));
649 IdtDescriptor->Base = (UINTN)((UINT8*)IdtBuffer + 16);
650 *(UINTN*)(IdtDescriptor->Base - sizeof(UINTN)) = (UINTN)GetPeiServicesTablePointer ();
651 }
652
653 //
654 // Need to make sure the GDT is loaded with values that support long mode and real mode.
655 //
656 AsmWriteGdtr (&mGdt);
657
658 //
659 // Prepare data for return back
660 //
661 PeiS3ResumeState = AllocatePool (sizeof(*PeiS3ResumeState));
662 ASSERT (PeiS3ResumeState != NULL);
663 DEBUG (( EFI_D_ERROR, "PeiS3ResumeState - %x\r\n", PeiS3ResumeState));
664 PeiS3ResumeState->ReturnCs = 0x10;
665 PeiS3ResumeState->ReturnEntryPoint = (EFI_PHYSICAL_ADDRESS)(UINTN)S3ResumeBootOs;
666 PeiS3ResumeState->ReturnStackPointer = (EFI_PHYSICAL_ADDRESS)(UINTN)&Status;
667 //
668 // Save IDT
669 //
670 AsmReadIdtr (&PeiS3ResumeState->Idtr);
671
672 if (FeaturePcdGet (PcdDxeIplSwitchToLongMode)) {
673 //
674 // X64 S3 Resume
675 //
676 DEBUG (( EFI_D_ERROR, "Enable X64 and transfer control to Standalone Boot Script Executor\r\n"));
677
678 //
679 // Switch to long mode to complete resume.
680 //
681 AsmEnablePaging64 (
682 0x38,
683 EfiBootScriptExecutorVariable->BootScriptExecutorEntrypoint,
684 (UINT64)(UINTN)AcpiS3Context,
685 (UINT64)(UINTN)PeiS3ResumeState,
686 (UINT64)(UINTN)(AcpiS3Context->BootScriptStackBase + AcpiS3Context->BootScriptStackSize)
687 );
688 } else {
689 //
690 // IA32 S3 Resume
691 //
692 DEBUG (( EFI_D_ERROR, "transfer control to Standalone Boot Script Executor\r\n"));
693 SwitchStack (
694 (SWITCH_STACK_ENTRY_POINT) (UINTN) EfiBootScriptExecutorVariable->BootScriptExecutorEntrypoint,
695 (VOID *)AcpiS3Context,
696 (VOID *)PeiS3ResumeState,
697 (VOID *)(UINTN)(AcpiS3Context->BootScriptStackBase + AcpiS3Context->BootScriptStackSize)
698 );
699 }
700
701 //
702 // Never run to here
703 //
704 CpuDeadLoop();
705 }
706 /**
707 Restores the platform to its preboot configuration for an S3 resume and
708 jumps to the OS waking vector.
709
710 This function will restore the platform to its pre-boot configuration that was
711 pre-stored in the boot script table and transfer control to OS waking vector.
712 Upon invocation, this function is responsible for locating the following
713 information before jumping to OS waking vector:
714 - ACPI tables
715 - boot script table
716 - any other information that it needs
717
718 The S3RestoreConfig() function then executes the pre-stored boot script table
719 and transitions the platform to the pre-boot state. The boot script is recorded
720 during regular boot using the EFI_S3_SAVE_STATE_PROTOCOL.Write() and
721 EFI_S3_SMM_SAVE_STATE_PROTOCOL.Write() functions. Finally, this function
722 transfers control to the OS waking vector. If the OS supports only a real-mode
723 waking vector, this function will switch from flat mode to real mode before
724 jumping to the waking vector. If all platform pre-boot configurations are
725 successfully restored and all other necessary information is ready, this
726 function will never return and instead will directly jump to the OS waking
727 vector. If this function returns, it indicates that the attempt to resume
728 from the ACPI S3 sleep state failed.
729
730 @param[in] This Pointer to this instance of the PEI_S3_RESUME_PPI
731
732 @retval EFI_ABORTED Execution of the S3 resume boot script table failed.
733 @retval EFI_NOT_FOUND Some necessary information that is used for the S3
734 resume boot path could not be located.
735
736 **/
737 EFI_STATUS
738 EFIAPI
739 S3RestoreConfig2 (
740 IN EFI_PEI_S3_RESUME2_PPI *This
741 )
742 {
743 EFI_STATUS Status;
744 PEI_SMM_ACCESS_PPI *SmmAccess;
745 UINTN Index;
746 ACPI_S3_CONTEXT *AcpiS3Context;
747 EFI_PEI_READ_ONLY_VARIABLE2_PPI *VariableServices;
748 EFI_PHYSICAL_ADDRESS TempEfiBootScriptExecutorVariable;
749 EFI_PHYSICAL_ADDRESS TempAcpiS3Context;
750 BOOT_SCRIPT_EXECUTOR_VARIABLE *EfiBootScriptExecutorVariable;
751 UINTN VarSize;
752 EFI_SMRAM_DESCRIPTOR *SmramDescriptor;
753 SMM_S3_RESUME_STATE *SmmS3ResumeState;
754 VOID *GuidHob;
755
756 DEBUG ((EFI_D_ERROR, "Enter S3 PEIM\r\n"));
757
758 Status = PeiServicesLocatePpi (
759 &gPeiSmmAccessPpiGuid,
760 0,
761 NULL,
762 (VOID **) &SmmAccess
763 );
764 for (Index = 0; !EFI_ERROR (Status); Index++) {
765 Status = SmmAccess->Open ((EFI_PEI_SERVICES **)GetPeiServicesTablePointer (), SmmAccess, Index);
766 }
767
768 Status = PeiServicesLocatePpi (
769 &gEfiPeiReadOnlyVariable2PpiGuid,
770 0,
771 NULL,
772 (VOID **) &VariableServices
773 );
774 if (EFI_ERROR (Status)) {
775 return Status;
776 }
777
778 VarSize = sizeof (EFI_PHYSICAL_ADDRESS);
779 Status = RestoreLockBox (
780 &gEfiAcpiVariableGuid,
781 &TempAcpiS3Context,
782 &VarSize
783 );
784 ASSERT_EFI_ERROR (Status);
785
786 AcpiS3Context = (ACPI_S3_CONTEXT *)(UINTN)TempAcpiS3Context;
787 ASSERT (AcpiS3Context != NULL);
788
789 Status = RestoreLockBox (
790 &gEfiAcpiS3ContextGuid,
791 NULL,
792 NULL
793 );
794 ASSERT_EFI_ERROR (Status);
795
796 VarSize = sizeof (TempEfiBootScriptExecutorVariable);
797 Status = RestoreLockBox (
798 &gEfiBootScriptExecutorVariableGuid,
799 &TempEfiBootScriptExecutorVariable,
800 &VarSize
801 );
802 ASSERT_EFI_ERROR (Status);
803
804 Status = RestoreLockBox (
805 &gEfiBootScriptExecutorContextGuid,
806 NULL,
807 NULL
808 );
809 ASSERT_EFI_ERROR (Status);
810
811 EfiBootScriptExecutorVariable = (BOOT_SCRIPT_EXECUTOR_VARIABLE *) (UINTN) TempEfiBootScriptExecutorVariable;
812
813 DEBUG (( EFI_D_ERROR, "AcpiS3Context = %x\n", AcpiS3Context));
814 DEBUG (( EFI_D_ERROR, "Waking Vector = %x\n", ((EFI_ACPI_2_0_FIRMWARE_ACPI_CONTROL_STRUCTURE *) ((UINTN) (AcpiS3Context->AcpiFacsTable)))->FirmwareWakingVector));
815 DEBUG (( EFI_D_ERROR, "AcpiS3Context->AcpiFacsTable = %x\n", AcpiS3Context->AcpiFacsTable));
816 DEBUG (( EFI_D_ERROR, "AcpiS3Context->S3NvsPageTableAddress = %x\n", AcpiS3Context->S3NvsPageTableAddress));
817 DEBUG (( EFI_D_ERROR, "AcpiS3Context->S3DebugBufferAddress = %x\n", AcpiS3Context->S3DebugBufferAddress));
818 DEBUG (( EFI_D_ERROR, "EfiBootScriptExecutorVariable->BootScriptExecutorEntrypoint = %x\n", EfiBootScriptExecutorVariable->BootScriptExecutorEntrypoint));
819
820 //
821 // Additional step for BootScript integrity - we only handle BootScript and BootScriptExecutor.
822 // Script dispatch image and context (parameter) are handled by platform.
823 // We just use restore all lock box in place, no need restore one by one.
824 //
825 Status = RestoreAllLockBoxInPlace ();
826 ASSERT_EFI_ERROR (Status);
827 if (EFI_ERROR (Status)) {
828 // Something wrong
829 CpuDeadLoop ();
830 }
831
832 //
833 // Attempt to use content from SMRAM first
834 //
835 GuidHob = GetFirstGuidHob (&gEfiAcpiVariableGuid);
836 if (GuidHob != NULL) {
837 SmramDescriptor = (EFI_SMRAM_DESCRIPTOR *) GET_GUID_HOB_DATA (GuidHob);
838 SmmS3ResumeState = (SMM_S3_RESUME_STATE *)(UINTN)SmramDescriptor->CpuStart;
839
840 SmmS3ResumeState->ReturnCs = AsmReadCs ();
841 SmmS3ResumeState->ReturnEntryPoint = (EFI_PHYSICAL_ADDRESS)(UINTN)S3ResumeExecuteBootScript;
842 SmmS3ResumeState->ReturnContext1 = (EFI_PHYSICAL_ADDRESS)(UINTN)AcpiS3Context;
843 SmmS3ResumeState->ReturnContext2 = (EFI_PHYSICAL_ADDRESS)(UINTN)EfiBootScriptExecutorVariable;
844 SmmS3ResumeState->ReturnStackPointer = (EFI_PHYSICAL_ADDRESS)(UINTN)&Status;
845
846 DEBUG (( EFI_D_ERROR, "SMM S3 Signature = %x\n", SmmS3ResumeState->Signature));
847 DEBUG (( EFI_D_ERROR, "SMM S3 Stack Base = %x\n", SmmS3ResumeState->SmmS3StackBase));
848 DEBUG (( EFI_D_ERROR, "SMM S3 Stack Size = %x\n", SmmS3ResumeState->SmmS3StackSize));
849 DEBUG (( EFI_D_ERROR, "SMM S3 Resume Entry Point = %x\n", SmmS3ResumeState->SmmS3ResumeEntryPoint));
850 DEBUG (( EFI_D_ERROR, "SMM S3 CR0 = %x\n", SmmS3ResumeState->SmmS3Cr0));
851 DEBUG (( EFI_D_ERROR, "SMM S3 CR3 = %x\n", SmmS3ResumeState->SmmS3Cr3));
852 DEBUG (( EFI_D_ERROR, "SMM S3 CR4 = %x\n", SmmS3ResumeState->SmmS3Cr4));
853 DEBUG (( EFI_D_ERROR, "SMM S3 Return CS = %x\n", SmmS3ResumeState->ReturnCs));
854 DEBUG (( EFI_D_ERROR, "SMM S3 Return Entry Point = %x\n", SmmS3ResumeState->ReturnEntryPoint));
855 DEBUG (( EFI_D_ERROR, "SMM S3 Return Context1 = %x\n", SmmS3ResumeState->ReturnContext1));
856 DEBUG (( EFI_D_ERROR, "SMM S3 Return Context2 = %x\n", SmmS3ResumeState->ReturnContext2));
857 DEBUG (( EFI_D_ERROR, "SMM S3 Return Stack Pointer = %x\n", SmmS3ResumeState->ReturnStackPointer));
858 DEBUG (( EFI_D_ERROR, "SMM S3 Smst = %x\n", SmmS3ResumeState->Smst));
859
860 //
861 // Disable interrupt of Debug timer.
862 //
863 SaveAndSetDebugTimerInterrupt (FALSE);
864
865 if (SmmS3ResumeState->Signature == SMM_S3_RESUME_SMM_32) {
866 SwitchStack (
867 (SWITCH_STACK_ENTRY_POINT)(UINTN)SmmS3ResumeState->SmmS3ResumeEntryPoint,
868 (VOID *)AcpiS3Context,
869 0,
870 (VOID *)(UINTN)(SmmS3ResumeState->SmmS3StackBase + SmmS3ResumeState->SmmS3StackSize)
871 );
872 }
873 if (SmmS3ResumeState->Signature == SMM_S3_RESUME_SMM_64) {
874 //
875 // Switch to long mode to complete resume.
876 //
877
878 //
879 // Need to make sure the GDT is loaded with values that support long mode and real mode.
880 //
881 AsmWriteGdtr (&mGdt);
882 AsmWriteCr3 ((UINTN)SmmS3ResumeState->SmmS3Cr3);
883 AsmEnablePaging64 (
884 0x38,
885 SmmS3ResumeState->SmmS3ResumeEntryPoint,
886 (UINT64)(UINTN)AcpiS3Context,
887 0,
888 SmmS3ResumeState->SmmS3StackBase + SmmS3ResumeState->SmmS3StackSize
889 );
890 }
891
892 }
893
894 S3ResumeExecuteBootScript (AcpiS3Context, EfiBootScriptExecutorVariable );
895 return EFI_SUCCESS;
896 }
897 /**
898 Main entry for S3 Resume PEIM.
899
900 This routine is to install EFI_PEI_S3_RESUME2_PPI.
901
902 @param FileHandle Handle of the file being invoked.
903 @param PeiServices Pointer to PEI Services table.
904
905 @retval EFI_SUCCESS S3Resume Ppi is installed successfully.
906
907 **/
908 EFI_STATUS
909 EFIAPI
910 PeimS3ResumeEntryPoint (
911 IN EFI_PEI_FILE_HANDLE FileHandle,
912 IN CONST EFI_PEI_SERVICES **PeiServices
913 )
914 {
915 EFI_STATUS Status;
916
917 //
918 // Install S3 Resume Ppi
919 //
920 Status = (**PeiServices).InstallPpi (PeiServices, &mPpiList);
921 ASSERT_EFI_ERROR (Status);
922
923 return EFI_SUCCESS;
924 }
925
EFI Development Kit II mirror for PVE