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


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