EdkCompatibilityPkg/Compatibility/SmmBaseOnSmmBase2Thunk/SmmBaseOnSmmBase2Thunk.c

   1 /** @file
   2   SMM Base Protocol on SMM Base2 Protocol Thunk driver.
   3
   4   This driver co-operates with SMM Base Helper SMM driver to provide SMM Base Protocol
   5   based on SMM Base2 Protocol.
   6
   7   This thunk driver is expected to be loaded before PI SMM IPL driver so that
   8   SMM BASE Protocol can be published immediately after SMM Base2 Protocol is installed to
   9   make SMM Base Protocol.InSmm() as early as possible.
  10
  11   Copyright (c) 2009 - 2010, Intel Corporation
  12   All rights reserved. This program and the accompanying materials
  13   are licensed and made available under the terms and conditions of the BSD License
  14   which accompanies this distribution.  The full text of the license may be found at
  15   http://opensource.org/licenses/bsd-license.php
  16
  17   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  18   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  19
  20 **/
  21
  22 #include <PiDxe.h>
  23 #include <FrameworkSmm.h>
  24
  25 #include <Protocol/SmmBase2.h>
  26 #include <Protocol/SmmCommunication.h>
  27 #include <Protocol/SmmBaseHelperReady.h>
  28
  29 #include <Guid/SmmBaseThunkCommunication.h>
  30 #include <Guid/EventGroup.h>
  31
  32 #include <Library/DebugLib.h>
  33 #include <Library/UefiBootServicesTableLib.h>
  34 #include <Library/UefiDriverEntryPoint.h>
  35 #include <Library/UefiLib.h>
  36 #include <Library/UefiRuntimeLib.h>
  37
  38 SMMBASETHUNK_COMMUNICATION_DATA  mCommunicationData = {
  39   EFI_SMM_BASE_THUNK_COMMUNICATION_GUID,
  40   sizeof (SMMBASE_FUNCTION_DATA)
  41 };
  42
  43 EFI_HANDLE                         mSmmBaseHandle = NULL;
  44 EFI_SMM_BASE2_PROTOCOL             *mSmmBase2 = NULL;
  45 EFI_SMM_COMMUNICATION_PROTOCOL     *mSmmCommunication = NULL;
  46 EFI_SMM_BASE_HELPER_READY_PROTOCOL *mSmmBaseHelperReady = NULL;
  47
  48 /**
  49   Determine if in SMM mode.
  50
  51   @retval TRUE   In SMM mode.
  52   @retval FALSE  Not in SMM mode.
  53 **/
  54 BOOLEAN
  55 IsInSmm (
  56   VOID
  57   )
  58 {
  59   EFI_STATUS Status;
  60   BOOLEAN    InSmm;
  61
  62   Status = mSmmBase2->InSmm (mSmmBase2, &InSmm);
  63   ASSERT_EFI_ERROR (Status);
  64   return InSmm;
  65 }
  66
  67 /**
  68   Invoke services provided by SMM Base Helper SMM driver.
  69 **/
  70 VOID
  71 SmmBaseHelperService (
  72   VOID
  73   )
  74 {
  75   UINTN DataSize;
  76
  77   mCommunicationData.FunctionData.Status = EFI_UNSUPPORTED;
  78
  79   if ((mCommunicationData.FunctionData.Function != SmmBaseFunctionCommunicate) && IsInSmm()) {
  80     ///
  81     /// If in SMM mode, directly call services in SMM Base Helper.
  82     ///
  83     DataSize = (UINTN)(sizeof (SMMBASE_FUNCTION_DATA));
  84     mSmmBaseHelperReady->ServiceEntry (
  85                            NULL,
  86                            NULL,
  87                            &mCommunicationData.FunctionData,
  88                            &DataSize
  89                            );
  90   } else {
  91     ///
  92     /// Call services in SMM Base Helper via SMM Communication Protocol.
  93     ///
  94     DataSize = (UINTN)(sizeof (mCommunicationData));
  95     mSmmCommunication->Communicate (
  96                          mSmmCommunication,
  97                          &mCommunicationData,
  98                          &DataSize
  99                          );
 100   }
 101 }
 102
 103 /**
 104   Register a given driver into SMRAM. This is the equivalent of performing
 105   the LoadImage/StartImage into System Management Mode.
 106
 107   @param[in]   This                  Protocol instance pointer.
 108   @param[in]   FilePath              Location of the image to be installed as the handler.
 109   @param[in]   SourceBuffer          Optional source buffer in case the image file
 110                                      is in memory.
 111   @param[in]   SourceSize            Size of the source image file, if in memory.
 112   @param[out]  ImageHandle           The handle that the base driver uses to decode
 113                                      the handler. Unique among SMM handlers only,
 114                                      not unique across DXE/EFI.
 115   @param[in]   LegacyIA32Binary      An optional parameter specifying that the associated
 116                                      file is a real-mode IA-32 binary.
 117
 118   @retval      EFI_SUCCESS           The operation was successful.
 119   @retval      EFI_OUT_OF_RESOURCES  There were no additional SMRAM resources to load the handler
 120   @retval      EFI_UNSUPPORTED       This platform does not support 16-bit handlers.
 121   @retval      EFI_UNSUPPORTED       Platform is in runtime.
 122   @retval      EFI_INVALID_PARAMETER The handlers was not the correct image type
 123 **/
 124 EFI_STATUS
 125 EFIAPI
 126 SmmBaseRegister (
 127   IN      EFI_SMM_BASE_PROTOCOL     *This,
 128   IN      EFI_DEVICE_PATH_PROTOCOL  *FilePath,
 129   IN      VOID                      *SourceBuffer,
 130   IN      UINTN                     SourceSize,
 131   OUT     EFI_HANDLE                *ImageHandle,
 132   IN      BOOLEAN                   LegacyIA32Binary
 133   )
 134 {
 135   if (LegacyIA32Binary) {
 136     return EFI_UNSUPPORTED;
 137   }
 138
 139   mCommunicationData.FunctionData.Function = SmmBaseFunctionRegister;
 140   mCommunicationData.FunctionData.Args.Register.FilePath = FilePath;
 141   mCommunicationData.FunctionData.Args.Register.SourceBuffer = SourceBuffer;
 142   mCommunicationData.FunctionData.Args.Register.SourceSize = SourceSize;
 143   mCommunicationData.FunctionData.Args.Register.ImageHandle = ImageHandle;
 144   mCommunicationData.FunctionData.Args.Register.LegacyIA32Binary = LegacyIA32Binary;
 145
 146   SmmBaseHelperService ();
 147   return mCommunicationData.FunctionData.Status;
 148 }
 149
 150 /**
 151   Removes a handler from execution within SMRAM.  This is the equivalent of performing
 152   the UnloadImage in System Management Mode.
 153
 154   @param[in]  This                  Protocol instance pointer.
 155   @param[in]  ImageHandle           The handler to be removed.
 156
 157   @retval     EFI_SUCCESS           The operation was successful
 158   @retval     EFI_INVALID_PARAMETER The handler did not exist
 159   @retval     EFI_UNSUPPORTED       Platform is in runtime.
 160 **/
 161 EFI_STATUS
 162 EFIAPI
 163 SmmBaseUnregister (
 164   IN      EFI_SMM_BASE_PROTOCOL     *This,
 165   IN      EFI_HANDLE                ImageHandle
 166   )
 167 {
 168   mCommunicationData.FunctionData.Function = SmmBaseFunctionUnregister;
 169   mCommunicationData.FunctionData.Args.UnRegister.ImageHandle = ImageHandle;
 170
 171   SmmBaseHelperService ();
 172   return mCommunicationData.FunctionData.Status;
 173 }
 174
 175 /**
 176   The SMM Inter-module Communicate Service Communicate() function
 177   provides a service to send/receive messages from a registered
 178   EFI service.  The BASE protocol driver is responsible for doing
 179   any of the copies such that the data lives in boot-service-accessible RAM.
 180
 181   @param[in]      This                  Protocol instance pointer.
 182   @param[in]      ImageHandle           The handle of the registered driver.
 183   @param[in, out]  CommunicationBuffer   Pointer to the buffer to convey into SMRAM.
 184   @param[in, out]  BufferSize            The size of the data buffer being passed in.
 185                                         On exit, the size of data being returned.
 186                                         Zero if the handler does not wish to reply with any data.
 187
 188   @retval         EFI_SUCCESS           The message was successfully posted
 189   @retval         EFI_INVALID_PARAMETER The buffer was NULL
 190 **/
 191 EFI_STATUS
 192 EFIAPI
 193 SmmBaseCommunicate (
 194   IN      EFI_SMM_BASE_PROTOCOL     *This,
 195   IN      EFI_HANDLE                ImageHandle,
 196   IN OUT  VOID                      *CommunicationBuffer,
 197   IN OUT  UINTN                     *BufferSize
 198   )
 199 {
 200   ///
 201   /// Note this is a runtime interface
 202   ///
 203
 204   mCommunicationData.FunctionData.Function = SmmBaseFunctionCommunicate;
 205   mCommunicationData.FunctionData.Args.Communicate.ImageHandle = ImageHandle;
 206   mCommunicationData.FunctionData.Args.Communicate.CommunicationBuffer = CommunicationBuffer;
 207   mCommunicationData.FunctionData.Args.Communicate.SourceSize = BufferSize;
 208
 209   SmmBaseHelperService ();
 210   return mCommunicationData.FunctionData.Status;
 211 }
 212
 213 /**
 214   Register a callback to execute within SMM.
 215   This allows receipt of messages created with EFI_SMM_BASE_PROTOCOL.Communicate().
 216
 217   @param[in]  This                  Protocol instance pointer.
 218   @param[in]  SmmImageHandle        Handle of the callback service.
 219   @param[in]  CallbackAddress       Address of the callback service.
 220   @param[in]  MakeLast              If present, will stipulate that the handler is posted to
 221                                     be executed last in the dispatch table.
 222   @param[in]  FloatingPointSave     An optional parameter that informs the
 223                                     EFI_SMM_ACCESS_PROTOCOL Driver core if it needs to save
 224                                     the floating point register state. If any handler
 225                                     require this, the state will be saved for all handlers.
 226
 227   @retval     EFI_SUCCESS           The operation was successful
 228   @retval     EFI_OUT_OF_RESOURCES  Not enough space in the dispatch queue
 229   @retval     EFI_UNSUPPORTED       Platform is in runtime.
 230   @retval     EFI_UNSUPPORTED       The caller is not in SMM.
 231 **/
 232 EFI_STATUS
 233 EFIAPI
 234 SmmBaseRegisterCallback (
 235   IN      EFI_SMM_BASE_PROTOCOL         *This,
 236   IN      EFI_HANDLE                    SmmImageHandle,
 237   IN      EFI_SMM_CALLBACK_ENTRY_POINT  CallbackAddress,
 238   IN      BOOLEAN                       MakeLast,
 239   IN      BOOLEAN                       FloatingPointSave
 240   )
 241 {
 242   if (!IsInSmm()) {
 243     return EFI_UNSUPPORTED;
 244   }
 245
 246   mCommunicationData.FunctionData.Function = SmmBaseFunctionRegisterCallback;
 247   mCommunicationData.FunctionData.Args.RegisterCallback.SmmImageHandle = SmmImageHandle;
 248   mCommunicationData.FunctionData.Args.RegisterCallback.CallbackAddress = CallbackAddress;
 249   mCommunicationData.FunctionData.Args.RegisterCallback.MakeLast = MakeLast;
 250   mCommunicationData.FunctionData.Args.RegisterCallback.FloatingPointSave = FloatingPointSave;
 251
 252   SmmBaseHelperService();
 253   return mCommunicationData.FunctionData.Status;
 254 }
 255
 256 /**
 257   This routine tells caller if execution context is SMM or not.
 258
 259   @param[in]   This                   Protocol instance pointer.
 260   @param[out]  InSmm                  Whether the caller is inside SMM for IA-32
 261                                       or servicing a PMI for the Itanium processor
 262                                       family.
 263
 264   @retval      EFI_SUCCESS            The operation was successful
 265   @retval      EFI_INVALID_PARAMETER  InSmm was NULL.
 266 **/
 267 EFI_STATUS
 268 EFIAPI
 269 SmmBaseInSmm (
 270   IN      EFI_SMM_BASE_PROTOCOL     *This,
 271   OUT     BOOLEAN                   *InSmm
 272   )
 273 {
 274   return mSmmBase2->InSmm (mSmmBase2, InSmm);
 275 }
 276
 277 /**
 278   The SmmAllocatePool() function allocates a memory region of Size bytes from memory of
 279   type PoolType and returns the address of the allocated memory in the location referenced
 280   by Buffer.  This function allocates pages from EFI SMRAM Memory as needed to grow the
 281   requested pool type.  All allocations are eight-byte aligned.
 282
 283   @param[in]   This                  Protocol instance pointer.
 284   @param[in]   PoolType              The type of pool to allocate.
 285                                      The only supported type is EfiRuntimeServicesData;
 286                                      the interface will internally map this runtime request to
 287                                      SMRAM for IA-32 and leave as this type for the Itanium
 288                                      processor family. Other types can be ignored.
 289   @param[in]   Size                  The number of bytes to allocate from the pool.
 290   @param[out]  Buffer                A pointer to a pointer to the allocated buffer if the call
 291                                      succeeds; undefined otherwise.
 292
 293   @retval      EFI_SUCCESS           The requested number of bytes was allocated.
 294   @retval      EFI_OUT_OF_RESOURCES  The pool requested could not be allocated.
 295   @retval      EFI_UNSUPPORTED       Platform is in runtime.
 296 **/
 297 EFI_STATUS
 298 EFIAPI
 299 SmmBaseSmmAllocatePool (
 300   IN      EFI_SMM_BASE_PROTOCOL     *This,
 301   IN      EFI_MEMORY_TYPE           PoolType,
 302   IN      UINTN                     Size,
 303   OUT     VOID                      **Buffer
 304   )
 305 {
 306   mCommunicationData.FunctionData.Function = SmmBaseFunctionAllocatePool;
 307   mCommunicationData.FunctionData.Args.AllocatePool.PoolType = PoolType;
 308   mCommunicationData.FunctionData.Args.AllocatePool.Size = Size;
 309   mCommunicationData.FunctionData.Args.AllocatePool.Buffer = Buffer;
 310
 311   SmmBaseHelperService ();
 312   return mCommunicationData.FunctionData.Status;
 313 }
 314
 315 /**
 316   The SmmFreePool() function returns the memory specified by Buffer to the system.
 317   On return, the memory's type is EFI SMRAM Memory.  The Buffer that is freed must
 318   have been allocated by SmmAllocatePool().
 319
 320   @param[in]  This                  Protocol instance pointer.
 321   @param[in]  Buffer                Pointer to the buffer allocation.
 322
 323   @retval     EFI_SUCCESS           The memory was returned to the system.
 324   @retval     EFI_INVALID_PARAMETER Buffer was invalid.
 325   @retval     EFI_UNSUPPORTED       Platform is in runtime.
 326 **/
 327 EFI_STATUS
 328 EFIAPI
 329 SmmBaseSmmFreePool (
 330   IN      EFI_SMM_BASE_PROTOCOL     *This,
 331   IN      VOID                      *Buffer
 332   )
 333 {
 334   mCommunicationData.FunctionData.Function = SmmBaseFunctionFreePool;
 335   mCommunicationData.FunctionData.Args.FreePool.Buffer = Buffer;
 336
 337   SmmBaseHelperService ();
 338   return mCommunicationData.FunctionData.Status;
 339 }
 340
 341 /**
 342   The GetSmstLocation() function returns the location of the System Management
 343   Service Table.  The use of the API is such that a driver can discover the
 344   location of the SMST in its entry point and then cache it in some driver
 345   global variable so that the SMST can be invoked in subsequent callbacks.
 346
 347   @param[in]  This                  Protocol instance pointer.
 348   @param[out] Smst                  Pointer to the SMST.
 349
 350   @retval     EFI_SUCCESS           The operation was successful
 351   @retval     EFI_INVALID_PARAMETER Smst was invalid.
 352   @retval     EFI_UNSUPPORTED       Not in SMM.
 353 **/
 354 EFI_STATUS
 355 EFIAPI
 356 SmmBaseGetSmstLocation (
 357   IN      EFI_SMM_BASE_PROTOCOL     *This,
 358   OUT     EFI_SMM_SYSTEM_TABLE      **Smst
 359   )
 360 {
 361   if (!IsInSmm ()) {
 362     return EFI_UNSUPPORTED;
 363   }
 364
 365   if (Smst == NULL) {
 366     return EFI_INVALID_PARAMETER;
 367   }
 368
 369   *Smst = mSmmBaseHelperReady->FrameworkSmst;
 370   return EFI_SUCCESS;
 371 }
 372
 373 /**
 374   Notification function of EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE
 375
 376   This is a notification function registered on EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE event.
 377   It convers pointer to new virtual address.
 378
 379   @param  Event        Event whose notification function is being invoked
 380   @param  Context      Pointer to the notification function's context
 381 **/
 382 VOID
 383 EFIAPI
 384 SmmBaseAddressChangeEvent (
 385   IN EFI_EVENT        Event,
 386   IN VOID             *Context
 387   )
 388 {
 389   EfiConvertPointer (0x0, (VOID **) &mSmmCommunication);
 390 }
 391
 392 ///
 393 /// SMM Base Protocol instance
 394 ///
 395 EFI_SMM_BASE_PROTOCOL  mSmmBase = {
 396   SmmBaseRegister,
 397   SmmBaseUnregister,
 398   SmmBaseCommunicate,
 399   SmmBaseRegisterCallback,
 400   SmmBaseInSmm,
 401   SmmBaseSmmAllocatePool,
 402   SmmBaseSmmFreePool,
 403   SmmBaseGetSmstLocation
 404 };
 405
 406 /**
 407   Entry Point for SMM Base Protocol on SMM Base2 Protocol Thunk driver.
 408
 409   @param[in] ImageHandle  Image handle of this driver.
 410   @param[in] SystemTable  A Pointer to the EFI System Table.
 411
 412   @retval EFI_SUCCESS  The entry point is executed successfully.
 413 **/
 414 EFI_STATUS
 415 EFIAPI
 416 SmmBaseThunkMain (
 417   IN EFI_HANDLE        ImageHandle,
 418   IN EFI_SYSTEM_TABLE  *SystemTable
 419   )
 420 {
 421   EFI_STATUS  Status;
 422   EFI_EVENT   Event;
 423
 424   //
 425   // Assume only one instance of SMM Base2 Protocol in the system
 426   // Locate SMM Base2 Protocol
 427   //
 428   Status = gBS->LocateProtocol (&gEfiSmmBase2ProtocolGuid, NULL, (VOID **) &mSmmBase2);
 429   ASSERT_EFI_ERROR (Status);
 430
 431   //
 432   // Assume only one instance of SMM Communication Protocol in the system
 433   // Locate SMM Communication Protocol
 434   //
 435   gBS->LocateProtocol (&gEfiSmmCommunicationProtocolGuid, NULL, (VOID **) &mSmmCommunication);
 436   ASSERT_EFI_ERROR (Status);
 437
 438   //
 439   // Assume only one instance of SMM Base Helper Ready Protocol in the system
 440   // Locate SMM Base Helper Ready Protocol
 441   //
 442   Status = gBS->LocateProtocol (&gEfiSmmBaseHelperReadyProtocolGuid, NULL, (VOID **) &mSmmBaseHelperReady);
 443   ASSERT_EFI_ERROR (Status);
 444
 445   //
 446   // Create event on SetVirtualAddressMap() to convert mSmmCommunication from a physical address to a virtual address
 447   //
 448   Status = gBS->CreateEventEx (
 449                   EVT_NOTIFY_SIGNAL,
 450                   TPL_NOTIFY,
 451                   SmmBaseAddressChangeEvent,
 452                   NULL,
 453                   &gEfiEventVirtualAddressChangeGuid,
 454                   &Event
 455                   );
 456   ASSERT_EFI_ERROR (Status);
 457
 458   //
 459   // Publish Framework SMM BASE Protocol immediately after SMM Base2 Protocol is installed to
 460   // make SMM Base Protocol.InSmm() available as early as possible.
 461   //
 462   Status = gBS->InstallMultipleProtocolInterfaces (
 463                   &mSmmBaseHandle,
 464                   &gEfiSmmBaseProtocolGuid, &mSmmBase,
 465                   NULL
 466                   );
 467   ASSERT_EFI_ERROR (Status);
 468
 469   return EFI_SUCCESS;
 470 }