UefiCpuPkg/Library/MpInitLib/DxeMpLib.c

   1 /** @file
   2   MP initialize support functions for DXE phase.
   3
   4   Copyright (c) 2016, Intel Corporation. All rights reserved.<BR>
   5   This program and the accompanying materials
   6   are licensed and made available under the terms and conditions of the BSD License
   7   which accompanies this distribution.  The full text of the license may be found at
   8   http://opensource.org/licenses/bsd-license.php
   9
  10   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12
  13 **/
  14
  15 #include "MpLib.h"
  16
  17 #include <Library/UefiLib.h>
  18 #include <Library/UefiBootServicesTableLib.h>
  19 #include <Library/DebugAgentLib.h>
  20 #include <Library/DxeServicesTableLib.h>
  21
  22 #include <Protocol/Timer.h>
  23
  24 #define  AP_CHECK_INTERVAL     (EFI_TIMER_PERIOD_MILLISECONDS (100))
  25 #define  AP_SAFE_STACK_SIZE    128
  26
  27 CPU_MP_DATA      *mCpuMpData = NULL;
  28 EFI_EVENT        mCheckAllApsEvent = NULL;
  29 EFI_EVENT        mMpInitExitBootServicesEvent = NULL;
  30 EFI_EVENT        mLegacyBootEvent = NULL;
  31 volatile BOOLEAN mStopCheckAllApsStatus = TRUE;
  32 VOID             *mReservedApLoopFunc = NULL;
  33 UINTN            mReservedTopOfApStack;
  34 volatile UINT32  mNumberToFinish = 0;
  35
  36 /**
  37   Enable Debug Agent to support source debugging on AP function.
  38
  39 **/
  40 VOID
  41 EnableDebugAgent (
  42   VOID
  43   )
  44 {
  45   //
  46   // Initialize Debug Agent to support source level debug in DXE phase
  47   //
  48   InitializeDebugAgent (DEBUG_AGENT_INIT_DXE_AP, NULL, NULL);
  49 }
  50
  51 /**
  52   Get the pointer to CPU MP Data structure.
  53
  54   @return  The pointer to CPU MP Data structure.
  55 **/
  56 CPU_MP_DATA *
  57 GetCpuMpData (
  58   VOID
  59   )
  60 {
  61   ASSERT (mCpuMpData != NULL);
  62   return mCpuMpData;
  63 }
  64
  65 /**
  66   Save the pointer to CPU MP Data structure.
  67
  68   @param[in] CpuMpData  The pointer to CPU MP Data structure will be saved.
  69 **/
  70 VOID
  71 SaveCpuMpData (
  72   IN CPU_MP_DATA   *CpuMpData
  73   )
  74 {
  75   mCpuMpData = CpuMpData;
  76 }
  77
  78 /**
  79   Get available system memory below 1MB by specified size.
  80
  81   @param[in] WakeupBufferSize   Wakeup buffer size required
  82
  83   @retval other   Return wakeup buffer address below 1MB.
  84   @retval -1      Cannot find free memory below 1MB.
  85 **/
  86 UINTN
  87 GetWakeupBuffer (
  88   IN UINTN                WakeupBufferSize
  89   )
  90 {
  91   EFI_STATUS              Status;
  92   EFI_PHYSICAL_ADDRESS    StartAddress;
  93
  94   StartAddress = BASE_1MB;
  95   Status = gBS->AllocatePages (
  96                   AllocateMaxAddress,
  97                   EfiBootServicesData,
  98                   EFI_SIZE_TO_PAGES (WakeupBufferSize),
  99                   &StartAddress
 100                   );
 101   ASSERT_EFI_ERROR (Status);
 102   if (!EFI_ERROR (Status)) {
 103     Status = gBS->FreePages(
 104                StartAddress,
 105                EFI_SIZE_TO_PAGES (WakeupBufferSize)
 106                );
 107     ASSERT_EFI_ERROR (Status);
 108     DEBUG ((DEBUG_INFO, "WakeupBufferStart = %x, WakeupBufferSize = %x\n",
 109                         (UINTN) StartAddress, WakeupBufferSize));
 110   } else {
 111     StartAddress = (EFI_PHYSICAL_ADDRESS) -1;
 112   }
 113   return (UINTN) StartAddress;
 114 }
 115
 116 /**
 117   Checks APs status and updates APs status if needed.
 118
 119 **/
 120 VOID
 121 CheckAndUpdateApsStatus (
 122   VOID
 123   )
 124 {
 125   UINTN                   ProcessorNumber;
 126   EFI_STATUS              Status;
 127   CPU_MP_DATA             *CpuMpData;
 128
 129   CpuMpData = GetCpuMpData ();
 130
 131   //
 132   // First, check whether pending StartupAllAPs() exists.
 133   //
 134   if (CpuMpData->WaitEvent != NULL) {
 135
 136     Status = CheckAllAPs ();
 137     //
 138     // If all APs finish for StartupAllAPs(), signal the WaitEvent for it.
 139     //
 140     if (Status != EFI_NOT_READY) {
 141       Status = gBS->SignalEvent (CpuMpData->WaitEvent);
 142       CpuMpData->WaitEvent = NULL;
 143     }
 144   }
 145
 146   //
 147   // Second, check whether pending StartupThisAPs() callings exist.
 148   //
 149   for (ProcessorNumber = 0; ProcessorNumber < CpuMpData->CpuCount; ProcessorNumber++) {
 150
 151     if (CpuMpData->CpuData[ProcessorNumber].WaitEvent == NULL) {
 152       continue;
 153     }
 154
 155     Status = CheckThisAP (ProcessorNumber);
 156
 157     if (Status != EFI_NOT_READY) {
 158       gBS->SignalEvent (CpuMpData->CpuData[ProcessorNumber].WaitEvent);
 159      CpuMpData->CpuData[ProcessorNumber].WaitEvent = NULL;
 160     }
 161   }
 162 }
 163
 164 /**
 165   Checks APs' status periodically.
 166
 167   This function is triggered by timer periodically to check the
 168   state of APs for StartupAllAPs() and StartupThisAP() executed
 169   in non-blocking mode.
 170
 171   @param[in]  Event    Event triggered.
 172   @param[in]  Context  Parameter passed with the event.
 173
 174 **/
 175 VOID
 176 EFIAPI
 177 CheckApsStatus (
 178   IN  EFI_EVENT                           Event,
 179   IN  VOID                                *Context
 180   )
 181 {
 182   //
 183   // If CheckApsStatus() is not stopped, otherwise return immediately.
 184   //
 185   if (!mStopCheckAllApsStatus) {
 186     CheckAndUpdateApsStatus ();
 187   }
 188 }
 189
 190 /**
 191   Get Protected mode code segment from current GDT table.
 192
 193   @return  Protected mode code segment value.
 194 **/
 195 UINT16
 196 GetProtectedModeCS (
 197   VOID
 198   )
 199 {
 200   IA32_DESCRIPTOR          GdtrDesc;
 201   IA32_SEGMENT_DESCRIPTOR  *GdtEntry;
 202   UINTN                    GdtEntryCount;
 203   UINT16                   Index;
 204
 205   Index = (UINT16) -1;
 206   AsmReadGdtr (&GdtrDesc);
 207   GdtEntryCount = (GdtrDesc.Limit + 1) / sizeof (IA32_SEGMENT_DESCRIPTOR);
 208   GdtEntry = (IA32_SEGMENT_DESCRIPTOR *) GdtrDesc.Base;
 209   for (Index = 0; Index < GdtEntryCount; Index++) {
 210     if (GdtEntry->Bits.L == 0) {
 211       if (GdtEntry->Bits.Type > 8 && GdtEntry->Bits.L == 0) {
 212         break;
 213       }
 214     }
 215     GdtEntry++;
 216   }
 217   ASSERT (Index != -1);
 218   return Index * 8;
 219 }
 220
 221 /**
 222   Do sync on APs.
 223
 224   @param[in, out] Buffer  Pointer to private data buffer.
 225 **/
 226 VOID
 227 EFIAPI
 228 RelocateApLoop (
 229   IN OUT VOID  *Buffer
 230   )
 231 {
 232   CPU_MP_DATA            *CpuMpData;
 233   BOOLEAN                MwaitSupport;
 234   ASM_RELOCATE_AP_LOOP   AsmRelocateApLoopFunc;
 235   UINTN                  ProcessorNumber;
 236
 237   MpInitLibWhoAmI (&ProcessorNumber);
 238   CpuMpData    = GetCpuMpData ();
 239   MwaitSupport = IsMwaitSupport ();
 240   AsmRelocateApLoopFunc = (ASM_RELOCATE_AP_LOOP) (UINTN) mReservedApLoopFunc;
 241   AsmRelocateApLoopFunc (
 242     MwaitSupport,
 243     CpuMpData->ApTargetCState,
 244     CpuMpData->PmCodeSegment,
 245     mReservedTopOfApStack - ProcessorNumber * AP_SAFE_STACK_SIZE,
 246     (UINTN) &mNumberToFinish
 247     );
 248   //
 249   // It should never reach here
 250   //
 251   ASSERT (FALSE);
 252 }
 253
 254 /**
 255   Callback function for ExitBootServices.
 256
 257   @param[in]  Event             Event whose notification function is being invoked.
 258   @param[in]  Context           The pointer to the notification function's context,
 259                                 which is implementation-dependent.
 260
 261 **/
 262 VOID
 263 EFIAPI
 264 MpInitChangeApLoopCallback (
 265   IN EFI_EVENT                Event,
 266   IN VOID                     *Context
 267   )
 268 {
 269   CPU_MP_DATA               *CpuMpData;
 270
 271   CpuMpData = GetCpuMpData ();
 272   CpuMpData->PmCodeSegment = GetProtectedModeCS ();
 273   CpuMpData->ApLoopMode = PcdGet8 (PcdCpuApLoopMode);
 274   mNumberToFinish = CpuMpData->CpuCount - 1;
 275   WakeUpAP (CpuMpData, TRUE, 0, RelocateApLoop, NULL);
 276   while (mNumberToFinish > 0) {
 277     CpuPause ();
 278   }
 279   DEBUG ((DEBUG_INFO, "%a() done!\n", __FUNCTION__));
 280 }
 281
 282 /**
 283   Initialize global data for MP support.
 284
 285   @param[in] CpuMpData  The pointer to CPU MP Data structure.
 286 **/
 287 VOID
 288 InitMpGlobalData (
 289   IN CPU_MP_DATA               *CpuMpData
 290   )
 291 {
 292   EFI_STATUS                          Status;
 293   EFI_PHYSICAL_ADDRESS                Address;
 294   UINTN                               ApSafeBufferSize;
 295   UINTN                               Index;
 296   EFI_GCD_MEMORY_SPACE_DESCRIPTOR     MemDesc;
 297   UINTN                               StackBase;
 298
 299   SaveCpuMpData (CpuMpData);
 300
 301   if (CpuMpData->CpuCount == 1) {
 302     //
 303     // If only BSP exists, return
 304     //
 305     return;
 306   }
 307
 308   if (PcdGetBool (PcdCpuStackGuard)) {
 309     //
 310     // One extra page at the bottom of the stack is needed for Guard page.
 311     //
 312     if (CpuMpData->CpuApStackSize <= EFI_PAGE_SIZE) {
 313       DEBUG ((DEBUG_ERROR, "PcdCpuApStackSize is not big enough for Stack Guard!\n"));
 314       ASSERT (FALSE);
 315     }
 316
 317     for (Index = 0; Index < CpuMpData->CpuCount; ++Index) {
 318       StackBase = CpuMpData->Buffer + Index * CpuMpData->CpuApStackSize;
 319
 320       Status = gDS->GetMemorySpaceDescriptor (StackBase, &MemDesc);
 321       ASSERT_EFI_ERROR (Status);
 322
 323       Status = gDS->SetMemorySpaceAttributes (
 324                       StackBase,
 325                       EFI_PAGES_TO_SIZE (1),
 326                       MemDesc.Attributes | EFI_MEMORY_RP
 327                       );
 328       ASSERT_EFI_ERROR (Status);
 329     }
 330   }
 331
 332   //
 333   // Avoid APs access invalid buffer data which allocated by BootServices,
 334   // so we will allocate reserved data for AP loop code. We also need to
 335   // allocate this buffer below 4GB due to APs may be transferred to 32bit
 336   // protected mode on long mode DXE.
 337   // Allocating it in advance since memory services are not available in
 338   // Exit Boot Services callback function.
 339   //
 340   ApSafeBufferSize  = CpuMpData->AddressMap.RelocateApLoopFuncSize;
 341   ApSafeBufferSize += CpuMpData->CpuCount * AP_SAFE_STACK_SIZE;
 342
 343   Address = BASE_4GB - 1;
 344   Status  = gBS->AllocatePages (
 345                    AllocateMaxAddress,
 346                    EfiReservedMemoryType,
 347                    EFI_SIZE_TO_PAGES (ApSafeBufferSize),
 348                    &Address
 349                    );
 350   ASSERT_EFI_ERROR (Status);
 351   mReservedApLoopFunc = (VOID *) (UINTN) Address;
 352   ASSERT (mReservedApLoopFunc != NULL);
 353   mReservedTopOfApStack = (UINTN) Address + EFI_PAGES_TO_SIZE (EFI_SIZE_TO_PAGES (ApSafeBufferSize));
 354   ASSERT ((mReservedTopOfApStack & (UINTN)(CPU_STACK_ALIGNMENT - 1)) == 0);
 355   CopyMem (
 356     mReservedApLoopFunc,
 357     CpuMpData->AddressMap.RelocateApLoopFuncAddress,
 358     CpuMpData->AddressMap.RelocateApLoopFuncSize
 359     );
 360
 361   Status = gBS->CreateEvent (
 362                   EVT_TIMER | EVT_NOTIFY_SIGNAL,
 363                   TPL_NOTIFY,
 364                   CheckApsStatus,
 365                   NULL,
 366                   &mCheckAllApsEvent
 367                   );
 368   ASSERT_EFI_ERROR (Status);
 369
 370   //
 371   // Set timer to check all APs status.
 372   //
 373   Status = gBS->SetTimer (
 374                   mCheckAllApsEvent,
 375                   TimerPeriodic,
 376                   AP_CHECK_INTERVAL
 377                   );
 378   ASSERT_EFI_ERROR (Status);
 379
 380   Status = gBS->CreateEvent (
 381                   EVT_SIGNAL_EXIT_BOOT_SERVICES,
 382                   TPL_CALLBACK,
 383                   MpInitChangeApLoopCallback,
 384                   NULL,
 385                   &mMpInitExitBootServicesEvent
 386                   );
 387   ASSERT_EFI_ERROR (Status);
 388
 389   Status = gBS->CreateEventEx (
 390                   EVT_NOTIFY_SIGNAL,
 391                   TPL_CALLBACK,
 392                   MpInitChangeApLoopCallback,
 393                   NULL,
 394                   &gEfiEventLegacyBootGuid,
 395                   &mLegacyBootEvent
 396                   );
 397   ASSERT_EFI_ERROR (Status);
 398 }
 399
 400 /**
 401   This service executes a caller provided function on all enabled APs.
 402
 403   @param[in]  Procedure               A pointer to the function to be run on
 404                                       enabled APs of the system. See type
 405                                       EFI_AP_PROCEDURE.
 406   @param[in]  SingleThread            If TRUE, then all the enabled APs execute
 407                                       the function specified by Procedure one by
 408                                       one, in ascending order of processor handle
 409                                       number.  If FALSE, then all the enabled APs
 410                                       execute the function specified by Procedure
 411                                       simultaneously.
 412   @param[in]  WaitEvent               The event created by the caller with CreateEvent()
 413                                       service.  If it is NULL, then execute in
 414                                       blocking mode. BSP waits until all APs finish
 415                                       or TimeoutInMicroSeconds expires.  If it's
 416                                       not NULL, then execute in non-blocking mode.
 417                                       BSP requests the function specified by
 418                                       Procedure to be started on all the enabled
 419                                       APs, and go on executing immediately. If
 420                                       all return from Procedure, or TimeoutInMicroSeconds
 421                                       expires, this event is signaled. The BSP
 422                                       can use the CheckEvent() or WaitForEvent()
 423                                       services to check the state of event.  Type
 424                                       EFI_EVENT is defined in CreateEvent() in
 425                                       the Unified Extensible Firmware Interface
 426                                       Specification.
 427   @param[in]  TimeoutInMicroseconds   Indicates the time limit in microseconds for
 428                                       APs to return from Procedure, either for
 429                                       blocking or non-blocking mode. Zero means
 430                                       infinity.  If the timeout expires before
 431                                       all APs return from Procedure, then Procedure
 432                                       on the failed APs is terminated. All enabled
 433                                       APs are available for next function assigned
 434                                       by MpInitLibStartupAllAPs() or
 435                                       MPInitLibStartupThisAP().
 436                                       If the timeout expires in blocking mode,
 437                                       BSP returns EFI_TIMEOUT.  If the timeout
 438                                       expires in non-blocking mode, WaitEvent
 439                                       is signaled with SignalEvent().
 440   @param[in]  ProcedureArgument       The parameter passed into Procedure for
 441                                       all APs.
 442   @param[out] FailedCpuList           If NULL, this parameter is ignored. Otherwise,
 443                                       if all APs finish successfully, then its
 444                                       content is set to NULL. If not all APs
 445                                       finish before timeout expires, then its
 446                                       content is set to address of the buffer
 447                                       holding handle numbers of the failed APs.
 448                                       The buffer is allocated by MP Initialization
 449                                       library, and it's the caller's responsibility to
 450                                       free the buffer with FreePool() service.
 451                                       In blocking mode, it is ready for consumption
 452                                       when the call returns. In non-blocking mode,
 453                                       it is ready when WaitEvent is signaled.  The
 454                                       list of failed CPU is terminated by
 455                                       END_OF_CPU_LIST.
 456
 457   @retval EFI_SUCCESS             In blocking mode, all APs have finished before
 458                                   the timeout expired.
 459   @retval EFI_SUCCESS             In non-blocking mode, function has been dispatched
 460                                   to all enabled APs.
 461   @retval EFI_UNSUPPORTED         A non-blocking mode request was made after the
 462                                   UEFI event EFI_EVENT_GROUP_READY_TO_BOOT was
 463                                   signaled.
 464   @retval EFI_UNSUPPORTED         WaitEvent is not NULL if non-blocking mode is not
 465                                   supported.
 466   @retval EFI_DEVICE_ERROR        Caller processor is AP.
 467   @retval EFI_NOT_STARTED         No enabled APs exist in the system.
 468   @retval EFI_NOT_READY           Any enabled APs are busy.
 469   @retval EFI_NOT_READY           MP Initialize Library is not initialized.
 470   @retval EFI_TIMEOUT             In blocking mode, the timeout expired before
 471                                   all enabled APs have finished.
 472   @retval EFI_INVALID_PARAMETER   Procedure is NULL.
 473
 474 **/
 475 EFI_STATUS
 476 EFIAPI
 477 MpInitLibStartupAllAPs (
 478   IN  EFI_AP_PROCEDURE          Procedure,
 479   IN  BOOLEAN                   SingleThread,
 480   IN  EFI_EVENT                 WaitEvent               OPTIONAL,
 481   IN  UINTN                     TimeoutInMicroseconds,
 482   IN  VOID                      *ProcedureArgument      OPTIONAL,
 483   OUT UINTN                     **FailedCpuList         OPTIONAL
 484   )
 485 {
 486   EFI_STATUS              Status;
 487
 488   //
 489   // Temporarily stop checkAllApsStatus for avoid resource dead-lock.
 490   //
 491   mStopCheckAllApsStatus = TRUE;
 492
 493   Status = StartupAllAPsWorker (
 494              Procedure,
 495              SingleThread,
 496              WaitEvent,
 497              TimeoutInMicroseconds,
 498              ProcedureArgument,
 499              FailedCpuList
 500              );
 501
 502   //
 503   // Start checkAllApsStatus
 504   //
 505   mStopCheckAllApsStatus = FALSE;
 506
 507   return Status;
 508 }
 509
 510 /**
 511   This service lets the caller get one enabled AP to execute a caller-provided
 512   function.
 513
 514   @param[in]  Procedure               A pointer to the function to be run on the
 515                                       designated AP of the system. See type
 516                                       EFI_AP_PROCEDURE.
 517   @param[in]  ProcessorNumber         The handle number of the AP. The range is
 518                                       from 0 to the total number of logical
 519                                       processors minus 1. The total number of
 520                                       logical processors can be retrieved by
 521                                       MpInitLibGetNumberOfProcessors().
 522   @param[in]  WaitEvent               The event created by the caller with CreateEvent()
 523                                       service.  If it is NULL, then execute in
 524                                       blocking mode. BSP waits until this AP finish
 525                                       or TimeoutInMicroSeconds expires.  If it's
 526                                       not NULL, then execute in non-blocking mode.
 527                                       BSP requests the function specified by
 528                                       Procedure to be started on this AP,
 529                                       and go on executing immediately. If this AP
 530                                       return from Procedure or TimeoutInMicroSeconds
 531                                       expires, this event is signaled. The BSP
 532                                       can use the CheckEvent() or WaitForEvent()
 533                                       services to check the state of event.  Type
 534                                       EFI_EVENT is defined in CreateEvent() in
 535                                       the Unified Extensible Firmware Interface
 536                                       Specification.
 537   @param[in]  TimeoutInMicroseconds   Indicates the time limit in microseconds for
 538                                       this AP to finish this Procedure, either for
 539                                       blocking or non-blocking mode. Zero means
 540                                       infinity.  If the timeout expires before
 541                                       this AP returns from Procedure, then Procedure
 542                                       on the AP is terminated. The
 543                                       AP is available for next function assigned
 544                                       by MpInitLibStartupAllAPs() or
 545                                       MpInitLibStartupThisAP().
 546                                       If the timeout expires in blocking mode,
 547                                       BSP returns EFI_TIMEOUT.  If the timeout
 548                                       expires in non-blocking mode, WaitEvent
 549                                       is signaled with SignalEvent().
 550   @param[in]  ProcedureArgument       The parameter passed into Procedure on the
 551                                       specified AP.
 552   @param[out] Finished                If NULL, this parameter is ignored.  In
 553                                       blocking mode, this parameter is ignored.
 554                                       In non-blocking mode, if AP returns from
 555                                       Procedure before the timeout expires, its
 556                                       content is set to TRUE. Otherwise, the
 557                                       value is set to FALSE. The caller can
 558                                       determine if the AP returned from Procedure
 559                                       by evaluating this value.
 560
 561   @retval EFI_SUCCESS             In blocking mode, specified AP finished before
 562                                   the timeout expires.
 563   @retval EFI_SUCCESS             In non-blocking mode, the function has been
 564                                   dispatched to specified AP.
 565   @retval EFI_UNSUPPORTED         A non-blocking mode request was made after the
 566                                   UEFI event EFI_EVENT_GROUP_READY_TO_BOOT was
 567                                   signaled.
 568   @retval EFI_UNSUPPORTED         WaitEvent is not NULL if non-blocking mode is not
 569                                   supported.
 570   @retval EFI_DEVICE_ERROR        The calling processor is an AP.
 571   @retval EFI_TIMEOUT             In blocking mode, the timeout expired before
 572                                   the specified AP has finished.
 573   @retval EFI_NOT_READY           The specified AP is busy.
 574   @retval EFI_NOT_READY           MP Initialize Library is not initialized.
 575   @retval EFI_NOT_FOUND           The processor with the handle specified by
 576                                   ProcessorNumber does not exist.
 577   @retval EFI_INVALID_PARAMETER   ProcessorNumber specifies the BSP or disabled AP.
 578   @retval EFI_INVALID_PARAMETER   Procedure is NULL.
 579
 580 **/
 581 EFI_STATUS
 582 EFIAPI
 583 MpInitLibStartupThisAP (
 584   IN  EFI_AP_PROCEDURE          Procedure,
 585   IN  UINTN                     ProcessorNumber,
 586   IN  EFI_EVENT                 WaitEvent               OPTIONAL,
 587   IN  UINTN                     TimeoutInMicroseconds,
 588   IN  VOID                      *ProcedureArgument      OPTIONAL,
 589   OUT BOOLEAN                   *Finished               OPTIONAL
 590   )
 591 {
 592   EFI_STATUS              Status;
 593
 594   //
 595   // temporarily stop checkAllApsStatus for avoid resource dead-lock.
 596   //
 597   mStopCheckAllApsStatus = TRUE;
 598
 599   Status = StartupThisAPWorker (
 600              Procedure,
 601              ProcessorNumber,
 602              WaitEvent,
 603              TimeoutInMicroseconds,
 604              ProcedureArgument,
 605              Finished
 606              );
 607
 608   mStopCheckAllApsStatus = FALSE;
 609
 610   return Status;
 611 }
 612
 613 /**
 614   This service switches the requested AP to be the BSP from that point onward.
 615   This service changes the BSP for all purposes. This call can only be performed
 616   by the current BSP.
 617
 618   @param[in] ProcessorNumber   The handle number of AP that is to become the new
 619                                BSP. The range is from 0 to the total number of
 620                                logical processors minus 1. The total number of
 621                                logical processors can be retrieved by
 622                                MpInitLibGetNumberOfProcessors().
 623   @param[in] EnableOldBSP      If TRUE, then the old BSP will be listed as an
 624                                enabled AP. Otherwise, it will be disabled.
 625
 626   @retval EFI_SUCCESS             BSP successfully switched.
 627   @retval EFI_UNSUPPORTED         Switching the BSP cannot be completed prior to
 628                                   this service returning.
 629   @retval EFI_UNSUPPORTED         Switching the BSP is not supported.
 630   @retval EFI_DEVICE_ERROR        The calling processor is an AP.
 631   @retval EFI_NOT_FOUND           The processor with the handle specified by
 632                                   ProcessorNumber does not exist.
 633   @retval EFI_INVALID_PARAMETER   ProcessorNumber specifies the current BSP or
 634                                   a disabled AP.
 635   @retval EFI_NOT_READY           The specified AP is busy.
 636   @retval EFI_NOT_READY           MP Initialize Library is not initialized.
 637
 638 **/
 639 EFI_STATUS
 640 EFIAPI
 641 MpInitLibSwitchBSP (
 642   IN UINTN                     ProcessorNumber,
 643   IN BOOLEAN                   EnableOldBSP
 644   )
 645 {
 646   EFI_STATUS                   Status;
 647   EFI_TIMER_ARCH_PROTOCOL      *Timer;
 648   UINT64                       TimerPeriod;
 649
 650   TimerPeriod = 0;
 651   //
 652   // Locate Timer Arch Protocol
 653   //
 654   Status = gBS->LocateProtocol (&gEfiTimerArchProtocolGuid, NULL, (VOID **) &Timer);
 655   if (EFI_ERROR (Status)) {
 656     Timer = NULL;
 657   }
 658
 659   if (Timer != NULL) {
 660     //
 661     // Save current rate of DXE Timer
 662     //
 663     Timer->GetTimerPeriod (Timer, &TimerPeriod);
 664     //
 665     // Disable DXE Timer and drain pending interrupts
 666     //
 667     Timer->SetTimerPeriod (Timer, 0);
 668   }
 669
 670   Status = SwitchBSPWorker (ProcessorNumber, EnableOldBSP);
 671
 672   if (Timer != NULL) {
 673     //
 674     // Enable and restore rate of DXE Timer
 675     //
 676     Timer->SetTimerPeriod (Timer, TimerPeriod);
 677   }
 678
 679   return Status;
 680 }
 681
 682 /**
 683   This service lets the caller enable or disable an AP from this point onward.
 684   This service may only be called from the BSP.
 685
 686   @param[in] ProcessorNumber   The handle number of AP.
 687                                The range is from 0 to the total number of
 688                                logical processors minus 1. The total number of
 689                                logical processors can be retrieved by
 690                                MpInitLibGetNumberOfProcessors().
 691   @param[in] EnableAP          Specifies the new state for the processor for
 692                                enabled, FALSE for disabled.
 693   @param[in] HealthFlag        If not NULL, a pointer to a value that specifies
 694                                the new health status of the AP. This flag
 695                                corresponds to StatusFlag defined in
 696                                EFI_MP_SERVICES_PROTOCOL.GetProcessorInfo(). Only
 697                                the PROCESSOR_HEALTH_STATUS_BIT is used. All other
 698                                bits are ignored.  If it is NULL, this parameter
 699                                is ignored.
 700
 701   @retval EFI_SUCCESS             The specified AP was enabled or disabled successfully.
 702   @retval EFI_UNSUPPORTED         Enabling or disabling an AP cannot be completed
 703                                   prior to this service returning.
 704   @retval EFI_UNSUPPORTED         Enabling or disabling an AP is not supported.
 705   @retval EFI_DEVICE_ERROR        The calling processor is an AP.
 706   @retval EFI_NOT_FOUND           Processor with the handle specified by ProcessorNumber
 707                                   does not exist.
 708   @retval EFI_INVALID_PARAMETER   ProcessorNumber specifies the BSP.
 709   @retval EFI_NOT_READY           MP Initialize Library is not initialized.
 710
 711 **/
 712 EFI_STATUS
 713 EFIAPI
 714 MpInitLibEnableDisableAP (
 715   IN  UINTN                     ProcessorNumber,
 716   IN  BOOLEAN                   EnableAP,
 717   IN  UINT32                    *HealthFlag OPTIONAL
 718   )
 719 {
 720   EFI_STATUS     Status;
 721   BOOLEAN        TempStopCheckState;
 722
 723   TempStopCheckState = FALSE;
 724   //
 725   // temporarily stop checkAllAPsStatus for initialize parameters.
 726   //
 727   if (!mStopCheckAllApsStatus) {
 728     mStopCheckAllApsStatus = TRUE;
 729     TempStopCheckState     = TRUE;
 730   }
 731
 732   Status = EnableDisableApWorker (ProcessorNumber, EnableAP, HealthFlag);
 733
 734   if (TempStopCheckState) {
 735     mStopCheckAllApsStatus = FALSE;
 736   }
 737
 738   return Status;
 739 }