StandaloneMmPkg/Drivers/StandaloneMmCpu/AArch64/EventHandle.c

   1 /** @file
   2
   3   Copyright (c) 2016 HP Development Company, L.P.
   4   Copyright (c) 2016 - 2021, Arm Limited. All rights reserved.
   5
   6   SPDX-License-Identifier: BSD-2-Clause-Patent
   7
   8 **/
   9
  10 #include <Base.h>
  11 #include <Pi/PiMmCis.h>
  12
  13
  14 #include <Library/ArmSvcLib.h>
  15 #include <Library/ArmLib.h>
  16 #include <Library/BaseMemoryLib.h>
  17 #include <Library/DebugLib.h>
  18 #include <Library/HobLib.h>
  19
  20 #include <Protocol/DebugSupport.h> // for EFI_SYSTEM_CONTEXT
  21
  22 #include <Guid/ZeroGuid.h>
  23 #include <Guid/MmramMemoryReserve.h>
  24
  25 #include <IndustryStandard/ArmStdSmc.h>
  26
  27 #include "StandaloneMmCpu.h"
  28
  29 EFI_STATUS
  30 EFIAPI
  31 MmFoundationEntryRegister (
  32   IN CONST EFI_MM_CONFIGURATION_PROTOCOL  *This,
  33   IN EFI_MM_ENTRY_POINT                    MmEntryPoint
  34   );
  35
  36 //
  37 // On ARM platforms every event is expected to have a GUID associated with
  38 // it. It will be used by the MM Entry point to find the handler for the
  39 // event. It will either be populated in a EFI_MM_COMMUNICATE_HEADER by the
  40 // caller of the event (e.g. MM_COMMUNICATE SMC) or by the CPU driver
  41 // (e.g. during an asynchronous event). In either case, this context is
  42 // maintained in an array which has an entry for each CPU. The pointer to this
  43 // array is held in PerCpuGuidedEventContext. Memory is allocated once the
  44 // number of CPUs in the system are made known through the
  45 // MP_INFORMATION_HOB_DATA.
  46 //
  47 EFI_MM_COMMUNICATE_HEADER **PerCpuGuidedEventContext = NULL;
  48
  49 // Descriptor with whereabouts of memory used for communication with the normal world
  50 EFI_MMRAM_DESCRIPTOR  mNsCommBuffer;
  51
  52 MP_INFORMATION_HOB_DATA *mMpInformationHobData;
  53
  54 EFI_MM_CONFIGURATION_PROTOCOL mMmConfig = {
  55   0,
  56   MmFoundationEntryRegister
  57 };
  58
  59 STATIC EFI_MM_ENTRY_POINT     mMmEntryPoint = NULL;
  60
  61 EFI_STATUS
  62 PiMmStandaloneArmTfCpuDriverEntry (
  63   IN UINTN EventId,
  64   IN UINTN CpuNumber,
  65   IN UINTN NsCommBufferAddr
  66   )
  67 {
  68   EFI_MM_COMMUNICATE_HEADER *GuidedEventContext = NULL;
  69   EFI_MM_ENTRY_CONTEXT        MmEntryPointContext = {0};
  70   EFI_STATUS                  Status;
  71   UINTN                       NsCommBufferSize;
  72
  73   DEBUG ((DEBUG_INFO, "Received event - 0x%x on cpu %d\n", EventId, CpuNumber));
  74
  75   Status = EFI_SUCCESS;
  76   //
  77   // ARM TF passes SMC FID of the MM_COMMUNICATE interface as the Event ID upon
  78   // receipt of a synchronous MM request. Use the Event ID to distinguish
  79   // between synchronous and asynchronous events.
  80   //
  81   if (ARM_SMC_ID_MM_COMMUNICATE_AARCH64 != EventId) {
  82     DEBUG ((DEBUG_INFO, "UnRecognized Event - 0x%x\n", EventId));
  83     return EFI_INVALID_PARAMETER;
  84   }
  85
  86   // Perform parameter validation of NsCommBufferAddr
  87   if (NsCommBufferAddr == (UINTN)NULL) {
  88     return EFI_INVALID_PARAMETER;
  89   }
  90
  91   if (NsCommBufferAddr < mNsCommBuffer.PhysicalStart) {
  92     return EFI_ACCESS_DENIED;
  93   }
  94
  95   if ((NsCommBufferAddr + sizeof (EFI_MM_COMMUNICATE_HEADER)) >=
  96       (mNsCommBuffer.PhysicalStart + mNsCommBuffer.PhysicalSize)) {
  97     return EFI_INVALID_PARAMETER;
  98   }
  99
 100   // Find out the size of the buffer passed
 101   NsCommBufferSize = ((EFI_MM_COMMUNICATE_HEADER *) NsCommBufferAddr)->MessageLength +
 102     sizeof (EFI_MM_COMMUNICATE_HEADER);
 103
 104   // perform bounds check.
 105   if (NsCommBufferAddr + NsCommBufferSize >=
 106       mNsCommBuffer.PhysicalStart + mNsCommBuffer.PhysicalSize) {
 107     return EFI_ACCESS_DENIED;
 108   }
 109
 110   // Now that the secure world can see the normal world buffer, allocate
 111   // memory to copy the communication buffer to the secure world.
 112   Status = mMmst->MmAllocatePool (
 113                     EfiRuntimeServicesData,
 114                     NsCommBufferSize,
 115                     (VOID **) &GuidedEventContext
 116                     );
 117
 118   if (Status != EFI_SUCCESS) {
 119     DEBUG ((DEBUG_INFO, "Mem alloc failed - 0x%x\n", EventId));
 120     return EFI_OUT_OF_RESOURCES;
 121   }
 122
 123   // X1 contains the VA of the normal world memory accessible from
 124   // S-EL0
 125   CopyMem (GuidedEventContext, (CONST VOID *) NsCommBufferAddr, NsCommBufferSize);
 126
 127   // Stash the pointer to the allocated Event Context for this CPU
 128   PerCpuGuidedEventContext[CpuNumber] = GuidedEventContext;
 129
 130   MmEntryPointContext.CurrentlyExecutingCpu = CpuNumber;
 131   MmEntryPointContext.NumberOfCpus = mMpInformationHobData->NumberOfProcessors;
 132
 133   // Populate the MM system table with MP and state information
 134   mMmst->CurrentlyExecutingCpu = CpuNumber;
 135   mMmst->NumberOfCpus = mMpInformationHobData->NumberOfProcessors;
 136   mMmst->CpuSaveStateSize = 0;
 137   mMmst->CpuSaveState = NULL;
 138
 139   if (mMmEntryPoint == NULL) {
 140     DEBUG ((DEBUG_INFO, "Mm Entry point Not Found\n"));
 141     return EFI_UNSUPPORTED;
 142   }
 143
 144   mMmEntryPoint (&MmEntryPointContext);
 145
 146   // Free the memory allocation done earlier and reset the per-cpu context
 147   ASSERT (GuidedEventContext);
 148   CopyMem ((VOID *)NsCommBufferAddr, (CONST VOID *) GuidedEventContext, NsCommBufferSize);
 149
 150   Status = mMmst->MmFreePool ((VOID *) GuidedEventContext);
 151   if (Status != EFI_SUCCESS) {
 152     return EFI_OUT_OF_RESOURCES;
 153   }
 154   PerCpuGuidedEventContext[CpuNumber] = NULL;
 155
 156   return Status;
 157 }
 158
 159 EFI_STATUS
 160 EFIAPI
 161 MmFoundationEntryRegister (
 162   IN CONST EFI_MM_CONFIGURATION_PROTOCOL  *This,
 163   IN EFI_MM_ENTRY_POINT                    MmEntryPoint
 164   )
 165 {
 166   // store the entry point in a global
 167   mMmEntryPoint = MmEntryPoint;
 168   return EFI_SUCCESS;
 169 }
 170
 171 /**
 172   This function is the main entry point for an MM handler dispatch
 173   or communicate-based callback.
 174
 175   @param  DispatchHandle  The unique handle assigned to this handler by MmiHandlerRegister().
 176   @param  Context         Points to an optional handler context which was specified when the handler was registered.
 177   @param  CommBuffer      A pointer to a collection of data in memory that will
 178                           be conveyed from a non-MM environment into an MM environment.
 179   @param  CommBufferSize  The size of the CommBuffer.
 180
 181   @return Status Code
 182
 183 **/
 184 EFI_STATUS
 185 EFIAPI
 186 PiMmCpuTpFwRootMmiHandler (
 187   IN     EFI_HANDLE               DispatchHandle,
 188   IN     CONST VOID               *Context,        OPTIONAL
 189   IN OUT VOID                     *CommBuffer,     OPTIONAL
 190   IN OUT UINTN                    *CommBufferSize  OPTIONAL
 191   )
 192 {
 193   EFI_STATUS Status;
 194   UINTN      CpuNumber;
 195
 196   ASSERT (Context == NULL);
 197   ASSERT (CommBuffer == NULL);
 198   ASSERT (CommBufferSize == NULL);
 199
 200   CpuNumber = mMmst->CurrentlyExecutingCpu;
 201   if (PerCpuGuidedEventContext[CpuNumber] == NULL) {
 202     return EFI_NOT_FOUND;
 203   }
 204
 205   DEBUG ((DEBUG_INFO, "CommBuffer - 0x%x, CommBufferSize - 0x%x\n",
 206           PerCpuGuidedEventContext[CpuNumber],
 207           PerCpuGuidedEventContext[CpuNumber]->MessageLength));
 208
 209   Status = mMmst->MmiManage (
 210                     &PerCpuGuidedEventContext[CpuNumber]->HeaderGuid,
 211                     NULL,
 212                     PerCpuGuidedEventContext[CpuNumber]->Data,
 213                     &PerCpuGuidedEventContext[CpuNumber]->MessageLength
 214                     );
 215
 216   if (Status != EFI_SUCCESS) {
 217     DEBUG ((DEBUG_WARN, "Unable to manage Guided Event - %d\n", Status));
 218   }
 219
 220   return Status;
 221 }