/*++

Copyright (c) 2013 Intel Corporation.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:

* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the
distribution.
* Neither the name of Intel Corporation nor the names of its
contributors may be used to endorse or promote products derived
from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


Module Name:

  SmmRuntime.c

Abstract:

  SMM Runtime Infrastructutre for the IA32 Runtime drivers.

--*/

#include "SmmRuntime.h"

EFI_SMM_RT_GLOBAL               *SmmRtGlobal;
EFI_SMM_RUNTIME_PROTOCOL  *mSmmRT         = NULL;

EFI_STATUS
CheckCallbacks (
  IN  EFI_GUID    *Protocol
  )
/*++

Routine Description:

  GC_TODO: Add function description

Arguments:

  Protocol  - GC_TODO: add argument description

Returns:

  EFI_SUCCESS - GC_TODO: Add description for return value

--*/
{
  UINTN i;

  //
  // Check if any notifications are pending.
  //
  for (i = 0; i < MAX_CALLBACK; i++) {
    if (SmmRtGlobal->Callback[i].Valid) {
      if (CompareGuid (Protocol, &SmmRtGlobal->Callback[i].ProtocolGuid)) {
        SmmRtGlobal->Callback[i].CallbackFunction (
                                  &SmmRtGlobal->Callback[i],
                                  SmmRtGlobal->Callback[i].Context
                                  );
      }
    }
  }

  return EFI_SUCCESS;
}

EFI_STATUS
EFIAPI
SmmSignalCallback (
  IN  EFI_EVENT   Event
  )
/*++

Routine Description:

  GC_TODO: Add function description

Arguments:

  Event - GC_TODO: add argument description

Returns:

  EFI_SUCCESS - GC_TODO: Add description for return value

--*/
{
  EFI_SMM_CALLBACK_SERVICES *Callback;

  Callback = (EFI_SMM_CALLBACK_SERVICES *) Event;

  if (Callback->CallbackFunction != NULL) {
    Callback->CallbackFunction (Event, Callback->Context);
  }

  return EFI_SUCCESS;
}

EFI_STATUS
EFIAPI
SmmEnableProtocolNotifyCallback (
  EFI_EVENT_NOTIFY            CallbackFunction,
  VOID                        *Context,
  EFI_GUID                    *ProtocolGuid,
  EFI_EVENT                   *Event
  )
/*++

Routine Description:

  GC_TODO: Add function description

Arguments:

  CallbackFunction  - GC_TODO: add argument description
  Context           - GC_TODO: add argument description
  ProtocolGuid      - GC_TODO: add argument description
  Event             - GC_TODO: add argument description

Returns:

  EFI_SUCCESS - GC_TODO: Add description for return value
  EFI_OUT_OF_RESOURCES - GC_TODO: Add description for return value

--*/
{
  UINTN i;

  for (i = 0; i < MAX_CALLBACK; i++) {
    if (!SmmRtGlobal->Callback[i].Valid) {
      SmmRtGlobal->Callback[i].Context          = Context;
      SmmRtGlobal->Callback[i].CallbackFunction = CallbackFunction;
      CopyMem (&SmmRtGlobal->Callback[i].ProtocolGuid, ProtocolGuid, sizeof (EFI_GUID));
      SmmRtGlobal->Callback[i].Valid  = TRUE;
      *Event                          = (EFI_EVENT) & SmmRtGlobal->Callback[i];
      return EFI_SUCCESS;
    }
  }

  return EFI_OUT_OF_RESOURCES;
}

EFI_STATUS
EFIAPI
SmmDisableProtocolNotifyCallback (
  IN  EFI_EVENT   Event
  )
/*++

Routine Description:

  GC_TODO: Add function description

Arguments:

  Event - GC_TODO: add argument description

Returns:

  EFI_SUCCESS - GC_TODO: Add description for return value

--*/
{
  EFI_SMM_CALLBACK_SERVICES *Callback;

  Callback        = (EFI_SMM_CALLBACK_SERVICES *) Event;

  Callback->Valid = FALSE;

  return EFI_SUCCESS;
}

EFI_STATUS
CheckServiceIndex (
  IN UINTN     Index,
  IN EFI_GUID  *Protocol,
  OUT VOID     **Interface
  )
/*++
  
  Routine Description:
    This Function gets the protocol interface related with the Index and updates the 
    internal data index when protocol match is found.

  Arguments:
    Index                 - Relative Index where protocol match should be done
    Protocol              - Protocol that should be matched with at the input Index.
    Interface             - Pointer to the Interface that matches with the protocol at a given Index.

  Returns:
    EFI_SUCCESS           - Protocol Match done successfully.
    EFI_NOT_FOUND         - Protocol Match couldn't be done.

--*/
{
  if (SmmRtGlobal->Services[Index].Valid) {
    if (CompareGuid (Protocol, &SmmRtGlobal->Services[Index].ProtocolGuid)) {
      *Interface                = SmmRtGlobal->Services[Index].Protocol;
      SmmRtGlobal->CurrentIndex = Index;
      return EFI_SUCCESS;
    }
  }

  return EFI_NOT_FOUND;
}

EFI_STATUS
EFIAPI
LocateSmmProtocol (
  EFI_GUID  *Protocol,
  VOID      *Registration, OPTIONAL
  VOID      **Interface
  )
/*++
  
  Routine Description:
    This Function locates the protocol interrface that satisfy the protocol GUID defination

  Arguments:
    Protocol              - Protocol GUID.
    Registration          - Optional per EFI specifications. Not required in SMM scope.
    Interface             - Pointer to the Interface that contains the protocol.

  Returns:
    EFI_SUCCESS           - Protocol Interface located within SMM scope.

--*/
// GC_TODO:    EFI_NOT_FOUND - add return value to function comment
{
  UINTN i;

  for (i = SmmRtGlobal->CurrentIndex; i < MAX_SMM_PROTOCOL; i++) {
    if (CheckServiceIndex (i, Protocol, Interface) == EFI_SUCCESS) {
      return EFI_SUCCESS;
    }
  }

  for (i = 0; i < SmmRtGlobal->CurrentIndex; i++) {
    if (CheckServiceIndex (i, Protocol, Interface) == EFI_SUCCESS) {
      return EFI_SUCCESS;
    }
  }

  return EFI_NOT_FOUND;
}

EFI_STATUS
EFIAPI
LocateSmmProtocolHandles (
  IN  EFI_GUID    *Protocol,
  OUT EFI_HANDLE  **Handles,
  OUT UINTN       *HandlesCount
  )
/*++
  
  Routine Description:
    This Function get the handles for a specific protocol.

  Arguments:
    Protocol              - Protocol GUID.
    Handles               - Array of handles that satisfy the protocol defination.
    HandlesCount          - Number of handles found

  Returns:
    EFI_SUCCESS           - Protocol handles located within SMM scope.

--*/
{
  UINTN       Index;
  UINTN       NumHandles;
  UINTN       Size;
  EFI_HANDLE  *Buffer;
  EFI_STATUS  Status;
  NumHandles  = 0;
  Buffer      = NULL;


  for (Index = 0; Index < MAX_SMM_PROTOCOL; Index++) {
    if (SmmRtGlobal->Services[Index].Valid) {
      if (CompareGuid (Protocol, &SmmRtGlobal->Services[Index].ProtocolGuid)) {
        SmmRtGlobal->HandleBuffer[NumHandles] = SmmRtGlobal->Services[Index].Handle;
        NumHandles++;
      }
    }
  }

  Size = NumHandles * sizeof (EFI_HANDLE);
  if (Size > 0) {
    Status = gSmst->SmmAllocatePool (EfiRuntimeServicesData, Size, (VOID *)&Buffer);
    CopyMem (Buffer, SmmRtGlobal->HandleBuffer, Size);
    *Handles      = Buffer;
    *HandlesCount = NumHandles;
  }

  return EFI_SUCCESS;
}

EFI_STATUS
EFIAPI
SmmHandleProtocol (
  IN EFI_HANDLE               Handle,
  IN EFI_GUID                 *Protocol,
  OUT VOID                    **Interface
  )
/*++
  
  Routine Description:
    This Function gets the interface pointer based upon the handle

  Arguments:
    Handle                - Protocol handle that is Installed within SMM space.
    Protocol              - Protocol GUID.
    Interface             - Interface pointer that points to a protocol.

  Returns:
    EFI_SUCCESS           - Protocol Interface found within SMM scope.
    EFI_NOT_FOUND         - Protocol not found.

--*/
{
  EFI_SMM_PROTO_SERVICES  *SmmServices;

  SmmServices = (EFI_SMM_PROTO_SERVICES *) Handle;

  if (SmmServices->Valid) {
    *Interface = SmmServices->Protocol;
    return EFI_SUCCESS;
  } else {
    return EFI_NOT_FOUND;
  }
}

EFI_STATUS
EFIAPI
InstallSmmProtocolInterface (
  IN OUT EFI_HANDLE           *Handle,
  IN EFI_GUID                 *Protocol,
  IN EFI_INTERFACE_TYPE       InterfaceType,
  IN VOID                     *Interface
  )
/*++
  
  Routine Description:
    This Function Installs the protocol interface within SMM scope.

  Arguments:
    Handle                - Protocol handle that is to be Installed within SMM space. On NULL we gat a new Protocol
                            Handle
    Protocol              - Protocol GUID that is to be Installed.
    InterfaceType         - Type of Interface per EFI specification.
    Interface             - Interface that needs to be Installed.

  Returns:
    EFI_SUCCESS           - Protocol Installed within SMM scope.
    EFI_OUT_OF_RESOURCES  - No more resources available to install another interface.

--*/
{
  UINTN i;

  for (i = 0; i < MAX_SMM_PROTOCOL; i++) {
    if (!SmmRtGlobal->Services[i].Valid) {
      SmmRtGlobal->Services[i].InterfaceType  = InterfaceType;
      SmmRtGlobal->Services[i].Protocol       = Interface;
      CopyMem (&SmmRtGlobal->Services[i].ProtocolGuid, Protocol, sizeof (EFI_GUID));
      SmmRtGlobal->Services[i].Valid = TRUE;
      if (*Handle == NULL) {
        SmmRtGlobal->Services[i].Handle = &SmmRtGlobal->Services[i];
        *Handle                         = SmmRtGlobal->Services[i].Handle;
      } else {
        SmmRtGlobal->Services[i].Handle = *Handle;
      }

      CheckCallbacks (Protocol);
      return EFI_SUCCESS;
    }
  }

  return EFI_OUT_OF_RESOURCES;
}

EFI_STATUS
EFIAPI
ReinstallSmmProtocolInterface (
  IN EFI_HANDLE               SmmProtocolHandle,
  IN EFI_GUID                 *Protocol,
  IN VOID                     *OldInterface,
  IN VOID                     *NewInterface
  )
/*++
  
  Routine Description:
    This Function Re-Installs the protocol interface within SMM scope.

  Arguments:
    SmmProtocolHandle     - Protocol handle that is to be Un-Installed.
    Protocol              - Protocol GUID that is to be Un-Installed.
    OldInterface          - Current Interface that needs to be Re-Installed.
    NewInterface          - New Interface that needs to be Re-Installed over OldInterface.

  Returns:
    EFI_SUCCESS           - Protocol Re-Installed within SMM scope.
    EFI_NOT_FOUND         - Old Interface Not Found.

--*/
{
  UINTN i;

  for (i = 0; i < MAX_SMM_PROTOCOL; i++) {
    if (SmmRtGlobal->Services[i].Valid) {
      if (SmmProtocolHandle == SmmRtGlobal->Services[i].Handle) {
        if (OldInterface == SmmRtGlobal->Services[i].Protocol) {
          SmmRtGlobal->Services[i].Protocol = NewInterface;
          CheckCallbacks (NewInterface);
          return EFI_SUCCESS;
        }
      }
    }
  }

  return EFI_NOT_FOUND;
}

EFI_STATUS
EFIAPI
UninstallSmmProtocolInterface (
  IN EFI_HANDLE               SmmProtocolHandle,
  IN EFI_GUID                 *Protocol,
  IN VOID                     *Interface
  )
/*++
  
  Routine Description:
    This Function Un-Installs the protocol interface from within SMM scope.

  Arguments:
    SmmProtocolHandle     - Protocol handle that is to be Un-Installed.
    Protocol              - Protocol GUID that is to be Un-Installed.
    Interface             - Interface Pointer that needs to be Un-Installed.
  Returns:
    EFI_SUCCESS           - Protocol Uninstalled from within SMM scope.
    EFI_NOT_FOUND         - Protocol Not Found.

--*/
{
  UINTN i;

  for (i = 0; i < MAX_SMM_PROTOCOL; i++) {
    if (SmmRtGlobal->Services[i].Valid) {
      if (SmmProtocolHandle == SmmRtGlobal->Services[i].Handle) {
        if (CompareGuid (Protocol, &SmmRtGlobal->Services[i].ProtocolGuid)) {
          if (Interface == SmmRtGlobal->Services[i].Protocol) {
            SmmRtGlobal->Services[i].Valid = FALSE;
            return EFI_SUCCESS;
          }
        }
      }
    }
  }

  return EFI_NOT_FOUND;
}

EFI_STATUS
EFIAPI
InstallVendorConfigurationTable (
  IN EFI_GUID                 *Guid,
  IN VOID                     *Table
  )
/*++
  
  Routine Description:
    This Function installs the configuration table within SMM scope.

  Arguments:
    Guid                  - Vandor GUID
    Table                 - Pointer to the Table. This table should be located within SMM scope.

  Returns:
    EFI_SUCCESS           - Vendor table Found
    EFI_OUT_OF_RESOURCES  - Vendor Table cannot be registered because no more SMM resources are there.

--*/
{
  UINTN i;

  //
  // Check if the vendor GUID already exists.
  //
  for (i = 0; i < MAX_SMM_PROTOCOL; i++) {
    if (SmmRtGlobal->ConfigTable[i].VendorTable != NULL) {
      if (CompareGuid (&SmmRtGlobal->ConfigTable[i].VendorGuid, Guid)) {
        SmmRtGlobal->ConfigTable[i].VendorTable = Table;
        return EFI_SUCCESS;
      }
    }
  }
  //
  // If the Vendor GUID don't exist, Find an empty slot.
  //
  for (i = 0; i < MAX_SMM_PROTOCOL; i++) {
    if (SmmRtGlobal->ConfigTable[i].VendorTable == NULL) {
      CopyMem (&SmmRtGlobal->ConfigTable[i].VendorGuid, Guid, sizeof (EFI_GUID));
      SmmRtGlobal->ConfigTable[i].VendorTable = Table;
      return EFI_SUCCESS;
    }
  }

  return EFI_OUT_OF_RESOURCES;
}

EFI_STATUS
EFIAPI
GetVendorConfigurationTable (
  IN EFI_GUID                 *Guid,
  OUT VOID                    **Table
  )
/*++
  
  Routine Description:
    This Function gets the configuration table that has been registered within SMM scope.

  Arguments:
    Guid                  - Vandor GUID
    Table                 - Pointer to the Table. This table should be located within SMM scope.

  Returns:
    EFI_SUCCESS           - Vendor table Found
    EFI_NOT_FOUND         - Vendor Table not found.

--*/
{
  UINTN i;

  //
  // Check if the vendor GUID already exists.
  //
  for (i = 0; i < MAX_SMM_PROTOCOL; i++) {
    if (SmmRtGlobal->ConfigTable[i].VendorTable != NULL) {
      if (CompareGuid (&SmmRtGlobal->ConfigTable[i].VendorGuid, Guid)) {
        *Table = SmmRtGlobal->ConfigTable[i].VendorTable;
        return EFI_SUCCESS;
      }
    }
  }

  return EFI_NOT_FOUND;
}

EFI_STATUS
EFIAPI
EfiRegisterRuntimeCallback (
  IN EFI_SMM_RUNTIME_CALLBACK               SmmRuntimeCallback,
  IN VOID                                   *Context,
  OUT EFI_HANDLE                            *SmmRuntimeCallHandle
  )
/*++
  
  Routine Description:
    This Function Registers the Callback Function from executing.

  Arguments:
    SmmRuntimeCallback    - Callback Function Name.
    Context               - Context, that is saved and restored when callback function is called.
    ChildRuntimeBuffer    - Returns the pointer to the messaging buffer that is to be used for SMM communication.
    SmmRuntimeCallHandle  - EFI Handle for the callback function. This handle is valid within SMM scope only.

  Returns:
    EFI_SUCCESS           - Callback Function Registered Successfully.
    EFI_OUT_OF_RESOURCES  - All SMM resources have been used up. So more callback functions cannot
                            be registered.  
--*/
{
  UINTN i;

  for (i = 0; i < MAX_SM_RT_CALLBACK; i++) {
    if (SmmRtGlobal->RtCallback[i].CallbackFunction == NULL) {
      SmmRtGlobal->RtCallback[i].CallbackFunction = SmmRuntimeCallback;
      SmmRtGlobal->RtCallback[i].Context          = Context;
      *SmmRuntimeCallHandle                       = &SmmRtGlobal->RtCallback[i];
      return EFI_SUCCESS;
    }
  }

  return EFI_OUT_OF_RESOURCES;
}

EFI_STATUS
EFIAPI
EfiUnRegisterRuntimeCallback (
  IN EFI_SMM_RUNTIME_CALLBACK       SmmRuntimeCallback
  )
/*++
  
  Routine Description:
    This Function Un-Registers the Callback Function from executing.

  Arguments:
    SmmRuntimeCallback  - Callback Function Name.

  Returns:
    EFI_SUCCESS         - Callback Function UnRegistered.
    EFI_NOT_FOUND       - Callback Function not found.
--*/
{
  UINTN i;

  for (i = 0; i < MAX_SM_RT_CALLBACK; i++) {
    if (SmmRtGlobal->RtCallback[i].CallbackFunction == SmmRuntimeCallback) {
      SmmRtGlobal->RtCallback[i].CallbackFunction = NULL;
      return EFI_SUCCESS;
    }
  }

  return EFI_NOT_FOUND;
}

EFI_STATUS
EFIAPI
SmmRuntimeManagementCallback (
  IN EFI_HANDLE             SmmImageHandle,
  IN CONST VOID             *Context         OPTIONAL,
  IN OUT VOID               *CommunicationBuffer,
  IN OUT UINTN              *SourceSize
  )
/*++
  
  Routine Description:
    This Function executes the Callback Function. This function is called at every SMI occurance.
    At the SMI occurance, it investigates if somebody asked for the Runtime Service. On a valid
    RT Service request, it executes the callback function.

  Arguments:
    SmmImageHandle      - Handle for the smm image of this driver
    Smst                - Pointer to the SMM System Table
    CommunicationBuffer - Pointer to the buffer that contains the communication Message
    Source Size         - Size of the memory image to be used for handler.

  Returns:
    EFI_SUCCESS         - Callback Function Executed
--*/
// GC_TODO:    SourceSize - add argument and description to function comment
{
  SMM_RUNTIME_COMMUNICATION_STRUCTURE *SmmRtStruct;
  EFI_SMM_RT_CALLBACK_SERVICES        *RtServices;

  RtServices  = NULL;

  SmmRtStruct = (SMM_RUNTIME_COMMUNICATION_STRUCTURE *) CommunicationBuffer;
  RtServices  = (EFI_SMM_RT_CALLBACK_SERVICES *) SmmRtStruct->PrivateData.SmmRuntimeCallHandle;

  if (RtServices != NULL) {
    RtServices->CallbackFunction (RtServices->Context, gSmst, (VOID *) &SmmRtStruct->PrivateData);
    SmmRtStruct->PrivateData.SmmRuntimeCallHandle = NULL;
  }

  return EFI_SUCCESS;
}

UINTN
DevicePathSize (
  IN EFI_DEVICE_PATH_PROTOCOL  *DevicePath
  )
/*++

Routine Description:

  GC_TODO: Add function description

Arguments:

  DevicePath  - GC_TODO: add argument description

Returns:

  GC_TODO: add return values

--*/
{
  EFI_DEVICE_PATH_PROTOCOL  *Start;

  if (DevicePath == NULL) {
    return 0;
  }
  //
  // Search for the end of the device path structure
  //
  Start = DevicePath;
  while (!IsDevicePathEnd (DevicePath)) {
    DevicePath = NextDevicePathNode (DevicePath);
  }
  //
  // Compute the size and add back in the size of the end device path structure
  //
  return ((UINTN) DevicePath - (UINTN) Start) + sizeof (EFI_DEVICE_PATH_PROTOCOL);
}

EFI_STATUS
SmmRuntimeInitialize (
  IN EFI_HANDLE               ImageHandle,
  IN EFI_SYSTEM_TABLE         *SystemTable
  )
/*++

Routine Description:

  GC_TODO: Add function description

Arguments:

  ImageHandle - GC_TODO: add argument description
  SystemTable - GC_TODO: add argument description

Returns:

  EFI_SUCCESS - GC_TODO: Add description for return value
  EFI_SUCCESS - GC_TODO: Add description for return value

--*/
{
  EFI_SMM_BASE2_PROTOCOL     *SmmBase;
  EFI_STATUS                Status;
  EFI_HANDLE                Handle;
  UINTN                     Size;
  BOOLEAN                   InSmm;
  EFI_SMM_COMMUNICATION_PROTOCOL  *SmmCommunication;
  EFI_SMM_RT_GLOBAL         *RtGlobal;
  RtGlobal        = NULL;




  Status          = gBS->LocateProtocol (&gEfiSmmBase2ProtocolGuid, NULL, &SmmBase);
    if (EFI_ERROR(Status)) {
	    return Status;
    }

  SmmBase->InSmm (SmmBase, &InSmm);

  SmmBase->GetSmstLocation (SmmBase, &gSmst);

    Status = gSmst->SmmAllocatePool (EfiRuntimeServicesData, sizeof (EFI_SMM_RT_GLOBAL), &SmmRtGlobal);
/****************************************************
**                                                 **
** EST override - begins here                      **
**                                                 **
****************************************************/
    ASSERT_EFI_ERROR (Status);    
/*+++++++++++++++++++++++++++++++++++++++++++++++++++
++                                                 ++
++ EST override - ends here                        ++
++                                                 ++
+++++++++++++++++++++++++++++++++++++++++++++++++++*/
    if (Status == EFI_SUCCESS) {
      ZeroMem (SmmRtGlobal, sizeof (EFI_SMM_RT_GLOBAL));
    }

    Status = gBS->AllocatePool (
                    EfiReservedMemoryType,
                    sizeof (SMM_RUNTIME_COMMUNICATION_STRUCTURE),
                    &SmmRtGlobal->SmmRtServices.ChildRuntimeBuffer
                    );
    ASSERT_EFI_ERROR (Status);
    ZeroMem (SmmRtGlobal->SmmRtServices.ChildRuntimeBuffer, sizeof (SMM_RUNTIME_COMMUNICATION_STRUCTURE));
    
    Status = gBS->AllocatePool (EfiReservedMemoryType, sizeof (EFI_SMM_RT_GLOBAL), &RtGlobal);
    ASSERT_EFI_ERROR (Status);
    ZeroMem (RtGlobal, sizeof (EFI_SMM_RT_GLOBAL));
    
    //
    // Register the Callback function that acts as a parent dispatcher for all the Runtime Functions.
    // Any RT function call should be a child of this callback.
    //
    SmmRtGlobal->SmmRtServices.ChildRuntimeBuffer->MessageLength = sizeof (SMM_RUNTIME_COMMUNICATION_STRUCTURE);
    SmmRtGlobal->SmmRtServices.ChildRuntimeBuffer->HeaderGuid = gEfiSmmRuntimeProtocolGuid;

    Status = gSmst->SmiHandlerRegister (
                    SmmRuntimeManagementCallback,
                    &gEfiSmmRuntimeProtocolGuid,
                    &ImageHandle
                    );
    ASSERT_EFI_ERROR (Status);

      
    SmmRtGlobal->CallbackEntryPoint = SmmRuntimeManagementCallback;

    Size = sizeof (SMM_RUNTIME_COMMUNICATION_STRUCTURE);
       
    Status = gBS->LocateProtocol (
                  &gEfiSmmCommunicationProtocolGuid,
                  NULL,
                  (VOID **)&SmmCommunication
                  );

    ASSERT_EFI_ERROR (Status);
    
    Status = SmmCommunication->Communicate (
                               SmmCommunication,
                               (VOID *) SmmRtGlobal->SmmRtServices.ChildRuntimeBuffer,
                               &Size
                               );
    ASSERT_EFI_ERROR (Status);

    //
    // Install the services that are called within the SMM scope. All Runtime Libraries will use these
    // functions to create the services required for driver bindings within the SMM space.
    //
    SmmRtGlobal->Signature  = SMM_RT_SIGNATURE;
    SmmRtGlobal->SmmRtServices.InstallProtocolInterface   = InstallSmmProtocolInterface;
    SmmRtGlobal->SmmRtServices.LocateProtocol             = LocateSmmProtocol;
    SmmRtGlobal->SmmRtServices.ReinstallProtocolInterface = ReinstallSmmProtocolInterface;
    SmmRtGlobal->SmmRtServices.UninstallProtocolInterface = UninstallSmmProtocolInterface;
    SmmRtGlobal->SmmRtServices.SignalProtocol             = SmmSignalCallback;
    SmmRtGlobal->SmmRtServices.EnableProtocolNotify       = SmmEnableProtocolNotifyCallback;
    SmmRtGlobal->SmmRtServices.DisableProtocolNotify      = SmmDisableProtocolNotifyCallback;
    SmmRtGlobal->SmmRtServices.LocateProtocolHandles      = LocateSmmProtocolHandles;
    SmmRtGlobal->SmmRtServices.HandleProtocol             = SmmHandleProtocol;
    SmmRtGlobal->SmmRtServices.InstallVendorConfigTable   = InstallVendorConfigurationTable;
    SmmRtGlobal->SmmRtServices.GetVendorConfigTable       = GetVendorConfigurationTable;
    SmmRtGlobal->SmmRtServices.RegisterSmmRuntimeChild    = EfiRegisterRuntimeCallback;
    SmmRtGlobal->SmmRtServices.UnRegisterSmmRuntimeChild  = EfiUnRegisterRuntimeCallback;

    SmmRtGlobal->SmmRtServices.SmmRuntime.Hdr.Signature   = 0;
    SmmRtGlobal->SmmRtServices.SmmRuntime.Hdr.Revision    = EFI_RUNTIME_SERVICES_REVISION;
    SmmRtGlobal->SmmRtServices.SmmRuntime.Hdr.HeaderSize  = sizeof (EFI_TABLE_HEADER);

/****************************************************
**                                                 **
** EST override - begins here                      **
**                                                 **
****************************************************/

    CopyMem (&SmmRtGlobal->SmmRtServices.SmmRuntime, SystemTable->RuntimeServices, sizeof (EFI_RUNTIME_SERVICES));

/****************************************************
**                                                 **
** EST override - ends here                      **
**                                                 **
****************************************************/

    //
    // Install the Driver within the SMM scope so that drivers created within the SMM scope can find it
    // and use the functionality. Runtime Library searches the protocol for performing the above functions.
    //
    Handle = NULL;
    Status = InstallSmmProtocolInterface (
              &Handle,
              &gEfiSmmRuntimeProtocolGuid,
              EFI_NATIVE_INTERFACE,
              &(SmmRtGlobal->SmmRtServices)
              );
    ASSERT_EFI_ERROR (Status);
    mSmmRT = &SmmRtGlobal->SmmRtServices;

    //
    //  Install the Protocol Interface in the Boot Time Space. This is requires to satisfy the
    //  dependency within the drivers that are dependent upon Smm Runtime Driver.
    //
    Handle = NULL;
    CopyMem (RtGlobal, SmmRtGlobal, sizeof (EFI_SMM_RT_GLOBAL));

    Status = gBS->InstallProtocolInterface (
                    &Handle,
                    &gEfiSmmRuntimeProtocolGuid,
                    EFI_NATIVE_INTERFACE,
                    &(RtGlobal->SmmRtServices)
                    );
    ASSERT_EFI_ERROR (Status);

  return EFI_SUCCESS;
}