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