UefiCpuPkg/CpuS3DataDxe/CpuS3Data.c

   1 /** @file
   2 ACPI CPU Data initialization module
   3
   4 This module initializes the ACPI_CPU_DATA structure and registers the address
   5 of this structure in the PcdCpuS3DataAddress PCD.  This is a generic/simple
   6 version of this module.  It does not provide a machine check handler or CPU
   7 register initialization tables for ACPI S3 resume.  It also only supports the
   8 number of CPUs reported by the MP Services Protocol, so this module does not
   9 support hot plug CPUs.  This module can be copied into a CPU specific package
  10 and customized if these additional features are required.
  11
  12 Copyright (c) 2013 - 2016, Intel Corporation. All rights reserved.<BR>
  13 Copyright (c) 2015, Red Hat, Inc.
  14
  15 This program and the accompanying materials
  16 are licensed and made available under the terms and conditions of the BSD License
  17 which accompanies this distribution.  The full text of the license may be found at
  18 http://opensource.org/licenses/bsd-license.php
  19
  20 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  21 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  22
  23 **/
  24
  25 #include <PiDxe.h>
  26
  27 #include <AcpiCpuData.h>
  28
  29 #include <Library/BaseLib.h>
  30 #include <Library/BaseMemoryLib.h>
  31 #include <Library/UefiBootServicesTableLib.h>
  32 #include <Library/DebugLib.h>
  33 #include <Library/MtrrLib.h>
  34
  35 #include <Protocol/MpService.h>
  36 #include <Guid/EventGroup.h>
  37
  38 //
  39 // Data structure used to allocate ACPI_CPU_DATA and its supporting structures
  40 //
  41 typedef struct {
  42   ACPI_CPU_DATA             AcpiCpuData;
  43   MTRR_SETTINGS             MtrrTable;
  44   IA32_DESCRIPTOR           GdtrProfile;
  45   IA32_DESCRIPTOR           IdtrProfile;
  46 } ACPI_CPU_DATA_EX;
  47
  48 /**
  49   Allocate EfiACPIMemoryNVS below 4G memory address.
  50
  51   This function allocates EfiACPIMemoryNVS below 4G memory address.
  52
  53   @param[in] Size   Size of memory to allocate.
  54
  55   @return       Allocated address for output.
  56
  57 **/
  58 VOID *
  59 AllocateAcpiNvsMemoryBelow4G (
  60   IN UINTN  Size
  61   )
  62 {
  63   EFI_PHYSICAL_ADDRESS  Address;
  64   EFI_STATUS            Status;
  65   VOID                  *Buffer;
  66
  67   Address = BASE_4GB - 1;
  68   Status  = gBS->AllocatePages (
  69                    AllocateMaxAddress,
  70                    EfiACPIMemoryNVS,
  71                    EFI_SIZE_TO_PAGES (Size),
  72                    &Address
  73                    );
  74   if (EFI_ERROR (Status)) {
  75     return NULL;
  76   }
  77
  78   Buffer = (VOID *)(UINTN)Address;
  79   ZeroMem (Buffer, Size);
  80
  81   return Buffer;
  82 }
  83
  84 /**
  85   Callback function executed when the EndOfDxe event group is signaled.
  86
  87   We delay allocating StartupVector and saving the MTRR settings until BDS signals EndOfDxe.
  88
  89   @param[in]  Event    Event whose notification function is being invoked.
  90   @param[out] Context  Pointer to the MTRR_SETTINGS buffer to fill in.
  91 **/
  92 VOID
  93 EFIAPI
  94 CpuS3DataOnEndOfDxe (
  95   IN  EFI_EVENT  Event,
  96   OUT VOID       *Context
  97   )
  98 {
  99   EFI_STATUS         Status;
 100   ACPI_CPU_DATA_EX   *AcpiCpuDataEx;
 101
 102   AcpiCpuDataEx = (ACPI_CPU_DATA_EX *) Context;
 103   //
 104   // Allocate a 4KB reserved page below 1MB
 105   //
 106   AcpiCpuDataEx->AcpiCpuData.StartupVector = BASE_1MB - 1;
 107   Status = gBS->AllocatePages (
 108                   AllocateMaxAddress,
 109                   EfiReservedMemoryType,
 110                   1,
 111                   &AcpiCpuDataEx->AcpiCpuData.StartupVector
 112                   );
 113   ASSERT_EFI_ERROR (Status);
 114
 115   DEBUG ((EFI_D_VERBOSE, "%a\n", __FUNCTION__));
 116   MtrrGetAllMtrrs (&AcpiCpuDataEx->MtrrTable);
 117
 118   //
 119   // Close event, so it will not be invoked again.
 120   //
 121   gBS->CloseEvent (Event);
 122 }
 123
 124 /**
 125    The entry function of the CpuS3Data driver.
 126
 127    Allocate and initialize all fields of the ACPI_CPU_DATA structure except the
 128    MTRR settings.  Register an event notification on gEfiEndOfDxeEventGroupGuid
 129    to capture the ACPI_CPU_DATA MTRR settings.  The PcdCpuS3DataAddress is set
 130    to the address that ACPI_CPU_DATA is allocated at.
 131
 132    @param[in] ImageHandle  The firmware allocated handle for the EFI image.
 133    @param[in] SystemTable  A pointer to the EFI System Table.
 134
 135    @retval EFI_SUCCESS     The entry point is executed successfully.
 136    @retval other           Some error occurs when executing this entry point.
 137
 138 **/
 139 EFI_STATUS
 140 EFIAPI
 141 CpuS3DataInitialize (
 142   IN EFI_HANDLE        ImageHandle,
 143   IN EFI_SYSTEM_TABLE  *SystemTable
 144   )
 145 {
 146   EFI_STATUS                 Status;
 147   ACPI_CPU_DATA_EX           *AcpiCpuDataEx;
 148   ACPI_CPU_DATA              *AcpiCpuData;
 149   EFI_MP_SERVICES_PROTOCOL   *MpServices;
 150   UINTN                      NumberOfCpus;
 151   UINTN                      NumberOfEnabledProcessors;
 152   VOID                       *Stack;
 153   UINTN                      TableSize;
 154   CPU_REGISTER_TABLE         *RegisterTable;
 155   UINTN                      Index;
 156   EFI_PROCESSOR_INFORMATION  ProcessorInfoBuffer;
 157   UINTN                      GdtSize;
 158   UINTN                      IdtSize;
 159   VOID                       *Gdt;
 160   VOID                       *Idt;
 161   EFI_EVENT                  Event;
 162
 163   //
 164   // Allocate ACPI NVS memory below 4G memory for use on ACPI S3 resume.
 165   //
 166   AcpiCpuDataEx = AllocateAcpiNvsMemoryBelow4G (sizeof (ACPI_CPU_DATA_EX));
 167   ASSERT (AcpiCpuDataEx != NULL);
 168   AcpiCpuData = &AcpiCpuDataEx->AcpiCpuData;
 169
 170   //
 171   // Get MP Services Protocol
 172   //
 173   Status = gBS->LocateProtocol (
 174                   &gEfiMpServiceProtocolGuid,
 175                   NULL,
 176                   (VOID **)&MpServices
 177                   );
 178   ASSERT_EFI_ERROR (Status);
 179
 180   //
 181   // Get the number of CPUs
 182   //
 183   Status = MpServices->GetNumberOfProcessors (
 184                          MpServices,
 185                          &NumberOfCpus,
 186                          &NumberOfEnabledProcessors
 187                          );
 188   ASSERT_EFI_ERROR (Status);
 189   AcpiCpuData->NumberOfCpus = (UINT32)NumberOfCpus;
 190
 191   //
 192   // Initialize ACPI_CPU_DATA fields
 193   //
 194   AcpiCpuData->StackSize                 = PcdGet32 (PcdCpuApStackSize);
 195   AcpiCpuData->ApMachineCheckHandlerBase = 0;
 196   AcpiCpuData->ApMachineCheckHandlerSize = 0;
 197   AcpiCpuData->GdtrProfile  = (EFI_PHYSICAL_ADDRESS)(UINTN)&AcpiCpuDataEx->GdtrProfile;
 198   AcpiCpuData->IdtrProfile  = (EFI_PHYSICAL_ADDRESS)(UINTN)&AcpiCpuDataEx->IdtrProfile;
 199   AcpiCpuData->MtrrTable    = (EFI_PHYSICAL_ADDRESS)(UINTN)&AcpiCpuDataEx->MtrrTable;
 200
 201   //
 202   // Allocate stack space for all CPUs
 203   //
 204   Stack = AllocateAcpiNvsMemoryBelow4G (NumberOfCpus * AcpiCpuData->StackSize);
 205   ASSERT (Stack != NULL);
 206   AcpiCpuData->StackAddress = (EFI_PHYSICAL_ADDRESS)(UINTN)Stack;
 207
 208   //
 209   // Get the boot processor's GDT and IDT
 210   //
 211   AsmReadGdtr (&AcpiCpuDataEx->GdtrProfile);
 212   AsmReadIdtr (&AcpiCpuDataEx->IdtrProfile);
 213
 214   //
 215   // Allocate GDT and IDT in ACPI NVS and copy current GDT and IDT contents
 216   //
 217   GdtSize = AcpiCpuDataEx->GdtrProfile.Limit + 1;
 218   IdtSize = AcpiCpuDataEx->IdtrProfile.Limit + 1;
 219   Gdt = AllocateAcpiNvsMemoryBelow4G (GdtSize + IdtSize);
 220   ASSERT (Gdt != NULL);
 221   Idt = (VOID *)((UINTN)Gdt + GdtSize);
 222   CopyMem (Gdt, (VOID *)AcpiCpuDataEx->GdtrProfile.Base, GdtSize);
 223   CopyMem (Idt, (VOID *)AcpiCpuDataEx->IdtrProfile.Base, IdtSize);
 224   AcpiCpuDataEx->GdtrProfile.Base = (UINTN)Gdt;
 225   AcpiCpuDataEx->IdtrProfile.Base = (UINTN)Idt;
 226
 227   //
 228   // Allocate buffer for empty RegisterTable and PreSmmInitRegisterTable for all CPUs
 229   //
 230   TableSize = 2 * NumberOfCpus * sizeof (CPU_REGISTER_TABLE);
 231   RegisterTable = (CPU_REGISTER_TABLE *)AllocateAcpiNvsMemoryBelow4G (TableSize);
 232   ASSERT (RegisterTable != NULL);
 233   for (Index = 0; Index < NumberOfCpus; Index++) {
 234     Status = MpServices->GetProcessorInfo (
 235                            MpServices,
 236                            Index,
 237                            &ProcessorInfoBuffer
 238                            );
 239     ASSERT_EFI_ERROR (Status);
 240
 241     RegisterTable[Index].InitialApicId      = (UINT32)ProcessorInfoBuffer.ProcessorId;
 242     RegisterTable[Index].TableLength        = 0;
 243     RegisterTable[Index].AllocatedSize      = 0;
 244     RegisterTable[Index].RegisterTableEntry = NULL;
 245
 246     RegisterTable[NumberOfCpus + Index].InitialApicId      = (UINT32)ProcessorInfoBuffer.ProcessorId;
 247     RegisterTable[NumberOfCpus + Index].TableLength        = 0;
 248     RegisterTable[NumberOfCpus + Index].AllocatedSize      = 0;
 249     RegisterTable[NumberOfCpus + Index].RegisterTableEntry = NULL;
 250   }
 251   AcpiCpuData->RegisterTable           = (EFI_PHYSICAL_ADDRESS)(UINTN)RegisterTable;
 252   AcpiCpuData->PreSmmInitRegisterTable = (EFI_PHYSICAL_ADDRESS)(UINTN)(RegisterTable + NumberOfCpus);
 253
 254   //
 255   // Set PcdCpuS3DataAddress to the base address of the ACPI_CPU_DATA structure
 256   //
 257   Status = PcdSet64S (PcdCpuS3DataAddress, (UINT64)(UINTN)AcpiCpuData);
 258   ASSERT_EFI_ERROR (Status);
 259
 260   //
 261   // Register EFI_END_OF_DXE_EVENT_GROUP_GUID event.
 262   // The notification function allocates StartupVector and saves MTRRs for ACPI_CPU_DATA
 263   //
 264   Status = gBS->CreateEventEx (
 265                   EVT_NOTIFY_SIGNAL,
 266                   TPL_CALLBACK,
 267                   CpuS3DataOnEndOfDxe,
 268                   AcpiCpuData,
 269                   &gEfiEndOfDxeEventGroupGuid,
 270                   &Event
 271                   );
 272   ASSERT_EFI_ERROR (Status);
 273
 274   return EFI_SUCCESS;
 275 }