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