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