2 CPU PEI Module installs CPU Multiple Processor PPI.
4 Copyright (c) 2015, Intel Corporation. All rights reserved.<BR>
5 This program and the accompanying materials
6 are licensed and made available under the terms and conditions of the BSD License
7 which accompanies this distribution. The full text of the license may be found at
8 http://opensource.org/licenses/bsd-license.php
10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
18 // Global Descriptor Table (GDT)
20 GLOBAL_REMOVE_IF_UNREFERENCED IA32_GDT mGdtEntries
[] = {
21 /* selector { Global Segment Descriptor } */
22 /* 0x00 */ {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}}, //null descriptor
23 /* 0x08 */ {{0xffff, 0, 0, 0x2, 1, 0, 1, 0xf, 0, 0, 1, 1, 0}}, //linear data segment descriptor
24 /* 0x10 */ {{0xffff, 0, 0, 0xf, 1, 0, 1, 0xf, 0, 0, 1, 1, 0}}, //linear code segment descriptor
25 /* 0x18 */ {{0xffff, 0, 0, 0x3, 1, 0, 1, 0xf, 0, 0, 1, 1, 0}}, //system data segment descriptor
26 /* 0x20 */ {{0xffff, 0, 0, 0xa, 1, 0, 1, 0xf, 0, 0, 1, 1, 0}}, //system code segment descriptor
27 /* 0x28 */ {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}}, //spare segment descriptor
28 /* 0x30 */ {{0xffff, 0, 0, 0x2, 1, 0, 1, 0xf, 0, 0, 1, 1, 0}}, //system data segment descriptor
29 /* 0x38 */ {{0xffff, 0, 0, 0xa, 1, 0, 1, 0xf, 0, 1, 0, 1, 0}}, //system code segment descriptor
30 /* 0x40 */ {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}}, //spare segment descriptor
36 GLOBAL_REMOVE_IF_UNREFERENCED IA32_DESCRIPTOR mGdt
= {
37 sizeof (mGdtEntries
) - 1,
41 GLOBAL_REMOVE_IF_UNREFERENCED EFI_PEI_NOTIFY_DESCRIPTOR mNotifyList
= {
42 (EFI_PEI_PPI_DESCRIPTOR_NOTIFY_CALLBACK
| EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST
),
43 &gEfiEndOfPeiSignalPpiGuid
,
48 Sort the APIC ID of all processors.
50 This function sorts the APIC ID of all processors so that processor number is
51 assigned in the ascending order of APIC ID which eases MP debugging.
53 @param PeiCpuMpData Pointer to PEI CPU MP Data
57 IN PEI_CPU_MP_DATA
*PeiCpuMpData
67 ApCount
= PeiCpuMpData
->CpuCount
- 1;
70 for (Index1
= 0; Index1
< ApCount
; Index1
++) {
73 // Sort key is the hardware default APIC ID
75 ApicId
= PeiCpuMpData
->CpuData
[Index1
].ApicId
;
76 for (Index2
= Index1
+ 1; Index2
<= ApCount
; Index2
++) {
77 if (ApicId
> PeiCpuMpData
->CpuData
[Index2
].ApicId
) {
79 ApicId
= PeiCpuMpData
->CpuData
[Index2
].ApicId
;
82 if (Index3
!= Index1
) {
83 CopyMem (&CpuData
, &PeiCpuMpData
->CpuData
[Index3
], sizeof (PEI_CPU_DATA
));
85 &PeiCpuMpData
->CpuData
[Index3
],
86 &PeiCpuMpData
->CpuData
[Index1
],
89 CopyMem (&PeiCpuMpData
->CpuData
[Index1
], &CpuData
, sizeof (PEI_CPU_DATA
));
94 // Get the processor number for the BSP
96 ApicId
= GetInitialApicId ();
97 for (Index1
= 0; Index1
< PeiCpuMpData
->CpuCount
; Index1
++) {
98 if (PeiCpuMpData
->CpuData
[Index1
].ApicId
== ApicId
) {
99 PeiCpuMpData
->BspNumber
= (UINT32
) Index1
;
107 Enable x2APIC mode on APs.
109 @param Buffer Pointer to private data buffer.
117 SetApicMode (LOCAL_APIC_MODE_X2APIC
);
123 @param MonitorFilterSize Returns the largest monitor-line size in bytes.
125 @return The AP loop mode.
129 OUT UINT16
*MonitorFilterSize
137 ASSERT (MonitorFilterSize
!= NULL
);
139 ApLoopMode
= PcdGet8 (PcdCpuApLoopMode
);
140 ASSERT (ApLoopMode
>= ApInHltLoop
&& ApLoopMode
<= ApInRunLoop
);
141 if (ApLoopMode
== ApInMwaitLoop
) {
142 AsmCpuid (CPUID_VERSION_INFO
, NULL
, NULL
, &RegEcx
, NULL
);
143 if ((RegEcx
& BIT3
) == 0) {
145 // If processor does not support MONITOR/MWAIT feature
146 // by CPUID.[EAX=01H]:ECX.BIT3, force AP in Hlt-loop mode
148 ApLoopMode
= ApInHltLoop
;
152 if (ApLoopMode
== ApInHltLoop
) {
153 *MonitorFilterSize
= 0;
154 } else if (ApLoopMode
== ApInRunLoop
) {
155 *MonitorFilterSize
= sizeof (UINT32
);
156 } else if (ApLoopMode
== ApInMwaitLoop
) {
158 // CPUID.[EAX=05H]:EBX.BIT0-15: Largest monitor-line size in bytes
159 // CPUID.[EAX=05H].EDX: C-states supported using MWAIT
161 AsmCpuid (CPUID_MONITOR_MWAIT
, NULL
, &RegEbx
, NULL
, &RegEdx
);
162 *MonitorFilterSize
= RegEbx
& 0xFFFF;
169 Get CPU MP Data pointer from the Guided HOB.
171 @return Pointer to Pointer to PEI CPU MP Data
178 EFI_HOB_GUID_TYPE
*GuidHob
;
180 PEI_CPU_MP_DATA
*CpuMpData
;
183 GuidHob
= GetFirstGuidHob (&gEfiCallerIdGuid
);
184 if (GuidHob
!= NULL
) {
185 DataInHob
= GET_GUID_HOB_DATA (GuidHob
);
186 CpuMpData
= (PEI_CPU_MP_DATA
*)(*(UINTN
*)DataInHob
);
188 ASSERT (CpuMpData
!= NULL
);
193 Save the volatile registers required to be restored following INIT IPI.
195 @param VolatileRegisters Returns buffer saved the volatile resisters
198 SaveVolatileRegisters (
199 OUT CPU_VOLATILE_REGISTERS
*VolatileRegisters
204 VolatileRegisters
->Cr0
= AsmReadCr0 ();
205 VolatileRegisters
->Cr3
= AsmReadCr3 ();
206 VolatileRegisters
->Cr4
= AsmReadCr4 ();
208 AsmCpuid (CPUID_VERSION_INFO
, NULL
, NULL
, NULL
, &RegEdx
);
209 if ((RegEdx
& BIT2
) != 0) {
211 // If processor supports Debugging Extensions feature
212 // by CPUID.[EAX=01H]:EDX.BIT2
214 VolatileRegisters
->Dr0
= AsmReadDr0 ();
215 VolatileRegisters
->Dr1
= AsmReadDr1 ();
216 VolatileRegisters
->Dr2
= AsmReadDr2 ();
217 VolatileRegisters
->Dr3
= AsmReadDr3 ();
218 VolatileRegisters
->Dr6
= AsmReadDr6 ();
219 VolatileRegisters
->Dr7
= AsmReadDr7 ();
224 Restore the volatile registers following INIT IPI.
226 @param VolatileRegisters Pointer to volatile resisters
227 @param IsRestoreDr TRUE: Restore DRx if supported
228 FALSE: Do not restore DRx
231 RestoreVolatileRegisters (
232 IN CPU_VOLATILE_REGISTERS
*VolatileRegisters
,
233 IN BOOLEAN IsRestoreDr
238 AsmWriteCr0 (VolatileRegisters
->Cr0
);
239 AsmWriteCr3 (VolatileRegisters
->Cr3
);
240 AsmWriteCr4 (VolatileRegisters
->Cr4
);
243 AsmCpuid (CPUID_VERSION_INFO
, NULL
, NULL
, NULL
, &RegEdx
);
244 if ((RegEdx
& BIT2
) != 0) {
246 // If processor supports Debugging Extensions feature
247 // by CPUID.[EAX=01H]:EDX.BIT2
249 AsmWriteDr0 (VolatileRegisters
->Dr0
);
250 AsmWriteDr1 (VolatileRegisters
->Dr1
);
251 AsmWriteDr2 (VolatileRegisters
->Dr2
);
252 AsmWriteDr3 (VolatileRegisters
->Dr3
);
253 AsmWriteDr6 (VolatileRegisters
->Dr6
);
254 AsmWriteDr7 (VolatileRegisters
->Dr7
);
260 This function will be called from AP reset code if BSP uses WakeUpAP.
262 @param ExchangeInfo Pointer to the MP exchange info buffer
263 @param NumApsExecuting Number of current executing AP
268 IN MP_CPU_EXCHANGE_INFO
*ExchangeInfo
,
269 IN UINTN NumApsExecuting
272 PEI_CPU_MP_DATA
*PeiCpuMpData
;
273 UINTN ProcessorNumber
;
274 EFI_AP_PROCEDURE Procedure
;
276 volatile UINT32
*ApStartupSignalBuffer
;
278 PeiCpuMpData
= ExchangeInfo
->PeiCpuMpData
;
280 if (PeiCpuMpData
->InitFlag
) {
281 ProcessorNumber
= NumApsExecuting
;
283 // Sync BSP's Control registers to APs
285 RestoreVolatileRegisters (&PeiCpuMpData
->CpuData
[0].VolatileRegisters
, FALSE
);
287 // This is first time AP wakeup, get BIST information from AP stack
289 BistData
= *(UINTN
*) (PeiCpuMpData
->Buffer
+ ProcessorNumber
* PeiCpuMpData
->CpuApStackSize
- sizeof (UINTN
));
290 PeiCpuMpData
->CpuData
[ProcessorNumber
].Health
.Uint32
= (UINT32
) BistData
;
291 PeiCpuMpData
->CpuData
[ProcessorNumber
].ApicId
= GetInitialApicId ();
292 if (PeiCpuMpData
->CpuData
[ProcessorNumber
].ApicId
>= 0xFF) {
294 // Set x2APIC mode if there are any logical processor reporting
295 // an APIC ID of 255 or greater.
297 AcquireSpinLock(&PeiCpuMpData
->MpLock
);
298 PeiCpuMpData
->X2ApicEnable
= TRUE
;
299 ReleaseSpinLock(&PeiCpuMpData
->MpLock
);
302 // Sync BSP's Mtrr table to all wakeup APs and load microcode on APs.
304 MtrrSetAllMtrrs (&PeiCpuMpData
->MtrrTable
);
306 PeiCpuMpData
->CpuData
[ProcessorNumber
].State
= CpuStateIdle
;
309 // Execute AP function if AP is not disabled
311 GetProcessorNumber (PeiCpuMpData
, &ProcessorNumber
);
312 if (PeiCpuMpData
->ApLoopMode
== ApInHltLoop
) {
314 // Restore AP's volatile registers saved
316 RestoreVolatileRegisters (&PeiCpuMpData
->CpuData
[ProcessorNumber
].VolatileRegisters
, TRUE
);
319 if ((PeiCpuMpData
->CpuData
[ProcessorNumber
].State
!= CpuStateDisabled
) &&
320 (PeiCpuMpData
->ApFunction
!= 0)) {
321 PeiCpuMpData
->CpuData
[ProcessorNumber
].State
= CpuStateBusy
;
322 Procedure
= (EFI_AP_PROCEDURE
)(UINTN
)PeiCpuMpData
->ApFunction
;
324 // Invoke AP function here
326 Procedure ((VOID
*)(UINTN
)PeiCpuMpData
->ApFunctionArgument
);
328 // Re-get the processor number due to BSP/AP maybe exchange in AP function
330 GetProcessorNumber (PeiCpuMpData
, &ProcessorNumber
);
331 PeiCpuMpData
->CpuData
[ProcessorNumber
].State
= CpuStateIdle
;
336 // AP finished executing C code
338 InterlockedIncrement ((UINT32
*)&PeiCpuMpData
->FinishedCount
);
341 // Place AP is specified loop mode
343 if (PeiCpuMpData
->ApLoopMode
== ApInHltLoop
) {
345 // Save AP volatile registers
347 SaveVolatileRegisters (&PeiCpuMpData
->CpuData
[ProcessorNumber
].VolatileRegisters
);
349 // Place AP in Hlt-loop
352 DisableInterrupts ();
357 ApStartupSignalBuffer
= PeiCpuMpData
->CpuData
[ProcessorNumber
].StartupApSignal
;
359 // Clear AP start-up signal
361 *ApStartupSignalBuffer
= 0;
363 DisableInterrupts ();
364 if (PeiCpuMpData
->ApLoopMode
== ApInMwaitLoop
) {
366 // Place AP in Mwait-loop
368 AsmMonitor ((UINTN
)ApStartupSignalBuffer
, 0, 0);
369 if (*ApStartupSignalBuffer
!= WAKEUP_AP_SIGNAL
) {
371 // If AP start-up signal is not set, place AP into
372 // the maximum C-state
374 AsmMwait (PeiCpuMpData
->ApTargetCState
<< 4, 0);
376 } else if (PeiCpuMpData
->ApLoopMode
== ApInRunLoop
) {
378 // Place AP in Run-loop
386 // If AP start-up signal is written, AP is waken up
387 // otherwise place AP in loop again
389 if (*ApStartupSignalBuffer
== WAKEUP_AP_SIGNAL
) {
397 This function will be called by BSP to wakeup AP.
399 @param PeiCpuMpData Pointer to PEI CPU MP Data
400 @param Broadcast TRUE: Send broadcast IPI to all APs
401 FALSE: Send IPI to AP by ApicId
402 @param ApicId Apic ID for the processor to be waked
403 @param Procedure The function to be invoked by AP
404 @param ProcedureArgument The argument to be passed into AP function
408 IN PEI_CPU_MP_DATA
*PeiCpuMpData
,
409 IN BOOLEAN Broadcast
,
411 IN EFI_AP_PROCEDURE Procedure
, OPTIONAL
412 IN VOID
*ProcedureArgument OPTIONAL
415 volatile MP_CPU_EXCHANGE_INFO
*ExchangeInfo
;
417 PeiCpuMpData
->ApFunction
= (UINTN
) Procedure
;
418 PeiCpuMpData
->ApFunctionArgument
= (UINTN
) ProcedureArgument
;
419 PeiCpuMpData
->FinishedCount
= 0;
421 ExchangeInfo
= PeiCpuMpData
->MpCpuExchangeInfo
;
422 ExchangeInfo
->Lock
= 0;
423 ExchangeInfo
->StackStart
= PeiCpuMpData
->Buffer
;
424 ExchangeInfo
->StackSize
= PeiCpuMpData
->CpuApStackSize
;
425 ExchangeInfo
->BufferStart
= PeiCpuMpData
->WakeupBuffer
;
426 ExchangeInfo
->PmodeOffset
= PeiCpuMpData
->AddressMap
.PModeEntryOffset
;
427 ExchangeInfo
->LmodeOffset
= PeiCpuMpData
->AddressMap
.LModeEntryOffset
;
428 ExchangeInfo
->Cr3
= AsmReadCr3 ();
429 ExchangeInfo
->CFunction
= (UINTN
) ApCFunction
;
430 ExchangeInfo
->NumApsExecuting
= 0;
431 ExchangeInfo
->PeiCpuMpData
= PeiCpuMpData
;
434 // Get the BSP's data of GDT and IDT
436 CopyMem ((VOID
*)&ExchangeInfo
->GdtrProfile
, &mGdt
, sizeof(mGdt
));
437 AsmReadIdtr ((IA32_DESCRIPTOR
*) &ExchangeInfo
->IdtrProfile
);
440 SendInitSipiSipiAllExcludingSelf ((UINT32
) ExchangeInfo
->BufferStart
);
442 SendInitSipiSipi (ApicId
, (UINT32
) ExchangeInfo
->BufferStart
);
449 Get available system memory below 1MB by specified size.
451 @param WakeupBufferSize Wakeup buffer size required
453 @retval other Return wakeup buffer address below 1MB.
454 @retval -1 Cannot find free memory below 1MB.
458 IN UINTN WakeupBufferSize
461 EFI_PEI_HOB_POINTERS Hob
;
462 UINTN WakeupBufferStart
;
463 UINTN WakeupBufferEnd
;
466 // Get the HOB list for processing
468 Hob
.Raw
= GetHobList ();
471 // Collect memory ranges
473 while (!END_OF_HOB_LIST (Hob
)) {
474 if (Hob
.Header
->HobType
== EFI_HOB_TYPE_RESOURCE_DESCRIPTOR
) {
475 if ((Hob
.ResourceDescriptor
->PhysicalStart
< BASE_1MB
) &&
476 (Hob
.ResourceDescriptor
->ResourceType
== EFI_RESOURCE_SYSTEM_MEMORY
) &&
477 ((Hob
.ResourceDescriptor
->ResourceAttribute
&
478 (EFI_RESOURCE_ATTRIBUTE_READ_PROTECTED
|
479 EFI_RESOURCE_ATTRIBUTE_WRITE_PROTECTED
|
480 EFI_RESOURCE_ATTRIBUTE_EXECUTION_PROTECTED
484 // Need memory under 1MB to be collected here
486 WakeupBufferEnd
= (UINTN
) (Hob
.ResourceDescriptor
->PhysicalStart
+ Hob
.ResourceDescriptor
->ResourceLength
);
487 if (WakeupBufferEnd
> BASE_1MB
) {
489 // Wakeup buffer should be under 1MB
491 WakeupBufferEnd
= BASE_1MB
;
494 // Wakeup buffer should be aligned on 4KB
496 WakeupBufferStart
= (WakeupBufferEnd
- WakeupBufferSize
) & ~(SIZE_4KB
- 1);
497 if (WakeupBufferStart
< Hob
.ResourceDescriptor
->PhysicalStart
) {
501 // Create a memory allocation HOB.
503 BuildMemoryAllocationHob (
508 return WakeupBufferStart
;
514 Hob
.Raw
= GET_NEXT_HOB (Hob
);
521 Get available system memory below 1MB by specified size.
523 @param PeiCpuMpData Pointer to PEI CPU MP Data
526 BackupAndPrepareWakeupBuffer(
527 IN PEI_CPU_MP_DATA
*PeiCpuMpData
531 (VOID
*) PeiCpuMpData
->BackupBuffer
,
532 (VOID
*) PeiCpuMpData
->WakeupBuffer
,
533 PeiCpuMpData
->BackupBufferSize
536 (VOID
*) PeiCpuMpData
->WakeupBuffer
,
537 (VOID
*) PeiCpuMpData
->AddressMap
.RendezvousFunnelAddress
,
538 PeiCpuMpData
->AddressMap
.RendezvousFunnelSize
543 Restore wakeup buffer data.
545 @param PeiCpuMpData Pointer to PEI CPU MP Data
549 IN PEI_CPU_MP_DATA
*PeiCpuMpData
552 CopyMem ((VOID
*) PeiCpuMpData
->WakeupBuffer
, (VOID
*) PeiCpuMpData
->BackupBuffer
, PeiCpuMpData
->BackupBufferSize
);
556 This function will get CPU count in the system.
558 @param PeiCpuMpData Pointer to PEI CPU MP Data
560 @return AP processor count
563 CountProcessorNumber (
564 IN PEI_CPU_MP_DATA
*PeiCpuMpData
568 // Load Microcode on BSP
572 // Store BSP's MTRR setting
574 MtrrGetAllMtrrs (&PeiCpuMpData
->MtrrTable
);
577 // Only perform AP detection if PcdCpuMaxLogicalProcessorNumber is greater than 1
579 if (PcdGet32 (PcdCpuMaxLogicalProcessorNumber
) > 1) {
581 // Send 1st broadcast IPI to APs to wakeup APs
583 PeiCpuMpData
->InitFlag
= TRUE
;
584 PeiCpuMpData
->X2ApicEnable
= FALSE
;
585 WakeUpAP (PeiCpuMpData
, TRUE
, 0, NULL
, NULL
);
587 // Wait for AP task to complete and then exit.
589 MicroSecondDelay (PcdGet32 (PcdCpuApInitTimeOutInMicroSeconds
));
590 PeiCpuMpData
->InitFlag
= FALSE
;
591 PeiCpuMpData
->CpuCount
+= (UINT32
)PeiCpuMpData
->MpCpuExchangeInfo
->NumApsExecuting
;
592 ASSERT (PeiCpuMpData
->CpuCount
<= PcdGet32 (PcdCpuMaxLogicalProcessorNumber
));
594 // Wait for all APs finished the initialization
596 while (PeiCpuMpData
->FinishedCount
< (PeiCpuMpData
->CpuCount
- 1)) {
600 if (PeiCpuMpData
->X2ApicEnable
) {
601 DEBUG ((EFI_D_INFO
, "Force x2APIC mode!\n"));
603 // Send 2nd broadcast IPI to all APs to enable x2APIC mode
605 WakeUpAP (PeiCpuMpData
, TRUE
, 0, ApFuncEnableX2Apic
, NULL
);
607 // Wait for all known APs finished
609 while (PeiCpuMpData
->FinishedCount
< (PeiCpuMpData
->CpuCount
- 1)) {
613 // Enable x2APIC on BSP
615 SetApicMode (LOCAL_APIC_MODE_X2APIC
);
617 DEBUG ((EFI_D_INFO
, "APIC MODE is %d\n", GetApicMode ()));
619 // Sort BSP/Aps by CPU APIC ID in ascending order
621 SortApicId (PeiCpuMpData
);
624 DEBUG ((EFI_D_INFO
, "CpuMpPei: Find %d processors in system.\n", PeiCpuMpData
->CpuCount
));
625 return PeiCpuMpData
->CpuCount
;
629 Prepare for AP wakeup buffer and copy AP reset code into it.
631 Get wakeup buffer below 1MB. Allocate memory for CPU MP Data and APs Stack.
633 @return Pointer to PEI CPU MP Data
636 PrepareAPStartupVector (
642 PEI_CPU_MP_DATA
*PeiCpuMpData
;
643 EFI_PHYSICAL_ADDRESS Buffer
;
646 UINTN WakeupBufferSize
;
647 MP_ASSEMBLY_ADDRESS_MAP AddressMap
;
649 UINT16 MonitorFilterSize
;
650 UINT8
*MonitorBuffer
;
653 AsmGetAddressMap (&AddressMap
);
654 WakeupBufferSize
= AddressMap
.RendezvousFunnelSize
+ sizeof (MP_CPU_EXCHANGE_INFO
);
655 WakeupBuffer
= GetWakeupBuffer ((WakeupBufferSize
+ SIZE_4KB
- 1) & ~(SIZE_4KB
- 1));
656 ASSERT (WakeupBuffer
!= (UINTN
) -1);
657 DEBUG ((EFI_D_INFO
, "CpuMpPei: WakeupBuffer = 0x%x\n", WakeupBuffer
));
660 // Allocate Pages for APs stack, CPU MP Data, backup buffer for wakeup buffer,
661 // and monitor buffer if required.
663 MaxCpuCount
= PcdGet32(PcdCpuMaxLogicalProcessorNumber
);
664 BufferSize
= PcdGet32 (PcdCpuApStackSize
) * MaxCpuCount
+ sizeof (PEI_CPU_MP_DATA
)
665 + WakeupBufferSize
+ sizeof (PEI_CPU_DATA
) * MaxCpuCount
;
666 ApLoopMode
= GetApLoopMode (&MonitorFilterSize
);
667 BufferSize
+= MonitorFilterSize
* MaxCpuCount
;
668 Status
= PeiServicesAllocatePages (
670 EFI_SIZE_TO_PAGES (BufferSize
),
673 ASSERT_EFI_ERROR (Status
);
675 PeiCpuMpData
= (PEI_CPU_MP_DATA
*) (UINTN
) (Buffer
+ PcdGet32 (PcdCpuApStackSize
) * MaxCpuCount
);
676 PeiCpuMpData
->Buffer
= (UINTN
) Buffer
;
677 PeiCpuMpData
->CpuApStackSize
= PcdGet32 (PcdCpuApStackSize
);
678 PeiCpuMpData
->WakeupBuffer
= WakeupBuffer
;
679 PeiCpuMpData
->BackupBuffer
= (UINTN
)PeiCpuMpData
+ sizeof (PEI_CPU_MP_DATA
);
680 PeiCpuMpData
->BackupBufferSize
= WakeupBufferSize
;
681 PeiCpuMpData
->MpCpuExchangeInfo
= (MP_CPU_EXCHANGE_INFO
*) (UINTN
) (WakeupBuffer
+ AddressMap
.RendezvousFunnelSize
);
683 PeiCpuMpData
->CpuCount
= 1;
684 PeiCpuMpData
->BspNumber
= 0;
685 PeiCpuMpData
->CpuData
= (PEI_CPU_DATA
*) (PeiCpuMpData
->BackupBuffer
+
686 PeiCpuMpData
->BackupBufferSize
);
687 PeiCpuMpData
->CpuData
[0].ApicId
= GetInitialApicId ();
688 PeiCpuMpData
->CpuData
[0].Health
.Uint32
= 0;
689 PeiCpuMpData
->EndOfPeiFlag
= FALSE
;
690 InitializeSpinLock(&PeiCpuMpData
->MpLock
);
691 SaveVolatileRegisters (&PeiCpuMpData
->CpuData
[0].VolatileRegisters
);
692 CopyMem (&PeiCpuMpData
->AddressMap
, &AddressMap
, sizeof (MP_ASSEMBLY_ADDRESS_MAP
));
694 // Initialize AP loop mode
696 PeiCpuMpData
->ApLoopMode
= ApLoopMode
;
697 DEBUG ((EFI_D_INFO
, "AP Loop Mode is %d\n", PeiCpuMpData
->ApLoopMode
));
698 MonitorBuffer
= (UINT8
*)(PeiCpuMpData
->CpuData
+ MaxCpuCount
);
699 if (PeiCpuMpData
->ApLoopMode
!= ApInHltLoop
) {
701 // Set up APs wakeup signal buffer
703 for (Index
= 0; Index
< MaxCpuCount
; Index
++) {
704 PeiCpuMpData
->CpuData
[Index
].StartupApSignal
=
705 (UINT32
*)(MonitorBuffer
+ MonitorFilterSize
* Index
);
709 // Backup original data and copy AP reset code in it
711 BackupAndPrepareWakeupBuffer(PeiCpuMpData
);
717 Notify function on End Of Pei PPI.
719 On S3 boot, this function will restore wakeup buffer data.
720 On normal boot, this function will flag wakeup buffer to be un-used type.
722 @param PeiServices The pointer to the PEI Services Table.
723 @param NotifyDescriptor Address of the notification descriptor data structure.
724 @param Ppi Address of the PPI that was installed.
726 @retval EFI_SUCCESS When everything is OK.
731 CpuMpEndOfPeiCallback (
732 IN EFI_PEI_SERVICES
**PeiServices
,
733 IN EFI_PEI_NOTIFY_DESCRIPTOR
*NotifyDescriptor
,
738 EFI_BOOT_MODE BootMode
;
739 PEI_CPU_MP_DATA
*PeiCpuMpData
;
740 EFI_PEI_HOB_POINTERS Hob
;
741 EFI_HOB_MEMORY_ALLOCATION
*MemoryHob
;
743 DEBUG ((EFI_D_INFO
, "CpuMpPei: CpuMpEndOfPeiCallback () invoked\n"));
745 Status
= PeiServicesGetBootMode (&BootMode
);
746 ASSERT_EFI_ERROR (Status
);
748 PeiCpuMpData
= GetMpHobData ();
749 ASSERT (PeiCpuMpData
!= NULL
);
751 if (BootMode
!= BOOT_ON_S3_RESUME
) {
753 // Get the HOB list for processing
755 Hob
.Raw
= GetHobList ();
757 // Collect memory ranges
759 while (!END_OF_HOB_LIST (Hob
)) {
760 if (Hob
.Header
->HobType
== EFI_HOB_TYPE_MEMORY_ALLOCATION
) {
761 MemoryHob
= Hob
.MemoryAllocation
;
762 if(MemoryHob
->AllocDescriptor
.MemoryBaseAddress
== PeiCpuMpData
->WakeupBuffer
) {
764 // Flag this HOB type to un-used
766 GET_HOB_TYPE (Hob
) = EFI_HOB_TYPE_UNUSED
;
770 Hob
.Raw
= GET_NEXT_HOB (Hob
);
773 RestoreWakeupBuffer (PeiCpuMpData
);
774 PeiCpuMpData
->EndOfPeiFlag
= TRUE
;
780 The Entry point of the MP CPU PEIM.
782 This function will wakeup APs and collect CPU AP count and install the
785 @param FileHandle Handle of the file being invoked.
786 @param PeiServices Describes the list of possible PEI Services.
788 @retval EFI_SUCCESS MpServicePpi is installed successfully.
794 IN EFI_PEI_FILE_HANDLE FileHandle
,
795 IN CONST EFI_PEI_SERVICES
**PeiServices
799 PEI_CPU_MP_DATA
*PeiCpuMpData
;
800 UINT32 ProcessorCount
;
803 // Load new GDT table on BSP
805 AsmInitializeGdt (&mGdt
);
807 // Get wakeup buffer and copy AP reset code in it
809 PeiCpuMpData
= PrepareAPStartupVector ();
811 // Count processor number and collect processor information
813 ProcessorCount
= CountProcessorNumber (PeiCpuMpData
);
815 // Build location of PEI CPU MP DATA buffer in HOB
819 (VOID
*)&PeiCpuMpData
,
823 // Update and publish CPU BIST information
825 CollectBistDataFromPpi (PeiServices
, PeiCpuMpData
);
827 // register an event for EndOfPei
829 Status
= PeiServicesNotifyPpi (&mNotifyList
);
830 ASSERT_EFI_ERROR (Status
);
832 // Install CPU MP PPI
834 Status
= PeiServicesInstallPpi(&mPeiCpuMpPpiDesc
);
835 ASSERT_EFI_ERROR (Status
);