2 Produces PI MP Services Protocol on top of Framework MP Services Protocol.
4 Intel's Framework MP Services Protocol is replaced by EFI_MP_SERVICES_PROTOCOL in PI 1.1.
5 This module produces PI MP Services Protocol on top of Framework MP Services Protocol.
7 Copyright (c) 2009 - 2010, Intel Corporation. All rights reserved.<BR>
8 This program and the accompanying materials
9 are licensed and made available under the terms and conditions of the BSD License
10 which accompanies this distribution. The full text of the license may be found at
11 http://opensource.org/licenses/bsd-license.php
13 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
14 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
19 #include "MpServicesOnFrameworkMpServicesThunk.h"
21 EFI_HANDLE mHandle
= NULL
;
22 MP_SYSTEM_DATA mMPSystemData
;
23 EFI_PHYSICAL_ADDRESS mStartupVector
;
24 MP_CPU_EXCHANGE_INFO
*mExchangeInfo
;
25 BOOLEAN mStopCheckAPsStatus
= FALSE
;
26 UINTN mNumberOfProcessors
;
27 EFI_GENERIC_MEMORY_TEST_PROTOCOL
*mGenMemoryTest
;
29 FRAMEWORK_EFI_MP_SERVICES_PROTOCOL
*mFrameworkMpService
;
30 EFI_MP_SERVICES_PROTOCOL mMpService
= {
31 GetNumberOfProcessors
,
42 Implementation of GetNumberOfProcessors() service of MP Services Protocol.
44 This service retrieves the number of logical processor in the platform
45 and the number of those logical processors that are enabled on this boot.
46 This service may only be called from the BSP.
48 @param This A pointer to the EFI_MP_SERVICES_PROTOCOL instance.
49 @param NumberOfProcessors Pointer to the total number of logical processors in the system,
50 including the BSP and disabled APs.
51 @param NumberOfEnabledProcessors Pointer to the number of enabled logical processors that exist
52 in system, including the BSP.
54 @retval EFI_SUCCESS Number of logical processors and enabled logical processors retrieved..
55 @retval EFI_DEVICE_ERROR Caller processor is AP.
56 @retval EFI_INVALID_PARAMETER NumberOfProcessors is NULL
57 @retval EFI_INVALID_PARAMETER NumberOfEnabledProcessors is NULL
62 GetNumberOfProcessors (
63 IN EFI_MP_SERVICES_PROTOCOL
*This
,
64 OUT UINTN
*NumberOfProcessors
,
65 OUT UINTN
*NumberOfEnabledProcessors
72 // Check whether caller processor is BSP
74 WhoAmI (This
, &CallerNumber
);
75 if (CallerNumber
!= GetBspNumber ()) {
76 return EFI_DEVICE_ERROR
;
80 // Check parameter NumberOfProcessors
82 if (NumberOfProcessors
== NULL
) {
83 return EFI_INVALID_PARAMETER
;
87 // Check parameter NumberOfEnabledProcessors
89 if (NumberOfEnabledProcessors
== NULL
) {
90 return EFI_INVALID_PARAMETER
;
93 Status
= mFrameworkMpService
->GetGeneralMPInfo (
97 NumberOfEnabledProcessors
,
101 ASSERT_EFI_ERROR (Status
);
107 Implementation of GetNumberOfProcessors() service of MP Services Protocol.
109 Gets detailed MP-related information on the requested processor at the
110 instant this call is made. This service may only be called from the BSP.
112 @param This A pointer to the EFI_MP_SERVICES_PROTOCOL instance.
113 @param ProcessorNumber The handle number of processor.
114 @param ProcessorInfoBuffer A pointer to the buffer where information for the requested processor is deposited.
116 @retval EFI_SUCCESS Processor information successfully returned.
117 @retval EFI_DEVICE_ERROR Caller processor is AP.
118 @retval EFI_INVALID_PARAMETER ProcessorInfoBuffer is NULL
119 @retval EFI_NOT_FOUND Processor with the handle specified by ProcessorNumber does not exist.
125 IN EFI_MP_SERVICES_PROTOCOL
*This
,
126 IN UINTN ProcessorNumber
,
127 OUT EFI_PROCESSOR_INFORMATION
*ProcessorInfoBuffer
133 EFI_MP_PROC_CONTEXT ProcessorContextBuffer
;
136 // Check whether caller processor is BSP
138 WhoAmI (This
, &CallerNumber
);
139 if (CallerNumber
!= GetBspNumber ()) {
140 return EFI_DEVICE_ERROR
;
144 // Check parameter ProcessorInfoBuffer
146 if (ProcessorInfoBuffer
== NULL
) {
147 return EFI_INVALID_PARAMETER
;
151 // Check whether processor with the handle specified by ProcessorNumber exists
153 if (ProcessorNumber
>= mNumberOfProcessors
) {
154 return EFI_NOT_FOUND
;
157 BufferSize
= sizeof (EFI_MP_PROC_CONTEXT
);
158 Status
= mFrameworkMpService
->GetProcessorContext (
162 &ProcessorContextBuffer
164 ASSERT_EFI_ERROR (Status
);
166 ProcessorInfoBuffer
->ProcessorId
= (UINT64
) ProcessorContextBuffer
.ApicID
;
169 // Get Status Flag of specified processor
171 ProcessorInfoBuffer
->StatusFlag
= 0;
173 if (ProcessorContextBuffer
.Enabled
) {
174 ProcessorInfoBuffer
->StatusFlag
|= PROCESSOR_ENABLED_BIT
;
177 if (ProcessorContextBuffer
.Designation
== EfiCpuBSP
) {
178 ProcessorInfoBuffer
->StatusFlag
|= PROCESSOR_AS_BSP_BIT
;
181 if (ProcessorContextBuffer
.Health
.Flags
.Uint32
== 0) {
182 ProcessorInfoBuffer
->StatusFlag
|= PROCESSOR_HEALTH_STATUS_BIT
;
185 ProcessorInfoBuffer
->Location
.Package
= (UINT32
) ProcessorContextBuffer
.PackageNumber
;
186 ProcessorInfoBuffer
->Location
.Core
= (UINT32
) ProcessorContextBuffer
.NumberOfCores
;
187 ProcessorInfoBuffer
->Location
.Thread
= (UINT32
) ProcessorContextBuffer
.NumberOfThreads
;
193 Implementation of StartupAllAPs() service of MP Services Protocol.
195 This service lets the caller get all enabled APs to execute a caller-provided function.
196 This service may only be called from the BSP.
198 @param This A pointer to the EFI_MP_SERVICES_PROTOCOL instance.
199 @param Procedure A pointer to the function to be run on enabled APs of the system.
200 @param SingleThread Indicates whether to execute the function simultaneously or one by one..
201 @param WaitEvent The event created by the caller.
202 If it is NULL, then execute in blocking mode.
203 If it is not NULL, then execute in non-blocking mode.
204 @param TimeoutInMicroSeconds The time limit in microseconds for this AP to finish the function.
206 @param ProcedureArgument Pointer to the optional parameter of the assigned function.
207 @param FailedCpuList The list of processor numbers that fail to finish the function before
208 TimeoutInMicrosecsond expires.
210 @retval EFI_SUCCESS In blocking mode, all APs have finished before the timeout expired.
211 @retval EFI_SUCCESS In non-blocking mode, function has been dispatched to all enabled APs.
212 @retval EFI_DEVICE_ERROR Caller processor is AP.
213 @retval EFI_NOT_STARTED No enabled AP exists in the system.
214 @retval EFI_NOT_READY Any enabled AP is busy.
215 @retval EFI_TIMEOUT In blocking mode, The timeout expired before all enabled APs have finished.
216 @retval EFI_INVALID_PARAMETER Procedure is NULL.
222 IN EFI_MP_SERVICES_PROTOCOL
*This
,
223 IN EFI_AP_PROCEDURE Procedure
,
224 IN BOOLEAN SingleThread
,
225 IN EFI_EVENT WaitEvent OPTIONAL
,
226 IN UINTN TimeoutInMicroSeconds
,
227 IN VOID
*ProcedureArgument OPTIONAL
,
228 OUT UINTN
**FailedCpuList OPTIONAL
232 UINTN ProcessorNumber
;
233 CPU_DATA_BLOCK
*CpuData
;
237 if (FailedCpuList
!= NULL
) {
238 *FailedCpuList
= NULL
;
242 // Check whether caller processor is BSP
244 BspNumber
= GetBspNumber ();
245 WhoAmI (This
, &ProcessorNumber
);
246 if (ProcessorNumber
!= BspNumber
) {
247 return EFI_DEVICE_ERROR
;
251 // Check parameter Procedure
253 if (Procedure
== NULL
) {
254 return EFI_INVALID_PARAMETER
;
258 // Temporarily suppress CheckAPsStatus()
260 mStopCheckAPsStatus
= TRUE
;
263 // Check whether all enabled APs are idle.
264 // If any enabled AP is not idle, return EFI_NOT_READY.
266 for (ProcessorNumber
= 0; ProcessorNumber
< mNumberOfProcessors
; ProcessorNumber
++) {
268 CpuData
= &mMPSystemData
.CpuData
[ProcessorNumber
];
270 mMPSystemData
.CpuList
[ProcessorNumber
] = FALSE
;
271 if (ProcessorNumber
!= BspNumber
) {
272 if (CpuData
->State
!= CpuStateDisabled
) {
273 if (CpuData
->State
!= CpuStateIdle
) {
274 mStopCheckAPsStatus
= FALSE
;
275 return EFI_NOT_READY
;
278 // Mark this processor as responsible for current calling.
280 mMPSystemData
.CpuList
[ProcessorNumber
] = TRUE
;
286 mMPSystemData
.FinishCount
= 0;
287 mMPSystemData
.StartCount
= 0;
290 // Go through all enabled APs to wakeup them for Procedure.
291 // If in Single Thread mode, then only one AP is woken up, and others are waiting.
293 for (ProcessorNumber
= 0; ProcessorNumber
< mNumberOfProcessors
; ProcessorNumber
++) {
295 CpuData
= &mMPSystemData
.CpuData
[ProcessorNumber
];
297 // Check whether this processor is responsible for current calling.
299 if (mMPSystemData
.CpuList
[ProcessorNumber
]) {
301 mMPSystemData
.StartCount
++;
303 AcquireSpinLock (&CpuData
->CpuDataLock
);
304 CpuData
->State
= CpuStateReady
;
305 ReleaseSpinLock (&CpuData
->CpuDataLock
);
322 // If no enabled AP exists, return EFI_NOT_STARTED.
324 if (mMPSystemData
.StartCount
== 0) {
325 mStopCheckAPsStatus
= FALSE
;
326 return EFI_NOT_STARTED
;
330 // If WaitEvent is not NULL, execute in non-blocking mode.
331 // BSP saves data for CheckAPsStatus(), and returns EFI_SUCCESS.
332 // CheckAPsStatus() will check completion and timeout periodically.
334 mMPSystemData
.Procedure
= Procedure
;
335 mMPSystemData
.ProcArguments
= ProcedureArgument
;
336 mMPSystemData
.SingleThread
= SingleThread
;
337 mMPSystemData
.FailedCpuList
= FailedCpuList
;
338 mMPSystemData
.ExpectedTime
= CalculateTimeout (TimeoutInMicroSeconds
, &mMPSystemData
.CurrentTime
);
339 mMPSystemData
.WaitEvent
= WaitEvent
;
342 // Allow CheckAPsStatus()
344 mStopCheckAPsStatus
= FALSE
;
346 if (WaitEvent
!= NULL
) {
351 // If WaitEvent is NULL, execute in blocking mode.
352 // BSP checks APs'state until all APs finish or TimeoutInMicrosecsond expires.
355 Status
= CheckAllAPs ();
356 } while (Status
== EFI_NOT_READY
);
362 Implementation of StartupThisAP() service of MP Services Protocol.
364 This service lets the caller get one enabled AP to execute a caller-provided function.
365 This service may only be called from the BSP.
367 @param This A pointer to the EFI_MP_SERVICES_PROTOCOL instance.
368 @param Procedure A pointer to the function to be run on the designated AP.
369 @param ProcessorNumber The handle number of AP..
370 @param WaitEvent The event created by the caller.
371 If it is NULL, then execute in blocking mode.
372 If it is not NULL, then execute in non-blocking mode.
373 @param TimeoutInMicroseconds The time limit in microseconds for this AP to finish the function.
375 @param ProcedureArgument Pointer to the optional parameter of the assigned function.
376 @param Finished Indicates whether AP has finished assigned function.
377 In blocking mode, it is ignored.
379 @retval EFI_SUCCESS In blocking mode, specified AP has finished before the timeout expires.
380 @retval EFI_SUCCESS In non-blocking mode, function has been dispatched to specified AP.
381 @retval EFI_DEVICE_ERROR Caller processor is AP.
382 @retval EFI_TIMEOUT In blocking mode, the timeout expires before specified AP has finished.
383 @retval EFI_NOT_READY Specified AP is busy.
384 @retval EFI_NOT_FOUND Processor with the handle specified by ProcessorNumber does not exist.
385 @retval EFI_INVALID_PARAMETER ProcessorNumber specifies the BSP or disabled AP.
386 @retval EFI_INVALID_PARAMETER Procedure is NULL.
392 IN EFI_MP_SERVICES_PROTOCOL
*This
,
393 IN EFI_AP_PROCEDURE Procedure
,
394 IN UINTN ProcessorNumber
,
395 IN EFI_EVENT WaitEvent OPTIONAL
,
396 IN UINTN TimeoutInMicroseconds
,
397 IN VOID
*ProcedureArgument OPTIONAL
,
398 OUT BOOLEAN
*Finished OPTIONAL
401 CPU_DATA_BLOCK
*CpuData
;
406 if (Finished
!= NULL
) {
411 // Check whether caller processor is BSP
413 BspNumber
= GetBspNumber ();
414 WhoAmI (This
, &CallerNumber
);
415 if (CallerNumber
!= BspNumber
) {
416 return EFI_DEVICE_ERROR
;
420 // Check whether processor with the handle specified by ProcessorNumber exists
422 if (ProcessorNumber
>= mNumberOfProcessors
) {
423 return EFI_NOT_FOUND
;
427 // Check whether specified processor is BSP
429 if (ProcessorNumber
== BspNumber
) {
430 return EFI_INVALID_PARAMETER
;
434 // Check parameter Procedure
436 if (Procedure
== NULL
) {
437 return EFI_INVALID_PARAMETER
;
440 CpuData
= &mMPSystemData
.CpuData
[ProcessorNumber
];
443 // Temporarily suppress CheckAPsStatus()
445 mStopCheckAPsStatus
= TRUE
;
448 // Check whether specified AP is disabled
450 if (CpuData
->State
== CpuStateDisabled
) {
451 mStopCheckAPsStatus
= FALSE
;
452 return EFI_INVALID_PARAMETER
;
456 // Check whether specified AP is busy
458 if (CpuData
->State
!= CpuStateIdle
) {
459 mStopCheckAPsStatus
= FALSE
;
460 return EFI_NOT_READY
;
464 // Wakeup specified AP for Procedure.
466 AcquireSpinLock (&CpuData
->CpuDataLock
);
467 CpuData
->State
= CpuStateReady
;
468 ReleaseSpinLock (&CpuData
->CpuDataLock
);
477 // If WaitEvent is not NULL, execute in non-blocking mode.
478 // BSP saves data for CheckAPsStatus(), and returns EFI_SUCCESS.
479 // CheckAPsStatus() will check completion and timeout periodically.
481 CpuData
->WaitEvent
= WaitEvent
;
482 CpuData
->Finished
= Finished
;
483 CpuData
->ExpectedTime
= CalculateTimeout (TimeoutInMicroseconds
, &CpuData
->CurrentTime
);
486 // Allow CheckAPsStatus()
488 mStopCheckAPsStatus
= FALSE
;
490 if (WaitEvent
!= NULL
) {
495 // If WaitEvent is NULL, execute in blocking mode.
496 // BSP checks AP's state until it finishes or TimeoutInMicrosecsond expires.
499 Status
= CheckThisAP (ProcessorNumber
);
500 } while (Status
== EFI_NOT_READY
);
506 Implementation of SwitchBSP() service of MP Services Protocol.
508 This service switches the requested AP to be the BSP from that point onward.
509 This service may only be called from the current BSP.
511 @param This A pointer to the EFI_MP_SERVICES_PROTOCOL instance.
512 @param ProcessorNumber The handle number of processor.
513 @param EnableOldBSP Whether to enable or disable the original BSP.
515 @retval EFI_SUCCESS BSP successfully switched.
516 @retval EFI_DEVICE_ERROR Caller processor is AP.
517 @retval EFI_NOT_FOUND Processor with the handle specified by ProcessorNumber does not exist.
518 @retval EFI_INVALID_PARAMETER ProcessorNumber specifies the BSP or disabled AP.
519 @retval EFI_NOT_READY Specified AP is busy.
525 IN EFI_MP_SERVICES_PROTOCOL
*This
,
526 IN UINTN ProcessorNumber
,
527 IN BOOLEAN EnableOldBSP
531 CPU_DATA_BLOCK
*CpuData
;
535 UINT32 CurrentTimerValue
;
536 UINT32 CurrentTimerRegister
;
537 UINT32 CurrentTimerDivide
;
538 UINT64 CurrentTscValue
;
539 BOOLEAN OldInterruptState
;
542 // Check whether caller processor is BSP
544 BspNumber
= GetBspNumber ();
545 WhoAmI (This
, &CallerNumber
);
546 if (CallerNumber
!= BspNumber
) {
547 return EFI_DEVICE_ERROR
;
551 // Check whether processor with the handle specified by ProcessorNumber exists
553 if (ProcessorNumber
>= mNumberOfProcessors
) {
554 return EFI_NOT_FOUND
;
558 // Check whether specified processor is BSP
560 if (ProcessorNumber
== BspNumber
) {
561 return EFI_INVALID_PARAMETER
;
564 CpuData
= &mMPSystemData
.CpuData
[ProcessorNumber
];
567 // Check whether specified AP is disabled
569 if (CpuData
->State
== CpuStateDisabled
) {
570 return EFI_INVALID_PARAMETER
;
574 // Check whether specified AP is busy
576 if (CpuData
->State
!= CpuStateIdle
) {
577 return EFI_NOT_READY
;
581 // Save and disable interrupt.
583 OldInterruptState
= SaveAndDisableInterrupts ();
586 // Record the current local APIC timer setting of BSP
588 ApicBase
= (UINTN
)AsmMsrBitFieldRead64 (MSR_IA32_APIC_BASE
, 12, 35) << 12;
589 CurrentTimerValue
= MmioRead32 (ApicBase
+ APIC_REGISTER_TIMER_COUNT
);
590 CurrentTimerRegister
= MmioRead32 (ApicBase
+ APIC_REGISTER_LVT_TIMER
);
591 CurrentTimerDivide
= MmioRead32 (ApicBase
+ APIC_REGISTER_TIMER_DIVIDE
);
593 // Set mask bit (BIT 16) of LVT Timer Register to disable its interrupt
595 MmioBitFieldWrite32 (ApicBase
+ APIC_REGISTER_LVT_TIMER
, 16, 16, 1);
598 // Record the current TSC value
600 CurrentTscValue
= AsmReadTsc ();
602 Status
= mFrameworkMpService
->SwitchBSP (
607 ASSERT_EFI_ERROR (Status
);
612 AsmWriteMsr64 (MSR_IA32_TIME_STAMP_COUNTER
, CurrentTscValue
);
615 // Restore local APIC timer setting to new BSP
617 MmioWrite32 (ApicBase
+ APIC_REGISTER_TIMER_DIVIDE
, CurrentTimerDivide
);
618 MmioWrite32 (ApicBase
+ APIC_REGISTER_TIMER_INIT_COUNT
, CurrentTimerValue
);
619 MmioWrite32 (ApicBase
+ APIC_REGISTER_LVT_TIMER
, CurrentTimerRegister
);
622 // Restore interrupt state.
624 SetInterruptState (OldInterruptState
);
626 ChangeCpuState (BspNumber
, EnableOldBSP
);
632 Implementation of EnableDisableAP() service of MP Services Protocol.
634 This service lets the caller enable or disable an AP.
635 This service may only be called from the BSP.
637 @param This A pointer to the EFI_MP_SERVICES_PROTOCOL instance.
638 @param ProcessorNumber The handle number of processor.
639 @param EnableAP Indicates whether the newstate of the AP is enabled or disabled.
640 @param HealthFlag Indicates new health state of the AP..
642 @retval EFI_SUCCESS AP successfully enabled or disabled.
643 @retval EFI_DEVICE_ERROR Caller processor is AP.
644 @retval EFI_NOT_FOUND Processor with the handle specified by ProcessorNumber does not exist.
645 @retval EFI_INVALID_PARAMETERS ProcessorNumber specifies the BSP.
651 IN EFI_MP_SERVICES_PROTOCOL
*This
,
652 IN UINTN ProcessorNumber
,
654 IN UINT32
*HealthFlag OPTIONAL
659 EFI_MP_HEALTH HealthState
;
660 EFI_MP_HEALTH
*HealthStatePointer
;
664 // Check whether caller processor is BSP
666 BspNumber
= GetBspNumber ();
667 WhoAmI (This
, &CallerNumber
);
668 if (CallerNumber
!= BspNumber
) {
669 return EFI_DEVICE_ERROR
;
673 // Check whether processor with the handle specified by ProcessorNumber exists
675 if (ProcessorNumber
>= mNumberOfProcessors
) {
676 return EFI_NOT_FOUND
;
680 // Check whether specified processor is BSP
682 if (ProcessorNumber
== BspNumber
) {
683 return EFI_INVALID_PARAMETER
;
686 if (HealthFlag
== NULL
) {
687 HealthStatePointer
= NULL
;
689 if ((*HealthFlag
& PROCESSOR_HEALTH_STATUS_BIT
) == 0) {
690 HealthState
.Flags
.Uint32
= 1;
692 HealthState
.Flags
.Uint32
= 0;
694 HealthState
.TestStatus
= 0;
696 HealthStatePointer
= &HealthState
;
699 Status
= mFrameworkMpService
->EnableDisableAP (
705 ASSERT_EFI_ERROR (Status
);
707 ChangeCpuState (ProcessorNumber
, EnableAP
);
713 Implementation of WhoAmI() service of MP Services Protocol.
715 This service lets the caller processor get its handle number.
716 This service may be called from the BSP and APs.
718 @param This A pointer to the EFI_MP_SERVICES_PROTOCOL instance.
719 @param ProcessorNumber Pointer to the handle number of AP.
721 @retval EFI_SUCCESS Processor number successfully returned.
722 @retval EFI_INVALID_PARAMETER ProcessorNumber is NULL
728 IN EFI_MP_SERVICES_PROTOCOL
*This
,
729 OUT UINTN
*ProcessorNumber
734 if (ProcessorNumber
== NULL
) {
735 return EFI_INVALID_PARAMETER
;
738 Status
= mFrameworkMpService
->WhoAmI (
742 ASSERT_EFI_ERROR (Status
);
748 Checks APs' status periodically.
750 This function is triggerred by timer perodically to check the
751 state of APs for StartupAllAPs() and StartupThisAP() executed
752 in non-blocking mode.
754 @param Event Event triggered.
755 @param Context Parameter passed with the event.
765 UINTN ProcessorNumber
;
766 CPU_DATA_BLOCK
*CpuData
;
770 // If CheckAPsStatus() is stopped, then return immediately.
772 if (mStopCheckAPsStatus
) {
777 // First, check whether pending StartupAllAPs() exists.
779 if (mMPSystemData
.WaitEvent
!= NULL
) {
781 Status
= CheckAllAPs ();
783 // If all APs finish for StartupAllAPs(), signal the WaitEvent for it..
785 if (Status
!= EFI_NOT_READY
) {
786 Status
= gBS
->SignalEvent (mMPSystemData
.WaitEvent
);
787 mMPSystemData
.WaitEvent
= NULL
;
792 // Second, check whether pending StartupThisAPs() callings exist.
794 for (ProcessorNumber
= 0; ProcessorNumber
< mNumberOfProcessors
; ProcessorNumber
++) {
796 CpuData
= &mMPSystemData
.CpuData
[ProcessorNumber
];
798 if (CpuData
->WaitEvent
== NULL
) {
802 Status
= CheckThisAP (ProcessorNumber
);
804 if (Status
!= EFI_NOT_READY
) {
805 gBS
->SignalEvent (CpuData
->WaitEvent
);
806 CpuData
->WaitEvent
= NULL
;
813 Checks status of all APs.
815 This function checks whether all APs have finished task assigned by StartupAllAPs(),
816 and whether timeout expires.
818 @retval EFI_SUCCESS All APs have finished task assigned by StartupAllAPs().
819 @retval EFI_TIMEOUT The timeout expires.
820 @retval EFI_NOT_READY APs have not finished task and timeout has not expired.
828 UINTN ProcessorNumber
;
829 UINTN NextProcessorNumber
;
833 CPU_DATA_BLOCK
*CpuData
;
835 NextProcessorNumber
= 0;
838 // Go through all APs that are responsible for the StartupAllAPs().
840 for (ProcessorNumber
= 0; ProcessorNumber
< mNumberOfProcessors
; ProcessorNumber
++) {
841 if (!mMPSystemData
.CpuList
[ProcessorNumber
]) {
845 CpuData
= &mMPSystemData
.CpuData
[ProcessorNumber
];
848 // Check the CPU state of AP. If it is CpuStateFinished, then the AP has finished its task.
849 // Only BSP and corresponding AP access this unit of CPU Data. This means the AP will not modify the
850 // value of state after setting the it to CpuStateFinished, so BSP can safely make use of its value.
852 AcquireSpinLock (&CpuData
->CpuDataLock
);
853 CpuState
= CpuData
->State
;
854 ReleaseSpinLock (&CpuData
->CpuDataLock
);
856 if (CpuState
== CpuStateFinished
) {
857 mMPSystemData
.FinishCount
++;
858 mMPSystemData
.CpuList
[ProcessorNumber
] = FALSE
;
860 AcquireSpinLock (&CpuData
->CpuDataLock
);
861 CpuData
->State
= CpuStateIdle
;
862 ReleaseSpinLock (&CpuData
->CpuDataLock
);
865 // If in Single Thread mode, then search for the next waiting AP for execution.
867 if (mMPSystemData
.SingleThread
) {
868 Status
= GetNextWaitingProcessorNumber (&NextProcessorNumber
);
870 if (!EFI_ERROR (Status
)) {
873 mMPSystemData
.Procedure
,
874 mMPSystemData
.ProcArguments
882 // If all APs finish, return EFI_SUCCESS.
884 if (mMPSystemData
.FinishCount
== mMPSystemData
.StartCount
) {
889 // If timeout expires, report timeout.
891 if (CheckTimeout (&mMPSystemData
.CurrentTime
, &mMPSystemData
.TotalTime
, mMPSystemData
.ExpectedTime
)) {
893 // If FailedCpuList is not NULL, record all failed APs in it.
895 if (mMPSystemData
.FailedCpuList
!= NULL
) {
896 *mMPSystemData
.FailedCpuList
= AllocatePool ((mMPSystemData
.StartCount
- mMPSystemData
.FinishCount
+ 1) * sizeof(UINTN
));
897 ASSERT (*mMPSystemData
.FailedCpuList
!= NULL
);
901 for (ProcessorNumber
= 0; ProcessorNumber
< mNumberOfProcessors
; ProcessorNumber
++) {
903 // Check whether this processor is responsible for StartupAllAPs().
905 if (mMPSystemData
.CpuList
[ProcessorNumber
]) {
907 // Reset failed APs to idle state
909 ResetProcessorToIdleState (ProcessorNumber
);
910 mMPSystemData
.CpuList
[ProcessorNumber
] = FALSE
;
911 if (mMPSystemData
.FailedCpuList
!= NULL
) {
912 (*mMPSystemData
.FailedCpuList
)[ListIndex
++] = ProcessorNumber
;
916 if (mMPSystemData
.FailedCpuList
!= NULL
) {
917 (*mMPSystemData
.FailedCpuList
)[ListIndex
] = END_OF_CPU_LIST
;
921 return EFI_NOT_READY
;
925 Checks status of specified AP.
927 This function checks whether specified AP has finished task assigned by StartupThisAP(),
928 and whether timeout expires.
930 @param ProcessorNumber The handle number of processor.
932 @retval EFI_SUCCESS Specified AP has finished task assigned by StartupThisAPs().
933 @retval EFI_TIMEOUT The timeout expires.
934 @retval EFI_NOT_READY Specified AP has not finished task and timeout has not expired.
939 UINTN ProcessorNumber
942 CPU_DATA_BLOCK
*CpuData
;
945 ASSERT (ProcessorNumber
< mNumberOfProcessors
);
946 ASSERT (ProcessorNumber
< MAX_CPU_NUMBER
);
948 CpuData
= &mMPSystemData
.CpuData
[ProcessorNumber
];
951 // Check the CPU state of AP. If it is CpuStateFinished, then the AP has finished its task.
952 // Only BSP and corresponding AP access this unit of CPU Data. This means the AP will not modify the
953 // value of state after setting the it to CpuStateFinished, so BSP can safely make use of its value.
955 AcquireSpinLock (&CpuData
->CpuDataLock
);
956 CpuState
= CpuData
->State
;
957 ReleaseSpinLock (&CpuData
->CpuDataLock
);
960 // If the APs finishes for StartupThisAP(), return EFI_SUCCESS.
962 if (CpuState
== CpuStateFinished
) {
964 AcquireSpinLock (&CpuData
->CpuDataLock
);
965 CpuData
->State
= CpuStateIdle
;
966 ReleaseSpinLock (&CpuData
->CpuDataLock
);
968 if (CpuData
->Finished
!= NULL
) {
969 *(CpuData
->Finished
) = TRUE
;
974 // If timeout expires for StartupThisAP(), report timeout.
976 if (CheckTimeout (&CpuData
->CurrentTime
, &CpuData
->TotalTime
, CpuData
->ExpectedTime
)) {
978 if (CpuData
->Finished
!= NULL
) {
979 *(CpuData
->Finished
) = FALSE
;
982 // Reset failed AP to idle state
984 ResetProcessorToIdleState (ProcessorNumber
);
989 return EFI_NOT_READY
;
993 Calculate timeout value and return the current performance counter value.
995 Calculate the number of performance counter ticks required for a timeout.
996 If TimeoutInMicroseconds is 0, return value is also 0, which is recognized
999 @param TimeoutInMicroseconds Timeout value in microseconds.
1000 @param CurrentTime Returns the current value of the performance counter.
1002 @return Expected timestamp counter for timeout.
1003 If TimeoutInMicroseconds is 0, return value is also 0, which is recognized
1009 IN UINTN TimeoutInMicroseconds
,
1010 OUT UINT64
*CurrentTime
1014 // Read the current value of the performance counter
1016 *CurrentTime
= GetPerformanceCounter ();
1019 // If TimeoutInMicroseconds is 0, return value is also 0, which is recognized
1022 if (TimeoutInMicroseconds
== 0) {
1027 // GetPerformanceCounterProperties () returns the timestamp counter's frequency
1028 // in Hz. So multiply the return value with TimeoutInMicroseconds and then divide
1029 // it by 1,000,000, to get the number of ticks for the timeout value.
1033 GetPerformanceCounterProperties (NULL
, NULL
),
1034 TimeoutInMicroseconds
1041 Checks whether timeout expires.
1043 Check whether the number of ellapsed performance counter ticks required for a timeout condition
1044 has been reached. If Timeout is zero, which means infinity, return value is always FALSE.
1046 @param PreviousTime On input, the value of the performance counter when it was last read.
1047 On output, the current value of the performance counter
1048 @param TotalTime The total amount of ellapsed time in performance counter ticks.
1049 @param Timeout The number of performance counter ticks required to reach a timeout condition.
1051 @retval TRUE A timeout condition has been reached.
1052 @retval FALSE A timeout condition has not been reached.
1057 IN OUT UINT64
*PreviousTime
,
1058 IN UINT64
*TotalTime
,
1071 GetPerformanceCounterProperties (&Start
, &End
);
1072 Cycle
= End
- Start
;
1077 CurrentTime
= GetPerformanceCounter();
1078 Delta
= (INT64
) (CurrentTime
- *PreviousTime
);
1085 *TotalTime
+= Delta
;
1086 *PreviousTime
= CurrentTime
;
1087 if (*TotalTime
> Timeout
) {
1094 Searches for the next waiting AP.
1096 Search for the next AP that is put in waiting state by single-threaded StartupAllAPs().
1098 @param NextProcessorNumber Pointer to the processor number of the next waiting AP.
1100 @retval EFI_SUCCESS The next waiting AP has been found.
1101 @retval EFI_NOT_FOUND No waiting AP exists.
1105 GetNextWaitingProcessorNumber (
1106 OUT UINTN
*NextProcessorNumber
1109 UINTN ProcessorNumber
;
1111 for (ProcessorNumber
= 0; ProcessorNumber
< mNumberOfProcessors
; ProcessorNumber
++) {
1113 if (mMPSystemData
.CpuList
[ProcessorNumber
]) {
1114 *NextProcessorNumber
= ProcessorNumber
;
1119 return EFI_NOT_FOUND
;
1123 Programs Local APIC registers for virtual wire mode.
1125 This function programs Local APIC registers for virtual wire mode.
1127 @param Bsp Indicates whether the programmed processor is going to be BSP
1131 ProgramVirtualWireMode (
1138 ApicBase
= (UINTN
)AsmMsrBitFieldRead64 (MSR_IA32_APIC_BASE
, 12, 35) << 12;
1141 // Program the Spurious Vector entry
1142 // Set bit 8 (APIC Software Enable/Disable) to enable local APIC,
1143 // and set Spurious Vector as 0x0F.
1145 MmioBitFieldWrite32 (ApicBase
+ APIC_REGISTER_SPURIOUS_VECTOR_OFFSET
, 0, 9, 0x10F);
1148 // Program the LINT0 vector entry as ExtInt
1149 // Set bits 8..10 to 7 as ExtInt Delivery Mode,
1150 // and clear bits for Delivery Status, Interrupt Input Pin Polarity, Remote IRR,
1151 // Trigger Mode, and Mask
1154 DisableInterrupts ();
1156 Value
= MmioRead32 (ApicBase
+ APIC_REGISTER_LINT0_VECTOR_OFFSET
);
1157 Value
= BitFieldWrite32 (Value
, 8, 10, 7);
1158 Value
= BitFieldWrite32 (Value
, 12, 16, 0);
1161 // For APs, LINT0 is masked
1163 Value
= BitFieldWrite32 (Value
, 16, 16, 1);
1165 MmioWrite32 (ApicBase
+ APIC_REGISTER_LINT0_VECTOR_OFFSET
, Value
);
1168 // Program the LINT1 vector entry as NMI
1169 // Set bits 8..10 to 4 as NMI Delivery Mode,
1170 // and clear bits for Delivery Status, Interrupt Input Pin Polarity, Remote IRR,
1172 // For BSP clear Mask bit, and for AP set mask bit.
1174 Value
= MmioRead32 (ApicBase
+ APIC_REGISTER_LINT1_VECTOR_OFFSET
);
1175 Value
= BitFieldWrite32 (Value
, 8, 10, 4);
1176 Value
= BitFieldWrite32 (Value
, 12, 16, 0);
1179 // For APs, LINT1 is masked
1181 Value
= BitFieldWrite32 (Value
, 16, 16, 1);
1183 MmioWrite32 (ApicBase
+ APIC_REGISTER_LINT1_VECTOR_OFFSET
, Value
);
1188 Wrapper function for all procedures assigned to AP.
1190 Wrapper function for all procedures assigned to AP via MP service protocol.
1191 It controls states of AP and invokes assigned precedure.
1199 EFI_AP_PROCEDURE Procedure
;
1201 UINTN ProcessorNumber
;
1202 CPU_DATA_BLOCK
*CpuData
;
1205 // Program virtual wire mode for AP, since it will be lost after AP wake up
1207 ProgramVirtualWireMode (FALSE
);
1210 // Initialize Debug Agent to support source level debug on AP code.
1212 InitializeDebugAgent (DEBUG_AGENT_INIT_DXE_AP
, NULL
, NULL
);
1214 WhoAmI (&mMpService
, &ProcessorNumber
);
1215 CpuData
= &mMPSystemData
.CpuData
[ProcessorNumber
];
1217 AcquireSpinLock (&CpuData
->CpuDataLock
);
1218 CpuData
->State
= CpuStateBusy
;
1219 ReleaseSpinLock (&CpuData
->CpuDataLock
);
1222 // Now let us check it out.
1224 AcquireSpinLock (&CpuData
->CpuDataLock
);
1225 Procedure
= CpuData
->Procedure
;
1226 Parameter
= CpuData
->Parameter
;
1227 ReleaseSpinLock (&CpuData
->CpuDataLock
);
1229 if (Procedure
!= NULL
) {
1231 Procedure (Parameter
);
1234 // if BSP is switched to AP, it continue execute from here, but it carries register state
1235 // of the old AP, so need to reload CpuData (might be stored in a register after compiler
1236 // optimization) to make sure it points to the right data
1238 WhoAmI (&mMpService
, &ProcessorNumber
);
1239 CpuData
= &mMPSystemData
.CpuData
[ProcessorNumber
];
1241 AcquireSpinLock (&CpuData
->CpuDataLock
);
1242 CpuData
->Procedure
= NULL
;
1243 ReleaseSpinLock (&CpuData
->CpuDataLock
);
1246 AcquireSpinLock (&CpuData
->CpuDataLock
);
1247 CpuData
->State
= CpuStateFinished
;
1248 ReleaseSpinLock (&CpuData
->CpuDataLock
);
1252 Sends INIT-SIPI-SIPI to AP.
1254 This function sends INIT-SIPI-SIPI to AP, and assign procedure specified by ApFunction.
1256 @param ProcessorNumber The processor number of the specified AP.
1257 @param ApicID The Local APIC ID of the specified AP.
1258 @param ApFunction The procedure for AP to work on.
1263 IN UINTN ProcessorNumber
,
1272 UINT32 VectorNumber
;
1273 UINT32 DeliveryMode
;
1275 mExchangeInfo
->ApFunction
= ApFunction
;
1276 mExchangeInfo
->ProcessorNumber
[ApicID
] = (UINT32
) ProcessorNumber
;
1278 ICRHigh
= ApicID
<< 24;
1279 ICRLow
= SPECIFY_CPU_MODE_BIT
| TRIGGER_MODE_LEVEL_BIT
| ASSERT_BIT
;
1282 DeliveryMode
= DELIVERY_MODE_INIT
;
1283 ICRLow
|= VectorNumber
| (DeliveryMode
<< 8);
1285 ApicBase
= (UINTN
)AsmMsrBitFieldRead64 (MSR_IA32_APIC_BASE
, 12, 35) << 12;;
1288 // Write Interrupt Command Registers to send INIT IPI.
1290 MmioWrite32 (ApicBase
+ APIC_REGISTER_ICR_HIGH_OFFSET
, ICRHigh
);
1291 MmioWrite32 (ApicBase
+ APIC_REGISTER_ICR_LOW_OFFSET
, ICRLow
);
1293 MicroSecondDelay (10);
1295 VectorNumber
= (UINT32
) RShiftU64 (mStartupVector
, 12);
1296 DeliveryMode
= DELIVERY_MODE_SIPI
;
1297 ICRLow
= SPECIFY_CPU_MODE_BIT
| TRIGGER_MODE_LEVEL_BIT
| ASSERT_BIT
;
1299 ICRLow
|= VectorNumber
| (DeliveryMode
<< 8);
1302 // Write Interrupt Command Register to send first SIPI IPI.
1304 MmioWrite32 (ApicBase
+ APIC_REGISTER_ICR_LOW_OFFSET
, ICRLow
);
1306 MicroSecondDelay (200);
1309 // Write Interrupt Command Register to send second SIPI IPI.
1311 MmioWrite32 (ApicBase
+ APIC_REGISTER_ICR_LOW_OFFSET
, ICRLow
);
1315 Function to wake up a specified AP and assign procedure to it.
1317 @param ProcessorNumber Handle number of the specified processor.
1318 @param Procedure Procedure to assign.
1319 @param ProcArguments Argument for Procedure.
1324 IN UINTN ProcessorNumber
,
1325 IN EFI_AP_PROCEDURE Procedure
,
1326 IN VOID
*ProcArguments
1330 CPU_DATA_BLOCK
*CpuData
;
1331 EFI_PROCESSOR_INFORMATION ProcessorInfoBuffer
;
1333 ASSERT (ProcessorNumber
< mNumberOfProcessors
);
1334 ASSERT (ProcessorNumber
< MAX_CPU_NUMBER
);
1336 CpuData
= &mMPSystemData
.CpuData
[ProcessorNumber
];
1338 AcquireSpinLock (&CpuData
->CpuDataLock
);
1339 CpuData
->Parameter
= ProcArguments
;
1340 CpuData
->Procedure
= Procedure
;
1341 ReleaseSpinLock (&CpuData
->CpuDataLock
);
1343 Status
= GetProcessorInfo (
1346 &ProcessorInfoBuffer
1348 ASSERT_EFI_ERROR (Status
);
1352 (UINT32
) ProcessorInfoBuffer
.ProcessorId
,
1353 (VOID
*) (UINTN
) ApProcWrapper
1358 Terminate AP's task and set it to idle state.
1360 This function terminates AP's task due to timeout by sending INIT-SIPI,
1361 and sends it to idle state.
1363 @param ProcessorNumber Handle number of the specified processor.
1367 ResetProcessorToIdleState (
1368 UINTN ProcessorNumber
1372 CPU_DATA_BLOCK
*CpuData
;
1373 EFI_PROCESSOR_INFORMATION ProcessorInfoBuffer
;
1375 Status
= GetProcessorInfo (
1378 &ProcessorInfoBuffer
1380 ASSERT_EFI_ERROR (Status
);
1384 (UINT32
) ProcessorInfoBuffer
.ProcessorId
,
1388 CpuData
= &mMPSystemData
.CpuData
[ProcessorNumber
];
1390 AcquireSpinLock (&CpuData
->CpuDataLock
);
1391 CpuData
->State
= CpuStateIdle
;
1392 ReleaseSpinLock (&CpuData
->CpuDataLock
);
1396 Worker function of EnableDisableAP ()
1398 Worker function of EnableDisableAP (). Changes state of specified processor.
1400 @param ProcessorNumber Processor number of specified AP.
1401 @param NewState Desired state of the specified AP.
1403 @retval EFI_SUCCESS AP's state successfully changed.
1408 IN UINTN ProcessorNumber
,
1412 CPU_DATA_BLOCK
*CpuData
;
1414 ASSERT (ProcessorNumber
< mNumberOfProcessors
);
1415 ASSERT (ProcessorNumber
< MAX_CPU_NUMBER
);
1417 CpuData
= &mMPSystemData
.CpuData
[ProcessorNumber
];
1420 AcquireSpinLock (&CpuData
->CpuDataLock
);
1421 CpuData
->State
= CpuStateDisabled
;
1422 ReleaseSpinLock (&CpuData
->CpuDataLock
);
1424 AcquireSpinLock (&CpuData
->CpuDataLock
);
1425 CpuData
->State
= CpuStateIdle
;
1426 ReleaseSpinLock (&CpuData
->CpuDataLock
);
1433 Test memory region of EfiGcdMemoryTypeReserved.
1435 @param Length The length of memory region to test.
1437 @retval EFI_SUCCESS The memory region passes test.
1438 @retval EFI_NOT_FOUND The memory region is not reserved memory.
1439 @retval EFI_DEVICE_ERROR The memory fails on test.
1443 TestReservedMemory (
1448 EFI_GCD_MEMORY_SPACE_DESCRIPTOR Descriptor
;
1449 EFI_PHYSICAL_ADDRESS Address
;
1450 UINTN LengthCovered
;
1451 UINTN RemainingLength
;
1454 // Walk through the memory descriptors covering the memory range.
1456 Address
= mStartupVector
;
1457 RemainingLength
= Length
;
1458 while (Address
< mStartupVector
+ Length
) {
1459 Status
= gDS
->GetMemorySpaceDescriptor(
1463 if (EFI_ERROR (Status
)) {
1464 return EFI_NOT_FOUND
;
1467 if (Descriptor
.GcdMemoryType
!= EfiGcdMemoryTypeReserved
) {
1468 return EFI_NOT_FOUND
;
1471 // Calculated the length of the intersected range.
1473 LengthCovered
= (UINTN
) (Descriptor
.BaseAddress
+ Descriptor
.Length
- Address
);
1474 if (LengthCovered
> RemainingLength
) {
1475 LengthCovered
= RemainingLength
;
1478 Status
= mGenMemoryTest
->CompatibleRangeTest (
1483 if (EFI_ERROR (Status
)) {
1484 return EFI_DEVICE_ERROR
;
1487 Address
+= LengthCovered
;
1488 RemainingLength
-= LengthCovered
;
1495 Allocates startup vector for APs.
1497 This function allocates Startup vector for APs.
1499 @param Size The size of startup vector.
1503 AllocateStartupVector (
1509 Status
= gBS
->LocateProtocol (
1510 &gEfiGenericMemTestProtocolGuid
,
1512 (VOID
**) &mGenMemoryTest
1514 if (EFI_ERROR (Status
)) {
1515 mGenMemoryTest
= NULL
;
1518 for (mStartupVector
= 0x7F000; mStartupVector
>= 0x2000; mStartupVector
-= EFI_PAGE_SIZE
) {
1519 if (mGenMemoryTest
!= NULL
) {
1521 // Test memory if it is EfiGcdMemoryTypeReserved.
1523 Status
= TestReservedMemory (EFI_SIZE_TO_PAGES (Size
) * EFI_PAGE_SIZE
);
1524 if (Status
== EFI_DEVICE_ERROR
) {
1529 Status
= gBS
->AllocatePages (
1531 EfiBootServicesCode
,
1532 EFI_SIZE_TO_PAGES (Size
),
1536 if (!EFI_ERROR (Status
)) {
1541 ASSERT_EFI_ERROR (Status
);
1545 Prepares Startup Vector for APs.
1547 This function prepares Startup Vector for APs.
1551 PrepareAPStartupVector (
1555 MP_ASSEMBLY_ADDRESS_MAP AddressMap
;
1556 IA32_DESCRIPTOR GdtrForBSP
;
1557 IA32_DESCRIPTOR IdtrForBSP
;
1558 EFI_PHYSICAL_ADDRESS GdtForAP
;
1559 EFI_PHYSICAL_ADDRESS IdtForAP
;
1563 // Get the address map of startup code for AP,
1564 // including code size, and offset of long jump instructions to redirect.
1566 AsmGetAddressMap (&AddressMap
);
1569 // Allocate a 4K-aligned region under 1M for startup vector for AP.
1570 // The region contains AP startup code and exchange data between BSP and AP.
1572 AllocateStartupVector (AddressMap
.Size
+ sizeof (MP_CPU_EXCHANGE_INFO
));
1575 // Copy AP startup code to startup vector, and then redirect the long jump
1576 // instructions for mode switching.
1578 CopyMem ((VOID
*) (UINTN
) mStartupVector
, AddressMap
.RendezvousFunnelAddress
, AddressMap
.Size
);
1579 *(UINT32
*) (UINTN
) (mStartupVector
+ AddressMap
.FlatJumpOffset
+ 3) = (UINT32
) (mStartupVector
+ AddressMap
.PModeEntryOffset
);
1581 // For IA32 mode, LongJumpOffset is filled with zero. If non-zero, then we are in X64 mode, so further redirect for long mode switch.
1583 if (AddressMap
.LongJumpOffset
!= 0) {
1584 *(UINT32
*) (UINTN
) (mStartupVector
+ AddressMap
.LongJumpOffset
+ 2) = (UINT32
) (mStartupVector
+ AddressMap
.LModeEntryOffset
);
1588 // Get the start address of exchange data between BSP and AP.
1590 mExchangeInfo
= (MP_CPU_EXCHANGE_INFO
*) (UINTN
) (mStartupVector
+ AddressMap
.Size
);
1592 ZeroMem ((VOID
*) mExchangeInfo
, sizeof (MP_CPU_EXCHANGE_INFO
));
1594 mExchangeInfo
->StackStart
= AllocatePages (EFI_SIZE_TO_PAGES (mNumberOfProcessors
* AP_STACK_SIZE
));
1595 mExchangeInfo
->StackSize
= AP_STACK_SIZE
;
1597 AsmReadGdtr (&GdtrForBSP
);
1598 AsmReadIdtr (&IdtrForBSP
);
1601 // Allocate memory under 4G to hold GDT for APs
1603 GdtForAP
= 0xffffffff;
1604 Status
= gBS
->AllocatePages (
1606 EfiBootServicesData
,
1607 EFI_SIZE_TO_PAGES ((GdtrForBSP
.Limit
+ 1) + (IdtrForBSP
.Limit
+ 1)),
1610 ASSERT_EFI_ERROR (Status
);
1612 IdtForAP
= (UINTN
) GdtForAP
+ GdtrForBSP
.Limit
+ 1;
1614 CopyMem ((VOID
*) (UINTN
) GdtForAP
, (VOID
*) GdtrForBSP
.Base
, GdtrForBSP
.Limit
+ 1);
1615 CopyMem ((VOID
*) (UINTN
) IdtForAP
, (VOID
*) IdtrForBSP
.Base
, IdtrForBSP
.Limit
+ 1);
1617 mExchangeInfo
->GdtrProfile
.Base
= (UINTN
) GdtForAP
;
1618 mExchangeInfo
->GdtrProfile
.Limit
= GdtrForBSP
.Limit
;
1619 mExchangeInfo
->IdtrProfile
.Base
= (UINTN
) IdtForAP
;
1620 mExchangeInfo
->IdtrProfile
.Limit
= IdtrForBSP
.Limit
;
1622 mExchangeInfo
->BufferStart
= (UINT32
) mStartupVector
;
1623 mExchangeInfo
->Cr3
= (UINT32
) (AsmReadCr3 ());
1627 Prepares memory region for processor configuration.
1629 This function prepares memory region for processor configuration.
1633 PrepareMemoryForConfiguration (
1640 // Initialize Spin Locks for system
1642 InitializeSpinLock (&mMPSystemData
.APSerializeLock
);
1643 for (Index
= 0; Index
< MAX_CPU_NUMBER
; Index
++) {
1644 InitializeSpinLock (&mMPSystemData
.CpuData
[Index
].CpuDataLock
);
1647 PrepareAPStartupVector ();
1651 Gets the processor number of BSP.
1653 @return The processor number of BSP.
1661 UINTN ProcessorNumber
;
1662 EFI_MP_PROC_CONTEXT ProcessorContextBuffer
;
1666 BufferSize
= sizeof (EFI_MP_PROC_CONTEXT
);
1668 for (ProcessorNumber
= 0; ProcessorNumber
< mNumberOfProcessors
; ProcessorNumber
++) {
1669 Status
= mFrameworkMpService
->GetProcessorContext (
1670 mFrameworkMpService
,
1673 &ProcessorContextBuffer
1675 ASSERT_EFI_ERROR (Status
);
1677 if (ProcessorContextBuffer
.Designation
== EfiCpuBSP
) {
1681 ASSERT (ProcessorNumber
< mNumberOfProcessors
);
1683 return ProcessorNumber
;
1687 Entrypoint of MP Services Protocol thunk driver.
1689 @param[in] ImageHandle The firmware allocated handle for the EFI image.
1690 @param[in] SystemTable A pointer to the EFI System Table.
1692 @retval EFI_SUCCESS The entry point is executed successfully.
1697 InitializeMpServicesProtocol (
1698 IN EFI_HANDLE ImageHandle
,
1699 IN EFI_SYSTEM_TABLE
*SystemTable
1705 // Locates Framework version MP Services Protocol
1707 Status
= gBS
->LocateProtocol (
1708 &gFrameworkEfiMpServiceProtocolGuid
,
1710 (VOID
**) &mFrameworkMpService
1712 ASSERT_EFI_ERROR (Status
);
1714 Status
= mFrameworkMpService
->GetGeneralMPInfo (
1715 mFrameworkMpService
,
1716 &mNumberOfProcessors
,
1722 ASSERT_EFI_ERROR (Status
);
1723 ASSERT (mNumberOfProcessors
< MAX_CPU_NUMBER
);
1725 PrepareMemoryForConfiguration ();
1728 // Create timer event to check AP state for non-blocking execution.
1730 Status
= gBS
->CreateEvent (
1731 EVT_TIMER
| EVT_NOTIFY_SIGNAL
,
1735 &mMPSystemData
.CheckAPsEvent
1737 ASSERT_EFI_ERROR (Status
);
1740 // Now install the MP services protocol.
1742 Status
= gBS
->InstallProtocolInterface (
1744 &gEfiMpServiceProtocolGuid
,
1745 EFI_NATIVE_INTERFACE
,
1748 ASSERT_EFI_ERROR (Status
);
1751 // Launch the timer event to check AP state.
1753 Status
= gBS
->SetTimer (
1754 mMPSystemData
.CheckAPsEvent
,
1758 ASSERT_EFI_ERROR (Status
);