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