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