UefiCpuPkg/CpuMpPei/CpuMpPei.c

   1 /** @file
   2   CPU PEI Module installs CPU Multiple Processor PPI.
   3
   4   Copyright (c) 2015, 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 "CpuMpPei.h"
  16
  17 //
  18 // Global Descriptor Table (GDT)
  19 //
  20 GLOBAL_REMOVE_IF_UNREFERENCED IA32_GDT mGdtEntries[] = {
  21 /* selector { Global Segment Descriptor                              } */
  22 /* 0x00 */  {{0,      0,  0,  0,    0,  0,  0,  0,    0,  0, 0,  0,  0}}, //null descriptor
  23 /* 0x08 */  {{0xffff, 0,  0,  0x2,  1,  0,  1,  0xf,  0,  0, 1,  1,  0}}, //linear data segment descriptor
  24 /* 0x10 */  {{0xffff, 0,  0,  0xf,  1,  0,  1,  0xf,  0,  0, 1,  1,  0}}, //linear code segment descriptor
  25 /* 0x18 */  {{0xffff, 0,  0,  0x3,  1,  0,  1,  0xf,  0,  0, 1,  1,  0}}, //system data segment descriptor
  26 /* 0x20 */  {{0xffff, 0,  0,  0xa,  1,  0,  1,  0xf,  0,  0, 1,  1,  0}}, //system code segment descriptor
  27 /* 0x28 */  {{0,      0,  0,  0,    0,  0,  0,  0,    0,  0, 0,  0,  0}}, //spare segment descriptor
  28 /* 0x30 */  {{0xffff, 0,  0,  0x2,  1,  0,  1,  0xf,  0,  0, 1,  1,  0}}, //system data segment descriptor
  29 /* 0x38 */  {{0xffff, 0,  0,  0xa,  1,  0,  1,  0xf,  0,  1, 0,  1,  0}}, //system code segment descriptor
  30 /* 0x40 */  {{0,      0,  0,  0,    0,  0,  0,  0,    0,  0, 0,  0,  0}}, //spare segment descriptor
  31 };
  32
  33 //
  34 // IA32 Gdt register
  35 //
  36 GLOBAL_REMOVE_IF_UNREFERENCED IA32_DESCRIPTOR mGdt = {
  37   sizeof (mGdtEntries) - 1,
  38   (UINTN) mGdtEntries
  39   };
  40
  41 GLOBAL_REMOVE_IF_UNREFERENCED EFI_PEI_NOTIFY_DESCRIPTOR mNotifyList = {
  42   (EFI_PEI_PPI_DESCRIPTOR_NOTIFY_CALLBACK | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST),
  43   &gEfiEndOfPeiSignalPpiGuid,
  44   CpuMpEndOfPeiCallback
  45 };
  46
  47 /**
  48   Sort the APIC ID of all processors.
  49
  50   This function sorts the APIC ID of all processors so that processor number is
  51   assigned in the ascending order of APIC ID which eases MP debugging.
  52
  53   @param PeiCpuMpData        Pointer to PEI CPU MP Data
  54 **/
  55 VOID
  56 SortApicId (
  57   IN PEI_CPU_MP_DATA   *PeiCpuMpData
  58   )
  59 {
  60   UINTN             Index1;
  61   UINTN             Index2;
  62   UINTN             Index3;
  63   UINT32            ApicId;
  64   EFI_HEALTH_FLAGS  Health;
  65   UINT32            ApCount;
  66
  67   ApCount = PeiCpuMpData->CpuCount - 1;
  68
  69   if (ApCount != 0) {
  70     for (Index1 = 0; Index1 < ApCount; Index1++) {
  71       Index3 = Index1;
  72       //
  73       // Sort key is the hardware default APIC ID
  74       //
  75       ApicId = PeiCpuMpData->CpuData[Index1].ApicId;
  76       for (Index2 = Index1 + 1; Index2 <= ApCount; Index2++) {
  77         if (ApicId > PeiCpuMpData->CpuData[Index2].ApicId) {
  78           Index3 = Index2;
  79           ApicId = PeiCpuMpData->CpuData[Index2].ApicId;
  80         }
  81       }
  82       if (Index3 != Index1) {
  83         PeiCpuMpData->CpuData[Index3].ApicId = PeiCpuMpData->CpuData[Index1].ApicId;
  84         PeiCpuMpData->CpuData[Index1].ApicId = ApicId;
  85         Health = PeiCpuMpData->CpuData[Index3].Health;
  86         PeiCpuMpData->CpuData[Index3].Health = PeiCpuMpData->CpuData[Index1].Health;
  87         PeiCpuMpData->CpuData[Index1].Health = Health;
  88       }
  89     }
  90
  91     //
  92     // Get the processor number for the BSP
  93     //
  94     ApicId = GetInitialApicId ();
  95     for (Index1 = 0; Index1 < PeiCpuMpData->CpuCount; Index1++) {
  96       if (PeiCpuMpData->CpuData[Index1].ApicId == ApicId) {
  97         PeiCpuMpData->BspNumber = (UINT32) Index1;
  98         break;
  99       }
 100     }
 101   }
 102 }
 103
 104 /**
 105   Get CPU MP Data pointer from the Guided HOB.
 106
 107   @return  Pointer to Pointer to PEI CPU MP Data
 108 **/
 109 PEI_CPU_MP_DATA *
 110 GetMpHobData (
 111   VOID
 112   )
 113 {
 114   EFI_HOB_GUID_TYPE       *GuidHob;
 115   VOID                    *DataInHob;
 116   PEI_CPU_MP_DATA         *CpuMpData;
 117
 118   CpuMpData = NULL;
 119   GuidHob = GetFirstGuidHob (&gEfiCallerIdGuid);
 120   if (GuidHob != NULL) {
 121     DataInHob = GET_GUID_HOB_DATA (GuidHob);
 122     CpuMpData = (PEI_CPU_MP_DATA *)(*(UINTN *)DataInHob);
 123   }
 124   ASSERT (CpuMpData != NULL);
 125   return CpuMpData;
 126 }
 127
 128 /**
 129   This function will be called from AP reset code if BSP uses WakeUpAP.
 130
 131   @param ExchangeInfo     Pointer to the MP exchange info buffer
 132   @param NumApsExecuting  Number of curret executing AP
 133 **/
 134 VOID
 135 EFIAPI
 136 ApCFunction (
 137   IN MP_CPU_EXCHANGE_INFO      *ExchangeInfo,
 138   IN UINTN                     NumApsExecuting
 139   )
 140 {
 141   PEI_CPU_MP_DATA            *PeiCpuMpData;
 142   UINTN                      ProcessorNumber;
 143   EFI_AP_PROCEDURE           Procedure;
 144   UINTN                      BistData;
 145
 146   PeiCpuMpData = ExchangeInfo->PeiCpuMpData;
 147   if (PeiCpuMpData->InitFlag) {
 148     //
 149     // This is first time AP wakeup, get BIST inforamtion from AP stack
 150     //
 151     BistData = *(UINTN *) (PeiCpuMpData->Buffer + NumApsExecuting * PeiCpuMpData->CpuApStackSize - sizeof (UINTN));
 152     PeiCpuMpData->CpuData[NumApsExecuting].ApicId        = GetInitialApicId ();
 153     PeiCpuMpData->CpuData[NumApsExecuting].Health.Uint32 = (UINT32) BistData;
 154     //
 155     // Sync BSP's Mtrr table to all wakeup APs and load microcode on APs.
 156     //
 157     MtrrSetAllMtrrs (&PeiCpuMpData->MtrrTable);
 158     MicrocodeDetect ();
 159   } else {
 160     //
 161     // Execute AP function if AP is not disabled
 162     //
 163     GetProcessorNumber (PeiCpuMpData, &ProcessorNumber);
 164     if ((PeiCpuMpData->CpuData[ProcessorNumber].State != CpuStateDisabled) &&
 165         (PeiCpuMpData->ApFunction != 0)) {
 166       PeiCpuMpData->CpuData[ProcessorNumber].State = CpuStateBusy;
 167       Procedure = (EFI_AP_PROCEDURE)(UINTN)PeiCpuMpData->ApFunction;
 168       Procedure ((VOID *)(UINTN)PeiCpuMpData->ApFunctionArgument);
 169       PeiCpuMpData->CpuData[ProcessorNumber].State = CpuStateIdle;
 170     }
 171   }
 172
 173   //
 174   // AP finished executing C code
 175   //
 176   InterlockedIncrement ((UINT32 *)&PeiCpuMpData->FinishedCount);
 177
 178   AsmCliHltLoop ();
 179 }
 180
 181 /**
 182   This function will be called by BSP to wakeup AP.
 183
 184   @param PeiCpuMpData       Pointer to PEI CPU MP Data
 185   @param Broadcast          TRUE:  Send broadcast IPI to all APs
 186                             FALSE: Send IPI to AP by ApicId
 187   @param ApicId             Apic ID for the processor to be waked
 188   @param Procedure          The function to be invoked by AP
 189   @param ProcedureArgument  The argument to be passed into AP function
 190 **/
 191 VOID
 192 WakeUpAP (
 193   IN PEI_CPU_MP_DATA           *PeiCpuMpData,
 194   IN BOOLEAN                   Broadcast,
 195   IN UINT32                    ApicId,
 196   IN EFI_AP_PROCEDURE          Procedure,              OPTIONAL
 197   IN VOID                      *ProcedureArgument      OPTIONAL
 198   )
 199 {
 200   volatile MP_CPU_EXCHANGE_INFO    *ExchangeInfo;
 201
 202   PeiCpuMpData->ApFunction         = (UINTN) Procedure;
 203   PeiCpuMpData->ApFunctionArgument = (UINTN) ProcedureArgument;
 204   PeiCpuMpData->FinishedCount      = 0;
 205
 206   ExchangeInfo                     = PeiCpuMpData->MpCpuExchangeInfo;
 207   ExchangeInfo->Lock               = 0;
 208   ExchangeInfo->StackStart         = PeiCpuMpData->Buffer;
 209   ExchangeInfo->StackSize          = PeiCpuMpData->CpuApStackSize;
 210   ExchangeInfo->BufferStart        = PeiCpuMpData->WakeupBuffer;
 211   ExchangeInfo->PmodeOffset        = PeiCpuMpData->AddressMap.PModeEntryOffset;
 212   ExchangeInfo->LmodeOffset        = PeiCpuMpData->AddressMap.LModeEntryOffset;
 213   ExchangeInfo->Cr3                = AsmReadCr3 ();
 214   ExchangeInfo->CFunction          = (UINTN) ApCFunction;
 215   ExchangeInfo->NumApsExecuting    = 0;
 216   ExchangeInfo->PeiCpuMpData       = PeiCpuMpData;
 217
 218   //
 219   // Get the BSP's data of GDT and IDT
 220   //
 221   CopyMem ((VOID *)&ExchangeInfo->GdtrProfile, &mGdt, sizeof(mGdt));
 222   AsmReadIdtr ((IA32_DESCRIPTOR *) &ExchangeInfo->IdtrProfile);
 223
 224   if (Broadcast) {
 225     SendInitSipiSipiAllExcludingSelf ((UINT32) ExchangeInfo->BufferStart);
 226   } else {
 227     SendInitSipiSipi (ApicId, (UINT32) ExchangeInfo->BufferStart);
 228   }
 229
 230   return ;
 231 }
 232
 233 /**
 234   Get available system memory below 1MB by specified size.
 235
 236   @param  WakeupBufferSize   Wakeup buffer size required
 237
 238   @retval other   Return wakeup buffer address below 1MB.
 239   @retval -1      Cannot find free memory below 1MB.
 240 **/
 241 UINTN
 242 GetWakeupBuffer (
 243   IN UINTN                WakeupBufferSize
 244   )
 245 {
 246   EFI_PEI_HOB_POINTERS    Hob;
 247   UINTN                   WakeupBufferStart;
 248   UINTN                   WakeupBufferEnd;
 249
 250   //
 251   // Get the HOB list for processing
 252   //
 253   Hob.Raw = GetHobList ();
 254
 255   //
 256   // Collect memory ranges
 257   //
 258   while (!END_OF_HOB_LIST (Hob)) {
 259     if (Hob.Header->HobType == EFI_HOB_TYPE_RESOURCE_DESCRIPTOR) {
 260       if ((Hob.ResourceDescriptor->PhysicalStart < BASE_1MB) &&
 261           (Hob.ResourceDescriptor->ResourceType == EFI_RESOURCE_SYSTEM_MEMORY) &&
 262           ((Hob.ResourceDescriptor->ResourceAttribute &
 263             (EFI_RESOURCE_ATTRIBUTE_READ_PROTECTED |
 264              EFI_RESOURCE_ATTRIBUTE_WRITE_PROTECTED |
 265              EFI_RESOURCE_ATTRIBUTE_EXECUTION_PROTECTED
 266              )) == 0)
 267            ) {
 268         //
 269         // Need memory under 1MB to be collected here
 270         //
 271         WakeupBufferEnd = (UINTN) (Hob.ResourceDescriptor->PhysicalStart + Hob.ResourceDescriptor->ResourceLength);
 272         if (WakeupBufferEnd > BASE_1MB) {
 273           //
 274           // Wakeup buffer should be under 1MB
 275           //
 276           WakeupBufferEnd = BASE_1MB;
 277         }
 278         //
 279         // Wakeup buffer should be aligned on 4KB
 280         //
 281         WakeupBufferStart = (WakeupBufferEnd - WakeupBufferSize) & ~(SIZE_4KB - 1);
 282         if (WakeupBufferStart < Hob.ResourceDescriptor->PhysicalStart) {
 283           continue;
 284         }
 285         //
 286         // Create a memory allocation HOB.
 287         //
 288         BuildMemoryAllocationHob (
 289           WakeupBufferStart,
 290           WakeupBufferSize,
 291           EfiBootServicesData
 292           );
 293         return WakeupBufferStart;
 294       }
 295     }
 296     //
 297     // Find the next HOB
 298     //
 299     Hob.Raw = GET_NEXT_HOB (Hob);
 300   }
 301
 302   return (UINTN) -1;
 303 }
 304
 305 /**
 306   Get available system memory below 1MB by specified size.
 307
 308   @param PeiCpuMpData        Pointer to PEI CPU MP Data
 309 **/
 310 VOID
 311 BackupAndPrepareWakeupBuffer(
 312   IN PEI_CPU_MP_DATA         *PeiCpuMpData
 313   )
 314 {
 315   CopyMem (
 316     (VOID *) PeiCpuMpData->BackupBuffer,
 317     (VOID *) PeiCpuMpData->WakeupBuffer,
 318     PeiCpuMpData->BackupBufferSize
 319     );
 320   CopyMem (
 321     (VOID *) PeiCpuMpData->WakeupBuffer,
 322     (VOID *) PeiCpuMpData->AddressMap.RendezvousFunnelAddress,
 323     PeiCpuMpData->AddressMap.RendezvousFunnelSize
 324     );
 325 }
 326
 327 /**
 328   Restore wakeup buffer data.
 329
 330   @param PeiCpuMpData        Pointer to PEI CPU MP Data
 331 **/
 332 VOID
 333 RestoreWakeupBuffer(
 334   IN PEI_CPU_MP_DATA         *PeiCpuMpData
 335   )
 336 {
 337   CopyMem ((VOID *) PeiCpuMpData->WakeupBuffer, (VOID *) PeiCpuMpData->BackupBuffer, PeiCpuMpData->BackupBufferSize);
 338 }
 339
 340 /**
 341   This function will get CPU count in the system.
 342
 343   @param PeiCpuMpData        Pointer to PEI CPU MP Data
 344
 345   @return  AP processor count
 346 **/
 347 UINT32
 348 CountProcessorNumber (
 349   IN PEI_CPU_MP_DATA            *PeiCpuMpData
 350   )
 351 {
 352   //
 353   // Load Microcode on BSP
 354   //
 355   MicrocodeDetect ();
 356   //
 357   // Store BSP's MTRR setting
 358   //
 359   MtrrGetAllMtrrs (&PeiCpuMpData->MtrrTable);
 360   //
 361   // Send broadcast IPI to APs to wakeup APs
 362   //
 363   PeiCpuMpData->InitFlag = 1;
 364   WakeUpAP (PeiCpuMpData, TRUE, 0, NULL, NULL);
 365   //
 366   // Wait for AP task to complete and then exit.
 367   //
 368   MicroSecondDelay (PcdGet32 (PcdCpuApInitTimeOutInMicroSeconds));
 369   PeiCpuMpData->InitFlag  = 0;
 370   PeiCpuMpData->CpuCount += (UINT32) PeiCpuMpData->MpCpuExchangeInfo->NumApsExecuting;
 371   ASSERT (PeiCpuMpData->CpuCount <= PcdGet32(PcdCpuMaxLogicalProcessorNumber));
 372   //
 373   // Sort BSP/Aps by CPU APIC ID in ascending order
 374   //
 375   SortApicId (PeiCpuMpData);
 376
 377   DEBUG ((EFI_D_INFO, "CpuMpPei: Find %d processors in system.\n", PeiCpuMpData->CpuCount));
 378   return PeiCpuMpData->CpuCount;
 379 }
 380
 381 /**
 382   Prepare for AP wakeup buffer and copy AP reset code into it.
 383
 384   Get wakeup buffer below 1MB. Allocate memory for CPU MP Data and APs Stack.
 385
 386   @return   Pointer to PEI CPU MP Data
 387 **/
 388 PEI_CPU_MP_DATA *
 389 PrepareAPStartupVector (
 390   VOID
 391   )
 392 {
 393   EFI_STATUS                    Status;
 394   UINT32                        MaxCpuCount;
 395   PEI_CPU_MP_DATA               *PeiCpuMpData;
 396   EFI_PHYSICAL_ADDRESS          Buffer;
 397   UINTN                         BufferSize;
 398   UINTN                         WakeupBuffer;
 399   UINTN                         WakeupBufferSize;
 400   MP_ASSEMBLY_ADDRESS_MAP       AddressMap;
 401
 402   AsmGetAddressMap (&AddressMap);
 403   WakeupBufferSize = AddressMap.RendezvousFunnelSize + sizeof (MP_CPU_EXCHANGE_INFO);
 404   WakeupBuffer     = GetWakeupBuffer ((WakeupBufferSize + SIZE_4KB - 1) & ~(SIZE_4KB - 1));
 405   ASSERT (WakeupBuffer != (UINTN) -1);
 406   DEBUG ((EFI_D_INFO, "CpuMpPei: WakeupBuffer = 0x%x\n", WakeupBuffer));
 407
 408   //
 409   // Allocate Pages for APs stack, CPU MP Data and backup buffer for wakeup buffer
 410   //
 411   MaxCpuCount = PcdGet32(PcdCpuMaxLogicalProcessorNumber);
 412   BufferSize  = PcdGet32 (PcdCpuApStackSize) * MaxCpuCount + sizeof (PEI_CPU_MP_DATA)
 413                   + WakeupBufferSize + sizeof (PEI_CPU_DATA) * MaxCpuCount;
 414   Status = PeiServicesAllocatePages (
 415              EfiBootServicesData,
 416              EFI_SIZE_TO_PAGES (BufferSize),
 417              &Buffer
 418              );
 419   ASSERT_EFI_ERROR (Status);
 420
 421   PeiCpuMpData = (PEI_CPU_MP_DATA *) (UINTN) (Buffer + PcdGet32 (PcdCpuApStackSize) * MaxCpuCount);
 422   PeiCpuMpData->Buffer            = (UINTN) Buffer;
 423   PeiCpuMpData->CpuApStackSize    = PcdGet32 (PcdCpuApStackSize);
 424   PeiCpuMpData->WakeupBuffer      = WakeupBuffer;
 425   PeiCpuMpData->BackupBuffer      = (UINTN)PeiCpuMpData + sizeof (PEI_CPU_MP_DATA);
 426   PeiCpuMpData->BackupBufferSize  = WakeupBufferSize;
 427   PeiCpuMpData->MpCpuExchangeInfo = (MP_CPU_EXCHANGE_INFO *) (UINTN) (WakeupBuffer + AddressMap.RendezvousFunnelSize);
 428
 429   PeiCpuMpData->CpuCount                 = 1;
 430   PeiCpuMpData->BspNumber                = 0;
 431   PeiCpuMpData->CpuData                  = (PEI_CPU_DATA *) (PeiCpuMpData->BackupBuffer +
 432                                                              PeiCpuMpData->BackupBufferSize);
 433   PeiCpuMpData->CpuData[0].ApicId        = GetInitialApicId ();
 434   PeiCpuMpData->CpuData[0].Health.Uint32 = 0;
 435   PeiCpuMpData->EndOfPeiFlag             = FALSE;
 436   CopyMem (&PeiCpuMpData->AddressMap, &AddressMap, sizeof (MP_ASSEMBLY_ADDRESS_MAP));
 437
 438   //
 439   // Backup original data and copy AP reset code in it
 440   //
 441   BackupAndPrepareWakeupBuffer(PeiCpuMpData);
 442
 443   return PeiCpuMpData;
 444 }
 445
 446 /**
 447   Notify function on End Of Pei PPI.
 448
 449   On S3 boot, this function will restore wakeup buffer data.
 450   On normal boot, this function will flag wakeup buffer to be un-used type.
 451
 452   @param  PeiServices        The pointer to the PEI Services Table.
 453   @param  NotifyDescriptor   Address of the notification descriptor data structure.
 454   @param  Ppi                Address of the PPI that was installed.
 455
 456   @retval EFI_SUCCESS        When everything is OK.
 457
 458 **/
 459 EFI_STATUS
 460 EFIAPI
 461 CpuMpEndOfPeiCallback (
 462   IN      EFI_PEI_SERVICES        **PeiServices,
 463   IN EFI_PEI_NOTIFY_DESCRIPTOR    *NotifyDescriptor,
 464   IN VOID                         *Ppi
 465   )
 466 {
 467   EFI_STATUS                Status;
 468   EFI_BOOT_MODE             BootMode;
 469   PEI_CPU_MP_DATA           *PeiCpuMpData;
 470   EFI_PEI_HOB_POINTERS      Hob;
 471   EFI_HOB_MEMORY_ALLOCATION *MemoryHob;
 472
 473   DEBUG ((EFI_D_INFO, "CpuMpPei: CpuMpEndOfPeiCallback () invokded\n"));
 474
 475   Status = PeiServicesGetBootMode (&BootMode);
 476   ASSERT_EFI_ERROR (Status);
 477
 478   PeiCpuMpData = GetMpHobData ();
 479   ASSERT (PeiCpuMpData != NULL);
 480
 481   if (BootMode != BOOT_ON_S3_RESUME) {
 482     //
 483     // Get the HOB list for processing
 484     //
 485     Hob.Raw = GetHobList ();
 486     //
 487     // Collect memory ranges
 488     //
 489     while (!END_OF_HOB_LIST (Hob)) {
 490       if (Hob.Header->HobType == EFI_HOB_TYPE_MEMORY_ALLOCATION) {
 491         MemoryHob = Hob.MemoryAllocation;
 492         if(MemoryHob->AllocDescriptor.MemoryBaseAddress == PeiCpuMpData->WakeupBuffer) {
 493           //
 494           // Flag this HOB type to un-used
 495           //
 496           GET_HOB_TYPE (Hob) = EFI_HOB_TYPE_UNUSED;
 497           break;
 498         }
 499       }
 500       Hob.Raw = GET_NEXT_HOB (Hob);
 501     }
 502   } else {
 503     RestoreWakeupBuffer (PeiCpuMpData);
 504     PeiCpuMpData->EndOfPeiFlag = TRUE;
 505   }
 506   return EFI_SUCCESS;
 507 }
 508
 509 /**
 510   The Entry point of the MP CPU PEIM.
 511
 512   This function will wakeup APs and collect CPU AP count and install the
 513   Mp Service Ppi.
 514
 515   @param  FileHandle    Handle of the file being invoked.
 516   @param  PeiServices   Describes the list of possible PEI Services.
 517
 518   @retval EFI_SUCCESS   MpServicePpi is installed successfully.
 519
 520 **/
 521 EFI_STATUS
 522 EFIAPI
 523 CpuMpPeimInit (
 524   IN       EFI_PEI_FILE_HANDLE  FileHandle,
 525   IN CONST EFI_PEI_SERVICES     **PeiServices
 526   )
 527 {
 528   EFI_STATUS           Status;
 529   PEI_CPU_MP_DATA      *PeiCpuMpData;
 530   UINT32               ProcessorCount;
 531
 532   //
 533   // Load new GDT table on BSP
 534   //
 535   AsmInitializeGdt (&mGdt);
 536   //
 537   // Get wakeup buffer and copy AP reset code in it
 538   //
 539   PeiCpuMpData = PrepareAPStartupVector ();
 540   //
 541   // Count processor number and collect processor information
 542   //
 543   ProcessorCount = CountProcessorNumber (PeiCpuMpData);
 544   //
 545   // Build location of PEI CPU MP DATA buffer in HOB
 546   //
 547   BuildGuidDataHob (
 548     &gEfiCallerIdGuid,
 549     (VOID *)&PeiCpuMpData,
 550     sizeof(UINT64)
 551     );
 552   //
 553   // Update and publish CPU BIST information
 554   //
 555   CollectBistDataFromPpi (PeiServices, PeiCpuMpData);
 556   //
 557   // register an event for EndOfPei
 558   //
 559   Status  = PeiServicesNotifyPpi (&mNotifyList);
 560   ASSERT_EFI_ERROR (Status);
 561   //
 562   // Install CPU MP PPI
 563   //
 564   Status = PeiServicesInstallPpi(&mPeiCpuMpPpiDesc);
 565   ASSERT_EFI_ERROR (Status);
 566
 567   return Status;
 568 }