ArmPkg/ArmExceptionLib: Add implementation of new API
[mirror_edk2.git] / UefiCpuPkg / Library / MpInitLib / MpLib.c
1 /** @file
2 CPU MP Initialize Library common functions.
3
4 Copyright (c) 2016 - 2017, 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
9
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.
12
13 **/
14
15 #include "MpLib.h"
16
17 EFI_GUID mCpuInitMpLibHobGuid = CPU_INIT_MP_LIB_HOB_GUID;
18
19 /**
20 The function will check if BSP Execute Disable is enabled.
21
22 DxeIpl may have enabled Execute Disable for BSP, APs need to
23 get the status and sync up the settings.
24 If BSP's CR0.Paging is not set, BSP execute Disble feature is
25 not working actually.
26
27 @retval TRUE BSP Execute Disable is enabled.
28 @retval FALSE BSP Execute Disable is not enabled.
29 **/
30 BOOLEAN
31 IsBspExecuteDisableEnabled (
32 VOID
33 )
34 {
35 UINT32 Eax;
36 CPUID_EXTENDED_CPU_SIG_EDX Edx;
37 MSR_IA32_EFER_REGISTER EferMsr;
38 BOOLEAN Enabled;
39 IA32_CR0 Cr0;
40
41 Enabled = FALSE;
42 Cr0.UintN = AsmReadCr0 ();
43 if (Cr0.Bits.PG != 0) {
44 //
45 // If CR0 Paging bit is set
46 //
47 AsmCpuid (CPUID_EXTENDED_FUNCTION, &Eax, NULL, NULL, NULL);
48 if (Eax >= CPUID_EXTENDED_CPU_SIG) {
49 AsmCpuid (CPUID_EXTENDED_CPU_SIG, NULL, NULL, NULL, &Edx.Uint32);
50 //
51 // CPUID 0x80000001
52 // Bit 20: Execute Disable Bit available.
53 //
54 if (Edx.Bits.NX != 0) {
55 EferMsr.Uint64 = AsmReadMsr64 (MSR_IA32_EFER);
56 //
57 // MSR 0xC0000080
58 // Bit 11: Execute Disable Bit enable.
59 //
60 if (EferMsr.Bits.NXE != 0) {
61 Enabled = TRUE;
62 }
63 }
64 }
65 }
66
67 return Enabled;
68 }
69
70 /**
71 Worker function for SwitchBSP().
72
73 Worker function for SwitchBSP(), assigned to the AP which is intended
74 to become BSP.
75
76 @param[in] Buffer Pointer to CPU MP Data
77 **/
78 VOID
79 EFIAPI
80 FutureBSPProc (
81 IN VOID *Buffer
82 )
83 {
84 CPU_MP_DATA *DataInHob;
85
86 DataInHob = (CPU_MP_DATA *) Buffer;
87 AsmExchangeRole (&DataInHob->APInfo, &DataInHob->BSPInfo);
88 }
89
90 /**
91 Get the Application Processors state.
92
93 @param[in] CpuData The pointer to CPU_AP_DATA of specified AP
94
95 @return The AP status
96 **/
97 CPU_STATE
98 GetApState (
99 IN CPU_AP_DATA *CpuData
100 )
101 {
102 return CpuData->State;
103 }
104
105 /**
106 Set the Application Processors state.
107
108 @param[in] CpuData The pointer to CPU_AP_DATA of specified AP
109 @param[in] State The AP status
110 **/
111 VOID
112 SetApState (
113 IN CPU_AP_DATA *CpuData,
114 IN CPU_STATE State
115 )
116 {
117 AcquireSpinLock (&CpuData->ApLock);
118 CpuData->State = State;
119 ReleaseSpinLock (&CpuData->ApLock);
120 }
121
122 /**
123 Save BSP's local APIC timer setting.
124
125 @param[in] CpuMpData Pointer to CPU MP Data
126 **/
127 VOID
128 SaveLocalApicTimerSetting (
129 IN CPU_MP_DATA *CpuMpData
130 )
131 {
132 //
133 // Record the current local APIC timer setting of BSP
134 //
135 GetApicTimerState (
136 &CpuMpData->DivideValue,
137 &CpuMpData->PeriodicMode,
138 &CpuMpData->Vector
139 );
140 CpuMpData->CurrentTimerCount = GetApicTimerCurrentCount ();
141 CpuMpData->TimerInterruptState = GetApicTimerInterruptState ();
142 }
143
144 /**
145 Sync local APIC timer setting from BSP to AP.
146
147 @param[in] CpuMpData Pointer to CPU MP Data
148 **/
149 VOID
150 SyncLocalApicTimerSetting (
151 IN CPU_MP_DATA *CpuMpData
152 )
153 {
154 //
155 // Sync local APIC timer setting from BSP to AP
156 //
157 InitializeApicTimer (
158 CpuMpData->DivideValue,
159 CpuMpData->CurrentTimerCount,
160 CpuMpData->PeriodicMode,
161 CpuMpData->Vector
162 );
163 //
164 // Disable AP's local APIC timer interrupt
165 //
166 DisableApicTimerInterrupt ();
167 }
168
169 /**
170 Save the volatile registers required to be restored following INIT IPI.
171
172 @param[out] VolatileRegisters Returns buffer saved the volatile resisters
173 **/
174 VOID
175 SaveVolatileRegisters (
176 OUT CPU_VOLATILE_REGISTERS *VolatileRegisters
177 )
178 {
179 CPUID_VERSION_INFO_EDX VersionInfoEdx;
180
181 VolatileRegisters->Cr0 = AsmReadCr0 ();
182 VolatileRegisters->Cr3 = AsmReadCr3 ();
183 VolatileRegisters->Cr4 = AsmReadCr4 ();
184
185 AsmCpuid (CPUID_VERSION_INFO, NULL, NULL, NULL, &VersionInfoEdx.Uint32);
186 if (VersionInfoEdx.Bits.DE != 0) {
187 //
188 // If processor supports Debugging Extensions feature
189 // by CPUID.[EAX=01H]:EDX.BIT2
190 //
191 VolatileRegisters->Dr0 = AsmReadDr0 ();
192 VolatileRegisters->Dr1 = AsmReadDr1 ();
193 VolatileRegisters->Dr2 = AsmReadDr2 ();
194 VolatileRegisters->Dr3 = AsmReadDr3 ();
195 VolatileRegisters->Dr6 = AsmReadDr6 ();
196 VolatileRegisters->Dr7 = AsmReadDr7 ();
197 }
198 }
199
200 /**
201 Restore the volatile registers following INIT IPI.
202
203 @param[in] VolatileRegisters Pointer to volatile resisters
204 @param[in] IsRestoreDr TRUE: Restore DRx if supported
205 FALSE: Do not restore DRx
206 **/
207 VOID
208 RestoreVolatileRegisters (
209 IN CPU_VOLATILE_REGISTERS *VolatileRegisters,
210 IN BOOLEAN IsRestoreDr
211 )
212 {
213 CPUID_VERSION_INFO_EDX VersionInfoEdx;
214
215 AsmWriteCr0 (VolatileRegisters->Cr0);
216 AsmWriteCr3 (VolatileRegisters->Cr3);
217 AsmWriteCr4 (VolatileRegisters->Cr4);
218
219 if (IsRestoreDr) {
220 AsmCpuid (CPUID_VERSION_INFO, NULL, NULL, NULL, &VersionInfoEdx.Uint32);
221 if (VersionInfoEdx.Bits.DE != 0) {
222 //
223 // If processor supports Debugging Extensions feature
224 // by CPUID.[EAX=01H]:EDX.BIT2
225 //
226 AsmWriteDr0 (VolatileRegisters->Dr0);
227 AsmWriteDr1 (VolatileRegisters->Dr1);
228 AsmWriteDr2 (VolatileRegisters->Dr2);
229 AsmWriteDr3 (VolatileRegisters->Dr3);
230 AsmWriteDr6 (VolatileRegisters->Dr6);
231 AsmWriteDr7 (VolatileRegisters->Dr7);
232 }
233 }
234 }
235
236 /**
237 Detect whether Mwait-monitor feature is supported.
238
239 @retval TRUE Mwait-monitor feature is supported.
240 @retval FALSE Mwait-monitor feature is not supported.
241 **/
242 BOOLEAN
243 IsMwaitSupport (
244 VOID
245 )
246 {
247 CPUID_VERSION_INFO_ECX VersionInfoEcx;
248
249 AsmCpuid (CPUID_VERSION_INFO, NULL, NULL, &VersionInfoEcx.Uint32, NULL);
250 return (VersionInfoEcx.Bits.MONITOR == 1) ? TRUE : FALSE;
251 }
252
253 /**
254 Get AP loop mode.
255
256 @param[out] MonitorFilterSize Returns the largest monitor-line size in bytes.
257
258 @return The AP loop mode.
259 **/
260 UINT8
261 GetApLoopMode (
262 OUT UINT32 *MonitorFilterSize
263 )
264 {
265 UINT8 ApLoopMode;
266 CPUID_MONITOR_MWAIT_EBX MonitorMwaitEbx;
267
268 ASSERT (MonitorFilterSize != NULL);
269
270 ApLoopMode = PcdGet8 (PcdCpuApLoopMode);
271 ASSERT (ApLoopMode >= ApInHltLoop && ApLoopMode <= ApInRunLoop);
272 if (ApLoopMode == ApInMwaitLoop) {
273 if (!IsMwaitSupport ()) {
274 //
275 // If processor does not support MONITOR/MWAIT feature,
276 // force AP in Hlt-loop mode
277 //
278 ApLoopMode = ApInHltLoop;
279 }
280 }
281
282 if (ApLoopMode != ApInMwaitLoop) {
283 *MonitorFilterSize = sizeof (UINT32);
284 } else {
285 //
286 // CPUID.[EAX=05H]:EBX.BIT0-15: Largest monitor-line size in bytes
287 // CPUID.[EAX=05H].EDX: C-states supported using MWAIT
288 //
289 AsmCpuid (CPUID_MONITOR_MWAIT, NULL, &MonitorMwaitEbx.Uint32, NULL, NULL);
290 *MonitorFilterSize = MonitorMwaitEbx.Bits.LargestMonitorLineSize;
291 }
292
293 return ApLoopMode;
294 }
295
296 /**
297 Sort the APIC ID of all processors.
298
299 This function sorts the APIC ID of all processors so that processor number is
300 assigned in the ascending order of APIC ID which eases MP debugging.
301
302 @param[in] CpuMpData Pointer to PEI CPU MP Data
303 **/
304 VOID
305 SortApicId (
306 IN CPU_MP_DATA *CpuMpData
307 )
308 {
309 UINTN Index1;
310 UINTN Index2;
311 UINTN Index3;
312 UINT32 ApicId;
313 CPU_INFO_IN_HOB CpuInfo;
314 UINT32 ApCount;
315 CPU_INFO_IN_HOB *CpuInfoInHob;
316
317 ApCount = CpuMpData->CpuCount - 1;
318 CpuInfoInHob = (CPU_INFO_IN_HOB *) (UINTN) CpuMpData->CpuInfoInHob;
319 if (ApCount != 0) {
320 for (Index1 = 0; Index1 < ApCount; Index1++) {
321 Index3 = Index1;
322 //
323 // Sort key is the hardware default APIC ID
324 //
325 ApicId = CpuInfoInHob[Index1].ApicId;
326 for (Index2 = Index1 + 1; Index2 <= ApCount; Index2++) {
327 if (ApicId > CpuInfoInHob[Index2].ApicId) {
328 Index3 = Index2;
329 ApicId = CpuInfoInHob[Index2].ApicId;
330 }
331 }
332 if (Index3 != Index1) {
333 CopyMem (&CpuInfo, &CpuInfoInHob[Index3], sizeof (CPU_INFO_IN_HOB));
334 CopyMem (
335 &CpuInfoInHob[Index3],
336 &CpuInfoInHob[Index1],
337 sizeof (CPU_INFO_IN_HOB)
338 );
339 CopyMem (&CpuInfoInHob[Index1], &CpuInfo, sizeof (CPU_INFO_IN_HOB));
340 }
341 }
342
343 //
344 // Get the processor number for the BSP
345 //
346 ApicId = GetInitialApicId ();
347 for (Index1 = 0; Index1 < CpuMpData->CpuCount; Index1++) {
348 if (CpuInfoInHob[Index1].ApicId == ApicId) {
349 CpuMpData->BspNumber = (UINT32) Index1;
350 break;
351 }
352 }
353 }
354 }
355
356 /**
357 Enable x2APIC mode on APs.
358
359 @param[in, out] Buffer Pointer to private data buffer.
360 **/
361 VOID
362 EFIAPI
363 ApFuncEnableX2Apic (
364 IN OUT VOID *Buffer
365 )
366 {
367 SetApicMode (LOCAL_APIC_MODE_X2APIC);
368 }
369
370 /**
371 Do sync on APs.
372
373 @param[in, out] Buffer Pointer to private data buffer.
374 **/
375 VOID
376 EFIAPI
377 ApInitializeSync (
378 IN OUT VOID *Buffer
379 )
380 {
381 CPU_MP_DATA *CpuMpData;
382
383 CpuMpData = (CPU_MP_DATA *) Buffer;
384 //
385 // Load microcode on AP
386 //
387 MicrocodeDetect (CpuMpData);
388 //
389 // Sync BSP's MTRR table to AP
390 //
391 MtrrSetAllMtrrs (&CpuMpData->MtrrTable);
392 }
393
394 /**
395 Find the current Processor number by APIC ID.
396
397 @param[in] CpuMpData Pointer to PEI CPU MP Data
398 @param[out] ProcessorNumber Return the pocessor number found
399
400 @retval EFI_SUCCESS ProcessorNumber is found and returned.
401 @retval EFI_NOT_FOUND ProcessorNumber is not found.
402 **/
403 EFI_STATUS
404 GetProcessorNumber (
405 IN CPU_MP_DATA *CpuMpData,
406 OUT UINTN *ProcessorNumber
407 )
408 {
409 UINTN TotalProcessorNumber;
410 UINTN Index;
411 CPU_INFO_IN_HOB *CpuInfoInHob;
412
413 CpuInfoInHob = (CPU_INFO_IN_HOB *) (UINTN) CpuMpData->CpuInfoInHob;
414
415 TotalProcessorNumber = CpuMpData->CpuCount;
416 for (Index = 0; Index < TotalProcessorNumber; Index ++) {
417 if (CpuInfoInHob[Index].ApicId == GetApicId ()) {
418 *ProcessorNumber = Index;
419 return EFI_SUCCESS;
420 }
421 }
422 return EFI_NOT_FOUND;
423 }
424
425 /**
426 This function will get CPU count in the system.
427
428 @param[in] CpuMpData Pointer to PEI CPU MP Data
429
430 @return CPU count detected
431 **/
432 UINTN
433 CollectProcessorCount (
434 IN CPU_MP_DATA *CpuMpData
435 )
436 {
437 UINTN Index;
438
439 //
440 // Send 1st broadcast IPI to APs to wakeup APs
441 //
442 CpuMpData->InitFlag = ApInitConfig;
443 CpuMpData->X2ApicEnable = FALSE;
444 WakeUpAP (CpuMpData, TRUE, 0, NULL, NULL);
445 CpuMpData->InitFlag = ApInitDone;
446 ASSERT (CpuMpData->CpuCount <= PcdGet32 (PcdCpuMaxLogicalProcessorNumber));
447 //
448 // Wait for all APs finished the initialization
449 //
450 while (CpuMpData->FinishedCount < (CpuMpData->CpuCount - 1)) {
451 CpuPause ();
452 }
453
454 if (CpuMpData->CpuCount > 255) {
455 //
456 // If there are more than 255 processor found, force to enable X2APIC
457 //
458 CpuMpData->X2ApicEnable = TRUE;
459 }
460 if (CpuMpData->X2ApicEnable) {
461 DEBUG ((DEBUG_INFO, "Force x2APIC mode!\n"));
462 //
463 // Wakeup all APs to enable x2APIC mode
464 //
465 WakeUpAP (CpuMpData, TRUE, 0, ApFuncEnableX2Apic, NULL);
466 //
467 // Wait for all known APs finished
468 //
469 while (CpuMpData->FinishedCount < (CpuMpData->CpuCount - 1)) {
470 CpuPause ();
471 }
472 //
473 // Enable x2APIC on BSP
474 //
475 SetApicMode (LOCAL_APIC_MODE_X2APIC);
476 //
477 // Set BSP/Aps state to IDLE
478 //
479 for (Index = 0; Index < CpuMpData->CpuCount; Index++) {
480 SetApState (&CpuMpData->CpuData[Index], CpuStateIdle);
481 }
482 }
483 DEBUG ((DEBUG_INFO, "APIC MODE is %d\n", GetApicMode ()));
484 //
485 // Sort BSP/Aps by CPU APIC ID in ascending order
486 //
487 SortApicId (CpuMpData);
488
489 DEBUG ((DEBUG_INFO, "MpInitLib: Find %d processors in system.\n", CpuMpData->CpuCount));
490
491 return CpuMpData->CpuCount;
492 }
493
494 /**
495 Initialize CPU AP Data when AP is wakeup at the first time.
496
497 @param[in, out] CpuMpData Pointer to PEI CPU MP Data
498 @param[in] ProcessorNumber The handle number of processor
499 @param[in] BistData Processor BIST data
500 @param[in] ApTopOfStack Top of AP stack
501
502 **/
503 VOID
504 InitializeApData (
505 IN OUT CPU_MP_DATA *CpuMpData,
506 IN UINTN ProcessorNumber,
507 IN UINT32 BistData,
508 IN UINT64 ApTopOfStack
509 )
510 {
511 CPU_INFO_IN_HOB *CpuInfoInHob;
512
513 CpuInfoInHob = (CPU_INFO_IN_HOB *) (UINTN) CpuMpData->CpuInfoInHob;
514 CpuInfoInHob[ProcessorNumber].InitialApicId = GetInitialApicId ();
515 CpuInfoInHob[ProcessorNumber].ApicId = GetApicId ();
516 CpuInfoInHob[ProcessorNumber].Health = BistData;
517 CpuInfoInHob[ProcessorNumber].ApTopOfStack = ApTopOfStack;
518
519 CpuMpData->CpuData[ProcessorNumber].Waiting = FALSE;
520 CpuMpData->CpuData[ProcessorNumber].CpuHealthy = (BistData == 0) ? TRUE : FALSE;
521 if (CpuInfoInHob[ProcessorNumber].InitialApicId >= 0xFF) {
522 //
523 // Set x2APIC mode if there are any logical processor reporting
524 // an Initial APIC ID of 255 or greater.
525 //
526 AcquireSpinLock(&CpuMpData->MpLock);
527 CpuMpData->X2ApicEnable = TRUE;
528 ReleaseSpinLock(&CpuMpData->MpLock);
529 }
530
531 InitializeSpinLock(&CpuMpData->CpuData[ProcessorNumber].ApLock);
532 SetApState (&CpuMpData->CpuData[ProcessorNumber], CpuStateIdle);
533 }
534
535 /**
536 This function will be called from AP reset code if BSP uses WakeUpAP.
537
538 @param[in] ExchangeInfo Pointer to the MP exchange info buffer
539 @param[in] ApIndex Number of current executing AP
540 **/
541 VOID
542 EFIAPI
543 ApWakeupFunction (
544 IN MP_CPU_EXCHANGE_INFO *ExchangeInfo,
545 IN UINTN ApIndex
546 )
547 {
548 CPU_MP_DATA *CpuMpData;
549 UINTN ProcessorNumber;
550 EFI_AP_PROCEDURE Procedure;
551 VOID *Parameter;
552 UINT32 BistData;
553 volatile UINT32 *ApStartupSignalBuffer;
554 CPU_INFO_IN_HOB *CpuInfoInHob;
555 UINT64 ApTopOfStack;
556 UINTN CurrentApicMode;
557
558 //
559 // AP finished assembly code and begin to execute C code
560 //
561 CpuMpData = ExchangeInfo->CpuMpData;
562
563 //
564 // AP's local APIC settings will be lost after received INIT IPI
565 // We need to re-initialize them at here
566 //
567 ProgramVirtualWireMode ();
568 SyncLocalApicTimerSetting (CpuMpData);
569
570 CurrentApicMode = GetApicMode ();
571 while (TRUE) {
572 if (CpuMpData->InitFlag == ApInitConfig) {
573 //
574 // Add CPU number
575 //
576 InterlockedIncrement ((UINT32 *) &CpuMpData->CpuCount);
577 ProcessorNumber = ApIndex;
578 //
579 // This is first time AP wakeup, get BIST information from AP stack
580 //
581 ApTopOfStack = CpuMpData->Buffer + (ProcessorNumber + 1) * CpuMpData->CpuApStackSize;
582 BistData = *(UINT32 *) ((UINTN) ApTopOfStack - sizeof (UINTN));
583 //
584 // Do some AP initialize sync
585 //
586 ApInitializeSync (CpuMpData);
587 //
588 // Sync BSP's Control registers to APs
589 //
590 RestoreVolatileRegisters (&CpuMpData->CpuData[0].VolatileRegisters, FALSE);
591 InitializeApData (CpuMpData, ProcessorNumber, BistData, ApTopOfStack);
592 ApStartupSignalBuffer = CpuMpData->CpuData[ProcessorNumber].StartupApSignal;
593 } else {
594 //
595 // Execute AP function if AP is ready
596 //
597 GetProcessorNumber (CpuMpData, &ProcessorNumber);
598 //
599 // Clear AP start-up signal when AP waken up
600 //
601 ApStartupSignalBuffer = CpuMpData->CpuData[ProcessorNumber].StartupApSignal;
602 InterlockedCompareExchange32 (
603 (UINT32 *) ApStartupSignalBuffer,
604 WAKEUP_AP_SIGNAL,
605 0
606 );
607 if (CpuMpData->ApLoopMode == ApInHltLoop) {
608 //
609 // Restore AP's volatile registers saved
610 //
611 RestoreVolatileRegisters (&CpuMpData->CpuData[ProcessorNumber].VolatileRegisters, TRUE);
612 }
613
614 if (GetApState (&CpuMpData->CpuData[ProcessorNumber]) == CpuStateReady) {
615 Procedure = (EFI_AP_PROCEDURE)CpuMpData->CpuData[ProcessorNumber].ApFunction;
616 Parameter = (VOID *) CpuMpData->CpuData[ProcessorNumber].ApFunctionArgument;
617 if (Procedure != NULL) {
618 SetApState (&CpuMpData->CpuData[ProcessorNumber], CpuStateBusy);
619 //
620 // Enable source debugging on AP function
621 //
622 EnableDebugAgent ();
623 //
624 // Invoke AP function here
625 //
626 Procedure (Parameter);
627 CpuInfoInHob = (CPU_INFO_IN_HOB *) (UINTN) CpuMpData->CpuInfoInHob;
628 if (CpuMpData->SwitchBspFlag) {
629 //
630 // Re-get the processor number due to BSP/AP maybe exchange in AP function
631 //
632 GetProcessorNumber (CpuMpData, &ProcessorNumber);
633 CpuMpData->CpuData[ProcessorNumber].ApFunction = 0;
634 CpuMpData->CpuData[ProcessorNumber].ApFunctionArgument = 0;
635 ApStartupSignalBuffer = CpuMpData->CpuData[ProcessorNumber].StartupApSignal;
636 CpuInfoInHob[ProcessorNumber].ApTopOfStack = CpuInfoInHob[CpuMpData->NewBspNumber].ApTopOfStack;
637 } else {
638 if (CpuInfoInHob[ProcessorNumber].ApicId != GetApicId () ||
639 CpuInfoInHob[ProcessorNumber].InitialApicId != GetInitialApicId ()) {
640 if (CurrentApicMode != GetApicMode ()) {
641 //
642 // If APIC mode change happened during AP function execution,
643 // we do not support APIC ID value changed.
644 //
645 ASSERT (FALSE);
646 CpuDeadLoop ();
647 } else {
648 //
649 // Re-get the CPU APICID and Initial APICID if they are changed
650 //
651 CpuInfoInHob[ProcessorNumber].ApicId = GetApicId ();
652 CpuInfoInHob[ProcessorNumber].InitialApicId = GetInitialApicId ();
653 }
654 }
655 }
656 }
657 SetApState (&CpuMpData->CpuData[ProcessorNumber], CpuStateFinished);
658 }
659 }
660
661 //
662 // AP finished executing C code
663 //
664 InterlockedIncrement ((UINT32 *) &CpuMpData->FinishedCount);
665 InterlockedDecrement ((UINT32 *) &CpuMpData->MpCpuExchangeInfo->NumApsExecuting);
666
667 //
668 // Place AP is specified loop mode
669 //
670 if (CpuMpData->ApLoopMode == ApInHltLoop) {
671 //
672 // Save AP volatile registers
673 //
674 SaveVolatileRegisters (&CpuMpData->CpuData[ProcessorNumber].VolatileRegisters);
675 //
676 // Place AP in HLT-loop
677 //
678 while (TRUE) {
679 DisableInterrupts ();
680 CpuSleep ();
681 CpuPause ();
682 }
683 }
684 while (TRUE) {
685 DisableInterrupts ();
686 if (CpuMpData->ApLoopMode == ApInMwaitLoop) {
687 //
688 // Place AP in MWAIT-loop
689 //
690 AsmMonitor ((UINTN) ApStartupSignalBuffer, 0, 0);
691 if (*ApStartupSignalBuffer != WAKEUP_AP_SIGNAL) {
692 //
693 // Check AP start-up signal again.
694 // If AP start-up signal is not set, place AP into
695 // the specified C-state
696 //
697 AsmMwait (CpuMpData->ApTargetCState << 4, 0);
698 }
699 } else if (CpuMpData->ApLoopMode == ApInRunLoop) {
700 //
701 // Place AP in Run-loop
702 //
703 CpuPause ();
704 } else {
705 ASSERT (FALSE);
706 }
707
708 //
709 // If AP start-up signal is written, AP is waken up
710 // otherwise place AP in loop again
711 //
712 if (*ApStartupSignalBuffer == WAKEUP_AP_SIGNAL) {
713 break;
714 }
715 }
716 }
717 }
718
719 /**
720 Wait for AP wakeup and write AP start-up signal till AP is waken up.
721
722 @param[in] ApStartupSignalBuffer Pointer to AP wakeup signal
723 **/
724 VOID
725 WaitApWakeup (
726 IN volatile UINT32 *ApStartupSignalBuffer
727 )
728 {
729 //
730 // If AP is waken up, StartupApSignal should be cleared.
731 // Otherwise, write StartupApSignal again till AP waken up.
732 //
733 while (InterlockedCompareExchange32 (
734 (UINT32 *) ApStartupSignalBuffer,
735 WAKEUP_AP_SIGNAL,
736 WAKEUP_AP_SIGNAL
737 ) != 0) {
738 CpuPause ();
739 }
740 }
741
742 /**
743 This function will fill the exchange info structure.
744
745 @param[in] CpuMpData Pointer to CPU MP Data
746
747 **/
748 VOID
749 FillExchangeInfoData (
750 IN CPU_MP_DATA *CpuMpData
751 )
752 {
753 volatile MP_CPU_EXCHANGE_INFO *ExchangeInfo;
754
755 ExchangeInfo = CpuMpData->MpCpuExchangeInfo;
756 ExchangeInfo->Lock = 0;
757 ExchangeInfo->StackStart = CpuMpData->Buffer;
758 ExchangeInfo->StackSize = CpuMpData->CpuApStackSize;
759 ExchangeInfo->BufferStart = CpuMpData->WakeupBuffer;
760 ExchangeInfo->ModeOffset = CpuMpData->AddressMap.ModeEntryOffset;
761
762 ExchangeInfo->CodeSegment = AsmReadCs ();
763 ExchangeInfo->DataSegment = AsmReadDs ();
764
765 ExchangeInfo->Cr3 = AsmReadCr3 ();
766
767 ExchangeInfo->CFunction = (UINTN) ApWakeupFunction;
768 ExchangeInfo->ApIndex = 0;
769 ExchangeInfo->NumApsExecuting = 0;
770 ExchangeInfo->InitFlag = (UINTN) CpuMpData->InitFlag;
771 ExchangeInfo->CpuInfo = (CPU_INFO_IN_HOB *) (UINTN) CpuMpData->CpuInfoInHob;
772 ExchangeInfo->CpuMpData = CpuMpData;
773
774 ExchangeInfo->EnableExecuteDisable = IsBspExecuteDisableEnabled ();
775
776 ExchangeInfo->InitializeFloatingPointUnitsAddress = (UINTN)InitializeFloatingPointUnits;
777
778 //
779 // Get the BSP's data of GDT and IDT
780 //
781 AsmReadGdtr ((IA32_DESCRIPTOR *) &ExchangeInfo->GdtrProfile);
782 AsmReadIdtr ((IA32_DESCRIPTOR *) &ExchangeInfo->IdtrProfile);
783 }
784
785 /**
786 Helper function that waits until the finished AP count reaches the specified
787 limit, or the specified timeout elapses (whichever comes first).
788
789 @param[in] CpuMpData Pointer to CPU MP Data.
790 @param[in] FinishedApLimit The number of finished APs to wait for.
791 @param[in] TimeLimit The number of microseconds to wait for.
792 **/
793 VOID
794 TimedWaitForApFinish (
795 IN CPU_MP_DATA *CpuMpData,
796 IN UINT32 FinishedApLimit,
797 IN UINT32 TimeLimit
798 );
799
800 /**
801 Get available system memory below 1MB by specified size.
802
803 @param[in] CpuMpData The pointer to CPU MP Data structure.
804 **/
805 VOID
806 BackupAndPrepareWakeupBuffer(
807 IN CPU_MP_DATA *CpuMpData
808 )
809 {
810 CopyMem (
811 (VOID *) CpuMpData->BackupBuffer,
812 (VOID *) CpuMpData->WakeupBuffer,
813 CpuMpData->BackupBufferSize
814 );
815 CopyMem (
816 (VOID *) CpuMpData->WakeupBuffer,
817 (VOID *) CpuMpData->AddressMap.RendezvousFunnelAddress,
818 CpuMpData->AddressMap.RendezvousFunnelSize
819 );
820 }
821
822 /**
823 Restore wakeup buffer data.
824
825 @param[in] CpuMpData The pointer to CPU MP Data structure.
826 **/
827 VOID
828 RestoreWakeupBuffer(
829 IN CPU_MP_DATA *CpuMpData
830 )
831 {
832 CopyMem (
833 (VOID *) CpuMpData->WakeupBuffer,
834 (VOID *) CpuMpData->BackupBuffer,
835 CpuMpData->BackupBufferSize
836 );
837 }
838
839 /**
840 Allocate reset vector buffer.
841
842 @param[in, out] CpuMpData The pointer to CPU MP Data structure.
843 **/
844 VOID
845 AllocateResetVector (
846 IN OUT CPU_MP_DATA *CpuMpData
847 )
848 {
849 UINTN ApResetVectorSize;
850
851 if (CpuMpData->WakeupBuffer == (UINTN) -1) {
852 ApResetVectorSize = CpuMpData->AddressMap.RendezvousFunnelSize +
853 sizeof (MP_CPU_EXCHANGE_INFO);
854
855 CpuMpData->WakeupBuffer = GetWakeupBuffer (ApResetVectorSize);
856 CpuMpData->MpCpuExchangeInfo = (MP_CPU_EXCHANGE_INFO *) (UINTN)
857 (CpuMpData->WakeupBuffer + CpuMpData->AddressMap.RendezvousFunnelSize);
858 }
859 BackupAndPrepareWakeupBuffer (CpuMpData);
860 }
861
862 /**
863 Free AP reset vector buffer.
864
865 @param[in] CpuMpData The pointer to CPU MP Data structure.
866 **/
867 VOID
868 FreeResetVector (
869 IN CPU_MP_DATA *CpuMpData
870 )
871 {
872 RestoreWakeupBuffer (CpuMpData);
873 }
874
875 /**
876 This function will be called by BSP to wakeup AP.
877
878 @param[in] CpuMpData Pointer to CPU MP Data
879 @param[in] Broadcast TRUE: Send broadcast IPI to all APs
880 FALSE: Send IPI to AP by ApicId
881 @param[in] ProcessorNumber The handle number of specified processor
882 @param[in] Procedure The function to be invoked by AP
883 @param[in] ProcedureArgument The argument to be passed into AP function
884 **/
885 VOID
886 WakeUpAP (
887 IN CPU_MP_DATA *CpuMpData,
888 IN BOOLEAN Broadcast,
889 IN UINTN ProcessorNumber,
890 IN EFI_AP_PROCEDURE Procedure, OPTIONAL
891 IN VOID *ProcedureArgument OPTIONAL
892 )
893 {
894 volatile MP_CPU_EXCHANGE_INFO *ExchangeInfo;
895 UINTN Index;
896 CPU_AP_DATA *CpuData;
897 BOOLEAN ResetVectorRequired;
898 CPU_INFO_IN_HOB *CpuInfoInHob;
899
900 CpuMpData->FinishedCount = 0;
901 ResetVectorRequired = FALSE;
902
903 if (CpuMpData->ApLoopMode == ApInHltLoop ||
904 CpuMpData->InitFlag != ApInitDone) {
905 ResetVectorRequired = TRUE;
906 AllocateResetVector (CpuMpData);
907 FillExchangeInfoData (CpuMpData);
908 SaveLocalApicTimerSetting (CpuMpData);
909 } else if (CpuMpData->ApLoopMode == ApInMwaitLoop) {
910 //
911 // Get AP target C-state each time when waking up AP,
912 // for it maybe updated by platform again
913 //
914 CpuMpData->ApTargetCState = PcdGet8 (PcdCpuApTargetCstate);
915 }
916
917 ExchangeInfo = CpuMpData->MpCpuExchangeInfo;
918
919 if (Broadcast) {
920 for (Index = 0; Index < CpuMpData->CpuCount; Index++) {
921 if (Index != CpuMpData->BspNumber) {
922 CpuData = &CpuMpData->CpuData[Index];
923 CpuData->ApFunction = (UINTN) Procedure;
924 CpuData->ApFunctionArgument = (UINTN) ProcedureArgument;
925 SetApState (CpuData, CpuStateReady);
926 if (CpuMpData->InitFlag != ApInitConfig) {
927 *(UINT32 *) CpuData->StartupApSignal = WAKEUP_AP_SIGNAL;
928 }
929 }
930 }
931 if (ResetVectorRequired) {
932 //
933 // Wakeup all APs
934 //
935 SendInitSipiSipiAllExcludingSelf ((UINT32) ExchangeInfo->BufferStart);
936 }
937 if (CpuMpData->InitFlag == ApInitConfig) {
938 //
939 // Here support two methods to collect AP count through adjust
940 // PcdCpuApInitTimeOutInMicroSeconds values.
941 //
942 // one way is set a value to just let the first AP to start the
943 // initialization, then through the later while loop to wait all Aps
944 // finsh the initialization.
945 // The other way is set a value to let all APs finished the initialzation.
946 // In this case, the later while loop is useless.
947 //
948 TimedWaitForApFinish (
949 CpuMpData,
950 PcdGet32 (PcdCpuMaxLogicalProcessorNumber) - 1,
951 PcdGet32 (PcdCpuApInitTimeOutInMicroSeconds)
952 );
953
954 while (CpuMpData->MpCpuExchangeInfo->NumApsExecuting != 0) {
955 CpuPause();
956 }
957 } else {
958 //
959 // Wait all APs waken up if this is not the 1st broadcast of SIPI
960 //
961 for (Index = 0; Index < CpuMpData->CpuCount; Index++) {
962 CpuData = &CpuMpData->CpuData[Index];
963 if (Index != CpuMpData->BspNumber) {
964 WaitApWakeup (CpuData->StartupApSignal);
965 }
966 }
967 }
968 } else {
969 CpuData = &CpuMpData->CpuData[ProcessorNumber];
970 CpuData->ApFunction = (UINTN) Procedure;
971 CpuData->ApFunctionArgument = (UINTN) ProcedureArgument;
972 SetApState (CpuData, CpuStateReady);
973 //
974 // Wakeup specified AP
975 //
976 ASSERT (CpuMpData->InitFlag != ApInitConfig);
977 *(UINT32 *) CpuData->StartupApSignal = WAKEUP_AP_SIGNAL;
978 if (ResetVectorRequired) {
979 CpuInfoInHob = (CPU_INFO_IN_HOB *) (UINTN) CpuMpData->CpuInfoInHob;
980 SendInitSipiSipi (
981 CpuInfoInHob[ProcessorNumber].ApicId,
982 (UINT32) ExchangeInfo->BufferStart
983 );
984 }
985 //
986 // Wait specified AP waken up
987 //
988 WaitApWakeup (CpuData->StartupApSignal);
989 }
990
991 if (ResetVectorRequired) {
992 FreeResetVector (CpuMpData);
993 }
994 }
995
996 /**
997 Calculate timeout value and return the current performance counter value.
998
999 Calculate the number of performance counter ticks required for a timeout.
1000 If TimeoutInMicroseconds is 0, return value is also 0, which is recognized
1001 as infinity.
1002
1003 @param[in] TimeoutInMicroseconds Timeout value in microseconds.
1004 @param[out] CurrentTime Returns the current value of the performance counter.
1005
1006 @return Expected time stamp counter for timeout.
1007 If TimeoutInMicroseconds is 0, return value is also 0, which is recognized
1008 as infinity.
1009
1010 **/
1011 UINT64
1012 CalculateTimeout (
1013 IN UINTN TimeoutInMicroseconds,
1014 OUT UINT64 *CurrentTime
1015 )
1016 {
1017 UINT64 TimeoutInSeconds;
1018 UINT64 TimestampCounterFreq;
1019
1020 //
1021 // Read the current value of the performance counter
1022 //
1023 *CurrentTime = GetPerformanceCounter ();
1024
1025 //
1026 // If TimeoutInMicroseconds is 0, return value is also 0, which is recognized
1027 // as infinity.
1028 //
1029 if (TimeoutInMicroseconds == 0) {
1030 return 0;
1031 }
1032
1033 //
1034 // GetPerformanceCounterProperties () returns the timestamp counter's frequency
1035 // in Hz.
1036 //
1037 TimestampCounterFreq = GetPerformanceCounterProperties (NULL, NULL);
1038
1039 //
1040 // Check the potential overflow before calculate the number of ticks for the timeout value.
1041 //
1042 if (DivU64x64Remainder (MAX_UINT64, TimeoutInMicroseconds, NULL) < TimestampCounterFreq) {
1043 //
1044 // Convert microseconds into seconds if direct multiplication overflows
1045 //
1046 TimeoutInSeconds = DivU64x32 (TimeoutInMicroseconds, 1000000);
1047 //
1048 // Assertion if the final tick count exceeds MAX_UINT64
1049 //
1050 ASSERT (DivU64x64Remainder (MAX_UINT64, TimeoutInSeconds, NULL) >= TimestampCounterFreq);
1051 return MultU64x64 (TimestampCounterFreq, TimeoutInSeconds);
1052 } else {
1053 //
1054 // No overflow case, multiply the return value with TimeoutInMicroseconds and then divide
1055 // it by 1,000,000, to get the number of ticks for the timeout value.
1056 //
1057 return DivU64x32 (
1058 MultU64x64 (
1059 TimestampCounterFreq,
1060 TimeoutInMicroseconds
1061 ),
1062 1000000
1063 );
1064 }
1065 }
1066
1067 /**
1068 Checks whether timeout expires.
1069
1070 Check whether the number of elapsed performance counter ticks required for
1071 a timeout condition has been reached.
1072 If Timeout is zero, which means infinity, return value is always FALSE.
1073
1074 @param[in, out] PreviousTime On input, the value of the performance counter
1075 when it was last read.
1076 On output, the current value of the performance
1077 counter
1078 @param[in] TotalTime The total amount of elapsed time in performance
1079 counter ticks.
1080 @param[in] Timeout The number of performance counter ticks required
1081 to reach a timeout condition.
1082
1083 @retval TRUE A timeout condition has been reached.
1084 @retval FALSE A timeout condition has not been reached.
1085
1086 **/
1087 BOOLEAN
1088 CheckTimeout (
1089 IN OUT UINT64 *PreviousTime,
1090 IN UINT64 *TotalTime,
1091 IN UINT64 Timeout
1092 )
1093 {
1094 UINT64 Start;
1095 UINT64 End;
1096 UINT64 CurrentTime;
1097 INT64 Delta;
1098 INT64 Cycle;
1099
1100 if (Timeout == 0) {
1101 return FALSE;
1102 }
1103 GetPerformanceCounterProperties (&Start, &End);
1104 Cycle = End - Start;
1105 if (Cycle < 0) {
1106 Cycle = -Cycle;
1107 }
1108 Cycle++;
1109 CurrentTime = GetPerformanceCounter();
1110 Delta = (INT64) (CurrentTime - *PreviousTime);
1111 if (Start > End) {
1112 Delta = -Delta;
1113 }
1114 if (Delta < 0) {
1115 Delta += Cycle;
1116 }
1117 *TotalTime += Delta;
1118 *PreviousTime = CurrentTime;
1119 if (*TotalTime > Timeout) {
1120 return TRUE;
1121 }
1122 return FALSE;
1123 }
1124
1125 /**
1126 Helper function that waits until the finished AP count reaches the specified
1127 limit, or the specified timeout elapses (whichever comes first).
1128
1129 @param[in] CpuMpData Pointer to CPU MP Data.
1130 @param[in] FinishedApLimit The number of finished APs to wait for.
1131 @param[in] TimeLimit The number of microseconds to wait for.
1132 **/
1133 VOID
1134 TimedWaitForApFinish (
1135 IN CPU_MP_DATA *CpuMpData,
1136 IN UINT32 FinishedApLimit,
1137 IN UINT32 TimeLimit
1138 )
1139 {
1140 //
1141 // CalculateTimeout() and CheckTimeout() consider a TimeLimit of 0
1142 // "infinity", so check for (TimeLimit == 0) explicitly.
1143 //
1144 if (TimeLimit == 0) {
1145 return;
1146 }
1147
1148 CpuMpData->TotalTime = 0;
1149 CpuMpData->ExpectedTime = CalculateTimeout (
1150 TimeLimit,
1151 &CpuMpData->CurrentTime
1152 );
1153 while (CpuMpData->FinishedCount < FinishedApLimit &&
1154 !CheckTimeout (
1155 &CpuMpData->CurrentTime,
1156 &CpuMpData->TotalTime,
1157 CpuMpData->ExpectedTime
1158 )) {
1159 CpuPause ();
1160 }
1161
1162 if (CpuMpData->FinishedCount >= FinishedApLimit) {
1163 DEBUG ((
1164 DEBUG_VERBOSE,
1165 "%a: reached FinishedApLimit=%u in %Lu microseconds\n",
1166 __FUNCTION__,
1167 FinishedApLimit,
1168 DivU64x64Remainder (
1169 MultU64x32 (CpuMpData->TotalTime, 1000000),
1170 GetPerformanceCounterProperties (NULL, NULL),
1171 NULL
1172 )
1173 ));
1174 }
1175 }
1176
1177 /**
1178 Reset an AP to Idle state.
1179
1180 Any task being executed by the AP will be aborted and the AP
1181 will be waiting for a new task in Wait-For-SIPI state.
1182
1183 @param[in] ProcessorNumber The handle number of processor.
1184 **/
1185 VOID
1186 ResetProcessorToIdleState (
1187 IN UINTN ProcessorNumber
1188 )
1189 {
1190 CPU_MP_DATA *CpuMpData;
1191
1192 CpuMpData = GetCpuMpData ();
1193
1194 CpuMpData->InitFlag = ApInitReconfig;
1195 WakeUpAP (CpuMpData, FALSE, ProcessorNumber, NULL, NULL);
1196 while (CpuMpData->FinishedCount < 1) {
1197 CpuPause ();
1198 }
1199 CpuMpData->InitFlag = ApInitDone;
1200
1201 SetApState (&CpuMpData->CpuData[ProcessorNumber], CpuStateIdle);
1202 }
1203
1204 /**
1205 Searches for the next waiting AP.
1206
1207 Search for the next AP that is put in waiting state by single-threaded StartupAllAPs().
1208
1209 @param[out] NextProcessorNumber Pointer to the processor number of the next waiting AP.
1210
1211 @retval EFI_SUCCESS The next waiting AP has been found.
1212 @retval EFI_NOT_FOUND No waiting AP exists.
1213
1214 **/
1215 EFI_STATUS
1216 GetNextWaitingProcessorNumber (
1217 OUT UINTN *NextProcessorNumber
1218 )
1219 {
1220 UINTN ProcessorNumber;
1221 CPU_MP_DATA *CpuMpData;
1222
1223 CpuMpData = GetCpuMpData ();
1224
1225 for (ProcessorNumber = 0; ProcessorNumber < CpuMpData->CpuCount; ProcessorNumber++) {
1226 if (CpuMpData->CpuData[ProcessorNumber].Waiting) {
1227 *NextProcessorNumber = ProcessorNumber;
1228 return EFI_SUCCESS;
1229 }
1230 }
1231
1232 return EFI_NOT_FOUND;
1233 }
1234
1235 /** Checks status of specified AP.
1236
1237 This function checks whether the specified AP has finished the task assigned
1238 by StartupThisAP(), and whether timeout expires.
1239
1240 @param[in] ProcessorNumber The handle number of processor.
1241
1242 @retval EFI_SUCCESS Specified AP has finished task assigned by StartupThisAPs().
1243 @retval EFI_TIMEOUT The timeout expires.
1244 @retval EFI_NOT_READY Specified AP has not finished task and timeout has not expired.
1245 **/
1246 EFI_STATUS
1247 CheckThisAP (
1248 IN UINTN ProcessorNumber
1249 )
1250 {
1251 CPU_MP_DATA *CpuMpData;
1252 CPU_AP_DATA *CpuData;
1253
1254 CpuMpData = GetCpuMpData ();
1255 CpuData = &CpuMpData->CpuData[ProcessorNumber];
1256
1257 //
1258 // Check the CPU state of AP. If it is CpuStateFinished, then the AP has finished its task.
1259 // Only BSP and corresponding AP access this unit of CPU Data. This means the AP will not modify the
1260 // value of state after setting the it to CpuStateFinished, so BSP can safely make use of its value.
1261 //
1262 //
1263 // If the AP finishes for StartupThisAP(), return EFI_SUCCESS.
1264 //
1265 if (GetApState(CpuData) == CpuStateFinished) {
1266 if (CpuData->Finished != NULL) {
1267 *(CpuData->Finished) = TRUE;
1268 }
1269 SetApState (CpuData, CpuStateIdle);
1270 return EFI_SUCCESS;
1271 } else {
1272 //
1273 // If timeout expires for StartupThisAP(), report timeout.
1274 //
1275 if (CheckTimeout (&CpuData->CurrentTime, &CpuData->TotalTime, CpuData->ExpectedTime)) {
1276 if (CpuData->Finished != NULL) {
1277 *(CpuData->Finished) = FALSE;
1278 }
1279 //
1280 // Reset failed AP to idle state
1281 //
1282 ResetProcessorToIdleState (ProcessorNumber);
1283
1284 return EFI_TIMEOUT;
1285 }
1286 }
1287 return EFI_NOT_READY;
1288 }
1289
1290 /**
1291 Checks status of all APs.
1292
1293 This function checks whether all APs have finished task assigned by StartupAllAPs(),
1294 and whether timeout expires.
1295
1296 @retval EFI_SUCCESS All APs have finished task assigned by StartupAllAPs().
1297 @retval EFI_TIMEOUT The timeout expires.
1298 @retval EFI_NOT_READY APs have not finished task and timeout has not expired.
1299 **/
1300 EFI_STATUS
1301 CheckAllAPs (
1302 VOID
1303 )
1304 {
1305 UINTN ProcessorNumber;
1306 UINTN NextProcessorNumber;
1307 UINTN ListIndex;
1308 EFI_STATUS Status;
1309 CPU_MP_DATA *CpuMpData;
1310 CPU_AP_DATA *CpuData;
1311
1312 CpuMpData = GetCpuMpData ();
1313
1314 NextProcessorNumber = 0;
1315
1316 //
1317 // Go through all APs that are responsible for the StartupAllAPs().
1318 //
1319 for (ProcessorNumber = 0; ProcessorNumber < CpuMpData->CpuCount; ProcessorNumber++) {
1320 if (!CpuMpData->CpuData[ProcessorNumber].Waiting) {
1321 continue;
1322 }
1323
1324 CpuData = &CpuMpData->CpuData[ProcessorNumber];
1325 //
1326 // Check the CPU state of AP. If it is CpuStateFinished, then the AP has finished its task.
1327 // Only BSP and corresponding AP access this unit of CPU Data. This means the AP will not modify the
1328 // value of state after setting the it to CpuStateFinished, so BSP can safely make use of its value.
1329 //
1330 if (GetApState(CpuData) == CpuStateFinished) {
1331 CpuMpData->RunningCount ++;
1332 CpuMpData->CpuData[ProcessorNumber].Waiting = FALSE;
1333 SetApState(CpuData, CpuStateIdle);
1334
1335 //
1336 // If in Single Thread mode, then search for the next waiting AP for execution.
1337 //
1338 if (CpuMpData->SingleThread) {
1339 Status = GetNextWaitingProcessorNumber (&NextProcessorNumber);
1340
1341 if (!EFI_ERROR (Status)) {
1342 WakeUpAP (
1343 CpuMpData,
1344 FALSE,
1345 (UINT32) NextProcessorNumber,
1346 CpuMpData->Procedure,
1347 CpuMpData->ProcArguments
1348 );
1349 }
1350 }
1351 }
1352 }
1353
1354 //
1355 // If all APs finish, return EFI_SUCCESS.
1356 //
1357 if (CpuMpData->RunningCount == CpuMpData->StartCount) {
1358 return EFI_SUCCESS;
1359 }
1360
1361 //
1362 // If timeout expires, report timeout.
1363 //
1364 if (CheckTimeout (
1365 &CpuMpData->CurrentTime,
1366 &CpuMpData->TotalTime,
1367 CpuMpData->ExpectedTime)
1368 ) {
1369 //
1370 // If FailedCpuList is not NULL, record all failed APs in it.
1371 //
1372 if (CpuMpData->FailedCpuList != NULL) {
1373 *CpuMpData->FailedCpuList =
1374 AllocatePool ((CpuMpData->StartCount - CpuMpData->FinishedCount + 1) * sizeof (UINTN));
1375 ASSERT (*CpuMpData->FailedCpuList != NULL);
1376 }
1377 ListIndex = 0;
1378
1379 for (ProcessorNumber = 0; ProcessorNumber < CpuMpData->CpuCount; ProcessorNumber++) {
1380 //
1381 // Check whether this processor is responsible for StartupAllAPs().
1382 //
1383 if (CpuMpData->CpuData[ProcessorNumber].Waiting) {
1384 //
1385 // Reset failed APs to idle state
1386 //
1387 ResetProcessorToIdleState (ProcessorNumber);
1388 CpuMpData->CpuData[ProcessorNumber].Waiting = FALSE;
1389 if (CpuMpData->FailedCpuList != NULL) {
1390 (*CpuMpData->FailedCpuList)[ListIndex++] = ProcessorNumber;
1391 }
1392 }
1393 }
1394 if (CpuMpData->FailedCpuList != NULL) {
1395 (*CpuMpData->FailedCpuList)[ListIndex] = END_OF_CPU_LIST;
1396 }
1397 return EFI_TIMEOUT;
1398 }
1399 return EFI_NOT_READY;
1400 }
1401
1402 /**
1403 MP Initialize Library initialization.
1404
1405 This service will allocate AP reset vector and wakeup all APs to do APs
1406 initialization.
1407
1408 This service must be invoked before all other MP Initialize Library
1409 service are invoked.
1410
1411 @retval EFI_SUCCESS MP initialization succeeds.
1412 @retval Others MP initialization fails.
1413
1414 **/
1415 EFI_STATUS
1416 EFIAPI
1417 MpInitLibInitialize (
1418 VOID
1419 )
1420 {
1421 CPU_MP_DATA *OldCpuMpData;
1422 CPU_INFO_IN_HOB *CpuInfoInHob;
1423 UINT32 MaxLogicalProcessorNumber;
1424 UINT32 ApStackSize;
1425 MP_ASSEMBLY_ADDRESS_MAP AddressMap;
1426 UINTN BufferSize;
1427 UINT32 MonitorFilterSize;
1428 VOID *MpBuffer;
1429 UINTN Buffer;
1430 CPU_MP_DATA *CpuMpData;
1431 UINT8 ApLoopMode;
1432 UINT8 *MonitorBuffer;
1433 UINTN Index;
1434 UINTN ApResetVectorSize;
1435 UINTN BackupBufferAddr;
1436
1437 OldCpuMpData = GetCpuMpDataFromGuidedHob ();
1438 if (OldCpuMpData == NULL) {
1439 MaxLogicalProcessorNumber = PcdGet32(PcdCpuMaxLogicalProcessorNumber);
1440 } else {
1441 MaxLogicalProcessorNumber = OldCpuMpData->CpuCount;
1442 }
1443 ASSERT (MaxLogicalProcessorNumber != 0);
1444
1445 AsmGetAddressMap (&AddressMap);
1446 ApResetVectorSize = AddressMap.RendezvousFunnelSize + sizeof (MP_CPU_EXCHANGE_INFO);
1447 ApStackSize = PcdGet32(PcdCpuApStackSize);
1448 ApLoopMode = GetApLoopMode (&MonitorFilterSize);
1449
1450 BufferSize = ApStackSize * MaxLogicalProcessorNumber;
1451 BufferSize += MonitorFilterSize * MaxLogicalProcessorNumber;
1452 BufferSize += sizeof (CPU_MP_DATA);
1453 BufferSize += ApResetVectorSize;
1454 BufferSize += (sizeof (CPU_AP_DATA) + sizeof (CPU_INFO_IN_HOB))* MaxLogicalProcessorNumber;
1455 MpBuffer = AllocatePages (EFI_SIZE_TO_PAGES (BufferSize));
1456 ASSERT (MpBuffer != NULL);
1457 ZeroMem (MpBuffer, BufferSize);
1458 Buffer = (UINTN) MpBuffer;
1459
1460 MonitorBuffer = (UINT8 *) (Buffer + ApStackSize * MaxLogicalProcessorNumber);
1461 BackupBufferAddr = (UINTN) MonitorBuffer + MonitorFilterSize * MaxLogicalProcessorNumber;
1462 CpuMpData = (CPU_MP_DATA *) (BackupBufferAddr + ApResetVectorSize);
1463 CpuMpData->Buffer = Buffer;
1464 CpuMpData->CpuApStackSize = ApStackSize;
1465 CpuMpData->BackupBuffer = BackupBufferAddr;
1466 CpuMpData->BackupBufferSize = ApResetVectorSize;
1467 CpuMpData->WakeupBuffer = (UINTN) -1;
1468 CpuMpData->CpuCount = 1;
1469 CpuMpData->BspNumber = 0;
1470 CpuMpData->WaitEvent = NULL;
1471 CpuMpData->SwitchBspFlag = FALSE;
1472 CpuMpData->CpuData = (CPU_AP_DATA *) (CpuMpData + 1);
1473 CpuMpData->CpuInfoInHob = (UINT64) (UINTN) (CpuMpData->CpuData + MaxLogicalProcessorNumber);
1474 CpuMpData->MicrocodePatchAddress = PcdGet64 (PcdCpuMicrocodePatchAddress);
1475 CpuMpData->MicrocodePatchRegionSize = PcdGet64 (PcdCpuMicrocodePatchRegionSize);
1476 InitializeSpinLock(&CpuMpData->MpLock);
1477 //
1478 // Save BSP's Control registers to APs
1479 //
1480 SaveVolatileRegisters (&CpuMpData->CpuData[0].VolatileRegisters);
1481 //
1482 // Set BSP basic information
1483 //
1484 InitializeApData (CpuMpData, 0, 0, CpuMpData->Buffer);
1485 //
1486 // Save assembly code information
1487 //
1488 CopyMem (&CpuMpData->AddressMap, &AddressMap, sizeof (MP_ASSEMBLY_ADDRESS_MAP));
1489 //
1490 // Finally set AP loop mode
1491 //
1492 CpuMpData->ApLoopMode = ApLoopMode;
1493 DEBUG ((DEBUG_INFO, "AP Loop Mode is %d\n", CpuMpData->ApLoopMode));
1494 //
1495 // Set up APs wakeup signal buffer
1496 //
1497 for (Index = 0; Index < MaxLogicalProcessorNumber; Index++) {
1498 CpuMpData->CpuData[Index].StartupApSignal =
1499 (UINT32 *)(MonitorBuffer + MonitorFilterSize * Index);
1500 }
1501 //
1502 // Load Microcode on BSP
1503 //
1504 MicrocodeDetect (CpuMpData);
1505 //
1506 // Store BSP's MTRR setting
1507 //
1508 MtrrGetAllMtrrs (&CpuMpData->MtrrTable);
1509 //
1510 // Enable the local APIC for Virtual Wire Mode.
1511 //
1512 ProgramVirtualWireMode ();
1513
1514 if (OldCpuMpData == NULL) {
1515 if (MaxLogicalProcessorNumber > 1) {
1516 //
1517 // Wakeup all APs and calculate the processor count in system
1518 //
1519 CollectProcessorCount (CpuMpData);
1520 }
1521 } else {
1522 //
1523 // APs have been wakeup before, just get the CPU Information
1524 // from HOB
1525 //
1526 CpuMpData->CpuCount = OldCpuMpData->CpuCount;
1527 CpuMpData->BspNumber = OldCpuMpData->BspNumber;
1528 CpuMpData->InitFlag = ApInitReconfig;
1529 CpuMpData->CpuInfoInHob = OldCpuMpData->CpuInfoInHob;
1530 CpuInfoInHob = (CPU_INFO_IN_HOB *) (UINTN) CpuMpData->CpuInfoInHob;
1531 for (Index = 0; Index < CpuMpData->CpuCount; Index++) {
1532 InitializeSpinLock(&CpuMpData->CpuData[Index].ApLock);
1533 if (CpuInfoInHob[Index].InitialApicId >= 255 || Index > 254) {
1534 CpuMpData->X2ApicEnable = TRUE;
1535 }
1536 CpuMpData->CpuData[Index].CpuHealthy = (CpuInfoInHob[Index].Health == 0)? TRUE:FALSE;
1537 CpuMpData->CpuData[Index].ApFunction = 0;
1538 CopyMem (
1539 &CpuMpData->CpuData[Index].VolatileRegisters,
1540 &CpuMpData->CpuData[0].VolatileRegisters,
1541 sizeof (CPU_VOLATILE_REGISTERS)
1542 );
1543 }
1544 if (MaxLogicalProcessorNumber > 1) {
1545 //
1546 // Wakeup APs to do some AP initialize sync
1547 //
1548 WakeUpAP (CpuMpData, TRUE, 0, ApInitializeSync, CpuMpData);
1549 //
1550 // Wait for all APs finished initialization
1551 //
1552 while (CpuMpData->FinishedCount < (CpuMpData->CpuCount - 1)) {
1553 CpuPause ();
1554 }
1555 CpuMpData->InitFlag = ApInitDone;
1556 for (Index = 0; Index < CpuMpData->CpuCount; Index++) {
1557 SetApState (&CpuMpData->CpuData[Index], CpuStateIdle);
1558 }
1559 }
1560 }
1561
1562 //
1563 // Initialize global data for MP support
1564 //
1565 InitMpGlobalData (CpuMpData);
1566
1567 return EFI_SUCCESS;
1568 }
1569
1570 /**
1571 Gets detailed MP-related information on the requested processor at the
1572 instant this call is made. This service may only be called from the BSP.
1573
1574 @param[in] ProcessorNumber The handle number of processor.
1575 @param[out] ProcessorInfoBuffer A pointer to the buffer where information for
1576 the requested processor is deposited.
1577 @param[out] HealthData Return processor health data.
1578
1579 @retval EFI_SUCCESS Processor information was returned.
1580 @retval EFI_DEVICE_ERROR The calling processor is an AP.
1581 @retval EFI_INVALID_PARAMETER ProcessorInfoBuffer is NULL.
1582 @retval EFI_NOT_FOUND The processor with the handle specified by
1583 ProcessorNumber does not exist in the platform.
1584 @retval EFI_NOT_READY MP Initialize Library is not initialized.
1585
1586 **/
1587 EFI_STATUS
1588 EFIAPI
1589 MpInitLibGetProcessorInfo (
1590 IN UINTN ProcessorNumber,
1591 OUT EFI_PROCESSOR_INFORMATION *ProcessorInfoBuffer,
1592 OUT EFI_HEALTH_FLAGS *HealthData OPTIONAL
1593 )
1594 {
1595 CPU_MP_DATA *CpuMpData;
1596 UINTN CallerNumber;
1597 CPU_INFO_IN_HOB *CpuInfoInHob;
1598
1599 CpuMpData = GetCpuMpData ();
1600 CpuInfoInHob = (CPU_INFO_IN_HOB *) (UINTN) CpuMpData->CpuInfoInHob;
1601
1602 //
1603 // Check whether caller processor is BSP
1604 //
1605 MpInitLibWhoAmI (&CallerNumber);
1606 if (CallerNumber != CpuMpData->BspNumber) {
1607 return EFI_DEVICE_ERROR;
1608 }
1609
1610 if (ProcessorInfoBuffer == NULL) {
1611 return EFI_INVALID_PARAMETER;
1612 }
1613
1614 if (ProcessorNumber >= CpuMpData->CpuCount) {
1615 return EFI_NOT_FOUND;
1616 }
1617
1618 ProcessorInfoBuffer->ProcessorId = (UINT64) CpuInfoInHob[ProcessorNumber].ApicId;
1619 ProcessorInfoBuffer->StatusFlag = 0;
1620 if (ProcessorNumber == CpuMpData->BspNumber) {
1621 ProcessorInfoBuffer->StatusFlag |= PROCESSOR_AS_BSP_BIT;
1622 }
1623 if (CpuMpData->CpuData[ProcessorNumber].CpuHealthy) {
1624 ProcessorInfoBuffer->StatusFlag |= PROCESSOR_HEALTH_STATUS_BIT;
1625 }
1626 if (GetApState (&CpuMpData->CpuData[ProcessorNumber]) == CpuStateDisabled) {
1627 ProcessorInfoBuffer->StatusFlag &= ~PROCESSOR_ENABLED_BIT;
1628 } else {
1629 ProcessorInfoBuffer->StatusFlag |= PROCESSOR_ENABLED_BIT;
1630 }
1631
1632 //
1633 // Get processor location information
1634 //
1635 GetProcessorLocationByApicId (
1636 CpuInfoInHob[ProcessorNumber].ApicId,
1637 &ProcessorInfoBuffer->Location.Package,
1638 &ProcessorInfoBuffer->Location.Core,
1639 &ProcessorInfoBuffer->Location.Thread
1640 );
1641
1642 if (HealthData != NULL) {
1643 HealthData->Uint32 = CpuInfoInHob[ProcessorNumber].Health;
1644 }
1645
1646 return EFI_SUCCESS;
1647 }
1648
1649 /**
1650 Worker function to switch the requested AP to be the BSP from that point onward.
1651
1652 @param[in] ProcessorNumber The handle number of AP that is to become the new BSP.
1653 @param[in] EnableOldBSP If TRUE, then the old BSP will be listed as an
1654 enabled AP. Otherwise, it will be disabled.
1655
1656 @retval EFI_SUCCESS BSP successfully switched.
1657 @retval others Failed to switch BSP.
1658
1659 **/
1660 EFI_STATUS
1661 SwitchBSPWorker (
1662 IN UINTN ProcessorNumber,
1663 IN BOOLEAN EnableOldBSP
1664 )
1665 {
1666 CPU_MP_DATA *CpuMpData;
1667 UINTN CallerNumber;
1668 CPU_STATE State;
1669 MSR_IA32_APIC_BASE_REGISTER ApicBaseMsr;
1670 BOOLEAN OldInterruptState;
1671 BOOLEAN OldTimerInterruptState;
1672
1673 //
1674 // Save and Disable Local APIC timer interrupt
1675 //
1676 OldTimerInterruptState = GetApicTimerInterruptState ();
1677 DisableApicTimerInterrupt ();
1678 //
1679 // Before send both BSP and AP to a procedure to exchange their roles,
1680 // interrupt must be disabled. This is because during the exchange role
1681 // process, 2 CPU may use 1 stack. If interrupt happens, the stack will
1682 // be corrupted, since interrupt return address will be pushed to stack
1683 // by hardware.
1684 //
1685 OldInterruptState = SaveAndDisableInterrupts ();
1686
1687 //
1688 // Mask LINT0 & LINT1 for the old BSP
1689 //
1690 DisableLvtInterrupts ();
1691
1692 CpuMpData = GetCpuMpData ();
1693
1694 //
1695 // Check whether caller processor is BSP
1696 //
1697 MpInitLibWhoAmI (&CallerNumber);
1698 if (CallerNumber != CpuMpData->BspNumber) {
1699 return EFI_DEVICE_ERROR;
1700 }
1701
1702 if (ProcessorNumber >= CpuMpData->CpuCount) {
1703 return EFI_NOT_FOUND;
1704 }
1705
1706 //
1707 // Check whether specified AP is disabled
1708 //
1709 State = GetApState (&CpuMpData->CpuData[ProcessorNumber]);
1710 if (State == CpuStateDisabled) {
1711 return EFI_INVALID_PARAMETER;
1712 }
1713
1714 //
1715 // Check whether ProcessorNumber specifies the current BSP
1716 //
1717 if (ProcessorNumber == CpuMpData->BspNumber) {
1718 return EFI_INVALID_PARAMETER;
1719 }
1720
1721 //
1722 // Check whether specified AP is busy
1723 //
1724 if (State == CpuStateBusy) {
1725 return EFI_NOT_READY;
1726 }
1727
1728 CpuMpData->BSPInfo.State = CPU_SWITCH_STATE_IDLE;
1729 CpuMpData->APInfo.State = CPU_SWITCH_STATE_IDLE;
1730 CpuMpData->SwitchBspFlag = TRUE;
1731 CpuMpData->NewBspNumber = ProcessorNumber;
1732
1733 //
1734 // Clear the BSP bit of MSR_IA32_APIC_BASE
1735 //
1736 ApicBaseMsr.Uint64 = AsmReadMsr64 (MSR_IA32_APIC_BASE);
1737 ApicBaseMsr.Bits.BSP = 0;
1738 AsmWriteMsr64 (MSR_IA32_APIC_BASE, ApicBaseMsr.Uint64);
1739
1740 //
1741 // Need to wakeUp AP (future BSP).
1742 //
1743 WakeUpAP (CpuMpData, FALSE, ProcessorNumber, FutureBSPProc, CpuMpData);
1744
1745 AsmExchangeRole (&CpuMpData->BSPInfo, &CpuMpData->APInfo);
1746
1747 //
1748 // Set the BSP bit of MSR_IA32_APIC_BASE on new BSP
1749 //
1750 ApicBaseMsr.Uint64 = AsmReadMsr64 (MSR_IA32_APIC_BASE);
1751 ApicBaseMsr.Bits.BSP = 1;
1752 AsmWriteMsr64 (MSR_IA32_APIC_BASE, ApicBaseMsr.Uint64);
1753
1754 //
1755 // Wait for old BSP finished AP task
1756 //
1757 while (GetApState (&CpuMpData->CpuData[CallerNumber]) != CpuStateFinished) {
1758 CpuPause ();
1759 }
1760
1761 CpuMpData->SwitchBspFlag = FALSE;
1762 //
1763 // Set old BSP enable state
1764 //
1765 if (!EnableOldBSP) {
1766 SetApState (&CpuMpData->CpuData[CallerNumber], CpuStateDisabled);
1767 } else {
1768 SetApState (&CpuMpData->CpuData[CallerNumber], CpuStateIdle);
1769 }
1770 //
1771 // Save new BSP number
1772 //
1773 CpuMpData->BspNumber = (UINT32) ProcessorNumber;
1774
1775 //
1776 // Restore interrupt state.
1777 //
1778 SetInterruptState (OldInterruptState);
1779
1780 if (OldTimerInterruptState) {
1781 EnableApicTimerInterrupt ();
1782 }
1783
1784 return EFI_SUCCESS;
1785 }
1786
1787 /**
1788 Worker function to let the caller enable or disable an AP from this point onward.
1789 This service may only be called from the BSP.
1790
1791 @param[in] ProcessorNumber The handle number of AP.
1792 @param[in] EnableAP Specifies the new state for the processor for
1793 enabled, FALSE for disabled.
1794 @param[in] HealthFlag If not NULL, a pointer to a value that specifies
1795 the new health status of the AP.
1796
1797 @retval EFI_SUCCESS The specified AP was enabled or disabled successfully.
1798 @retval others Failed to Enable/Disable AP.
1799
1800 **/
1801 EFI_STATUS
1802 EnableDisableApWorker (
1803 IN UINTN ProcessorNumber,
1804 IN BOOLEAN EnableAP,
1805 IN UINT32 *HealthFlag OPTIONAL
1806 )
1807 {
1808 CPU_MP_DATA *CpuMpData;
1809 UINTN CallerNumber;
1810
1811 CpuMpData = GetCpuMpData ();
1812
1813 //
1814 // Check whether caller processor is BSP
1815 //
1816 MpInitLibWhoAmI (&CallerNumber);
1817 if (CallerNumber != CpuMpData->BspNumber) {
1818 return EFI_DEVICE_ERROR;
1819 }
1820
1821 if (ProcessorNumber == CpuMpData->BspNumber) {
1822 return EFI_INVALID_PARAMETER;
1823 }
1824
1825 if (ProcessorNumber >= CpuMpData->CpuCount) {
1826 return EFI_NOT_FOUND;
1827 }
1828
1829 if (!EnableAP) {
1830 SetApState (&CpuMpData->CpuData[ProcessorNumber], CpuStateDisabled);
1831 } else {
1832 ResetProcessorToIdleState (ProcessorNumber);
1833 }
1834
1835 if (HealthFlag != NULL) {
1836 CpuMpData->CpuData[ProcessorNumber].CpuHealthy =
1837 (BOOLEAN) ((*HealthFlag & PROCESSOR_HEALTH_STATUS_BIT) != 0);
1838 }
1839
1840 return EFI_SUCCESS;
1841 }
1842
1843 /**
1844 This return the handle number for the calling processor. This service may be
1845 called from the BSP and APs.
1846
1847 @param[out] ProcessorNumber Pointer to the handle number of AP.
1848 The range is from 0 to the total number of
1849 logical processors minus 1. The total number of
1850 logical processors can be retrieved by
1851 MpInitLibGetNumberOfProcessors().
1852
1853 @retval EFI_SUCCESS The current processor handle number was returned
1854 in ProcessorNumber.
1855 @retval EFI_INVALID_PARAMETER ProcessorNumber is NULL.
1856 @retval EFI_NOT_READY MP Initialize Library is not initialized.
1857
1858 **/
1859 EFI_STATUS
1860 EFIAPI
1861 MpInitLibWhoAmI (
1862 OUT UINTN *ProcessorNumber
1863 )
1864 {
1865 CPU_MP_DATA *CpuMpData;
1866
1867 if (ProcessorNumber == NULL) {
1868 return EFI_INVALID_PARAMETER;
1869 }
1870
1871 CpuMpData = GetCpuMpData ();
1872
1873 return GetProcessorNumber (CpuMpData, ProcessorNumber);
1874 }
1875
1876 /**
1877 Retrieves the number of logical processor in the platform and the number of
1878 those logical processors that are enabled on this boot. This service may only
1879 be called from the BSP.
1880
1881 @param[out] NumberOfProcessors Pointer to the total number of logical
1882 processors in the system, including the BSP
1883 and disabled APs.
1884 @param[out] NumberOfEnabledProcessors Pointer to the number of enabled logical
1885 processors that exist in system, including
1886 the BSP.
1887
1888 @retval EFI_SUCCESS The number of logical processors and enabled
1889 logical processors was retrieved.
1890 @retval EFI_DEVICE_ERROR The calling processor is an AP.
1891 @retval EFI_INVALID_PARAMETER NumberOfProcessors is NULL and NumberOfEnabledProcessors
1892 is NULL.
1893 @retval EFI_NOT_READY MP Initialize Library is not initialized.
1894
1895 **/
1896 EFI_STATUS
1897 EFIAPI
1898 MpInitLibGetNumberOfProcessors (
1899 OUT UINTN *NumberOfProcessors, OPTIONAL
1900 OUT UINTN *NumberOfEnabledProcessors OPTIONAL
1901 )
1902 {
1903 CPU_MP_DATA *CpuMpData;
1904 UINTN CallerNumber;
1905 UINTN ProcessorNumber;
1906 UINTN EnabledProcessorNumber;
1907 UINTN Index;
1908
1909 CpuMpData = GetCpuMpData ();
1910
1911 if ((NumberOfProcessors == NULL) && (NumberOfEnabledProcessors == NULL)) {
1912 return EFI_INVALID_PARAMETER;
1913 }
1914
1915 //
1916 // Check whether caller processor is BSP
1917 //
1918 MpInitLibWhoAmI (&CallerNumber);
1919 if (CallerNumber != CpuMpData->BspNumber) {
1920 return EFI_DEVICE_ERROR;
1921 }
1922
1923 ProcessorNumber = CpuMpData->CpuCount;
1924 EnabledProcessorNumber = 0;
1925 for (Index = 0; Index < ProcessorNumber; Index++) {
1926 if (GetApState (&CpuMpData->CpuData[Index]) != CpuStateDisabled) {
1927 EnabledProcessorNumber ++;
1928 }
1929 }
1930
1931 if (NumberOfProcessors != NULL) {
1932 *NumberOfProcessors = ProcessorNumber;
1933 }
1934 if (NumberOfEnabledProcessors != NULL) {
1935 *NumberOfEnabledProcessors = EnabledProcessorNumber;
1936 }
1937
1938 return EFI_SUCCESS;
1939 }
1940
1941
1942 /**
1943 Worker function to execute a caller provided function on all enabled APs.
1944
1945 @param[in] Procedure A pointer to the function to be run on
1946 enabled APs of the system.
1947 @param[in] SingleThread If TRUE, then all the enabled APs execute
1948 the function specified by Procedure one by
1949 one, in ascending order of processor handle
1950 number. If FALSE, then all the enabled APs
1951 execute the function specified by Procedure
1952 simultaneously.
1953 @param[in] WaitEvent The event created by the caller with CreateEvent()
1954 service.
1955 @param[in] TimeoutInMicroseconds Indicates the time limit in microseconds for
1956 APs to return from Procedure, either for
1957 blocking or non-blocking mode.
1958 @param[in] ProcedureArgument The parameter passed into Procedure for
1959 all APs.
1960 @param[out] FailedCpuList If all APs finish successfully, then its
1961 content is set to NULL. If not all APs
1962 finish before timeout expires, then its
1963 content is set to address of the buffer
1964 holding handle numbers of the failed APs.
1965
1966 @retval EFI_SUCCESS In blocking mode, all APs have finished before
1967 the timeout expired.
1968 @retval EFI_SUCCESS In non-blocking mode, function has been dispatched
1969 to all enabled APs.
1970 @retval others Failed to Startup all APs.
1971
1972 **/
1973 EFI_STATUS
1974 StartupAllAPsWorker (
1975 IN EFI_AP_PROCEDURE Procedure,
1976 IN BOOLEAN SingleThread,
1977 IN EFI_EVENT WaitEvent OPTIONAL,
1978 IN UINTN TimeoutInMicroseconds,
1979 IN VOID *ProcedureArgument OPTIONAL,
1980 OUT UINTN **FailedCpuList OPTIONAL
1981 )
1982 {
1983 EFI_STATUS Status;
1984 CPU_MP_DATA *CpuMpData;
1985 UINTN ProcessorCount;
1986 UINTN ProcessorNumber;
1987 UINTN CallerNumber;
1988 CPU_AP_DATA *CpuData;
1989 BOOLEAN HasEnabledAp;
1990 CPU_STATE ApState;
1991
1992 CpuMpData = GetCpuMpData ();
1993
1994 if (FailedCpuList != NULL) {
1995 *FailedCpuList = NULL;
1996 }
1997
1998 if (CpuMpData->CpuCount == 1) {
1999 return EFI_NOT_STARTED;
2000 }
2001
2002 if (Procedure == NULL) {
2003 return EFI_INVALID_PARAMETER;
2004 }
2005
2006 //
2007 // Check whether caller processor is BSP
2008 //
2009 MpInitLibWhoAmI (&CallerNumber);
2010 if (CallerNumber != CpuMpData->BspNumber) {
2011 return EFI_DEVICE_ERROR;
2012 }
2013
2014 //
2015 // Update AP state
2016 //
2017 CheckAndUpdateApsStatus ();
2018
2019 ProcessorCount = CpuMpData->CpuCount;
2020 HasEnabledAp = FALSE;
2021 //
2022 // Check whether all enabled APs are idle.
2023 // If any enabled AP is not idle, return EFI_NOT_READY.
2024 //
2025 for (ProcessorNumber = 0; ProcessorNumber < ProcessorCount; ProcessorNumber++) {
2026 CpuData = &CpuMpData->CpuData[ProcessorNumber];
2027 if (ProcessorNumber != CpuMpData->BspNumber) {
2028 ApState = GetApState (CpuData);
2029 if (ApState != CpuStateDisabled) {
2030 HasEnabledAp = TRUE;
2031 if (ApState != CpuStateIdle) {
2032 //
2033 // If any enabled APs are busy, return EFI_NOT_READY.
2034 //
2035 return EFI_NOT_READY;
2036 }
2037 }
2038 }
2039 }
2040
2041 if (!HasEnabledAp) {
2042 //
2043 // If no enabled AP exists, return EFI_NOT_STARTED.
2044 //
2045 return EFI_NOT_STARTED;
2046 }
2047
2048 CpuMpData->StartCount = 0;
2049 for (ProcessorNumber = 0; ProcessorNumber < ProcessorCount; ProcessorNumber++) {
2050 CpuData = &CpuMpData->CpuData[ProcessorNumber];
2051 CpuData->Waiting = FALSE;
2052 if (ProcessorNumber != CpuMpData->BspNumber) {
2053 if (CpuData->State == CpuStateIdle) {
2054 //
2055 // Mark this processor as responsible for current calling.
2056 //
2057 CpuData->Waiting = TRUE;
2058 CpuMpData->StartCount++;
2059 }
2060 }
2061 }
2062
2063 CpuMpData->Procedure = Procedure;
2064 CpuMpData->ProcArguments = ProcedureArgument;
2065 CpuMpData->SingleThread = SingleThread;
2066 CpuMpData->FinishedCount = 0;
2067 CpuMpData->RunningCount = 0;
2068 CpuMpData->FailedCpuList = FailedCpuList;
2069 CpuMpData->ExpectedTime = CalculateTimeout (
2070 TimeoutInMicroseconds,
2071 &CpuMpData->CurrentTime
2072 );
2073 CpuMpData->TotalTime = 0;
2074 CpuMpData->WaitEvent = WaitEvent;
2075
2076 if (!SingleThread) {
2077 WakeUpAP (CpuMpData, TRUE, 0, Procedure, ProcedureArgument);
2078 } else {
2079 for (ProcessorNumber = 0; ProcessorNumber < ProcessorCount; ProcessorNumber++) {
2080 if (ProcessorNumber == CallerNumber) {
2081 continue;
2082 }
2083 if (CpuMpData->CpuData[ProcessorNumber].Waiting) {
2084 WakeUpAP (CpuMpData, FALSE, ProcessorNumber, Procedure, ProcedureArgument);
2085 break;
2086 }
2087 }
2088 }
2089
2090 Status = EFI_SUCCESS;
2091 if (WaitEvent == NULL) {
2092 do {
2093 Status = CheckAllAPs ();
2094 } while (Status == EFI_NOT_READY);
2095 }
2096
2097 return Status;
2098 }
2099
2100 /**
2101 Worker function to let the caller get one enabled AP to execute a caller-provided
2102 function.
2103
2104 @param[in] Procedure A pointer to the function to be run on
2105 enabled APs of the system.
2106 @param[in] ProcessorNumber The handle number of the AP.
2107 @param[in] WaitEvent The event created by the caller with CreateEvent()
2108 service.
2109 @param[in] TimeoutInMicroseconds Indicates the time limit in microseconds for
2110 APs to return from Procedure, either for
2111 blocking or non-blocking mode.
2112 @param[in] ProcedureArgument The parameter passed into Procedure for
2113 all APs.
2114 @param[out] Finished If AP returns from Procedure before the
2115 timeout expires, its content is set to TRUE.
2116 Otherwise, the value is set to FALSE.
2117
2118 @retval EFI_SUCCESS In blocking mode, specified AP finished before
2119 the timeout expires.
2120 @retval others Failed to Startup AP.
2121
2122 **/
2123 EFI_STATUS
2124 StartupThisAPWorker (
2125 IN EFI_AP_PROCEDURE Procedure,
2126 IN UINTN ProcessorNumber,
2127 IN EFI_EVENT WaitEvent OPTIONAL,
2128 IN UINTN TimeoutInMicroseconds,
2129 IN VOID *ProcedureArgument OPTIONAL,
2130 OUT BOOLEAN *Finished OPTIONAL
2131 )
2132 {
2133 EFI_STATUS Status;
2134 CPU_MP_DATA *CpuMpData;
2135 CPU_AP_DATA *CpuData;
2136 UINTN CallerNumber;
2137
2138 CpuMpData = GetCpuMpData ();
2139
2140 if (Finished != NULL) {
2141 *Finished = FALSE;
2142 }
2143
2144 //
2145 // Check whether caller processor is BSP
2146 //
2147 MpInitLibWhoAmI (&CallerNumber);
2148 if (CallerNumber != CpuMpData->BspNumber) {
2149 return EFI_DEVICE_ERROR;
2150 }
2151
2152 //
2153 // Check whether processor with the handle specified by ProcessorNumber exists
2154 //
2155 if (ProcessorNumber >= CpuMpData->CpuCount) {
2156 return EFI_NOT_FOUND;
2157 }
2158
2159 //
2160 // Check whether specified processor is BSP
2161 //
2162 if (ProcessorNumber == CpuMpData->BspNumber) {
2163 return EFI_INVALID_PARAMETER;
2164 }
2165
2166 //
2167 // Check parameter Procedure
2168 //
2169 if (Procedure == NULL) {
2170 return EFI_INVALID_PARAMETER;
2171 }
2172
2173 //
2174 // Update AP state
2175 //
2176 CheckAndUpdateApsStatus ();
2177
2178 //
2179 // Check whether specified AP is disabled
2180 //
2181 if (GetApState (&CpuMpData->CpuData[ProcessorNumber]) == CpuStateDisabled) {
2182 return EFI_INVALID_PARAMETER;
2183 }
2184
2185 //
2186 // If WaitEvent is not NULL, execute in non-blocking mode.
2187 // BSP saves data for CheckAPsStatus(), and returns EFI_SUCCESS.
2188 // CheckAPsStatus() will check completion and timeout periodically.
2189 //
2190 CpuData = &CpuMpData->CpuData[ProcessorNumber];
2191 CpuData->WaitEvent = WaitEvent;
2192 CpuData->Finished = Finished;
2193 CpuData->ExpectedTime = CalculateTimeout (TimeoutInMicroseconds, &CpuData->CurrentTime);
2194 CpuData->TotalTime = 0;
2195
2196 WakeUpAP (CpuMpData, FALSE, ProcessorNumber, Procedure, ProcedureArgument);
2197
2198 //
2199 // If WaitEvent is NULL, execute in blocking mode.
2200 // BSP checks AP's state until it finishes or TimeoutInMicrosecsond expires.
2201 //
2202 Status = EFI_SUCCESS;
2203 if (WaitEvent == NULL) {
2204 do {
2205 Status = CheckThisAP (ProcessorNumber);
2206 } while (Status == EFI_NOT_READY);
2207 }
2208
2209 return Status;
2210 }
2211
2212 /**
2213 Get pointer to CPU MP Data structure from GUIDed HOB.
2214
2215 @return The pointer to CPU MP Data structure.
2216 **/
2217 CPU_MP_DATA *
2218 GetCpuMpDataFromGuidedHob (
2219 VOID
2220 )
2221 {
2222 EFI_HOB_GUID_TYPE *GuidHob;
2223 VOID *DataInHob;
2224 CPU_MP_DATA *CpuMpData;
2225
2226 CpuMpData = NULL;
2227 GuidHob = GetFirstGuidHob (&mCpuInitMpLibHobGuid);
2228 if (GuidHob != NULL) {
2229 DataInHob = GET_GUID_HOB_DATA (GuidHob);
2230 CpuMpData = (CPU_MP_DATA *) (*(UINTN *) DataInHob);
2231 }
2232 return CpuMpData;
2233 }
2234