StandaloneMmPkg/Drivers/StandaloneMmCpu/AArch64/EventHandle.c

   1 /** @file
   2
   3   Copyright (c) 2016 HP Development Company, L.P.
   4   Copyright (c) 2016 - 2018, 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 && (NsCommBufferAddr < mNsCommBuffer.PhysicalStart))
  88     return EFI_ACCESS_DENIED;
  89
  90   if ((NsCommBufferAddr + sizeof (EFI_MM_COMMUNICATE_HEADER)) >=
  91       (mNsCommBuffer.PhysicalStart + mNsCommBuffer.PhysicalSize))
  92     return EFI_INVALID_PARAMETER;
  93
  94   // Find out the size of the buffer passed
  95   NsCommBufferSize = ((EFI_MM_COMMUNICATE_HEADER *) NsCommBufferAddr)->MessageLength +
  96     sizeof (EFI_MM_COMMUNICATE_HEADER);
  97
  98   // perform bounds check.
  99   if (NsCommBufferAddr + NsCommBufferSize >=
 100       mNsCommBuffer.PhysicalStart + mNsCommBuffer.PhysicalSize)
 101     return EFI_ACCESS_DENIED;
 102
 103
 104   // Now that the secure world can see the normal world buffer, allocate
 105   // memory to copy the communication buffer to the secure world.
 106   Status = mMmst->MmAllocatePool (
 107                     EfiRuntimeServicesData,
 108                     NsCommBufferSize,
 109                     (VOID **) &GuidedEventContext
 110                     );
 111
 112   if (Status != EFI_SUCCESS) {
 113     DEBUG ((DEBUG_INFO, "Mem alloc failed - 0x%x\n", EventId));
 114     return EFI_OUT_OF_RESOURCES;
 115   }
 116
 117   // X1 contains the VA of the normal world memory accessible from
 118   // S-EL0
 119   CopyMem (GuidedEventContext, (CONST VOID *) NsCommBufferAddr, NsCommBufferSize);
 120
 121   // Stash the pointer to the allocated Event Context for this CPU
 122   PerCpuGuidedEventContext[CpuNumber] = GuidedEventContext;
 123
 124   MmEntryPointContext.CurrentlyExecutingCpu = CpuNumber;
 125   MmEntryPointContext.NumberOfCpus = mMpInformationHobData->NumberOfProcessors;
 126
 127   // Populate the MM system table with MP and state information
 128   mMmst->CurrentlyExecutingCpu = CpuNumber;
 129   mMmst->NumberOfCpus = mMpInformationHobData->NumberOfProcessors;
 130   mMmst->CpuSaveStateSize = 0;
 131   mMmst->CpuSaveState = NULL;
 132
 133   if (mMmEntryPoint == NULL) {
 134     DEBUG ((DEBUG_INFO, "Mm Entry point Not Found\n"));
 135     return EFI_UNSUPPORTED;
 136   }
 137
 138   mMmEntryPoint (&MmEntryPointContext);
 139
 140   // Free the memory allocation done earlier and reset the per-cpu context
 141   ASSERT (GuidedEventContext);
 142   CopyMem ((VOID *)NsCommBufferAddr, (CONST VOID *) GuidedEventContext, NsCommBufferSize);
 143
 144   Status = mMmst->MmFreePool ((VOID *) GuidedEventContext);
 145   if (Status != EFI_SUCCESS) {
 146     return EFI_OUT_OF_RESOURCES;
 147   }
 148   PerCpuGuidedEventContext[CpuNumber] = NULL;
 149
 150   return Status;
 151 }
 152
 153 EFI_STATUS
 154 EFIAPI
 155 MmFoundationEntryRegister (
 156   IN CONST EFI_MM_CONFIGURATION_PROTOCOL  *This,
 157   IN EFI_MM_ENTRY_POINT                    MmEntryPoint
 158   )
 159 {
 160   // store the entry point in a global
 161   mMmEntryPoint = MmEntryPoint;
 162   return EFI_SUCCESS;
 163 }
 164
 165 /**
 166   This function is the main entry point for an MM handler dispatch
 167   or communicate-based callback.
 168
 169   @param  DispatchHandle  The unique handle assigned to this handler by MmiHandlerRegister().
 170   @param  Context         Points to an optional handler context which was specified when the handler was registered.
 171   @param  CommBuffer      A pointer to a collection of data in memory that will
 172                           be conveyed from a non-MM environment into an MM environment.
 173   @param  CommBufferSize  The size of the CommBuffer.
 174
 175   @return Status Code
 176
 177 **/
 178 EFI_STATUS
 179 EFIAPI
 180 PiMmCpuTpFwRootMmiHandler (
 181   IN     EFI_HANDLE               DispatchHandle,
 182   IN     CONST VOID               *Context,        OPTIONAL
 183   IN OUT VOID                     *CommBuffer,     OPTIONAL
 184   IN OUT UINTN                    *CommBufferSize  OPTIONAL
 185   )
 186 {
 187   EFI_STATUS Status;
 188   UINTN      CpuNumber;
 189
 190   ASSERT (Context == NULL);
 191   ASSERT (CommBuffer == NULL);
 192   ASSERT (CommBufferSize == NULL);
 193
 194   CpuNumber = mMmst->CurrentlyExecutingCpu;
 195   if (!PerCpuGuidedEventContext[CpuNumber])
 196     return EFI_NOT_FOUND;
 197
 198   DEBUG ((DEBUG_INFO, "CommBuffer - 0x%x, CommBufferSize - 0x%x\n",
 199           PerCpuGuidedEventContext[CpuNumber],
 200           PerCpuGuidedEventContext[CpuNumber]->MessageLength));
 201
 202   Status = mMmst->MmiManage (
 203                     &PerCpuGuidedEventContext[CpuNumber]->HeaderGuid,
 204                     NULL,
 205                     PerCpuGuidedEventContext[CpuNumber]->Data,
 206                     &PerCpuGuidedEventContext[CpuNumber]->MessageLength
 207                     );
 208
 209   if (Status != EFI_SUCCESS) {
 210     DEBUG ((DEBUG_WARN, "Unable to manage Guided Event - %d\n", Status));
 211   }
 212
 213   return Status;
 214 }