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->MpCpuExchangeInfo + 1);
 432   PeiCpuMpData->CpuData[0].ApicId        = GetInitialApicId ();
 433   PeiCpuMpData->CpuData[0].Health.Uint32 = 0;
 434   PeiCpuMpData->EndOfPeiFlag             = FALSE;
 435   CopyMem (&PeiCpuMpData->AddressMap, &AddressMap, sizeof (MP_ASSEMBLY_ADDRESS_MAP));
 436
 437   //
 438   // Backup original data and copy AP reset code in it
 439   //
 440   BackupAndPrepareWakeupBuffer(PeiCpuMpData);
 441
 442   return PeiCpuMpData;
 443 }
 444
 445 /**
 446   Notify function on End Of Pei PPI.
 447
 448   On S3 boot, this function will restore wakeup buffer data.
 449   On normal boot, this function will flag wakeup buffer to be un-used type.
 450
 451   @param  PeiServices        The pointer to the PEI Services Table.
 452   @param  NotifyDescriptor   Address of the notification descriptor data structure.
 453   @param  Ppi                Address of the PPI that was installed.
 454
 455   @retval EFI_SUCCESS        When everything is OK.
 456
 457 **/
 458 EFI_STATUS
 459 EFIAPI
 460 CpuMpEndOfPeiCallback (
 461   IN      EFI_PEI_SERVICES        **PeiServices,
 462   IN EFI_PEI_NOTIFY_DESCRIPTOR    *NotifyDescriptor,
 463   IN VOID                         *Ppi
 464   )
 465 {
 466   EFI_STATUS                Status;
 467   EFI_BOOT_MODE             BootMode;
 468   PEI_CPU_MP_DATA           *PeiCpuMpData;
 469   EFI_PEI_HOB_POINTERS      Hob;
 470   EFI_HOB_MEMORY_ALLOCATION *MemoryHob;
 471
 472   DEBUG ((EFI_D_INFO, "CpuMpPei: CpuMpEndOfPeiCallback () invokded\n"));
 473
 474   Status = PeiServicesGetBootMode (&BootMode);
 475   ASSERT_EFI_ERROR (Status);
 476
 477   PeiCpuMpData = GetMpHobData ();
 478   ASSERT (PeiCpuMpData != NULL);
 479
 480   if (BootMode != BOOT_ON_S3_RESUME) {
 481     //
 482     // Get the HOB list for processing
 483     //
 484     Hob.Raw = GetHobList ();
 485     //
 486     // Collect memory ranges
 487     //
 488     while (!END_OF_HOB_LIST (Hob)) {
 489       if (Hob.Header->HobType == EFI_HOB_TYPE_MEMORY_ALLOCATION) {
 490         MemoryHob = Hob.MemoryAllocation;
 491         if(MemoryHob->AllocDescriptor.MemoryBaseAddress == PeiCpuMpData->WakeupBuffer) {
 492           //
 493           // Flag this HOB type to un-used
 494           //
 495           GET_HOB_TYPE (Hob) = EFI_HOB_TYPE_UNUSED;
 496           break;
 497         }
 498       }
 499       Hob.Raw = GET_NEXT_HOB (Hob);
 500     }
 501   } else {
 502     RestoreWakeupBuffer (PeiCpuMpData);
 503     PeiCpuMpData->EndOfPeiFlag = TRUE;
 504   }
 505   return EFI_SUCCESS;
 506 }
 507
 508 /**
 509   The Entry point of the MP CPU PEIM.
 510
 511   This function will wakeup APs and collect CPU AP count and install the
 512   Mp Service Ppi.
 513
 514   @param  FileHandle    Handle of the file being invoked.
 515   @param  PeiServices   Describes the list of possible PEI Services.
 516
 517   @retval EFI_SUCCESS   MpServicePpi is installed successfully.
 518
 519 **/
 520 EFI_STATUS
 521 EFIAPI
 522 CpuMpPeimInit (
 523   IN       EFI_PEI_FILE_HANDLE  FileHandle,
 524   IN CONST EFI_PEI_SERVICES     **PeiServices
 525   )
 526 {
 527   EFI_STATUS           Status;
 528   PEI_CPU_MP_DATA      *PeiCpuMpData;
 529   UINT32               ProcessorCount;
 530
 531   //
 532   // Load new GDT table on BSP
 533   //
 534   AsmInitializeGdt (&mGdt);
 535   //
 536   // Get wakeup buffer and copy AP reset code in it
 537   //
 538   PeiCpuMpData = PrepareAPStartupVector ();
 539   //
 540   // Count processor number and collect processor information
 541   //
 542   ProcessorCount = CountProcessorNumber (PeiCpuMpData);
 543   //
 544   // Build location of PEI CPU MP DATA buffer in HOB
 545   //
 546   BuildGuidDataHob (
 547     &gEfiCallerIdGuid,
 548     (VOID *)&PeiCpuMpData,
 549     sizeof(UINT64)
 550     );
 551   //
 552   // Update and publish CPU BIST information
 553   //
 554   CollectBistDataFromPpi (PeiServices, PeiCpuMpData);
 555   //
 556   // register an event for EndOfPei
 557   //
 558   Status  = PeiServicesNotifyPpi (&mNotifyList);
 559   ASSERT_EFI_ERROR (Status);
 560   //
 561   // Install CPU MP PPI
 562   //
 563   Status = PeiServicesInstallPpi(&mPeiCpuMpPpiDesc);
 564   ASSERT_EFI_ERROR (Status);
 565
 566   return Status;
 567 }