UefiCpuPkg/CpuMpPei/CpuMpPei.h

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