]> git.proxmox.com Git - mirror_edk2.git/blob - UefiCpuPkg/Library/MpInitLib/MpLib.c
projects / mirror_edk2.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
UefiCpuPkg/MpInitLib: Change AP Index variable name.
[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] NumApsExecuting 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
666 //
667 // Place AP is specified loop mode
668 //
669 if (CpuMpData->ApLoopMode == ApInHltLoop) {
670 //
671 // Save AP volatile registers
672 //
673 SaveVolatileRegisters (&CpuMpData->CpuData[ProcessorNumber].VolatileRegisters);
674 //
675 // Place AP in HLT-loop
676 //
677 while (TRUE) {
678 DisableInterrupts ();
679 CpuSleep ();
680 CpuPause ();
681 }
682 }
683 while (TRUE) {
684 DisableInterrupts ();
685 if (CpuMpData->ApLoopMode == ApInMwaitLoop) {
686 //
687 // Place AP in MWAIT-loop
688 //
689 AsmMonitor ((UINTN) ApStartupSignalBuffer, 0, 0);
690 if (*ApStartupSignalBuffer != WAKEUP_AP_SIGNAL) {
691 //
692 // Check AP start-up signal again.
693 // If AP start-up signal is not set, place AP into
694 // the specified C-state
695 //
696 AsmMwait (CpuMpData->ApTargetCState << 4, 0);
697 }
698 } else if (CpuMpData->ApLoopMode == ApInRunLoop) {
699 //
700 // Place AP in Run-loop
701 //
702 CpuPause ();
703 } else {
704 ASSERT (FALSE);
705 }
706
707 //
708 // If AP start-up signal is written, AP is waken up
709 // otherwise place AP in loop again
710 //
711 if (*ApStartupSignalBuffer == WAKEUP_AP_SIGNAL) {
712 break;
713 }
714 }
715 }
716 }
717
718 /**
719 Wait for AP wakeup and write AP start-up signal till AP is waken up.
720
721 @param[in] ApStartupSignalBuffer Pointer to AP wakeup signal
722 **/
723 VOID
724 WaitApWakeup (
725 IN volatile UINT32 *ApStartupSignalBuffer
726 )
727 {
728 //
729 // If AP is waken up, StartupApSignal should be cleared.
730 // Otherwise, write StartupApSignal again till AP waken up.
731 //
732 while (InterlockedCompareExchange32 (
733 (UINT32 *) ApStartupSignalBuffer,
734 WAKEUP_AP_SIGNAL,
735 WAKEUP_AP_SIGNAL
736 ) != 0) {
737 CpuPause ();
738 }
739 }
740
741 /**
742 This function will fill the exchange info structure.
743
744 @param[in] CpuMpData Pointer to CPU MP Data
745
746 **/
747 VOID
748 FillExchangeInfoData (
749 IN CPU_MP_DATA *CpuMpData
750 )
751 {
752 volatile MP_CPU_EXCHANGE_INFO *ExchangeInfo;
753
754 ExchangeInfo = CpuMpData->MpCpuExchangeInfo;
755 ExchangeInfo->Lock = 0;
756 ExchangeInfo->StackStart = CpuMpData->Buffer;
757 ExchangeInfo->StackSize = CpuMpData->CpuApStackSize;
758 ExchangeInfo->BufferStart = CpuMpData->WakeupBuffer;
759 ExchangeInfo->ModeOffset = CpuMpData->AddressMap.ModeEntryOffset;
760
761 ExchangeInfo->CodeSegment = AsmReadCs ();
762 ExchangeInfo->DataSegment = AsmReadDs ();
763
764 ExchangeInfo->Cr3 = AsmReadCr3 ();
765
766 ExchangeInfo->CFunction = (UINTN) ApWakeupFunction;
767 ExchangeInfo->ApIndex = 0;
768 ExchangeInfo->InitFlag = (UINTN) CpuMpData->InitFlag;
769 ExchangeInfo->CpuInfo = (CPU_INFO_IN_HOB *) (UINTN) CpuMpData->CpuInfoInHob;
770 ExchangeInfo->CpuMpData = CpuMpData;
771
772 ExchangeInfo->EnableExecuteDisable = IsBspExecuteDisableEnabled ();
773
774 ExchangeInfo->InitializeFloatingPointUnitsAddress = (UINTN)InitializeFloatingPointUnits;
775
776 //
777 // Get the BSP's data of GDT and IDT
778 //
779 AsmReadGdtr ((IA32_DESCRIPTOR *) &ExchangeInfo->GdtrProfile);
780 AsmReadIdtr ((IA32_DESCRIPTOR *) &ExchangeInfo->IdtrProfile);
781 }
782
783 /**
784 Helper function that waits until the finished AP count reaches the specified
785 limit, or the specified timeout elapses (whichever comes first).
786
787 @param[in] CpuMpData Pointer to CPU MP Data.
788 @param[in] FinishedApLimit The number of finished APs to wait for.
789 @param[in] TimeLimit The number of microseconds to wait for.
790 **/
791 VOID
792 TimedWaitForApFinish (
793 IN CPU_MP_DATA *CpuMpData,
794 IN UINT32 FinishedApLimit,
795 IN UINT32 TimeLimit
796 );
797
798 /**
799 Get available system memory below 1MB by specified size.
800
801 @param[in] CpuMpData The pointer to CPU MP Data structure.
802 **/
803 VOID
804 BackupAndPrepareWakeupBuffer(
805 IN CPU_MP_DATA *CpuMpData
806 )
807 {
808 CopyMem (
809 (VOID *) CpuMpData->BackupBuffer,
810 (VOID *) CpuMpData->WakeupBuffer,
811 CpuMpData->BackupBufferSize
812 );
813 CopyMem (
814 (VOID *) CpuMpData->WakeupBuffer,
815 (VOID *) CpuMpData->AddressMap.RendezvousFunnelAddress,
816 CpuMpData->AddressMap.RendezvousFunnelSize
817 );
818 }
819
820 /**
821 Restore wakeup buffer data.
822
823 @param[in] CpuMpData The pointer to CPU MP Data structure.
824 **/
825 VOID
826 RestoreWakeupBuffer(
827 IN CPU_MP_DATA *CpuMpData
828 )
829 {
830 CopyMem (
831 (VOID *) CpuMpData->WakeupBuffer,
832 (VOID *) CpuMpData->BackupBuffer,
833 CpuMpData->BackupBufferSize
834 );
835 }
836
837 /**
838 Allocate reset vector buffer.
839
840 @param[in, out] CpuMpData The pointer to CPU MP Data structure.
841 **/
842 VOID
843 AllocateResetVector (
844 IN OUT CPU_MP_DATA *CpuMpData
845 )
846 {
847 UINTN ApResetVectorSize;
848
849 if (CpuMpData->WakeupBuffer == (UINTN) -1) {
850 ApResetVectorSize = CpuMpData->AddressMap.RendezvousFunnelSize +
851 sizeof (MP_CPU_EXCHANGE_INFO);
852
853 CpuMpData->WakeupBuffer = GetWakeupBuffer (ApResetVectorSize);
854 CpuMpData->MpCpuExchangeInfo = (MP_CPU_EXCHANGE_INFO *) (UINTN)
855 (CpuMpData->WakeupBuffer + CpuMpData->AddressMap.RendezvousFunnelSize);
856 }
857 BackupAndPrepareWakeupBuffer (CpuMpData);
858 }
859
860 /**
861 Free AP reset vector buffer.
862
863 @param[in] CpuMpData The pointer to CPU MP Data structure.
864 **/
865 VOID
866 FreeResetVector (
867 IN CPU_MP_DATA *CpuMpData
868 )
869 {
870 RestoreWakeupBuffer (CpuMpData);
871 }
872
873 /**
874 This function will be called by BSP to wakeup AP.
875
876 @param[in] CpuMpData Pointer to CPU MP Data
877 @param[in] Broadcast TRUE: Send broadcast IPI to all APs
878 FALSE: Send IPI to AP by ApicId
879 @param[in] ProcessorNumber The handle number of specified processor
880 @param[in] Procedure The function to be invoked by AP
881 @param[in] ProcedureArgument The argument to be passed into AP function
882 **/
883 VOID
884 WakeUpAP (
885 IN CPU_MP_DATA *CpuMpData,
886 IN BOOLEAN Broadcast,
887 IN UINTN ProcessorNumber,
888 IN EFI_AP_PROCEDURE Procedure, OPTIONAL
889 IN VOID *ProcedureArgument OPTIONAL
890 )
891 {
892 volatile MP_CPU_EXCHANGE_INFO *ExchangeInfo;
893 UINTN Index;
894 CPU_AP_DATA *CpuData;
895 BOOLEAN ResetVectorRequired;
896 CPU_INFO_IN_HOB *CpuInfoInHob;
897
898 CpuMpData->FinishedCount = 0;
899 ResetVectorRequired = FALSE;
900
901 if (CpuMpData->ApLoopMode == ApInHltLoop ||
902 CpuMpData->InitFlag != ApInitDone) {
903 ResetVectorRequired = TRUE;
904 AllocateResetVector (CpuMpData);
905 FillExchangeInfoData (CpuMpData);
906 SaveLocalApicTimerSetting (CpuMpData);
907 } else if (CpuMpData->ApLoopMode == ApInMwaitLoop) {
908 //
909 // Get AP target C-state each time when waking up AP,
910 // for it maybe updated by platform again
911 //
912 CpuMpData->ApTargetCState = PcdGet8 (PcdCpuApTargetCstate);
913 }
914
915 ExchangeInfo = CpuMpData->MpCpuExchangeInfo;
916
917 if (Broadcast) {
918 for (Index = 0; Index < CpuMpData->CpuCount; Index++) {
919 if (Index != CpuMpData->BspNumber) {
920 CpuData = &CpuMpData->CpuData[Index];
921 CpuData->ApFunction = (UINTN) Procedure;
922 CpuData->ApFunctionArgument = (UINTN) ProcedureArgument;
923 SetApState (CpuData, CpuStateReady);
924 if (CpuMpData->InitFlag != ApInitConfig) {
925 *(UINT32 *) CpuData->StartupApSignal = WAKEUP_AP_SIGNAL;
926 }
927 }
928 }
929 if (ResetVectorRequired) {
930 //
931 // Wakeup all APs
932 //
933 SendInitSipiSipiAllExcludingSelf ((UINT32) ExchangeInfo->BufferStart);
934 }
935 if (CpuMpData->InitFlag == ApInitConfig) {
936 //
937 // Wait for all potential APs waken up in one specified period
938 //
939 TimedWaitForApFinish (
940 CpuMpData,
941 PcdGet32 (PcdCpuMaxLogicalProcessorNumber) - 1,
942 PcdGet32 (PcdCpuApInitTimeOutInMicroSeconds)
943 );
944 } else {
945 //
946 // Wait all APs waken up if this is not the 1st broadcast of SIPI
947 //
948 for (Index = 0; Index < CpuMpData->CpuCount; Index++) {
949 CpuData = &CpuMpData->CpuData[Index];
950 if (Index != CpuMpData->BspNumber) {
951 WaitApWakeup (CpuData->StartupApSignal);
952 }
953 }
954 }
955 } else {
956 CpuData = &CpuMpData->CpuData[ProcessorNumber];
957 CpuData->ApFunction = (UINTN) Procedure;
958 CpuData->ApFunctionArgument = (UINTN) ProcedureArgument;
959 SetApState (CpuData, CpuStateReady);
960 //
961 // Wakeup specified AP
962 //
963 ASSERT (CpuMpData->InitFlag != ApInitConfig);
964 *(UINT32 *) CpuData->StartupApSignal = WAKEUP_AP_SIGNAL;
965 if (ResetVectorRequired) {
966 CpuInfoInHob = (CPU_INFO_IN_HOB *) (UINTN) CpuMpData->CpuInfoInHob;
967 SendInitSipiSipi (
968 CpuInfoInHob[ProcessorNumber].ApicId,
969 (UINT32) ExchangeInfo->BufferStart
970 );
971 }
972 //
973 // Wait specified AP waken up
974 //
975 WaitApWakeup (CpuData->StartupApSignal);
976 }
977
978 if (ResetVectorRequired) {
979 FreeResetVector (CpuMpData);
980 }
981 }
982
983 /**
984 Calculate timeout value and return the current performance counter value.
985
986 Calculate the number of performance counter ticks required for a timeout.
987 If TimeoutInMicroseconds is 0, return value is also 0, which is recognized
988 as infinity.
989
990 @param[in] TimeoutInMicroseconds Timeout value in microseconds.
991 @param[out] CurrentTime Returns the current value of the performance counter.
992
993 @return Expected time stamp counter for timeout.
994 If TimeoutInMicroseconds is 0, return value is also 0, which is recognized
995 as infinity.
996
997 **/
998 UINT64
999 CalculateTimeout (
1000 IN UINTN TimeoutInMicroseconds,
1001 OUT UINT64 *CurrentTime
1002 )
1003 {
1004 UINT64 TimeoutInSeconds;
1005 UINT64 TimestampCounterFreq;
1006
1007 //
1008 // Read the current value of the performance counter
1009 //
1010 *CurrentTime = GetPerformanceCounter ();
1011
1012 //
1013 // If TimeoutInMicroseconds is 0, return value is also 0, which is recognized
1014 // as infinity.
1015 //
1016 if (TimeoutInMicroseconds == 0) {
1017 return 0;
1018 }
1019
1020 //
1021 // GetPerformanceCounterProperties () returns the timestamp counter's frequency
1022 // in Hz.
1023 //
1024 TimestampCounterFreq = GetPerformanceCounterProperties (NULL, NULL);
1025
1026 //
1027 // Check the potential overflow before calculate the number of ticks for the timeout value.
1028 //
1029 if (DivU64x64Remainder (MAX_UINT64, TimeoutInMicroseconds, NULL) < TimestampCounterFreq) {
1030 //
1031 // Convert microseconds into seconds if direct multiplication overflows
1032 //
1033 TimeoutInSeconds = DivU64x32 (TimeoutInMicroseconds, 1000000);
1034 //
1035 // Assertion if the final tick count exceeds MAX_UINT64
1036 //
1037 ASSERT (DivU64x64Remainder (MAX_UINT64, TimeoutInSeconds, NULL) >= TimestampCounterFreq);
1038 return MultU64x64 (TimestampCounterFreq, TimeoutInSeconds);
1039 } else {
1040 //
1041 // No overflow case, multiply the return value with TimeoutInMicroseconds and then divide
1042 // it by 1,000,000, to get the number of ticks for the timeout value.
1043 //
1044 return DivU64x32 (
1045 MultU64x64 (
1046 TimestampCounterFreq,
1047 TimeoutInMicroseconds
1048 ),
1049 1000000
1050 );
1051 }
1052 }
1053
1054 /**
1055 Checks whether timeout expires.
1056
1057 Check whether the number of elapsed performance counter ticks required for
1058 a timeout condition has been reached.
1059 If Timeout is zero, which means infinity, return value is always FALSE.
1060
1061 @param[in, out] PreviousTime On input, the value of the performance counter
1062 when it was last read.
1063 On output, the current value of the performance
1064 counter
1065 @param[in] TotalTime The total amount of elapsed time in performance
1066 counter ticks.
1067 @param[in] Timeout The number of performance counter ticks required
1068 to reach a timeout condition.
1069
1070 @retval TRUE A timeout condition has been reached.
1071 @retval FALSE A timeout condition has not been reached.
1072
1073 **/
1074 BOOLEAN
1075 CheckTimeout (
1076 IN OUT UINT64 *PreviousTime,
1077 IN UINT64 *TotalTime,
1078 IN UINT64 Timeout
1079 )
1080 {
1081 UINT64 Start;
1082 UINT64 End;
1083 UINT64 CurrentTime;
1084 INT64 Delta;
1085 INT64 Cycle;
1086
1087 if (Timeout == 0) {
1088 return FALSE;
1089 }
1090 GetPerformanceCounterProperties (&Start, &End);
1091 Cycle = End - Start;
1092 if (Cycle < 0) {
1093 Cycle = -Cycle;
1094 }
1095 Cycle++;
1096 CurrentTime = GetPerformanceCounter();
1097 Delta = (INT64) (CurrentTime - *PreviousTime);
1098 if (Start > End) {
1099 Delta = -Delta;
1100 }
1101 if (Delta < 0) {
1102 Delta += Cycle;
1103 }
1104 *TotalTime += Delta;
1105 *PreviousTime = CurrentTime;
1106 if (*TotalTime > Timeout) {
1107 return TRUE;
1108 }
1109 return FALSE;
1110 }
1111
1112 /**
1113 Helper function that waits until the finished AP count reaches the specified
1114 limit, or the specified timeout elapses (whichever comes first).
1115
1116 @param[in] CpuMpData Pointer to CPU MP Data.
1117 @param[in] FinishedApLimit The number of finished APs to wait for.
1118 @param[in] TimeLimit The number of microseconds to wait for.
1119 **/
1120 VOID
1121 TimedWaitForApFinish (
1122 IN CPU_MP_DATA *CpuMpData,
1123 IN UINT32 FinishedApLimit,
1124 IN UINT32 TimeLimit
1125 )
1126 {
1127 //
1128 // CalculateTimeout() and CheckTimeout() consider a TimeLimit of 0
1129 // "infinity", so check for (TimeLimit == 0) explicitly.
1130 //
1131 if (TimeLimit == 0) {
1132 return;
1133 }
1134
1135 CpuMpData->TotalTime = 0;
1136 CpuMpData->ExpectedTime = CalculateTimeout (
1137 TimeLimit,
1138 &CpuMpData->CurrentTime
1139 );
1140 while (CpuMpData->FinishedCount < FinishedApLimit &&
1141 !CheckTimeout (
1142 &CpuMpData->CurrentTime,
1143 &CpuMpData->TotalTime,
1144 CpuMpData->ExpectedTime
1145 )) {
1146 CpuPause ();
1147 }
1148
1149 if (CpuMpData->FinishedCount >= FinishedApLimit) {
1150 DEBUG ((
1151 DEBUG_VERBOSE,
1152 "%a: reached FinishedApLimit=%u in %Lu microseconds\n",
1153 __FUNCTION__,
1154 FinishedApLimit,
1155 DivU64x64Remainder (
1156 MultU64x32 (CpuMpData->TotalTime, 1000000),
1157 GetPerformanceCounterProperties (NULL, NULL),
1158 NULL
1159 )
1160 ));
1161 }
1162 }
1163
1164 /**
1165 Reset an AP to Idle state.
1166
1167 Any task being executed by the AP will be aborted and the AP
1168 will be waiting for a new task in Wait-For-SIPI state.
1169
1170 @param[in] ProcessorNumber The handle number of processor.
1171 **/
1172 VOID
1173 ResetProcessorToIdleState (
1174 IN UINTN ProcessorNumber
1175 )
1176 {
1177 CPU_MP_DATA *CpuMpData;
1178
1179 CpuMpData = GetCpuMpData ();
1180
1181 CpuMpData->InitFlag = ApInitReconfig;
1182 WakeUpAP (CpuMpData, FALSE, ProcessorNumber, NULL, NULL);
1183 while (CpuMpData->FinishedCount < 1) {
1184 CpuPause ();
1185 }
1186 CpuMpData->InitFlag = ApInitDone;
1187
1188 SetApState (&CpuMpData->CpuData[ProcessorNumber], CpuStateIdle);
1189 }
1190
1191 /**
1192 Searches for the next waiting AP.
1193
1194 Search for the next AP that is put in waiting state by single-threaded StartupAllAPs().
1195
1196 @param[out] NextProcessorNumber Pointer to the processor number of the next waiting AP.
1197
1198 @retval EFI_SUCCESS The next waiting AP has been found.
1199 @retval EFI_NOT_FOUND No waiting AP exists.
1200
1201 **/
1202 EFI_STATUS
1203 GetNextWaitingProcessorNumber (
1204 OUT UINTN *NextProcessorNumber
1205 )
1206 {
1207 UINTN ProcessorNumber;
1208 CPU_MP_DATA *CpuMpData;
1209
1210 CpuMpData = GetCpuMpData ();
1211
1212 for (ProcessorNumber = 0; ProcessorNumber < CpuMpData->CpuCount; ProcessorNumber++) {
1213 if (CpuMpData->CpuData[ProcessorNumber].Waiting) {
1214 *NextProcessorNumber = ProcessorNumber;
1215 return EFI_SUCCESS;
1216 }
1217 }
1218
1219 return EFI_NOT_FOUND;
1220 }
1221
1222 /** Checks status of specified AP.
1223
1224 This function checks whether the specified AP has finished the task assigned
1225 by StartupThisAP(), and whether timeout expires.
1226
1227 @param[in] ProcessorNumber The handle number of processor.
1228
1229 @retval EFI_SUCCESS Specified AP has finished task assigned by StartupThisAPs().
1230 @retval EFI_TIMEOUT The timeout expires.
1231 @retval EFI_NOT_READY Specified AP has not finished task and timeout has not expired.
1232 **/
1233 EFI_STATUS
1234 CheckThisAP (
1235 IN UINTN ProcessorNumber
1236 )
1237 {
1238 CPU_MP_DATA *CpuMpData;
1239 CPU_AP_DATA *CpuData;
1240
1241 CpuMpData = GetCpuMpData ();
1242 CpuData = &CpuMpData->CpuData[ProcessorNumber];
1243
1244 //
1245 // Check the CPU state of AP. If it is CpuStateFinished, then the AP has finished its task.
1246 // Only BSP and corresponding AP access this unit of CPU Data. This means the AP will not modify the
1247 // value of state after setting the it to CpuStateFinished, so BSP can safely make use of its value.
1248 //
1249 //
1250 // If the AP finishes for StartupThisAP(), return EFI_SUCCESS.
1251 //
1252 if (GetApState(CpuData) == CpuStateFinished) {
1253 if (CpuData->Finished != NULL) {
1254 *(CpuData->Finished) = TRUE;
1255 }
1256 SetApState (CpuData, CpuStateIdle);
1257 return EFI_SUCCESS;
1258 } else {
1259 //
1260 // If timeout expires for StartupThisAP(), report timeout.
1261 //
1262 if (CheckTimeout (&CpuData->CurrentTime, &CpuData->TotalTime, CpuData->ExpectedTime)) {
1263 if (CpuData->Finished != NULL) {
1264 *(CpuData->Finished) = FALSE;
1265 }
1266 //
1267 // Reset failed AP to idle state
1268 //
1269 ResetProcessorToIdleState (ProcessorNumber);
1270
1271 return EFI_TIMEOUT;
1272 }
1273 }
1274 return EFI_NOT_READY;
1275 }
1276
1277 /**
1278 Checks status of all APs.
1279
1280 This function checks whether all APs have finished task assigned by StartupAllAPs(),
1281 and whether timeout expires.
1282
1283 @retval EFI_SUCCESS All APs have finished task assigned by StartupAllAPs().
1284 @retval EFI_TIMEOUT The timeout expires.
1285 @retval EFI_NOT_READY APs have not finished task and timeout has not expired.
1286 **/
1287 EFI_STATUS
1288 CheckAllAPs (
1289 VOID
1290 )
1291 {
1292 UINTN ProcessorNumber;
1293 UINTN NextProcessorNumber;
1294 UINTN ListIndex;
1295 EFI_STATUS Status;
1296 CPU_MP_DATA *CpuMpData;
1297 CPU_AP_DATA *CpuData;
1298
1299 CpuMpData = GetCpuMpData ();
1300
1301 NextProcessorNumber = 0;
1302
1303 //
1304 // Go through all APs that are responsible for the StartupAllAPs().
1305 //
1306 for (ProcessorNumber = 0; ProcessorNumber < CpuMpData->CpuCount; ProcessorNumber++) {
1307 if (!CpuMpData->CpuData[ProcessorNumber].Waiting) {
1308 continue;
1309 }
1310
1311 CpuData = &CpuMpData->CpuData[ProcessorNumber];
1312 //
1313 // Check the CPU state of AP. If it is CpuStateFinished, then the AP has finished its task.
1314 // Only BSP and corresponding AP access this unit of CPU Data. This means the AP will not modify the
1315 // value of state after setting the it to CpuStateFinished, so BSP can safely make use of its value.
1316 //
1317 if (GetApState(CpuData) == CpuStateFinished) {
1318 CpuMpData->RunningCount ++;
1319 CpuMpData->CpuData[ProcessorNumber].Waiting = FALSE;
1320 SetApState(CpuData, CpuStateIdle);
1321
1322 //
1323 // If in Single Thread mode, then search for the next waiting AP for execution.
1324 //
1325 if (CpuMpData->SingleThread) {
1326 Status = GetNextWaitingProcessorNumber (&NextProcessorNumber);
1327
1328 if (!EFI_ERROR (Status)) {
1329 WakeUpAP (
1330 CpuMpData,
1331 FALSE,
1332 (UINT32) NextProcessorNumber,
1333 CpuMpData->Procedure,
1334 CpuMpData->ProcArguments
1335 );
1336 }
1337 }
1338 }
1339 }
1340
1341 //
1342 // If all APs finish, return EFI_SUCCESS.
1343 //
1344 if (CpuMpData->RunningCount == CpuMpData->StartCount) {
1345 return EFI_SUCCESS;
1346 }
1347
1348 //
1349 // If timeout expires, report timeout.
1350 //
1351 if (CheckTimeout (
1352 &CpuMpData->CurrentTime,
1353 &CpuMpData->TotalTime,
1354 CpuMpData->ExpectedTime)
1355 ) {
1356 //
1357 // If FailedCpuList is not NULL, record all failed APs in it.
1358 //
1359 if (CpuMpData->FailedCpuList != NULL) {
1360 *CpuMpData->FailedCpuList =
1361 AllocatePool ((CpuMpData->StartCount - CpuMpData->FinishedCount + 1) * sizeof (UINTN));
1362 ASSERT (*CpuMpData->FailedCpuList != NULL);
1363 }
1364 ListIndex = 0;
1365
1366 for (ProcessorNumber = 0; ProcessorNumber < CpuMpData->CpuCount; ProcessorNumber++) {
1367 //
1368 // Check whether this processor is responsible for StartupAllAPs().
1369 //
1370 if (CpuMpData->CpuData[ProcessorNumber].Waiting) {
1371 //
1372 // Reset failed APs to idle state
1373 //
1374 ResetProcessorToIdleState (ProcessorNumber);
1375 CpuMpData->CpuData[ProcessorNumber].Waiting = FALSE;
1376 if (CpuMpData->FailedCpuList != NULL) {
1377 (*CpuMpData->FailedCpuList)[ListIndex++] = ProcessorNumber;
1378 }
1379 }
1380 }
1381 if (CpuMpData->FailedCpuList != NULL) {
1382 (*CpuMpData->FailedCpuList)[ListIndex] = END_OF_CPU_LIST;
1383 }
1384 return EFI_TIMEOUT;
1385 }
1386 return EFI_NOT_READY;
1387 }
1388
1389 /**
1390 MP Initialize Library initialization.
1391
1392 This service will allocate AP reset vector and wakeup all APs to do APs
1393 initialization.
1394
1395 This service must be invoked before all other MP Initialize Library
1396 service are invoked.
1397
1398 @retval EFI_SUCCESS MP initialization succeeds.
1399 @retval Others MP initialization fails.
1400
1401 **/
1402 EFI_STATUS
1403 EFIAPI
1404 MpInitLibInitialize (
1405 VOID
1406 )
1407 {
1408 CPU_MP_DATA *OldCpuMpData;
1409 CPU_INFO_IN_HOB *CpuInfoInHob;
1410 UINT32 MaxLogicalProcessorNumber;
1411 UINT32 ApStackSize;
1412 MP_ASSEMBLY_ADDRESS_MAP AddressMap;
1413 UINTN BufferSize;
1414 UINT32 MonitorFilterSize;
1415 VOID *MpBuffer;
1416 UINTN Buffer;
1417 CPU_MP_DATA *CpuMpData;
1418 UINT8 ApLoopMode;
1419 UINT8 *MonitorBuffer;
1420 UINTN Index;
1421 UINTN ApResetVectorSize;
1422 UINTN BackupBufferAddr;
1423
1424 OldCpuMpData = GetCpuMpDataFromGuidedHob ();
1425 if (OldCpuMpData == NULL) {
1426 MaxLogicalProcessorNumber = PcdGet32(PcdCpuMaxLogicalProcessorNumber);
1427 } else {
1428 MaxLogicalProcessorNumber = OldCpuMpData->CpuCount;
1429 }
1430 ASSERT (MaxLogicalProcessorNumber != 0);
1431
1432 AsmGetAddressMap (&AddressMap);
1433 ApResetVectorSize = AddressMap.RendezvousFunnelSize + sizeof (MP_CPU_EXCHANGE_INFO);
1434 ApStackSize = PcdGet32(PcdCpuApStackSize);
1435 ApLoopMode = GetApLoopMode (&MonitorFilterSize);
1436
1437 BufferSize = ApStackSize * MaxLogicalProcessorNumber;
1438 BufferSize += MonitorFilterSize * MaxLogicalProcessorNumber;
1439 BufferSize += sizeof (CPU_MP_DATA);
1440 BufferSize += ApResetVectorSize;
1441 BufferSize += (sizeof (CPU_AP_DATA) + sizeof (CPU_INFO_IN_HOB))* MaxLogicalProcessorNumber;
1442 MpBuffer = AllocatePages (EFI_SIZE_TO_PAGES (BufferSize));
1443 ASSERT (MpBuffer != NULL);
1444 ZeroMem (MpBuffer, BufferSize);
1445 Buffer = (UINTN) MpBuffer;
1446
1447 MonitorBuffer = (UINT8 *) (Buffer + ApStackSize * MaxLogicalProcessorNumber);
1448 BackupBufferAddr = (UINTN) MonitorBuffer + MonitorFilterSize * MaxLogicalProcessorNumber;
1449 CpuMpData = (CPU_MP_DATA *) (BackupBufferAddr + ApResetVectorSize);
1450 CpuMpData->Buffer = Buffer;
1451 CpuMpData->CpuApStackSize = ApStackSize;
1452 CpuMpData->BackupBuffer = BackupBufferAddr;
1453 CpuMpData->BackupBufferSize = ApResetVectorSize;
1454 CpuMpData->WakeupBuffer = (UINTN) -1;
1455 CpuMpData->CpuCount = 1;
1456 CpuMpData->BspNumber = 0;
1457 CpuMpData->WaitEvent = NULL;
1458 CpuMpData->SwitchBspFlag = FALSE;
1459 CpuMpData->CpuData = (CPU_AP_DATA *) (CpuMpData + 1);
1460 CpuMpData->CpuInfoInHob = (UINT64) (UINTN) (CpuMpData->CpuData + MaxLogicalProcessorNumber);
1461 CpuMpData->MicrocodePatchAddress = PcdGet64 (PcdCpuMicrocodePatchAddress);
1462 CpuMpData->MicrocodePatchRegionSize = PcdGet64 (PcdCpuMicrocodePatchRegionSize);
1463 InitializeSpinLock(&CpuMpData->MpLock);
1464 //
1465 // Save BSP's Control registers to APs
1466 //
1467 SaveVolatileRegisters (&CpuMpData->CpuData[0].VolatileRegisters);
1468 //
1469 // Set BSP basic information
1470 //
1471 InitializeApData (CpuMpData, 0, 0, CpuMpData->Buffer);
1472 //
1473 // Save assembly code information
1474 //
1475 CopyMem (&CpuMpData->AddressMap, &AddressMap, sizeof (MP_ASSEMBLY_ADDRESS_MAP));
1476 //
1477 // Finally set AP loop mode
1478 //
1479 CpuMpData->ApLoopMode = ApLoopMode;
1480 DEBUG ((DEBUG_INFO, "AP Loop Mode is %d\n", CpuMpData->ApLoopMode));
1481 //
1482 // Set up APs wakeup signal buffer
1483 //
1484 for (Index = 0; Index < MaxLogicalProcessorNumber; Index++) {
1485 CpuMpData->CpuData[Index].StartupApSignal =
1486 (UINT32 *)(MonitorBuffer + MonitorFilterSize * Index);
1487 }
1488 //
1489 // Load Microcode on BSP
1490 //
1491 MicrocodeDetect (CpuMpData);
1492 //
1493 // Store BSP's MTRR setting
1494 //
1495 MtrrGetAllMtrrs (&CpuMpData->MtrrTable);
1496 //
1497 // Enable the local APIC for Virtual Wire Mode.
1498 //
1499 ProgramVirtualWireMode ();
1500
1501 if (OldCpuMpData == NULL) {
1502 if (MaxLogicalProcessorNumber > 1) {
1503 //
1504 // Wakeup all APs and calculate the processor count in system
1505 //
1506 CollectProcessorCount (CpuMpData);
1507 }
1508 } else {
1509 //
1510 // APs have been wakeup before, just get the CPU Information
1511 // from HOB
1512 //
1513 CpuMpData->CpuCount = OldCpuMpData->CpuCount;
1514 CpuMpData->BspNumber = OldCpuMpData->BspNumber;
1515 CpuMpData->InitFlag = ApInitReconfig;
1516 CpuMpData->CpuInfoInHob = OldCpuMpData->CpuInfoInHob;
1517 CpuInfoInHob = (CPU_INFO_IN_HOB *) (UINTN) CpuMpData->CpuInfoInHob;
1518 for (Index = 0; Index < CpuMpData->CpuCount; Index++) {
1519 InitializeSpinLock(&CpuMpData->CpuData[Index].ApLock);
1520 if (CpuInfoInHob[Index].InitialApicId >= 255 || Index > 254) {
1521 CpuMpData->X2ApicEnable = TRUE;
1522 }
1523 CpuMpData->CpuData[Index].CpuHealthy = (CpuInfoInHob[Index].Health == 0)? TRUE:FALSE;
1524 CpuMpData->CpuData[Index].ApFunction = 0;
1525 CopyMem (
1526 &CpuMpData->CpuData[Index].VolatileRegisters,
1527 &CpuMpData->CpuData[0].VolatileRegisters,
1528 sizeof (CPU_VOLATILE_REGISTERS)
1529 );
1530 }
1531 if (MaxLogicalProcessorNumber > 1) {
1532 //
1533 // Wakeup APs to do some AP initialize sync
1534 //
1535 WakeUpAP (CpuMpData, TRUE, 0, ApInitializeSync, CpuMpData);
1536 //
1537 // Wait for all APs finished initialization
1538 //
1539 while (CpuMpData->FinishedCount < (CpuMpData->CpuCount - 1)) {
1540 CpuPause ();
1541 }
1542 CpuMpData->InitFlag = ApInitDone;
1543 for (Index = 0; Index < CpuMpData->CpuCount; Index++) {
1544 SetApState (&CpuMpData->CpuData[Index], CpuStateIdle);
1545 }
1546 }
1547 }
1548
1549 //
1550 // Initialize global data for MP support
1551 //
1552 InitMpGlobalData (CpuMpData);
1553
1554 return EFI_SUCCESS;
1555 }
1556
1557 /**
1558 Gets detailed MP-related information on the requested processor at the
1559 instant this call is made. This service may only be called from the BSP.
1560
1561 @param[in] ProcessorNumber The handle number of processor.
1562 @param[out] ProcessorInfoBuffer A pointer to the buffer where information for
1563 the requested processor is deposited.
1564 @param[out] HealthData Return processor health data.
1565
1566 @retval EFI_SUCCESS Processor information was returned.
1567 @retval EFI_DEVICE_ERROR The calling processor is an AP.
1568 @retval EFI_INVALID_PARAMETER ProcessorInfoBuffer is NULL.
1569 @retval EFI_NOT_FOUND The processor with the handle specified by
1570 ProcessorNumber does not exist in the platform.
1571 @retval EFI_NOT_READY MP Initialize Library is not initialized.
1572
1573 **/
1574 EFI_STATUS
1575 EFIAPI
1576 MpInitLibGetProcessorInfo (
1577 IN UINTN ProcessorNumber,
1578 OUT EFI_PROCESSOR_INFORMATION *ProcessorInfoBuffer,
1579 OUT EFI_HEALTH_FLAGS *HealthData OPTIONAL
1580 )
1581 {
1582 CPU_MP_DATA *CpuMpData;
1583 UINTN CallerNumber;
1584 CPU_INFO_IN_HOB *CpuInfoInHob;
1585
1586 CpuMpData = GetCpuMpData ();
1587 CpuInfoInHob = (CPU_INFO_IN_HOB *) (UINTN) CpuMpData->CpuInfoInHob;
1588
1589 //
1590 // Check whether caller processor is BSP
1591 //
1592 MpInitLibWhoAmI (&CallerNumber);
1593 if (CallerNumber != CpuMpData->BspNumber) {
1594 return EFI_DEVICE_ERROR;
1595 }
1596
1597 if (ProcessorInfoBuffer == NULL) {
1598 return EFI_INVALID_PARAMETER;
1599 }
1600
1601 if (ProcessorNumber >= CpuMpData->CpuCount) {
1602 return EFI_NOT_FOUND;
1603 }
1604
1605 ProcessorInfoBuffer->ProcessorId = (UINT64) CpuInfoInHob[ProcessorNumber].ApicId;
1606 ProcessorInfoBuffer->StatusFlag = 0;
1607 if (ProcessorNumber == CpuMpData->BspNumber) {
1608 ProcessorInfoBuffer->StatusFlag |= PROCESSOR_AS_BSP_BIT;
1609 }
1610 if (CpuMpData->CpuData[ProcessorNumber].CpuHealthy) {
1611 ProcessorInfoBuffer->StatusFlag |= PROCESSOR_HEALTH_STATUS_BIT;
1612 }
1613 if (GetApState (&CpuMpData->CpuData[ProcessorNumber]) == CpuStateDisabled) {
1614 ProcessorInfoBuffer->StatusFlag &= ~PROCESSOR_ENABLED_BIT;
1615 } else {
1616 ProcessorInfoBuffer->StatusFlag |= PROCESSOR_ENABLED_BIT;
1617 }
1618
1619 //
1620 // Get processor location information
1621 //
1622 GetProcessorLocationByApicId (
1623 CpuInfoInHob[ProcessorNumber].ApicId,
1624 &ProcessorInfoBuffer->Location.Package,
1625 &ProcessorInfoBuffer->Location.Core,
1626 &ProcessorInfoBuffer->Location.Thread
1627 );
1628
1629 if (HealthData != NULL) {
1630 HealthData->Uint32 = CpuInfoInHob[ProcessorNumber].Health;
1631 }
1632
1633 return EFI_SUCCESS;
1634 }
1635
1636 /**
1637 Worker function to switch the requested AP to be the BSP from that point onward.
1638
1639 @param[in] ProcessorNumber The handle number of AP that is to become the new BSP.
1640 @param[in] EnableOldBSP If TRUE, then the old BSP will be listed as an
1641 enabled AP. Otherwise, it will be disabled.
1642
1643 @retval EFI_SUCCESS BSP successfully switched.
1644 @retval others Failed to switch BSP.
1645
1646 **/
1647 EFI_STATUS
1648 SwitchBSPWorker (
1649 IN UINTN ProcessorNumber,
1650 IN BOOLEAN EnableOldBSP
1651 )
1652 {
1653 CPU_MP_DATA *CpuMpData;
1654 UINTN CallerNumber;
1655 CPU_STATE State;
1656 MSR_IA32_APIC_BASE_REGISTER ApicBaseMsr;
1657 BOOLEAN OldInterruptState;
1658 BOOLEAN OldTimerInterruptState;
1659
1660 //
1661 // Save and Disable Local APIC timer interrupt
1662 //
1663 OldTimerInterruptState = GetApicTimerInterruptState ();
1664 DisableApicTimerInterrupt ();
1665 //
1666 // Before send both BSP and AP to a procedure to exchange their roles,
1667 // interrupt must be disabled. This is because during the exchange role
1668 // process, 2 CPU may use 1 stack. If interrupt happens, the stack will
1669 // be corrupted, since interrupt return address will be pushed to stack
1670 // by hardware.
1671 //
1672 OldInterruptState = SaveAndDisableInterrupts ();
1673
1674 //
1675 // Mask LINT0 & LINT1 for the old BSP
1676 //
1677 DisableLvtInterrupts ();
1678
1679 CpuMpData = GetCpuMpData ();
1680
1681 //
1682 // Check whether caller processor is BSP
1683 //
1684 MpInitLibWhoAmI (&CallerNumber);
1685 if (CallerNumber != CpuMpData->BspNumber) {
1686 return EFI_DEVICE_ERROR;
1687 }
1688
1689 if (ProcessorNumber >= CpuMpData->CpuCount) {
1690 return EFI_NOT_FOUND;
1691 }
1692
1693 //
1694 // Check whether specified AP is disabled
1695 //
1696 State = GetApState (&CpuMpData->CpuData[ProcessorNumber]);
1697 if (State == CpuStateDisabled) {
1698 return EFI_INVALID_PARAMETER;
1699 }
1700
1701 //
1702 // Check whether ProcessorNumber specifies the current BSP
1703 //
1704 if (ProcessorNumber == CpuMpData->BspNumber) {
1705 return EFI_INVALID_PARAMETER;
1706 }
1707
1708 //
1709 // Check whether specified AP is busy
1710 //
1711 if (State == CpuStateBusy) {
1712 return EFI_NOT_READY;
1713 }
1714
1715 CpuMpData->BSPInfo.State = CPU_SWITCH_STATE_IDLE;
1716 CpuMpData->APInfo.State = CPU_SWITCH_STATE_IDLE;
1717 CpuMpData->SwitchBspFlag = TRUE;
1718 CpuMpData->NewBspNumber = ProcessorNumber;
1719
1720 //
1721 // Clear the BSP bit of MSR_IA32_APIC_BASE
1722 //
1723 ApicBaseMsr.Uint64 = AsmReadMsr64 (MSR_IA32_APIC_BASE);
1724 ApicBaseMsr.Bits.BSP = 0;
1725 AsmWriteMsr64 (MSR_IA32_APIC_BASE, ApicBaseMsr.Uint64);
1726
1727 //
1728 // Need to wakeUp AP (future BSP).
1729 //
1730 WakeUpAP (CpuMpData, FALSE, ProcessorNumber, FutureBSPProc, CpuMpData);
1731
1732 AsmExchangeRole (&CpuMpData->BSPInfo, &CpuMpData->APInfo);
1733
1734 //
1735 // Set the BSP bit of MSR_IA32_APIC_BASE on new BSP
1736 //
1737 ApicBaseMsr.Uint64 = AsmReadMsr64 (MSR_IA32_APIC_BASE);
1738 ApicBaseMsr.Bits.BSP = 1;
1739 AsmWriteMsr64 (MSR_IA32_APIC_BASE, ApicBaseMsr.Uint64);
1740
1741 //
1742 // Wait for old BSP finished AP task
1743 //
1744 while (GetApState (&CpuMpData->CpuData[CallerNumber]) != CpuStateFinished) {
1745 CpuPause ();
1746 }
1747
1748 CpuMpData->SwitchBspFlag = FALSE;
1749 //
1750 // Set old BSP enable state
1751 //
1752 if (!EnableOldBSP) {
1753 SetApState (&CpuMpData->CpuData[CallerNumber], CpuStateDisabled);
1754 } else {
1755 SetApState (&CpuMpData->CpuData[CallerNumber], CpuStateIdle);
1756 }
1757 //
1758 // Save new BSP number
1759 //
1760 CpuMpData->BspNumber = (UINT32) ProcessorNumber;
1761
1762 //
1763 // Restore interrupt state.
1764 //
1765 SetInterruptState (OldInterruptState);
1766
1767 if (OldTimerInterruptState) {
1768 EnableApicTimerInterrupt ();
1769 }
1770
1771 return EFI_SUCCESS;
1772 }
1773
1774 /**
1775 Worker function to let the caller enable or disable an AP from this point onward.
1776 This service may only be called from the BSP.
1777
1778 @param[in] ProcessorNumber The handle number of AP.
1779 @param[in] EnableAP Specifies the new state for the processor for
1780 enabled, FALSE for disabled.
1781 @param[in] HealthFlag If not NULL, a pointer to a value that specifies
1782 the new health status of the AP.
1783
1784 @retval EFI_SUCCESS The specified AP was enabled or disabled successfully.
1785 @retval others Failed to Enable/Disable AP.
1786
1787 **/
1788 EFI_STATUS
1789 EnableDisableApWorker (
1790 IN UINTN ProcessorNumber,
1791 IN BOOLEAN EnableAP,
1792 IN UINT32 *HealthFlag OPTIONAL
1793 )
1794 {
1795 CPU_MP_DATA *CpuMpData;
1796 UINTN CallerNumber;
1797
1798 CpuMpData = GetCpuMpData ();
1799
1800 //
1801 // Check whether caller processor is BSP
1802 //
1803 MpInitLibWhoAmI (&CallerNumber);
1804 if (CallerNumber != CpuMpData->BspNumber) {
1805 return EFI_DEVICE_ERROR;
1806 }
1807
1808 if (ProcessorNumber == CpuMpData->BspNumber) {
1809 return EFI_INVALID_PARAMETER;
1810 }
1811
1812 if (ProcessorNumber >= CpuMpData->CpuCount) {
1813 return EFI_NOT_FOUND;
1814 }
1815
1816 if (!EnableAP) {
1817 SetApState (&CpuMpData->CpuData[ProcessorNumber], CpuStateDisabled);
1818 } else {
1819 ResetProcessorToIdleState (ProcessorNumber);
1820 }
1821
1822 if (HealthFlag != NULL) {
1823 CpuMpData->CpuData[ProcessorNumber].CpuHealthy =
1824 (BOOLEAN) ((*HealthFlag & PROCESSOR_HEALTH_STATUS_BIT) != 0);
1825 }
1826
1827 return EFI_SUCCESS;
1828 }
1829
1830 /**
1831 This return the handle number for the calling processor. This service may be
1832 called from the BSP and APs.
1833
1834 @param[out] ProcessorNumber Pointer to the handle number of AP.
1835 The range is from 0 to the total number of
1836 logical processors minus 1. The total number of
1837 logical processors can be retrieved by
1838 MpInitLibGetNumberOfProcessors().
1839
1840 @retval EFI_SUCCESS The current processor handle number was returned
1841 in ProcessorNumber.
1842 @retval EFI_INVALID_PARAMETER ProcessorNumber is NULL.
1843 @retval EFI_NOT_READY MP Initialize Library is not initialized.
1844
1845 **/
1846 EFI_STATUS
1847 EFIAPI
1848 MpInitLibWhoAmI (
1849 OUT UINTN *ProcessorNumber
1850 )
1851 {
1852 CPU_MP_DATA *CpuMpData;
1853
1854 if (ProcessorNumber == NULL) {
1855 return EFI_INVALID_PARAMETER;
1856 }
1857
1858 CpuMpData = GetCpuMpData ();
1859
1860 return GetProcessorNumber (CpuMpData, ProcessorNumber);
1861 }
1862
1863 /**
1864 Retrieves the number of logical processor in the platform and the number of
1865 those logical processors that are enabled on this boot. This service may only
1866 be called from the BSP.
1867
1868 @param[out] NumberOfProcessors Pointer to the total number of logical
1869 processors in the system, including the BSP
1870 and disabled APs.
1871 @param[out] NumberOfEnabledProcessors Pointer to the number of enabled logical
1872 processors that exist in system, including
1873 the BSP.
1874
1875 @retval EFI_SUCCESS The number of logical processors and enabled
1876 logical processors was retrieved.
1877 @retval EFI_DEVICE_ERROR The calling processor is an AP.
1878 @retval EFI_INVALID_PARAMETER NumberOfProcessors is NULL and NumberOfEnabledProcessors
1879 is NULL.
1880 @retval EFI_NOT_READY MP Initialize Library is not initialized.
1881
1882 **/
1883 EFI_STATUS
1884 EFIAPI
1885 MpInitLibGetNumberOfProcessors (
1886 OUT UINTN *NumberOfProcessors, OPTIONAL
1887 OUT UINTN *NumberOfEnabledProcessors OPTIONAL
1888 )
1889 {
1890 CPU_MP_DATA *CpuMpData;
1891 UINTN CallerNumber;
1892 UINTN ProcessorNumber;
1893 UINTN EnabledProcessorNumber;
1894 UINTN Index;
1895
1896 CpuMpData = GetCpuMpData ();
1897
1898 if ((NumberOfProcessors == NULL) && (NumberOfEnabledProcessors == NULL)) {
1899 return EFI_INVALID_PARAMETER;
1900 }
1901
1902 //
1903 // Check whether caller processor is BSP
1904 //
1905 MpInitLibWhoAmI (&CallerNumber);
1906 if (CallerNumber != CpuMpData->BspNumber) {
1907 return EFI_DEVICE_ERROR;
1908 }
1909
1910 ProcessorNumber = CpuMpData->CpuCount;
1911 EnabledProcessorNumber = 0;
1912 for (Index = 0; Index < ProcessorNumber; Index++) {
1913 if (GetApState (&CpuMpData->CpuData[Index]) != CpuStateDisabled) {
1914 EnabledProcessorNumber ++;
1915 }
1916 }
1917
1918 if (NumberOfProcessors != NULL) {
1919 *NumberOfProcessors = ProcessorNumber;
1920 }
1921 if (NumberOfEnabledProcessors != NULL) {
1922 *NumberOfEnabledProcessors = EnabledProcessorNumber;
1923 }
1924
1925 return EFI_SUCCESS;
1926 }
1927
1928
1929 /**
1930 Worker function to execute a caller provided function on all enabled APs.
1931
1932 @param[in] Procedure A pointer to the function to be run on
1933 enabled APs of the system.
1934 @param[in] SingleThread If TRUE, then all the enabled APs execute
1935 the function specified by Procedure one by
1936 one, in ascending order of processor handle
1937 number. If FALSE, then all the enabled APs
1938 execute the function specified by Procedure
1939 simultaneously.
1940 @param[in] WaitEvent The event created by the caller with CreateEvent()
1941 service.
1942 @param[in] TimeoutInMicroseconds Indicates the time limit in microseconds for
1943 APs to return from Procedure, either for
1944 blocking or non-blocking mode.
1945 @param[in] ProcedureArgument The parameter passed into Procedure for
1946 all APs.
1947 @param[out] FailedCpuList If all APs finish successfully, then its
1948 content is set to NULL. If not all APs
1949 finish before timeout expires, then its
1950 content is set to address of the buffer
1951 holding handle numbers of the failed APs.
1952
1953 @retval EFI_SUCCESS In blocking mode, all APs have finished before
1954 the timeout expired.
1955 @retval EFI_SUCCESS In non-blocking mode, function has been dispatched
1956 to all enabled APs.
1957 @retval others Failed to Startup all APs.
1958
1959 **/
1960 EFI_STATUS
1961 StartupAllAPsWorker (
1962 IN EFI_AP_PROCEDURE Procedure,
1963 IN BOOLEAN SingleThread,
1964 IN EFI_EVENT WaitEvent OPTIONAL,
1965 IN UINTN TimeoutInMicroseconds,
1966 IN VOID *ProcedureArgument OPTIONAL,
1967 OUT UINTN **FailedCpuList OPTIONAL
1968 )
1969 {
1970 EFI_STATUS Status;
1971 CPU_MP_DATA *CpuMpData;
1972 UINTN ProcessorCount;
1973 UINTN ProcessorNumber;
1974 UINTN CallerNumber;
1975 CPU_AP_DATA *CpuData;
1976 BOOLEAN HasEnabledAp;
1977 CPU_STATE ApState;
1978
1979 CpuMpData = GetCpuMpData ();
1980
1981 if (FailedCpuList != NULL) {
1982 *FailedCpuList = NULL;
1983 }
1984
1985 if (CpuMpData->CpuCount == 1) {
1986 return EFI_NOT_STARTED;
1987 }
1988
1989 if (Procedure == NULL) {
1990 return EFI_INVALID_PARAMETER;
1991 }
1992
1993 //
1994 // Check whether caller processor is BSP
1995 //
1996 MpInitLibWhoAmI (&CallerNumber);
1997 if (CallerNumber != CpuMpData->BspNumber) {
1998 return EFI_DEVICE_ERROR;
1999 }
2000
2001 //
2002 // Update AP state
2003 //
2004 CheckAndUpdateApsStatus ();
2005
2006 ProcessorCount = CpuMpData->CpuCount;
2007 HasEnabledAp = FALSE;
2008 //
2009 // Check whether all enabled APs are idle.
2010 // If any enabled AP is not idle, return EFI_NOT_READY.
2011 //
2012 for (ProcessorNumber = 0; ProcessorNumber < ProcessorCount; ProcessorNumber++) {
2013 CpuData = &CpuMpData->CpuData[ProcessorNumber];
2014 if (ProcessorNumber != CpuMpData->BspNumber) {
2015 ApState = GetApState (CpuData);
2016 if (ApState != CpuStateDisabled) {
2017 HasEnabledAp = TRUE;
2018 if (ApState != CpuStateIdle) {
2019 //
2020 // If any enabled APs are busy, return EFI_NOT_READY.
2021 //
2022 return EFI_NOT_READY;
2023 }
2024 }
2025 }
2026 }
2027
2028 if (!HasEnabledAp) {
2029 //
2030 // If no enabled AP exists, return EFI_NOT_STARTED.
2031 //
2032 return EFI_NOT_STARTED;
2033 }
2034
2035 CpuMpData->StartCount = 0;
2036 for (ProcessorNumber = 0; ProcessorNumber < ProcessorCount; ProcessorNumber++) {
2037 CpuData = &CpuMpData->CpuData[ProcessorNumber];
2038 CpuData->Waiting = FALSE;
2039 if (ProcessorNumber != CpuMpData->BspNumber) {
2040 if (CpuData->State == CpuStateIdle) {
2041 //
2042 // Mark this processor as responsible for current calling.
2043 //
2044 CpuData->Waiting = TRUE;
2045 CpuMpData->StartCount++;
2046 }
2047 }
2048 }
2049
2050 CpuMpData->Procedure = Procedure;
2051 CpuMpData->ProcArguments = ProcedureArgument;
2052 CpuMpData->SingleThread = SingleThread;
2053 CpuMpData->FinishedCount = 0;
2054 CpuMpData->RunningCount = 0;
2055 CpuMpData->FailedCpuList = FailedCpuList;
2056 CpuMpData->ExpectedTime = CalculateTimeout (
2057 TimeoutInMicroseconds,
2058 &CpuMpData->CurrentTime
2059 );
2060 CpuMpData->TotalTime = 0;
2061 CpuMpData->WaitEvent = WaitEvent;
2062
2063 if (!SingleThread) {
2064 WakeUpAP (CpuMpData, TRUE, 0, Procedure, ProcedureArgument);
2065 } else {
2066 for (ProcessorNumber = 0; ProcessorNumber < ProcessorCount; ProcessorNumber++) {
2067 if (ProcessorNumber == CallerNumber) {
2068 continue;
2069 }
2070 if (CpuMpData->CpuData[ProcessorNumber].Waiting) {
2071 WakeUpAP (CpuMpData, FALSE, ProcessorNumber, Procedure, ProcedureArgument);
2072 break;
2073 }
2074 }
2075 }
2076
2077 Status = EFI_SUCCESS;
2078 if (WaitEvent == NULL) {
2079 do {
2080 Status = CheckAllAPs ();
2081 } while (Status == EFI_NOT_READY);
2082 }
2083
2084 return Status;
2085 }
2086
2087 /**
2088 Worker function to let the caller get one enabled AP to execute a caller-provided
2089 function.
2090
2091 @param[in] Procedure A pointer to the function to be run on
2092 enabled APs of the system.
2093 @param[in] ProcessorNumber The handle number of the AP.
2094 @param[in] WaitEvent The event created by the caller with CreateEvent()
2095 service.
2096 @param[in] TimeoutInMicroseconds Indicates the time limit in microseconds for
2097 APs to return from Procedure, either for
2098 blocking or non-blocking mode.
2099 @param[in] ProcedureArgument The parameter passed into Procedure for
2100 all APs.
2101 @param[out] Finished If AP returns from Procedure before the
2102 timeout expires, its content is set to TRUE.
2103 Otherwise, the value is set to FALSE.
2104
2105 @retval EFI_SUCCESS In blocking mode, specified AP finished before
2106 the timeout expires.
2107 @retval others Failed to Startup AP.
2108
2109 **/
2110 EFI_STATUS
2111 StartupThisAPWorker (
2112 IN EFI_AP_PROCEDURE Procedure,
2113 IN UINTN ProcessorNumber,
2114 IN EFI_EVENT WaitEvent OPTIONAL,
2115 IN UINTN TimeoutInMicroseconds,
2116 IN VOID *ProcedureArgument OPTIONAL,
2117 OUT BOOLEAN *Finished OPTIONAL
2118 )
2119 {
2120 EFI_STATUS Status;
2121 CPU_MP_DATA *CpuMpData;
2122 CPU_AP_DATA *CpuData;
2123 UINTN CallerNumber;
2124
2125 CpuMpData = GetCpuMpData ();
2126
2127 if (Finished != NULL) {
2128 *Finished = FALSE;
2129 }
2130
2131 //
2132 // Check whether caller processor is BSP
2133 //
2134 MpInitLibWhoAmI (&CallerNumber);
2135 if (CallerNumber != CpuMpData->BspNumber) {
2136 return EFI_DEVICE_ERROR;
2137 }
2138
2139 //
2140 // Check whether processor with the handle specified by ProcessorNumber exists
2141 //
2142 if (ProcessorNumber >= CpuMpData->CpuCount) {
2143 return EFI_NOT_FOUND;
2144 }
2145
2146 //
2147 // Check whether specified processor is BSP
2148 //
2149 if (ProcessorNumber == CpuMpData->BspNumber) {
2150 return EFI_INVALID_PARAMETER;
2151 }
2152
2153 //
2154 // Check parameter Procedure
2155 //
2156 if (Procedure == NULL) {
2157 return EFI_INVALID_PARAMETER;
2158 }
2159
2160 //
2161 // Update AP state
2162 //
2163 CheckAndUpdateApsStatus ();
2164
2165 //
2166 // Check whether specified AP is disabled
2167 //
2168 if (GetApState (&CpuMpData->CpuData[ProcessorNumber]) == CpuStateDisabled) {
2169 return EFI_INVALID_PARAMETER;
2170 }
2171
2172 //
2173 // If WaitEvent is not NULL, execute in non-blocking mode.
2174 // BSP saves data for CheckAPsStatus(), and returns EFI_SUCCESS.
2175 // CheckAPsStatus() will check completion and timeout periodically.
2176 //
2177 CpuData = &CpuMpData->CpuData[ProcessorNumber];
2178 CpuData->WaitEvent = WaitEvent;
2179 CpuData->Finished = Finished;
2180 CpuData->ExpectedTime = CalculateTimeout (TimeoutInMicroseconds, &CpuData->CurrentTime);
2181 CpuData->TotalTime = 0;
2182
2183 WakeUpAP (CpuMpData, FALSE, ProcessorNumber, Procedure, ProcedureArgument);
2184
2185 //
2186 // If WaitEvent is NULL, execute in blocking mode.
2187 // BSP checks AP's state until it finishes or TimeoutInMicrosecsond expires.
2188 //
2189 Status = EFI_SUCCESS;
2190 if (WaitEvent == NULL) {
2191 do {
2192 Status = CheckThisAP (ProcessorNumber);
2193 } while (Status == EFI_NOT_READY);
2194 }
2195
2196 return Status;
2197 }
2198
2199 /**
2200 Get pointer to CPU MP Data structure from GUIDed HOB.
2201
2202 @return The pointer to CPU MP Data structure.
2203 **/
2204 CPU_MP_DATA *
2205 GetCpuMpDataFromGuidedHob (
2206 VOID
2207 )
2208 {
2209 EFI_HOB_GUID_TYPE *GuidHob;
2210 VOID *DataInHob;
2211 CPU_MP_DATA *CpuMpData;
2212
2213 CpuMpData = NULL;
2214 GuidHob = GetFirstGuidHob (&mCpuInitMpLibHobGuid);
2215 if (GuidHob != NULL) {
2216 DataInHob = GET_GUID_HOB_DATA (GuidHob);
2217 CpuMpData = (CPU_MP_DATA *) (*(UINTN *) DataInHob);
2218 }
2219 return CpuMpData;
2220 }
2221
EFI Development Kit II mirror for PVE