[mirror_edk2.git] / MdeModulePkg / Core / PiSmmCore / PiSmmIpl.c

/** @file\r
  SMM IPL that produces SMM related runtime protocols and load the SMM Core into SMRAM\r
\r
  Copyright (c) 2009 - 2010, Intel Corporation.  All rights reserved.<BR>\r
  This program and the accompanying materials are licensed and made available \r
  under the terms and conditions of the BSD License which accompanies this \r
  distribution.  The full text of the license may be found at        \r
  http://opensource.org/licenses/bsd-license.php                                            \r
\r
  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     \r
  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             \r
\r
**/\r
\r
#include <PiDxe.h>\r
\r
#include <Protocol/SmmBase2.h>\r
#include <Protocol/SmmCommunication.h>\r
#include <Protocol/SmmAccess2.h>\r
#include <Protocol/SmmConfiguration.h>\r
#include <Protocol/SmmControl2.h>\r
#include <Protocol/DxeSmmReadyToLock.h>\r
#include <Protocol/FirmwareVolume2.h>\r
\r
#include <Guid/EventGroup.h>\r
#include <Guid/EventLegacyBios.h>\r
\r
#include <Library/BaseLib.h>\r
#include <Library/BaseMemoryLib.h>\r
#include <Library/PeCoffLib.h>\r
#include <Library/CacheMaintenanceLib.h>\r
#include <Library/MemoryAllocationLib.h>\r
#include <Library/DebugLib.h>\r
#include <Library/UefiBootServicesTableLib.h>\r
#include <Library/DxeServicesTableLib.h>\r
#include <Library/UefiLib.h>\r
#include <Library/UefiRuntimeLib.h>\r
\r
#include "PiSmmCorePrivateData.h"\r
\r
//\r
// Function prototypes from produced protocols\r
//\r
\r
/**\r
  Indicate whether the driver is currently executing in the SMM Initialization phase.\r
\r
  @param   This                    The EFI_SMM_BASE2_PROTOCOL instance.\r
  @param   InSmram                 Pointer to a Boolean which, on return, indicates that the driver is currently executing\r
                                   inside of SMRAM (TRUE) or outside of SMRAM (FALSE).\r
\r
  @retval  EFI_INVALID_PARAMETER   InSmram was NULL.\r
  @retval  EFI_SUCCESS             The call returned successfully.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
SmmBase2InSmram (\r
  IN CONST EFI_SMM_BASE2_PROTOCOL  *This,\r
  OUT      BOOLEAN                 *InSmram\r
  );\r
\r
/**\r
  Retrieves the location of the System Management System Table (SMST).\r
\r
  @param   This                    The EFI_SMM_BASE2_PROTOCOL instance.\r
  @param   Smst                    On return, points to a pointer to the System Management Service Table (SMST).\r
\r
  @retval  EFI_INVALID_PARAMETER   Smst or This was invalid.\r
  @retval  EFI_SUCCESS             The memory was returned to the system.\r
  @retval  EFI_UNSUPPORTED         Not in SMM.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
SmmBase2GetSmstLocation (\r
  IN CONST EFI_SMM_BASE2_PROTOCOL  *This,\r
  OUT      EFI_SMM_SYSTEM_TABLE2   **Smst\r
  );\r
\r
/**\r
  Communicates with a registered handler.\r
  \r
  This function provides a service to send and receive messages from a registered \r
  UEFI service.  This function is part of the SMM Communication Protocol that may \r
  be called in physical mode prior to SetVirtualAddressMap() and in virtual mode \r
  after SetVirtualAddressMap().\r
\r
  @param[in]     This                The EFI_SMM_COMMUNICATION_PROTOCOL instance.\r
  @param[in out] CommBuffer          A pointer to the buffer to convey into SMRAM.\r
  @param[in out] CommSize            The size of the data buffer being passed in.On exit, the size of data\r
                                     being returned. Zero if the handler does not wish to reply with any data.\r
\r
  @retval EFI_SUCCESS                The message was successfully posted.\r
  @retval EFI_INVALID_PARAMETER      The CommBuffer was NULL.\r
**/\r
EFI_STATUS\r
EFIAPI\r
SmmCommunicationCommunicate (\r
  IN CONST EFI_SMM_COMMUNICATION_PROTOCOL  *This,\r
  IN OUT VOID                              *CommBuffer,\r
  IN OUT UINTN                             *CommSize\r
  );\r
\r
/**\r
  Event notification that is fired every time a gEfiSmmConfigurationProtocol installs.\r
\r
  @param  Event                 The Event that is being processed, not used.\r
  @param  Context               Event Context, not used.\r
\r
**/\r
VOID\r
EFIAPI\r
SmmIplSmmConfigurationEventNotify (\r
  IN EFI_EVENT  Event,\r
  IN VOID       *Context\r
  );\r
\r
/**\r
  Event notification that is fired every time a DxeSmmReadyToLock protocol is added\r
  or if gEfiEventReadyToBootGuid is signalled.\r
\r
  @param  Event                 The Event that is being processed, not used.\r
  @param  Context               Event Context, not used.\r
\r
**/\r
VOID\r
EFIAPI\r
SmmIplReadyToLockEventNotify (\r
  IN EFI_EVENT  Event,\r
  IN VOID       *Context\r
  );\r
\r
/**\r
  Event notification that is fired when DxeDispatch Event Group is signaled.\r
\r
  @param  Event                 The Event that is being processed, not used.\r
  @param  Context               Event Context, not used.\r
\r
**/\r
VOID\r
EFIAPI\r
SmmIplGuidedEventNotify (\r
  IN EFI_EVENT  Event,\r
  IN VOID       *Context\r
  );\r
\r
/**\r
  Notification function of EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE.\r
\r
  This is a notification function registered on EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE event.\r
  It convers pointer to new virtual address.\r
\r
  @param  Event        Event whose notification function is being invoked.\r
  @param  Context      Pointer to the notification function's context.\r
\r
**/\r
VOID\r
EFIAPI\r
SmmIplSetVirtualAddressNotify (\r
  IN EFI_EVENT  Event,\r
  IN VOID       *Context\r
  );\r
\r
//\r
// Data structure used to declare a table of protocol notifications and event \r
// notifications required by the SMM IPL\r
//\r
typedef struct {\r
  BOOLEAN           Protocol;\r
  BOOLEAN           CloseOnLock;\r
  EFI_GUID          *Guid;\r
  EFI_EVENT_NOTIFY  NotifyFunction;\r
  VOID              *NotifyContext;\r
  EFI_EVENT         Event;\r
} SMM_IPL_EVENT_NOTIFICATION;\r
\r
//\r
// Handle to install the SMM Base2 Protocol and the SMM Communication Protocol\r
//\r
EFI_HANDLE  mSmmIplHandle = NULL;\r
\r
//\r
// SMM Base 2 Protocol instance\r
//\r
EFI_SMM_BASE2_PROTOCOL  mSmmBase2 = {\r
  SmmBase2InSmram,\r
  SmmBase2GetSmstLocation\r
};\r
\r
//\r
// SMM Communication Protocol instance\r
//\r
EFI_SMM_COMMUNICATION_PROTOCOL  mSmmCommunication = {\r
  SmmCommunicationCommunicate\r
};\r
\r
//\r
// SMM Core Private Data structure that contains the data shared between\r
// the SMM IPL and the SMM Core.\r
//\r
SMM_CORE_PRIVATE_DATA  mSmmCorePrivateData = {\r
  SMM_CORE_PRIVATE_DATA_SIGNATURE,    // Signature\r
  NULL,                               // SmmIplImageHandle\r
  0,                                  // SmramRangeCount\r
  NULL,                               // SmramRanges\r
  NULL,                               // SmmEntryPoint\r
  FALSE,                              // SmmEntryPointRegistered\r
  FALSE,                              // InSmm\r
  NULL,                               // Smst\r
  0,                                  // BufferSize\r
  NULL,                               // CommunicationBuffer\r
  EFI_SUCCESS                         // ReturnStatus\r
};\r
\r
//\r
// Global pointer used to access mSmmCorePrivateData from outside and inside SMM\r
//\r
SMM_CORE_PRIVATE_DATA  *gSmmCorePrivate = &mSmmCorePrivateData;\r
\r
//\r
// SMM IPL global variables\r
//\r
EFI_SMM_CONTROL2_PROTOCOL  *mSmmControl2;\r
EFI_SMM_ACCESS2_PROTOCOL   *mSmmAccess;\r
EFI_SMRAM_DESCRIPTOR       *mCurrentSmramRange;\r
BOOLEAN                    mSmmLocked = FALSE;\r
\r
//\r
// Table of Protocol notification and GUIDed Event notifications that the SMM IPL requires\r
//\r
SMM_IPL_EVENT_NOTIFICATION  mSmmIplEvents[] = {\r
  //\r
  // Declare protocol notification on the SMM Configuration protocol.  When this notification is etablished, \r
  // the associated event is immediately signalled, so the notification function will be executed and the \r
  // SMM Configuration Protocol will be found if it is already in the handle database.\r
  //\r
  { TRUE,  FALSE, &gEfiSmmConfigurationProtocolGuid,  SmmIplSmmConfigurationEventNotify, &gEfiSmmConfigurationProtocolGuid,  NULL },\r
  //\r
  // Declare protocl notification on DxeSmmReadyToLock protocols.  When this notification is etablished, \r
  // the associated event is immediately signalled, so the notification function will be executed and the \r
  // DXE SMM Ready To Lock Protocol will be found if it is already in the handle database.\r
  //\r
  { TRUE,  TRUE,  &gEfiDxeSmmReadyToLockProtocolGuid, SmmIplReadyToLockEventNotify,      &gEfiDxeSmmReadyToLockProtocolGuid, NULL },\r
  //\r
  // Declare event notification on the DXE Dispatch Event Group.  This event is signaled by the DXE Core\r
  // each time the DXE Core dispatcher has completed its work.  When this event is signalled, the SMM Core\r
  // if notified, so the SMM Core can dispatch SMM drivers.\r
  //\r
  { FALSE, TRUE,  &gEfiEventDxeDispatchGuid,          SmmIplGuidedEventNotify,           &gEfiEventDxeDispatchGuid,          NULL },\r
  //\r
  // Declare event notification on Ready To Boot Event Group.  This is an extra event notification that is\r
  // used to make sure SMRAM is locked before any boot options are processed.\r
  //\r
  { FALSE, TRUE,  &gEfiEventReadyToBootGuid,          SmmIplReadyToLockEventNotify,      &gEfiEventReadyToBootGuid,          NULL },\r
  //\r
  // Declare event notification on Legacy Boot Event Group.  This is used to inform the SMM Core that the platform \r
  // is performing a legacy boot operation, and that the UEFI environment is no longer available and the SMM Core \r
  // must guarantee that it does not access any UEFI related structures outside of SMRAM.\r
  //\r
  { FALSE, FALSE, &gEfiEventLegacyBootGuid,           SmmIplGuidedEventNotify,           &gEfiEventLegacyBootGuid,           NULL },\r
  //\r
  // Declare event notification on SetVirtualAddressMap() Event Group.  This is used to convert gSmmCorePrivate \r
  // and mSmmControl2 from physical addresses to virtual addresses.\r
  //\r
  { FALSE, FALSE, &gEfiEventVirtualAddressChangeGuid, SmmIplSetVirtualAddressNotify,     NULL,                               NULL },\r
  //\r
  // Terminate the table of event notifications\r
  //\r
  { FALSE, FALSE, NULL,                               NULL,                              NULL,                               NULL }\r
};\r
\r
/**\r
  Indicate whether the driver is currently executing in the SMM Initialization phase.\r
\r
  @param   This                    The EFI_SMM_BASE2_PROTOCOL instance.\r
  @param   InSmram                 Pointer to a Boolean which, on return, indicates that the driver is currently executing\r
                                   inside of SMRAM (TRUE) or outside of SMRAM (FALSE).\r
\r
  @retval  EFI_INVALID_PARAMETER   InSmram was NULL.\r
  @retval  EFI_SUCCESS             The call returned successfully.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
SmmBase2InSmram (\r
  IN CONST EFI_SMM_BASE2_PROTOCOL  *This,\r
  OUT      BOOLEAN                 *InSmram\r
  )\r
{\r
  if (InSmram == NULL) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  *InSmram = gSmmCorePrivate->InSmm;\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Retrieves the location of the System Management System Table (SMST).\r
\r
  @param   This                    The EFI_SMM_BASE2_PROTOCOL instance.\r
  @param   Smst                    On return, points to a pointer to the System Management Service Table (SMST).\r
\r
  @retval  EFI_INVALID_PARAMETER   Smst or This was invalid.\r
  @retval  EFI_SUCCESS             The memory was returned to the system.\r
  @retval  EFI_UNSUPPORTED         Not in SMM.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
SmmBase2GetSmstLocation (\r
  IN CONST EFI_SMM_BASE2_PROTOCOL  *This,\r
  OUT      EFI_SMM_SYSTEM_TABLE2   **Smst\r
  )\r
{\r
  if ((This == NULL) ||(Smst == NULL)) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
  \r
  if (!gSmmCorePrivate->InSmm) {\r
    return EFI_UNSUPPORTED;\r
  }\r
  \r
  *Smst = gSmmCorePrivate->Smst;\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Communicates with a registered handler.\r
  \r
  This function provides a service to send and receive messages from a registered \r
  UEFI service.  This function is part of the SMM Communication Protocol that may \r
  be called in physical mode prior to SetVirtualAddressMap() and in virtual mode \r
  after SetVirtualAddressMap().\r
\r
  @param[in] This                The EFI_SMM_COMMUNICATION_PROTOCOL instance.\r
  @param[in out] CommBuffer          A pointer to the buffer to convey into SMRAM.\r
  @param[in out] CommSize            The size of the data buffer being passed in.On exit, the size of data\r
                                 being returned. Zero if the handler does not wish to reply with any data.\r
\r
  @retval EFI_SUCCESS            The message was successfully posted.\r
  @retval EFI_INVALID_PARAMETER  The CommBuffer was NULL.\r
**/\r
EFI_STATUS\r
EFIAPI\r
SmmCommunicationCommunicate (\r
  IN CONST EFI_SMM_COMMUNICATION_PROTOCOL  *This,\r
  IN OUT VOID                              *CommBuffer,\r
  IN OUT UINTN                             *CommSize\r
  )\r
{\r
  EFI_STATUS                  Status;\r
  EFI_SMM_COMMUNICATE_HEADER  *CommunicateHeader;\r
  BOOLEAN                     OldInSmm;\r
\r
  //\r
  // Check parameters\r
  //\r
  if ((CommBuffer == NULL) || (CommSize == NULL)) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  //\r
  // If not already in SMM, then generate a Software SMI\r
  //\r
  if (!gSmmCorePrivate->InSmm && gSmmCorePrivate->SmmEntryPointRegistered) {\r
    //\r
    // Put arguments for Software SMI in gSmmCorePrivate\r
    //\r
    gSmmCorePrivate->CommunicationBuffer = CommBuffer;\r
    gSmmCorePrivate->BufferSize          = CommSize;\r
\r
    //\r
    // Generate Software SMI\r
    //\r
    Status = mSmmControl2->Trigger (mSmmControl2, NULL, NULL, FALSE, 0);\r
    if (EFI_ERROR (Status)) {\r
      return EFI_UNSUPPORTED;\r
    }\r
\r
    //\r
    // Return status from software SMI \r
    //\r
    return gSmmCorePrivate->ReturnStatus;\r
  }\r
\r
  //\r
  // If we are in SMM, then the execution mode must be physical, which means that\r
  // OS established virtual addresses can not be used.  If SetVirtualAddressMap()\r
  // has been called, then a direct invocation of the Software SMI is not \r
  // not allowed so return EFI_INVALID_PARAMETER.\r
  //\r
  if (EfiGoneVirtual()) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  //\r
  // Save current InSmm state and set InSmm state to TRUE\r
  //\r
  OldInSmm = gSmmCorePrivate->InSmm;\r
  gSmmCorePrivate->InSmm = TRUE;\r
\r
  //\r
  // Already in SMM and before SetVirtualAddressMap(), so call SmiManage() directly.\r
  //\r
  CommunicateHeader = (EFI_SMM_COMMUNICATE_HEADER *)CommBuffer;\r
  *CommSize -= OFFSET_OF (EFI_SMM_COMMUNICATE_HEADER, Data);\r
  Status = gSmmCorePrivate->Smst->SmiManage (\r
                                    &CommunicateHeader->HeaderGuid, \r
                                    NULL, \r
                                    CommunicateHeader->Data, \r
                                    CommSize\r
                                    );\r
\r
  //\r
  // Update CommunicationBuffer, BufferSize and ReturnStatus\r
  // Communicate service finished, reset the pointer to CommBuffer to NULL\r
  //\r
  *CommSize += OFFSET_OF (EFI_SMM_COMMUNICATE_HEADER, Data);\r
\r
  //\r
  // Restore original InSmm state\r
  //\r
  gSmmCorePrivate->InSmm = OldInSmm;\r
\r
  return (Status == EFI_WARN_INTERRUPT_SOURCE_QUIESCED) ? EFI_SUCCESS : EFI_NOT_FOUND;\r
}\r
\r
/**\r
  Event notification that is fired when DxeDispatch Event Group is signaled.\r
\r
  @param  Event                 The Event that is being processed, not used.\r
  @param  Context               Event Context, not used.\r
\r
**/\r
VOID\r
EFIAPI\r
SmmIplGuidedEventNotify (\r
  IN EFI_EVENT  Event,\r
  IN VOID       *Context\r
  )\r
{\r
  EFI_SMM_COMMUNICATE_HEADER  CommunicateHeader;\r
  UINTN                       Size;\r
\r
  //\r
  // Use Guid to initialize EFI_SMM_COMMUNICATE_HEADER structure \r
  //\r
  CopyGuid (&CommunicateHeader.HeaderGuid, (EFI_GUID *)Context);\r
  CommunicateHeader.MessageLength = 1;\r
  CommunicateHeader.Data[0] = 0;\r
\r
  //\r
  // Generate the Software SMI and return the result\r
  //\r
  Size = sizeof (CommunicateHeader);\r
  SmmCommunicationCommunicate (&mSmmCommunication, &CommunicateHeader, &Size);\r
}\r
\r
/**\r
  Event notification that is fired every time a gEfiSmmConfigurationProtocol installs.\r
\r
  @param  Event                 The Event that is being processed, not used.\r
  @param  Context               Event Context, not used.\r
\r
**/\r
VOID\r
EFIAPI\r
SmmIplSmmConfigurationEventNotify (\r
  IN EFI_EVENT  Event,\r
  IN VOID       *Context\r
  )\r
{\r
  EFI_STATUS                      Status;\r
  EFI_SMM_CONFIGURATION_PROTOCOL  *SmmConfiguration;\r
\r
  //\r
  // Make sure this notification is for this handler\r
  //\r
  Status = gBS->LocateProtocol (Context, NULL, (VOID **)&SmmConfiguration);\r
  if (EFI_ERROR (Status)) {\r
    return;\r
  }\r
\r
  //\r
  // Register the SMM Entry Point provided by the SMM Core with the SMM COnfiguration protocol\r
  //\r
  Status = SmmConfiguration->RegisterSmmEntry (SmmConfiguration, gSmmCorePrivate->SmmEntryPoint);\r
  ASSERT_EFI_ERROR (Status);\r
\r
  //\r
  // Set flag to indicate that the SM< Entry Point has been registered which \r
  // means that SMIs are now fully operational.\r
  //\r
  gSmmCorePrivate->SmmEntryPointRegistered = TRUE;\r
\r
  //\r
  // Print debug message showing SMM Core entry point address.\r
  //\r
  DEBUG ((DEBUG_INFO, "SMM IPL registered SMM Entry Point address %p\n", (VOID *)(UINTN)gSmmCorePrivate->SmmEntryPoint));\r
\r
  //\r
  // Attempt to reset SMRAM cacheability to UC\r
  //\r
  Status = gDS->SetMemorySpaceAttributes(\r
                  mCurrentSmramRange->CpuStart, \r
                  mCurrentSmramRange->PhysicalSize,\r
                  EFI_MEMORY_UC\r
                  );\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((DEBUG_WARN, "SMM IPL failed to reset SMRAM window to EFI_MEMORY_UC\n"));\r
  }  \r
\r
  //\r
  // Close all SMRAM ranges to protect SMRAM\r
  //\r
  Status = mSmmAccess->Close (mSmmAccess);\r
  ASSERT_EFI_ERROR (Status);\r
\r
  //\r
  // Print debug message that the SMRAM window is now closed.\r
  //\r
  DEBUG ((DEBUG_INFO, "SMM IPL closed SMRAM window\n"));\r
}\r
\r
/**\r
  Event notification that is fired every time a DxeSmmReadyToLock protocol is added\r
  or if gEfiEventReadyToBootGuid is signalled.\r
\r
  @param  Event                 The Event that is being processed, not used.\r
  @param  Context               Event Context, not used.\r
\r
**/\r
VOID\r
EFIAPI\r
SmmIplReadyToLockEventNotify (\r
  IN EFI_EVENT  Event,\r
  IN VOID       *Context\r
  )\r
{\r
  EFI_STATUS  Status;\r
  VOID        *Interface;\r
  UINTN       Index;\r
\r
  //\r
  // See if we are already locked\r
  //\r
  if (mSmmLocked) {\r
    return;\r
  }\r
  \r
  //\r
  // Make sure this notification is for this handler\r
  //\r
  if (CompareGuid ((EFI_GUID *)Context, &gEfiDxeSmmReadyToLockProtocolGuid)) {\r
    Status = gBS->LocateProtocol (&gEfiDxeSmmReadyToLockProtocolGuid, NULL, &Interface);\r
    if (EFI_ERROR (Status)) {\r
      return;\r
    }\r
  } else {\r
    //\r
    // If SMM is not locked yet and we got here from gEfiEventReadyToBootGuid being \r
    // signalled, then gEfiDxeSmmReadyToLockProtocolGuid was not installed as expected.\r
    // Print a warning on debug builds.\r
    //\r
    DEBUG ((DEBUG_WARN, "SMM IPL!  DXE SMM Ready To Lock Protocol not installed before Ready To Boot signal\n"));\r
  }\r
\r
  //\r
  // Lock the SMRAM (Note: Locking SMRAM may not be supported on all platforms)\r
  //\r
  mSmmAccess->Lock (mSmmAccess);\r
\r
  //\r
  // Close protocol and event notification events that do not apply after the \r
  // DXE SMM Ready To Lock Protocol has been installed or the Ready To Boot \r
  // event has been signalled.\r
  //\r
  for (Index = 0; mSmmIplEvents[Index].NotifyFunction != NULL; Index++) {\r
    if (mSmmIplEvents[Index].CloseOnLock) {\r
      gBS->CloseEvent (mSmmIplEvents[Index].Event);\r
    }\r
  }\r
\r
  //\r
  // Inform SMM Core that the DxeSmmReadyToLock protocol was installed\r
  //\r
  SmmIplGuidedEventNotify (Event, (VOID *)&gEfiDxeSmmReadyToLockProtocolGuid);\r
\r
  //\r
  // Print debug message that the SMRAM window is now locked.\r
  //\r
  DEBUG ((DEBUG_INFO, "SMM IPL locked SMRAM window\n"));\r
  \r
  //\r
  // Set flag so this operation will not be performed again\r
  //\r
  mSmmLocked = TRUE;\r
}\r
\r
/**\r
  Notification function of EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE.\r
\r
  This is a notification function registered on EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE event.\r
  It convers pointer to new virtual address.\r
\r
  @param  Event        Event whose notification function is being invoked.\r
  @param  Context      Pointer to the notification function's context.\r
\r
**/\r
VOID\r
EFIAPI\r
SmmIplSetVirtualAddressNotify (\r
  IN EFI_EVENT  Event,\r
  IN VOID       *Context\r
  )\r
{\r
  EfiConvertPointer (0x0, (VOID **)&mSmmControl2);\r
}\r
\r
/**\r
  Searches all Firmware Volumes for the first file matching FileType and SectionType and returns the section data.\r
\r
  @param   FileType                FileType to search for within any of the firmware volumes in the platform.\r
  @param   SectionType             SectionType to search for within any of the matching FileTypes in the firmware volumes in the platform.\r
  @param   SourceSize              Return the size of the returned section data..\r
\r
  @retval  != NULL                 Pointer to the allocated buffer containing the section data.\r
  @retval  NULL                    Section data was not found.\r
\r
**/\r
VOID *\r
GetSectionInAnyFv (\r
  IN  EFI_FV_FILETYPE   FileType,\r
  IN  EFI_SECTION_TYPE  SectionType,\r
  OUT UINTN             *SourceSize\r
  )\r
{\r
  EFI_STATUS                    Status;\r
  UINTN                         HandleCount;\r
  EFI_HANDLE                    *HandleBuffer;\r
  UINTN                         Index;\r
  EFI_FIRMWARE_VOLUME2_PROTOCOL *Fv;\r
  UINTN                         Key;\r
  EFI_GUID                      NameGuid;\r
  EFI_FV_FILE_ATTRIBUTES        Attributes;\r
  VOID                          *SourceBuffer;\r
  UINT32                        AuthenticationStatus;\r
\r
  HandleBuffer = NULL;\r
  Status = gBS->LocateHandleBuffer (\r
                  ByProtocol,\r
                  &gEfiFirmwareVolume2ProtocolGuid,\r
                  NULL,\r
                  &HandleCount,\r
                  &HandleBuffer\r
                  );\r
  if (EFI_ERROR (Status)) {\r
    return NULL;\r
  }\r
\r
  for (Index = 0; Index < HandleCount; Index++) {\r
    Status = gBS->HandleProtocol (\r
                    HandleBuffer[Index],\r
                    &gEfiFirmwareVolume2ProtocolGuid,\r
                    (VOID **)&Fv\r
                    );\r
    if (EFI_ERROR (Status)) {\r
      continue;\r
    }\r
\r
    //\r
    // Use Firmware Volume 2 Protocol to search for a file of type FileType\r
    //\r
    Key = 0;   \r
    Status = Fv->GetNextFile (Fv, &Key, &FileType, &NameGuid, &Attributes, SourceSize);\r
    if (EFI_ERROR (Status)) {\r
      continue;\r
    }\r
\r
    //\r
    // Use Firmware Volume 2 Protocol to read a section of type SectionType\r
    //\r
    SourceBuffer = NULL;\r
    Status = Fv->ReadSection (Fv, &NameGuid, SectionType, 0, &SourceBuffer, SourceSize, &AuthenticationStatus);\r
    if (!EFI_ERROR (Status)) {\r
      FreePool (HandleBuffer);\r
      return SourceBuffer;\r
    }\r
  }  \r
\r
  FreePool(HandleBuffer);\r
  \r
  return NULL;\r
}\r
\r
/**\r
  Load the SMM Core image into SMRAM and executes the SMM Core from SMRAM.\r
\r
  @param[in] SmramRange  Descriptor for the range of SMRAM to reload the \r
                         currently executing image.\r
  @param[in] Context     Context to pass into SMM Core\r
\r
  @return  EFI_STATUS\r
\r
**/\r
EFI_STATUS\r
ExecuteSmmCoreFromSmram (\r
  IN EFI_SMRAM_DESCRIPTOR  *SmramRange,\r
  IN VOID                  *Context\r
  )\r
{\r
  EFI_STATUS                    Status;\r
  VOID                          *SourceBuffer;\r
  UINTN                         SourceSize;\r
  PE_COFF_LOADER_IMAGE_CONTEXT  ImageContext;\r
  UINTN                         PageCount;\r
  EFI_PHYSICAL_ADDRESS          DestinationBuffer;\r
  EFI_IMAGE_ENTRY_POINT         EntryPoint;\r
\r
  //\r
  // Search all Firmware Volumes for a PE/COFF image in a file of type SMM_CORE\r
  //  \r
  SourceBuffer = GetSectionInAnyFv (EFI_FV_FILETYPE_SMM_CORE, EFI_SECTION_PE32, &SourceSize);\r
  if (SourceBuffer == NULL) {\r
    return EFI_NOT_FOUND;\r
  }\r
  \r
  //\r
  // Initilize ImageContext\r
  //\r
  ImageContext.Handle    = SourceBuffer;\r
  ImageContext.ImageRead = PeCoffLoaderImageReadFromMemory;\r
\r
  //\r
  // Get information about the image being loaded\r
  //\r
  Status = PeCoffLoaderGetImageInfo (&ImageContext);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  //\r
  // Allocate memory for the image being loaded from the EFI_SRAM_DESCRIPTOR \r
  // specified by SmramRange\r
  //\r
  PageCount = (UINTN)EFI_SIZE_TO_PAGES(ImageContext.ImageSize + ImageContext.SectionAlignment);\r
\r
  ASSERT ((SmramRange->PhysicalSize & EFI_PAGE_MASK) == 0);\r
  ASSERT (SmramRange->PhysicalSize > EFI_PAGES_TO_SIZE (PageCount));\r
\r
  SmramRange->PhysicalSize -= EFI_PAGES_TO_SIZE (PageCount);\r
  DestinationBuffer = SmramRange->CpuStart + SmramRange->PhysicalSize;\r
\r
  //\r
  // Align buffer on section boundry\r
  //\r
  ImageContext.ImageAddress = DestinationBuffer;\r
  ImageContext.ImageAddress += ImageContext.SectionAlignment - 1;\r
  ImageContext.ImageAddress &= ~(ImageContext.SectionAlignment - 1);\r
\r
  //\r
  // Print debug message showing SMM Core load address.\r
  //\r
  DEBUG ((DEBUG_INFO, "SMM IPL loading SMM Core at SMRAM address %p\n", (VOID *)(UINTN)ImageContext.ImageAddress));\r
\r
  //\r
  // Load the image to our new buffer\r
  //\r
  Status = PeCoffLoaderLoadImage (&ImageContext);\r
  if (!EFI_ERROR (Status)) {\r
    //\r
    // Relocate the image in our new buffer\r
    //\r
    Status = PeCoffLoaderRelocateImage (&ImageContext);\r
    if (!EFI_ERROR (Status)) {\r
      //\r
      // Flush the instruction cache so the image data are written before we execute it\r
      //\r
      InvalidateInstructionCacheRange ((VOID *)(UINTN)ImageContext.ImageAddress, (UINTN)ImageContext.ImageSize);\r
\r
      //\r
      // Print debug message showing SMM Core entry point address.\r
      //\r
      DEBUG ((DEBUG_INFO, "SMM IPL calling SMM Core at SMRAM address %p\n", (VOID *)(UINTN)ImageContext.EntryPoint));\r
\r
      //\r
      // Execute image\r
      //\r
      EntryPoint = (EFI_IMAGE_ENTRY_POINT)(UINTN)ImageContext.EntryPoint;\r
      Status = EntryPoint ((EFI_HANDLE)Context, gST);\r
    }\r
  }\r
\r
  //\r
  // If the load operation, relocate operation, or the image execution return an\r
  // error, then free memory allocated from the EFI_SRAM_DESCRIPTOR specified by \r
  // SmramRange\r
  //\r
  if (EFI_ERROR (Status)) {\r
    SmramRange->PhysicalSize += EFI_PAGES_TO_SIZE (PageCount);\r
  }\r
\r
  //\r
  // Always free memory allocted by GetFileBufferByFilePath ()\r
  //\r
  FreePool (SourceBuffer);\r
\r
  return Status;\r
}\r
\r
/**\r
  The Entry Point for SMM IPL\r
\r
  Load SMM Core into SMRAM, register SMM Core entry point for SMIs, install \r
  SMM Base 2 Protocol and SMM Communication Protocol, and register for the \r
  critical events required to coordinate between DXE and SMM environments.\r
  \r
  @param  ImageHandle    The firmware allocated handle for the EFI image.\r
  @param  SystemTable    A pointer to the EFI System Table.\r
\r
  @retval EFI_SUCCESS    The entry point is executed successfully.\r
  @retval Other          Some error occurred when executing this entry point.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
SmmIplEntry (\r
  IN EFI_HANDLE        ImageHandle,\r
  IN EFI_SYSTEM_TABLE  *SystemTable\r
  )\r
{\r
  EFI_STATUS                      Status;\r
  EFI_SMM_CONFIGURATION_PROTOCOL  *SmmConfiguration;\r
  UINTN                           Size;\r
  UINTN                           Index;\r
  EFI_SMM_RESERVED_SMRAM_REGION   *SmramResRegion;\r
  UINT64                          MaxSize;\r
  VOID                            *Registration;\r
\r
  //\r
  // Fill in the image handle of the SMM IPL so the SMM Core can use this as the \r
  // ParentImageHandle field of the Load Image Protocol for all SMM Drivers loaded \r
  // by the SMM Core\r
  //\r
  mSmmCorePrivateData.SmmIplImageHandle = ImageHandle;\r
\r
  //\r
  // Get SMM Access Protocol\r
  //\r
  Status = gBS->LocateProtocol (&gEfiSmmAccess2ProtocolGuid, NULL, (VOID **)&mSmmAccess);\r
  ASSERT_EFI_ERROR (Status);\r
\r
  //\r
  // Get SMM Control2 Protocol\r
  //\r
  Status = gBS->LocateProtocol (&gEfiSmmControl2ProtocolGuid, NULL, (VOID **)&mSmmControl2);\r
  ASSERT_EFI_ERROR (Status);\r
\r
  //\r
  // Get SMM Configuration Protocol if it is present\r
  //\r
  SmmConfiguration = NULL;\r
  Status = gBS->LocateProtocol (&gEfiSmmConfigurationProtocolGuid, NULL, (VOID **) &SmmConfiguration);\r
\r
  //\r
  // Get SMRAM information\r
  //\r
  Size = 0;\r
  Status = mSmmAccess->GetCapabilities (mSmmAccess, &Size, NULL);\r
  ASSERT (Status == EFI_BUFFER_TOO_SMALL);\r
\r
  gSmmCorePrivate->SmramRanges = (EFI_SMRAM_DESCRIPTOR *)AllocatePool (Size);\r
  ASSERT (gSmmCorePrivate->SmramRanges != NULL);\r
\r
  Status = mSmmAccess->GetCapabilities (mSmmAccess, &Size, gSmmCorePrivate->SmramRanges);\r
  ASSERT_EFI_ERROR (Status);\r
\r
  gSmmCorePrivate->SmramRangeCount = Size / sizeof (EFI_SMRAM_DESCRIPTOR);\r
\r
  //\r
  // Open all SMRAM ranges\r
  //\r
  Status = mSmmAccess->Open (mSmmAccess);\r
  ASSERT_EFI_ERROR (Status);\r
\r
  //\r
  // Print debug message that the SMRAM window is now open.\r
  //\r
  DEBUG ((DEBUG_INFO, "SMM IPL opened SMRAM window\n"));\r
\r
  //\r
  // Subtract SMRAM any reserved SMRAM regions.\r
  //\r
  if (SmmConfiguration != NULL) {\r
    SmramResRegion = SmmConfiguration->SmramReservedRegions;\r
    while (SmramResRegion->SmramReservedSize != 0) {\r
      for (Index = 0; Index < gSmmCorePrivate->SmramRangeCount; Index ++) {\r
        if ((SmramResRegion->SmramReservedStart >= gSmmCorePrivate->SmramRanges[Index].CpuStart)  &&      \\r
           ((SmramResRegion->SmramReservedStart + SmramResRegion->SmramReservedSize) <=   \\r
           (gSmmCorePrivate->SmramRanges[Index].CpuStart + gSmmCorePrivate->SmramRanges[Index].PhysicalSize))) {\r
          //\r
          // This range has reserved area, calculate the left free size\r
          //\r
          gSmmCorePrivate->SmramRanges[Index].PhysicalSize = SmramResRegion->SmramReservedStart - gSmmCorePrivate->SmramRanges[Index].CpuStart;\r
        }\r
      }\r
      SmramResRegion++;\r
    }\r
  }\r
  \r
  //\r
  // Find the largest SMRAM range between 1MB and 4GB that is at least 1MB in size\r
  //\r
  mCurrentSmramRange = NULL;\r
  for (Index = 0, MaxSize = SIZE_1MB; Index < gSmmCorePrivate->SmramRangeCount; Index++) {\r
    if (gSmmCorePrivate->SmramRanges[Index].CpuStart >= BASE_1MB) {\r
      if ((gSmmCorePrivate->SmramRanges[Index].CpuStart + gSmmCorePrivate->SmramRanges[Index].PhysicalSize) <= BASE_4GB) {\r
        if (gSmmCorePrivate->SmramRanges[Index].PhysicalSize >= MaxSize) {\r
          MaxSize = gSmmCorePrivate->SmramRanges[Index].PhysicalSize;\r
          mCurrentSmramRange = &gSmmCorePrivate->SmramRanges[Index];\r
        }\r
      }\r
    }\r
  }\r
\r
  if (mCurrentSmramRange != NULL) {\r
    //\r
    // Print debug message showing SMRAM window that will be used by SMM IPL and SMM Core\r
    //\r
    DEBUG ((DEBUG_INFO, "SMM IPL found SMRAM window %p - %p\n", \r
      (VOID *)(UINTN)mCurrentSmramRange->CpuStart, \r
      (VOID *)(UINTN)(mCurrentSmramRange->CpuStart + mCurrentSmramRange->PhysicalSize - 1)\r
      ));\r
\r
    //\r
    // Attempt to set SMRAM cacheability to WB\r
    //\r
    Status = gDS->SetMemorySpaceAttributes(\r
                    mCurrentSmramRange->CpuStart, \r
                    mCurrentSmramRange->PhysicalSize,\r
                    EFI_MEMORY_WB\r
                    );\r
    if (EFI_ERROR (Status)) {\r
      DEBUG ((DEBUG_WARN, "SMM IPL failed to set SMRAM window to EFI_MEMORY_WB\n"));\r
    }  \r
\r
    //\r
    // Load SMM Core into SMRAM and execute it from SMRAM\r
    //\r
    Status = ExecuteSmmCoreFromSmram (mCurrentSmramRange, gSmmCorePrivate);\r
    if (EFI_ERROR (Status)) {\r
      //\r
      // Print error message that the SMM Core failed to be loaded and executed.\r
      //\r
      DEBUG ((DEBUG_ERROR, "SMM IPL could not load and execute SMM Core from SMRAM\n"));\r
\r
      //\r
      // Attempt to reset SMRAM cacheability to UC\r
      //\r
      Status = gDS->SetMemorySpaceAttributes(\r
                      mCurrentSmramRange->CpuStart, \r
                      mCurrentSmramRange->PhysicalSize,\r
                      EFI_MEMORY_UC\r
                      );\r
      if (EFI_ERROR (Status)) {\r
        DEBUG ((DEBUG_WARN, "SMM IPL failed to reset SMRAM window to EFI_MEMORY_UC\n"));\r
      }  \r
    }\r
  } else {\r
    //\r
    // Print error message that there are not enough SMRAM resources to load the SMM Core.\r
    //\r
    DEBUG ((DEBUG_ERROR, "SMM IPL could not find a large enough SMRAM region to load SMM Core\n"));\r
  }\r
\r
  //\r
  // If the SMM Core could not be loaded then close SMRAM window, free allocated \r
  // resources, and return an error so SMM IPL will be unloaded.\r
  //\r
  if (mCurrentSmramRange == NULL || EFI_ERROR (Status)) {\r
    //\r
    // Close all SMRAM ranges\r
    //\r
    Status = mSmmAccess->Close (mSmmAccess);\r
    ASSERT_EFI_ERROR (Status);\r
\r
    //\r
    // Print debug message that the SMRAM window is now closed.\r
    //\r
    DEBUG ((DEBUG_INFO, "SMM IPL closed SMRAM window\n"));\r
\r
    //\r
    // Free all allocated resources\r
    //\r
    FreePool (gSmmCorePrivate->SmramRanges);\r
    \r
    return EFI_UNSUPPORTED;\r
  }\r
  \r
  //\r
  // Install SMM Base2 Protocol and SMM Communication Protocol\r
  //\r
  Status = gBS->InstallMultipleProtocolInterfaces (\r
                  &mSmmIplHandle,\r
                  &gEfiSmmBase2ProtocolGuid,         &mSmmBase2,\r
                  &gEfiSmmCommunicationProtocolGuid, &mSmmCommunication,\r
                  NULL\r
                  );\r
  ASSERT_EFI_ERROR (Status);\r
\r
  //\r
  // Create the set of protocol and event notififcations that the SMM IPL requires\r
  //\r
  for (Index = 0; mSmmIplEvents[Index].NotifyFunction != NULL; Index++) {\r
    if (mSmmIplEvents[Index].Protocol) {\r
      mSmmIplEvents[Index].Event = EfiCreateProtocolNotifyEvent (\r
                                     mSmmIplEvents[Index].Guid,\r
                                    TPL_CALLBACK,\r
                                     mSmmIplEvents[Index].NotifyFunction,\r
                                     mSmmIplEvents[Index].NotifyContext,\r
                                    &Registration\r
                                    );\r
    } else {\r
      Status = gBS->CreateEventEx (\r
                      EVT_NOTIFY_SIGNAL,\r
                      TPL_CALLBACK,\r
                      mSmmIplEvents[Index].NotifyFunction,\r
                      mSmmIplEvents[Index].NotifyContext,\r
                      mSmmIplEvents[Index].Guid,\r
                      &mSmmIplEvents[Index].Event\r
                      );\r
      ASSERT_EFI_ERROR (Status);\r
    }\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r