]> git.proxmox.com Git - mirror_edk2.git/blob - UefiCpuPkg/Library/MpInitLib/MpLib.c
projects / mirror_edk2.git / blob
? search:


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