2 CPU PEI Module installs CPU Multiple Processor PPI.
4 Copyright (c) 2015 - 2016, 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 DisableInterrupts ();
360 if (PeiCpuMpData
->ApLoopMode
== ApInMwaitLoop
) {
362 // Place AP in Mwait-loop
364 AsmMonitor ((UINTN
)ApStartupSignalBuffer
, 0, 0);
365 if (*ApStartupSignalBuffer
!= WAKEUP_AP_SIGNAL
) {
367 // If AP start-up signal is not set, place AP into
368 // the maximum C-state
370 AsmMwait (PeiCpuMpData
->ApTargetCState
<< 4, 0);
372 } else if (PeiCpuMpData
->ApLoopMode
== ApInRunLoop
) {
374 // Place AP in Run-loop
382 // If AP start-up signal is written, AP is waken up
383 // otherwise place AP in loop again
385 if (*ApStartupSignalBuffer
== WAKEUP_AP_SIGNAL
) {
387 // Clear AP start-up signal when AP waken up
389 InterlockedCompareExchange32 (
390 (UINT32
*)ApStartupSignalBuffer
,
401 Write AP start-up signal to wakeup AP.
403 @param ApStartupSignalBuffer Pointer to AP wakeup signal
407 IN
volatile UINT32
*ApStartupSignalBuffer
410 *ApStartupSignalBuffer
= WAKEUP_AP_SIGNAL
;
412 // If AP is waken up, StartupApSignal should be cleared.
413 // Otherwise, write StartupApSignal again till AP waken up.
415 while (InterlockedCompareExchange32 (
416 (UINT32
*)ApStartupSignalBuffer
,
425 This function will be called by BSP to wakeup AP.
427 @param PeiCpuMpData Pointer to PEI CPU MP Data
428 @param Broadcast TRUE: Send broadcast IPI to all APs
429 FALSE: Send IPI to AP by ApicId
430 @param ProcessorNumber The handle number of specified processor
431 @param Procedure The function to be invoked by AP
432 @param ProcedureArgument The argument to be passed into AP function
436 IN PEI_CPU_MP_DATA
*PeiCpuMpData
,
437 IN BOOLEAN Broadcast
,
438 IN UINTN ProcessorNumber
,
439 IN EFI_AP_PROCEDURE Procedure
, OPTIONAL
440 IN VOID
*ProcedureArgument OPTIONAL
443 volatile MP_CPU_EXCHANGE_INFO
*ExchangeInfo
;
446 PeiCpuMpData
->ApFunction
= (UINTN
) Procedure
;
447 PeiCpuMpData
->ApFunctionArgument
= (UINTN
) ProcedureArgument
;
448 PeiCpuMpData
->FinishedCount
= 0;
450 ExchangeInfo
= PeiCpuMpData
->MpCpuExchangeInfo
;
451 ExchangeInfo
->Lock
= 0;
452 ExchangeInfo
->StackStart
= PeiCpuMpData
->Buffer
;
453 ExchangeInfo
->StackSize
= PeiCpuMpData
->CpuApStackSize
;
454 ExchangeInfo
->BufferStart
= PeiCpuMpData
->WakeupBuffer
;
455 ExchangeInfo
->PmodeOffset
= PeiCpuMpData
->AddressMap
.PModeEntryOffset
;
456 ExchangeInfo
->LmodeOffset
= PeiCpuMpData
->AddressMap
.LModeEntryOffset
;
457 ExchangeInfo
->Cr3
= AsmReadCr3 ();
458 ExchangeInfo
->CFunction
= (UINTN
) ApCFunction
;
459 ExchangeInfo
->NumApsExecuting
= 0;
460 ExchangeInfo
->PeiCpuMpData
= PeiCpuMpData
;
463 // Get the BSP's data of GDT and IDT
465 CopyMem ((VOID
*)&ExchangeInfo
->GdtrProfile
, &mGdt
, sizeof(mGdt
));
466 AsmReadIdtr ((IA32_DESCRIPTOR
*) &ExchangeInfo
->IdtrProfile
);
468 if (PeiCpuMpData
->ApLoopMode
== ApInMwaitLoop
) {
470 // Get AP target C-state each time when waking up AP,
471 // for it maybe updated by platform again
473 PeiCpuMpData
->ApTargetCState
= PcdGet8 (PcdCpuApTargetCstate
);
477 // Wakeup APs per AP loop state
479 if (PeiCpuMpData
->ApLoopMode
== ApInHltLoop
|| PeiCpuMpData
->InitFlag
) {
481 SendInitSipiSipiAllExcludingSelf ((UINT32
) ExchangeInfo
->BufferStart
);
484 PeiCpuMpData
->CpuData
[ProcessorNumber
].ApicId
,
485 (UINT32
) ExchangeInfo
->BufferStart
488 } else if ((PeiCpuMpData
->ApLoopMode
== ApInMwaitLoop
) ||
489 (PeiCpuMpData
->ApLoopMode
== ApInRunLoop
)) {
491 for (Index
= 0; Index
< PeiCpuMpData
->CpuCount
; Index
++) {
492 if (Index
!= PeiCpuMpData
->BspNumber
) {
493 WriteStartupSignal (PeiCpuMpData
->CpuData
[Index
].StartupApSignal
);
497 WriteStartupSignal (PeiCpuMpData
->CpuData
[ProcessorNumber
].StartupApSignal
);
506 Get available system memory below 1MB by specified size.
508 @param WakeupBufferSize Wakeup buffer size required
510 @retval other Return wakeup buffer address below 1MB.
511 @retval -1 Cannot find free memory below 1MB.
515 IN UINTN WakeupBufferSize
518 EFI_PEI_HOB_POINTERS Hob
;
519 UINTN WakeupBufferStart
;
520 UINTN WakeupBufferEnd
;
523 // Get the HOB list for processing
525 Hob
.Raw
= GetHobList ();
528 // Collect memory ranges
530 while (!END_OF_HOB_LIST (Hob
)) {
531 if (Hob
.Header
->HobType
== EFI_HOB_TYPE_RESOURCE_DESCRIPTOR
) {
532 if ((Hob
.ResourceDescriptor
->PhysicalStart
< BASE_1MB
) &&
533 (Hob
.ResourceDescriptor
->ResourceType
== EFI_RESOURCE_SYSTEM_MEMORY
) &&
534 ((Hob
.ResourceDescriptor
->ResourceAttribute
&
535 (EFI_RESOURCE_ATTRIBUTE_READ_PROTECTED
|
536 EFI_RESOURCE_ATTRIBUTE_WRITE_PROTECTED
|
537 EFI_RESOURCE_ATTRIBUTE_EXECUTION_PROTECTED
541 // Need memory under 1MB to be collected here
543 WakeupBufferEnd
= (UINTN
) (Hob
.ResourceDescriptor
->PhysicalStart
+ Hob
.ResourceDescriptor
->ResourceLength
);
544 if (WakeupBufferEnd
> BASE_1MB
) {
546 // Wakeup buffer should be under 1MB
548 WakeupBufferEnd
= BASE_1MB
;
551 // Wakeup buffer should be aligned on 4KB
553 WakeupBufferStart
= (WakeupBufferEnd
- WakeupBufferSize
) & ~(SIZE_4KB
- 1);
554 if (WakeupBufferStart
< Hob
.ResourceDescriptor
->PhysicalStart
) {
558 // Create a memory allocation HOB.
560 BuildMemoryAllocationHob (
565 return WakeupBufferStart
;
571 Hob
.Raw
= GET_NEXT_HOB (Hob
);
578 Get available system memory below 1MB by specified size.
580 @param PeiCpuMpData Pointer to PEI CPU MP Data
583 BackupAndPrepareWakeupBuffer(
584 IN PEI_CPU_MP_DATA
*PeiCpuMpData
588 (VOID
*) PeiCpuMpData
->BackupBuffer
,
589 (VOID
*) PeiCpuMpData
->WakeupBuffer
,
590 PeiCpuMpData
->BackupBufferSize
593 (VOID
*) PeiCpuMpData
->WakeupBuffer
,
594 (VOID
*) PeiCpuMpData
->AddressMap
.RendezvousFunnelAddress
,
595 PeiCpuMpData
->AddressMap
.RendezvousFunnelSize
600 Restore wakeup buffer data.
602 @param PeiCpuMpData Pointer to PEI CPU MP Data
606 IN PEI_CPU_MP_DATA
*PeiCpuMpData
609 CopyMem ((VOID
*) PeiCpuMpData
->WakeupBuffer
, (VOID
*) PeiCpuMpData
->BackupBuffer
, PeiCpuMpData
->BackupBufferSize
);
613 This function will get CPU count in the system.
615 @param PeiCpuMpData Pointer to PEI CPU MP Data
617 @return AP processor count
620 CountProcessorNumber (
621 IN PEI_CPU_MP_DATA
*PeiCpuMpData
625 // Load Microcode on BSP
629 // Store BSP's MTRR setting
631 MtrrGetAllMtrrs (&PeiCpuMpData
->MtrrTable
);
634 // Only perform AP detection if PcdCpuMaxLogicalProcessorNumber is greater than 1
636 if (PcdGet32 (PcdCpuMaxLogicalProcessorNumber
) > 1) {
638 // Send 1st broadcast IPI to APs to wakeup APs
640 PeiCpuMpData
->InitFlag
= TRUE
;
641 PeiCpuMpData
->X2ApicEnable
= FALSE
;
642 WakeUpAP (PeiCpuMpData
, TRUE
, 0, NULL
, NULL
);
644 // Wait for AP task to complete and then exit.
646 MicroSecondDelay (PcdGet32 (PcdCpuApInitTimeOutInMicroSeconds
));
647 PeiCpuMpData
->InitFlag
= FALSE
;
648 PeiCpuMpData
->CpuCount
+= (UINT32
)PeiCpuMpData
->MpCpuExchangeInfo
->NumApsExecuting
;
649 ASSERT (PeiCpuMpData
->CpuCount
<= PcdGet32 (PcdCpuMaxLogicalProcessorNumber
));
651 // Wait for all APs finished the initialization
653 while (PeiCpuMpData
->FinishedCount
< (PeiCpuMpData
->CpuCount
- 1)) {
657 if (PeiCpuMpData
->X2ApicEnable
) {
658 DEBUG ((EFI_D_INFO
, "Force x2APIC mode!\n"));
660 // Wakeup all APs to enable x2APIC mode
662 WakeUpAP (PeiCpuMpData
, TRUE
, 0, ApFuncEnableX2Apic
, NULL
);
664 // Wait for all known APs finished
666 while (PeiCpuMpData
->FinishedCount
< (PeiCpuMpData
->CpuCount
- 1)) {
670 // Enable x2APIC on BSP
672 SetApicMode (LOCAL_APIC_MODE_X2APIC
);
674 DEBUG ((EFI_D_INFO
, "APIC MODE is %d\n", GetApicMode ()));
676 // Sort BSP/Aps by CPU APIC ID in ascending order
678 SortApicId (PeiCpuMpData
);
681 DEBUG ((EFI_D_INFO
, "CpuMpPei: Find %d processors in system.\n", PeiCpuMpData
->CpuCount
));
682 return PeiCpuMpData
->CpuCount
;
686 Prepare for AP wakeup buffer and copy AP reset code into it.
688 Get wakeup buffer below 1MB. Allocate memory for CPU MP Data and APs Stack.
690 @return Pointer to PEI CPU MP Data
693 PrepareAPStartupVector (
699 PEI_CPU_MP_DATA
*PeiCpuMpData
;
700 EFI_PHYSICAL_ADDRESS Buffer
;
703 UINTN WakeupBufferSize
;
704 MP_ASSEMBLY_ADDRESS_MAP AddressMap
;
706 UINT16 MonitorFilterSize
;
707 UINT8
*MonitorBuffer
;
710 AsmGetAddressMap (&AddressMap
);
711 WakeupBufferSize
= AddressMap
.RendezvousFunnelSize
+ sizeof (MP_CPU_EXCHANGE_INFO
);
712 WakeupBuffer
= GetWakeupBuffer ((WakeupBufferSize
+ SIZE_4KB
- 1) & ~(SIZE_4KB
- 1));
713 ASSERT (WakeupBuffer
!= (UINTN
) -1);
714 DEBUG ((EFI_D_INFO
, "CpuMpPei: WakeupBuffer = 0x%x\n", WakeupBuffer
));
717 // Allocate Pages for APs stack, CPU MP Data, backup buffer for wakeup buffer,
718 // and monitor buffer if required.
720 MaxCpuCount
= PcdGet32(PcdCpuMaxLogicalProcessorNumber
);
721 BufferSize
= PcdGet32 (PcdCpuApStackSize
) * MaxCpuCount
+ sizeof (PEI_CPU_MP_DATA
)
722 + WakeupBufferSize
+ sizeof (PEI_CPU_DATA
) * MaxCpuCount
;
723 ApLoopMode
= GetApLoopMode (&MonitorFilterSize
);
724 BufferSize
+= MonitorFilterSize
* MaxCpuCount
;
725 Status
= PeiServicesAllocatePages (
727 EFI_SIZE_TO_PAGES (BufferSize
),
730 ASSERT_EFI_ERROR (Status
);
732 PeiCpuMpData
= (PEI_CPU_MP_DATA
*) (UINTN
) (Buffer
+ PcdGet32 (PcdCpuApStackSize
) * MaxCpuCount
);
733 PeiCpuMpData
->Buffer
= (UINTN
) Buffer
;
734 PeiCpuMpData
->CpuApStackSize
= PcdGet32 (PcdCpuApStackSize
);
735 PeiCpuMpData
->WakeupBuffer
= WakeupBuffer
;
736 PeiCpuMpData
->BackupBuffer
= (UINTN
)PeiCpuMpData
+ sizeof (PEI_CPU_MP_DATA
);
737 PeiCpuMpData
->BackupBufferSize
= WakeupBufferSize
;
738 PeiCpuMpData
->MpCpuExchangeInfo
= (MP_CPU_EXCHANGE_INFO
*) (UINTN
) (WakeupBuffer
+ AddressMap
.RendezvousFunnelSize
);
740 PeiCpuMpData
->CpuCount
= 1;
741 PeiCpuMpData
->BspNumber
= 0;
742 PeiCpuMpData
->CpuData
= (PEI_CPU_DATA
*) (PeiCpuMpData
->BackupBuffer
+
743 PeiCpuMpData
->BackupBufferSize
);
744 PeiCpuMpData
->CpuData
[0].ApicId
= GetInitialApicId ();
745 PeiCpuMpData
->CpuData
[0].Health
.Uint32
= 0;
746 PeiCpuMpData
->EndOfPeiFlag
= FALSE
;
747 InitializeSpinLock(&PeiCpuMpData
->MpLock
);
748 SaveVolatileRegisters (&PeiCpuMpData
->CpuData
[0].VolatileRegisters
);
749 CopyMem (&PeiCpuMpData
->AddressMap
, &AddressMap
, sizeof (MP_ASSEMBLY_ADDRESS_MAP
));
751 // Initialize AP loop mode
753 PeiCpuMpData
->ApLoopMode
= ApLoopMode
;
754 DEBUG ((EFI_D_INFO
, "AP Loop Mode is %d\n", PeiCpuMpData
->ApLoopMode
));
755 MonitorBuffer
= (UINT8
*)(PeiCpuMpData
->CpuData
+ MaxCpuCount
);
756 if (PeiCpuMpData
->ApLoopMode
!= ApInHltLoop
) {
758 // Set up APs wakeup signal buffer
760 for (Index
= 0; Index
< MaxCpuCount
; Index
++) {
761 PeiCpuMpData
->CpuData
[Index
].StartupApSignal
=
762 (UINT32
*)(MonitorBuffer
+ MonitorFilterSize
* Index
);
766 // Backup original data and copy AP reset code in it
768 BackupAndPrepareWakeupBuffer(PeiCpuMpData
);
774 Notify function on End Of Pei PPI.
776 On S3 boot, this function will restore wakeup buffer data.
777 On normal boot, this function will flag wakeup buffer to be un-used type.
779 @param PeiServices The pointer to the PEI Services Table.
780 @param NotifyDescriptor Address of the notification descriptor data structure.
781 @param Ppi Address of the PPI that was installed.
783 @retval EFI_SUCCESS When everything is OK.
788 CpuMpEndOfPeiCallback (
789 IN EFI_PEI_SERVICES
**PeiServices
,
790 IN EFI_PEI_NOTIFY_DESCRIPTOR
*NotifyDescriptor
,
795 EFI_BOOT_MODE BootMode
;
796 PEI_CPU_MP_DATA
*PeiCpuMpData
;
797 EFI_PEI_HOB_POINTERS Hob
;
798 EFI_HOB_MEMORY_ALLOCATION
*MemoryHob
;
800 DEBUG ((EFI_D_INFO
, "CpuMpPei: CpuMpEndOfPeiCallback () invoked\n"));
802 Status
= PeiServicesGetBootMode (&BootMode
);
803 ASSERT_EFI_ERROR (Status
);
805 PeiCpuMpData
= GetMpHobData ();
806 ASSERT (PeiCpuMpData
!= NULL
);
808 if (BootMode
!= BOOT_ON_S3_RESUME
) {
810 // Get the HOB list for processing
812 Hob
.Raw
= GetHobList ();
814 // Collect memory ranges
816 while (!END_OF_HOB_LIST (Hob
)) {
817 if (Hob
.Header
->HobType
== EFI_HOB_TYPE_MEMORY_ALLOCATION
) {
818 MemoryHob
= Hob
.MemoryAllocation
;
819 if(MemoryHob
->AllocDescriptor
.MemoryBaseAddress
== PeiCpuMpData
->WakeupBuffer
) {
821 // Flag this HOB type to un-used
823 GET_HOB_TYPE (Hob
) = EFI_HOB_TYPE_UNUSED
;
827 Hob
.Raw
= GET_NEXT_HOB (Hob
);
830 RestoreWakeupBuffer (PeiCpuMpData
);
831 PeiCpuMpData
->EndOfPeiFlag
= TRUE
;
837 The Entry point of the MP CPU PEIM.
839 This function will wakeup APs and collect CPU AP count and install the
842 @param FileHandle Handle of the file being invoked.
843 @param PeiServices Describes the list of possible PEI Services.
845 @retval EFI_SUCCESS MpServicePpi is installed successfully.
851 IN EFI_PEI_FILE_HANDLE FileHandle
,
852 IN CONST EFI_PEI_SERVICES
**PeiServices
856 PEI_CPU_MP_DATA
*PeiCpuMpData
;
859 // Load new GDT table on BSP
861 AsmInitializeGdt (&mGdt
);
863 // Get wakeup buffer and copy AP reset code in it
865 PeiCpuMpData
= PrepareAPStartupVector ();
867 // Count processor number and collect processor information
869 CountProcessorNumber (PeiCpuMpData
);
871 // Build location of PEI CPU MP DATA buffer in HOB
875 (VOID
*)&PeiCpuMpData
,
879 // Update and publish CPU BIST information
881 CollectBistDataFromPpi (PeiServices
, PeiCpuMpData
);
883 // register an event for EndOfPei
885 Status
= PeiServicesNotifyPpi (&mNotifyList
);
886 ASSERT_EFI_ERROR (Status
);
888 // Install CPU MP PPI
890 Status
= PeiServicesInstallPpi(&mPeiCpuMpPpiDesc
);
891 ASSERT_EFI_ERROR (Status
);