UefiCpuPkg/CpuMpPei/CpuMpPei.h

   1 /** @file
   2   Definitions to install Multiple Processor PPI.
   3
   4   Copyright (c) 2015 - 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 #ifndef _CPU_MP_PEI_H_
  16 #define _CPU_MP_PEI_H_
  17
  18 #include <PiPei.h>
  19
  20 #include <Ppi/MpServices.h>
  21 #include <Ppi/SecPlatformInformation.h>
  22 #include <Ppi/SecPlatformInformation2.h>
  23 #include <Ppi/EndOfPeiPhase.h>
  24 #include <Ppi/VectorHandoffInfo.h>
  25
  26 #include <Register/Cpuid.h>
  27 #include <Register/LocalApic.h>
  28
  29 #include <Library/BaseLib.h>
  30 #include <Library/BaseMemoryLib.h>
  31 #include <Library/DebugLib.h>
  32 #include <Library/HobLib.h>
  33 #include <Library/LocalApicLib.h>
  34 #include <Library/MtrrLib.h>
  35 #include <Library/PcdLib.h>
  36 #include <Library/PeimEntryPoint.h>
  37 #include <Library/PeiServicesLib.h>
  38 #include <Library/ReportStatusCodeLib.h>
  39 #include <Library/SynchronizationLib.h>
  40 #include <Library/TimerLib.h>
  41 #include <Library/UefiCpuLib.h>
  42 #include <Library/CpuLib.h>
  43 #include <Library/CpuExceptionHandlerLib.h>
  44
  45 #include "Microcode.h"
  46
  47 //
  48 // AP state
  49 //
  50 typedef enum {
  51   CpuStateIdle,
  52   CpuStateBusy,
  53   CpuStateDisabled
  54 } CPU_STATE;
  55
  56 #define WAKEUP_AP_SIGNAL SIGNATURE_32 ('S', 'T', 'A', 'P')
  57
  58 typedef enum {
  59   ApInHltLoop   = 1,
  60   ApInMwaitLoop = 2,
  61   ApInRunLoop   = 3
  62 } AP_LOOP_MODE;
  63
  64 //
  65 // AP reset code information
  66 //
  67 typedef struct {
  68   UINT8             *RendezvousFunnelAddress;
  69   UINTN             PModeEntryOffset;
  70   UINTN             LModeEntryOffset;
  71   UINTN             RendezvousFunnelSize;
  72 } MP_ASSEMBLY_ADDRESS_MAP;
  73
  74 //
  75 // CPU exchange information for switch BSP
  76 //
  77 typedef struct {
  78   UINT8             State;        // offset 0
  79   UINTN             StackPointer; // offset 4 / 8
  80   IA32_DESCRIPTOR   Gdtr;         // offset 8 / 16
  81   IA32_DESCRIPTOR   Idtr;         // offset 14 / 26
  82 } CPU_EXCHANGE_ROLE_INFO;
  83
  84 typedef struct _PEI_CPU_MP_DATA  PEI_CPU_MP_DATA;
  85
  86 #pragma pack(1)
  87
  88 typedef union {
  89   struct {
  90     UINT32  LimitLow    : 16;
  91     UINT32  BaseLow     : 16;
  92     UINT32  BaseMid     : 8;
  93     UINT32  Type        : 4;
  94     UINT32  System      : 1;
  95     UINT32  Dpl         : 2;
  96     UINT32  Present     : 1;
  97     UINT32  LimitHigh   : 4;
  98     UINT32  Software    : 1;
  99     UINT32  Reserved    : 1;
 100     UINT32  DefaultSize : 1;
 101     UINT32  Granularity : 1;
 102     UINT32  BaseHigh    : 8;
 103   } Bits;
 104   UINT64  Uint64;
 105 } IA32_GDT;
 106
 107 //
 108 // MP CPU exchange information for AP reset code
 109 // This structure is required to be packed because fixed field offsets
 110 // into this structure are used in assembly code in this module
 111 //
 112 typedef struct {
 113   UINTN                 Lock;
 114   UINTN                 StackStart;
 115   UINTN                 StackSize;
 116   UINTN                 CFunction;
 117   IA32_DESCRIPTOR       GdtrProfile;
 118   IA32_DESCRIPTOR       IdtrProfile;
 119   UINTN                 BufferStart;
 120   UINTN                 PmodeOffset;
 121   UINTN                 NumApsExecuting;
 122   UINTN                 CodeSegment;
 123   UINTN                 DataSegment;
 124   UINTN                 LmodeOffset;
 125   UINTN                 Cr3;
 126   PEI_CPU_MP_DATA       *PeiCpuMpData;
 127 } MP_CPU_EXCHANGE_INFO;
 128
 129 #pragma pack()
 130
 131 typedef struct {
 132   UINTN                          Cr0;
 133   UINTN                          Cr3;
 134   UINTN                          Cr4;
 135   UINTN                          Dr0;
 136   UINTN                          Dr1;
 137   UINTN                          Dr2;
 138   UINTN                          Dr3;
 139   UINTN                          Dr6;
 140   UINTN                          Dr7;
 141 } CPU_VOLATILE_REGISTERS;
 142
 143 typedef struct {
 144   volatile UINT32                *StartupApSignal;
 145   UINT32                         ApicId;
 146   EFI_HEALTH_FLAGS               Health;
 147   CPU_STATE                      State;
 148   BOOLEAN                        CpuHealthy;
 149   CPU_VOLATILE_REGISTERS         VolatileRegisters;
 150 } PEI_CPU_DATA;
 151
 152 //
 153 // PEI CPU MP Data save in memory
 154 //
 155 struct _PEI_CPU_MP_DATA {
 156   SPIN_LOCK                      MpLock;
 157   UINT32                         CpuCount;
 158   UINT32                         BspNumber;
 159   UINTN                          Buffer;
 160   UINTN                          CpuApStackSize;
 161   MP_ASSEMBLY_ADDRESS_MAP        AddressMap;
 162   UINTN                          WakeupBuffer;
 163   UINTN                          BackupBuffer;
 164   UINTN                          BackupBufferSize;
 165   UINTN                          ApFunction;
 166   UINTN                          ApFunctionArgument;
 167   volatile UINT32                FinishedCount;
 168   BOOLEAN                        EndOfPeiFlag;
 169   BOOLEAN                        InitFlag;
 170   BOOLEAN                        X2ApicEnable;
 171   CPU_EXCHANGE_ROLE_INFO         BSPInfo;
 172   CPU_EXCHANGE_ROLE_INFO         APInfo;
 173   MTRR_SETTINGS                  MtrrTable;
 174   UINT8                          ApLoopMode;
 175   UINT8                          ApTargetCState;
 176   PEI_CPU_DATA                   *CpuData;
 177   volatile MP_CPU_EXCHANGE_INFO  *MpCpuExchangeInfo;
 178 };
 179 extern EFI_PEI_PPI_DESCRIPTOR   mPeiCpuMpPpiDesc;
 180
 181
 182 /**
 183   Assembly code to get starting address and size of the rendezvous entry for APs.
 184   Information for fixing a jump instruction in the code is also returned.
 185
 186   @param AddressMap  Output buffer for address map information.
 187 **/
 188 VOID
 189 EFIAPI
 190 AsmGetAddressMap (
 191   OUT MP_ASSEMBLY_ADDRESS_MAP    *AddressMap
 192   );
 193
 194 /**
 195   Assembly code to load GDT table and update segment accordingly.
 196
 197   @param Gdtr   Pointer to GDT descriptor
 198 **/
 199 VOID
 200 EFIAPI
 201 AsmInitializeGdt (
 202   IN IA32_DESCRIPTOR  *Gdtr
 203   );
 204
 205 /**
 206   Get available system memory below 1MB by specified size.
 207
 208   @param PeiCpuMpData        Pointer to PEI CPU MP Data
 209 **/
 210 VOID
 211 BackupAndPrepareWakeupBuffer(
 212   IN PEI_CPU_MP_DATA         *PeiCpuMpData
 213   );
 214
 215 /**
 216   Restore wakeup buffer data.
 217
 218   @param PeiCpuMpData        Pointer to PEI CPU MP Data
 219 **/
 220 VOID
 221 RestoreWakeupBuffer(
 222   IN PEI_CPU_MP_DATA         *PeiCpuMpData
 223   );
 224
 225 /**
 226   Notify function on End Of Pei PPI.
 227
 228   On S3 boot, this function will restore wakeup buffer data.
 229   On normal boot, this function will flag wakeup buffer to be un-used type.
 230
 231   @param  PeiServices        The pointer to the PEI Services Table.
 232   @param  NotifyDescriptor   Address of the notification descriptor data structure.
 233   @param  Ppi                Address of the PPI that was installed.
 234
 235   @retval EFI_SUCCESS        When everything is OK.
 236
 237 **/
 238 EFI_STATUS
 239 EFIAPI
 240 CpuMpEndOfPeiCallback (
 241   IN      EFI_PEI_SERVICES        **PeiServices,
 242   IN EFI_PEI_NOTIFY_DESCRIPTOR    *NotifyDescriptor,
 243   IN VOID                         *Ppi
 244   );
 245
 246 /**
 247   This function will be called by BSP to wakeup AP.
 248
 249   @param PeiCpuMpData       Pointer to PEI CPU MP Data
 250   @param Broadcast          TRUE:  Send broadcast IPI to all APs
 251                             FALSE: Send IPI to AP by ApicId
 252   @param ProcessorNumber    The handle number of specified processor
 253   @param Procedure          The function to be invoked by AP
 254   @param ProcedureArgument  The argument to be passed into AP function
 255 **/
 256 VOID
 257 WakeUpAP (
 258   IN PEI_CPU_MP_DATA           *PeiCpuMpData,
 259   IN BOOLEAN                   Broadcast,
 260   IN UINTN                     ProcessorNumber,
 261   IN EFI_AP_PROCEDURE          Procedure,              OPTIONAL
 262   IN VOID                      *ProcedureArgument      OPTIONAL
 263   );
 264
 265 /**
 266   Get CPU MP Data pointer from the Guided HOB.
 267
 268   @return  Pointer to Pointer to PEI CPU MP Data
 269 **/
 270 PEI_CPU_MP_DATA *
 271 GetMpHobData (
 272   VOID
 273   );
 274
 275 /**
 276   Find the current Processor number by APIC ID.
 277
 278   @param PeiCpuMpData        Pointer to PEI CPU MP Data
 279   @param ProcessorNumber     Return the pocessor number found
 280
 281   @retval EFI_SUCCESS        ProcessorNumber is found and returned.
 282   @retval EFI_NOT_FOUND      ProcessorNumber is not found.
 283 **/
 284 EFI_STATUS
 285 GetProcessorNumber (
 286   IN PEI_CPU_MP_DATA         *PeiCpuMpData,
 287   OUT UINTN                  *ProcessorNumber
 288   );
 289
 290 /**
 291   Collects BIST data from PPI.
 292
 293   This function collects BIST data from Sec Platform Information2 PPI
 294   or SEC Platform Information PPI.
 295
 296   @param PeiServices         Pointer to PEI Services Table
 297   @param PeiCpuMpData        Pointer to PEI CPU MP Data
 298
 299 **/
 300 VOID
 301 CollectBistDataFromPpi (
 302   IN CONST EFI_PEI_SERVICES             **PeiServices,
 303   IN PEI_CPU_MP_DATA                    *PeiCpuMpData
 304   );
 305
 306 /**
 307   Implementation of the PlatformInformation2 service in EFI_SEC_PLATFORM_INFORMATION2_PPI.
 308
 309   @param  PeiServices                The pointer to the PEI Services Table.
 310   @param  StructureSize              The pointer to the variable describing size of the input buffer.
 311   @param  PlatformInformationRecord2 The pointer to the EFI_SEC_PLATFORM_INFORMATION_RECORD2.
 312
 313   @retval EFI_SUCCESS                The data was successfully returned.
 314   @retval EFI_BUFFER_TOO_SMALL       The buffer was too small. The current buffer size needed to
 315                                      hold the record is returned in StructureSize.
 316
 317 **/
 318 EFI_STATUS
 319 EFIAPI
 320 SecPlatformInformation2 (
 321   IN CONST EFI_PEI_SERVICES                   **PeiServices,
 322   IN OUT UINT64                               *StructureSize,
 323      OUT EFI_SEC_PLATFORM_INFORMATION_RECORD2 *PlatformInformationRecord2
 324   );
 325
 326 /**
 327   Detect whether specified processor can find matching microcode patch and load it.
 328
 329   @param PeiCpuMpData        Pointer to PEI CPU MP Data
 330 **/
 331 VOID
 332 MicrocodeDetect (
 333   IN PEI_CPU_MP_DATA            *PeiCpuMpData
 334   );
 335
 336 #endif