Add PI SMM IPL and PI SMM Core

git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@10094 6f19259b-4bc3-4df7-8a09-765794883524

1 files changed, 333 insertions, 0 deletions

diff --git a/MdeModulePkg/Core/PiSmmCore/Smi.c b/MdeModulePkg/Core/PiSmmCore/Smi.c
new file mode 100644
index 0000000000..ccf6c0de2c
--- /dev/null
+++ b/MdeModulePkg/Core/PiSmmCore/Smi.c
@@ -0,0 +1,333 @@
+/** @file

+  SMI management.

+

+  Copyright (c) 2009 - 2010, Intel Corporation.  All rights reserved.<BR>

+  This program and the accompanying materials are licensed and made available 

+  under the terms and conditions of the BSD License which accompanies this 

+  distribution.  The full text of the license may be found at        

+  http://opensource.org/licenses/bsd-license.php                                            

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+

+**/

+

+#include "PiSmmCore.h"

+

+//

+// SMM_HANDLER - used for each SMM handler

+//

+

+#define SMI_ENTRY_SIGNATURE  SIGNATURE_32('s','m','i','e')

+

+ typedef struct {

+  UINTN       Signature;

+  LIST_ENTRY  AllEntries;  // All entries

+

+  EFI_GUID    HandlerType; // Type of interrupt

+  LIST_ENTRY  SmiHandlers; // All handlers

+} SMI_ENTRY;

+

+#define SMI_HANDLER_SIGNATURE  SIGNATURE_32('s','m','i','h')

+

+ typedef struct {

+  UINTN                         Signature;

+  LIST_ENTRY                    Link;        // Link on SMI_ENTRY.SmiHandlers

+  EFI_SMM_HANDLER_ENTRY_POINT2  Handler;     // The smm handler's entry point

+  SMI_ENTRY                     *SmiEntry;

+} SMI_HANDLER;

+

+LIST_ENTRY  mRootSmiHandlerList = INITIALIZE_LIST_HEAD_VARIABLE (mRootSmiHandlerList);

+LIST_ENTRY  mSmiEntryList       = INITIALIZE_LIST_HEAD_VARIABLE (mSmiEntryList);

+

+/**

+  Finds the SMI entry for the requested handler type.

+

+  @param  HandlerType            The type of the interrupt

+  @param  Create                 Create a new entry if not found

+

+  @return SMI entry

+

+**/

+SMI_ENTRY  *

+EFIAPI

+SmmCoreFindSmiEntry (

+  IN EFI_GUID  *HandlerType,

+  IN BOOLEAN   Create

+  )

+{

+  LIST_ENTRY  *Link;

+  SMI_ENTRY   *Item;

+  SMI_ENTRY   *SmiEntry;

+

+  //

+  // Search the SMI entry list for the matching GUID

+  //

+  SmiEntry = NULL;

+  for (Link = mSmiEntryList.ForwardLink;

+       Link != &mSmiEntryList;

+       Link = Link->ForwardLink) {

+

+    Item = CR (Link, SMI_ENTRY, AllEntries, SMI_ENTRY_SIGNATURE);

+    if (CompareGuid (&Item->HandlerType, HandlerType)) {

+      //

+      // This is the SMI entry

+      //

+      SmiEntry = Item;

+      break;

+    }

+  }

+

+  //

+  // If the protocol entry was not found and Create is TRUE, then

+  // allocate a new entry

+  //

+  if ((SmiEntry == NULL) && Create) {

+    SmiEntry = AllocatePool (sizeof(SMI_ENTRY));

+    if (SmiEntry != NULL) {

+      //

+      // Initialize new SMI entry structure

+      //

+      SmiEntry->Signature = SMI_ENTRY_SIGNATURE;

+      CopyGuid ((VOID *)&SmiEntry->HandlerType, HandlerType);

+      InitializeListHead (&SmiEntry->SmiHandlers);

+

+      //

+      // Add it to SMI entry list

+      //

+      InsertTailList (&mSmiEntryList, &SmiEntry->AllEntries);

+    }

+  }

+  return SmiEntry;

+}

+

+/**

+  Manage SMI of a particular type.

+

+  @param  HandlerType    Points to the handler type or NULL for root SMI handlers.

+  @param  Context        Points to an optional context buffer.

+  @param  CommBuffer     Points to the optional communication buffer.

+  @param  CommBufferSize Points to the size of the optional communication buffer.

+

+  @retval EFI_SUCCESS                        Interrupt source was processed successfully but not quiesced.

+  @retval EFI_INTERRUPT_PENDING              One or more SMI sources could not be quiesced.

+  @retval EFI_WARN_INTERRUPT_SOURCE_PENDING  Interrupt source was not handled or quiesced.

+  @retval EFI_WARN_INTERRUPT_SOURCE_QUIESCED Interrupt source was handled and quiesced.

+

+**/

+EFI_STATUS

+EFIAPI

+SmiManage (

+  IN     CONST EFI_GUID  *HandlerType,

+  IN     CONST VOID      *Context         OPTIONAL,

+  IN OUT VOID            *CommBuffer      OPTIONAL,

+  IN OUT UINTN           *CommBufferSize  OPTIONAL

+  )

+{

+  LIST_ENTRY   *Link;

+  LIST_ENTRY   *Head;

+  SMI_ENTRY    *SmiEntry;

+  SMI_HANDLER  *SmiHandler;

+  BOOLEAN      InterruptQuiesced;

+  EFI_STATUS   Status;

+  

+  if (HandlerType == NULL) {

+    //

+    // Root SMI handler

+    //

+    Status = EFI_WARN_INTERRUPT_SOURCE_PENDING;

+

+    Head = &mRootSmiHandlerList;

+    for (Link = Head->ForwardLink; Link != Head; Link = Link->ForwardLink) {

+      SmiHandler = CR (Link, SMI_HANDLER, Link, SMI_HANDLER_SIGNATURE);

+

+      Status = SmiHandler->Handler (

+                 (EFI_HANDLE) SmiHandler,

+                 Context,

+                 CommBuffer,

+                 CommBufferSize

+                 );

+      if (Status == EFI_SUCCESS || Status == EFI_INTERRUPT_PENDING) {

+        return Status;

+      }

+    }

+    return Status;

+  }

+

+  //

+  // Non-root SMI handler

+  //

+  SmiEntry = SmmCoreFindSmiEntry ((EFI_GUID *) HandlerType, FALSE);

+  if (SmiEntry == NULL) {

+    //

+    // There is no handler registered for this interrupt source

+    //

+    return EFI_WARN_INTERRUPT_SOURCE_PENDING;

+  }

+

+  InterruptQuiesced = FALSE;

+  Head = &SmiEntry->SmiHandlers;

+  for (Link = Head->ForwardLink; Link != Head; Link = Link->ForwardLink) {

+    SmiHandler = CR (Link, SMI_HANDLER, Link, SMI_HANDLER_SIGNATURE);

+

+    Status = SmiHandler->Handler (

+               (EFI_HANDLE) SmiHandler,

+               Context,

+               CommBuffer,

+               CommBufferSize

+               );

+

+    switch (Status) {

+    case EFI_INTERRUPT_PENDING:

+      //

+      // If a handler returns EFI_INTERRUPT_PENDING, the interrupt could not be

+      // quiesced, then no additional handlers will be processed,

+      // and EFI_INTERRUPT_PENDING will be returned

+      //

+      return EFI_INTERRUPT_PENDING;

+

+    case EFI_SUCCESS:

+      //

+      // If handler return EFI_SUCCESS, the interrupt was handled and quiesced,

+      // no other handlers should still be called,

+      // and EFI_WARN_INTERRUPT_SOURCE_QUIESCED will be returned

+      //

+      return EFI_WARN_INTERRUPT_SOURCE_QUIESCED;

+

+    case EFI_WARN_INTERRUPT_SOURCE_QUIESCED:

+      //

+      // If at least one of the handlers report EFI_WARN_INTERRUPT_SOURCE_QUIESCED,

+      // then this function will return EFI_WARN_INTERRUPT_SOURCE_QUIESCED

+      //

+      InterruptQuiesced = TRUE;

+      break;

+

+    default:

+      break;

+    }

+  }

+

+  if (InterruptQuiesced) {

+    Status = EFI_WARN_INTERRUPT_SOURCE_QUIESCED;

+  } else {

+    //

+    // If no handler report EFI_WARN_INTERRUPT_SOURCE_QUIESCED, then this

+    // function will return EFI_INTERRUPT_PENDING

+    //

+    Status = EFI_INTERRUPT_PENDING;

+  }

+  return Status;

+}

+

+/**

+  Registers a handler to execute within SMM.

+

+  @param  Handler        Handler service funtion pointer.

+  @param  HandlerType    Points to the handler type or NULL for root SMI handlers.

+  @param  DispatchHandle On return, contains a unique handle which can be used to later unregister the handler function.

+

+  @retval EFI_SUCCESS           Handler register success.

+  @retval EFI_INVALID_PARAMETER Handler or DispatchHandle is NULL.

+

+**/

+EFI_STATUS

+EFIAPI

+SmiHandlerRegister (

+  IN  EFI_SMM_HANDLER_ENTRY_POINT2  Handler,

+  IN  CONST EFI_GUID                *HandlerType  OPTIONAL,

+  OUT EFI_HANDLE                    *DispatchHandle

+  )

+{

+  SMI_HANDLER  *SmiHandler;

+  SMI_ENTRY    *SmiEntry;

+  LIST_ENTRY   *List;

+

+  if (Handler == NULL || DispatchHandle == NULL) {

+    return EFI_INVALID_PARAMETER;

+  }

+

+  SmiHandler = AllocateZeroPool (sizeof (SMI_HANDLER));

+  if (SmiHandler == NULL) {

+    return EFI_OUT_OF_RESOURCES;

+  }

+

+  SmiHandler->Signature = SMI_HANDLER_SIGNATURE;

+  SmiHandler->Handler = Handler;

+

+  if (HandlerType == NULL) {

+    //

+    // This is root SMI handler

+    //

+    SmiEntry = NULL;

+    List = &mRootSmiHandlerList;

+  } else {

+    //

+    // None root SMI handler

+    //

+    SmiEntry = SmmCoreFindSmiEntry ((EFI_GUID *) HandlerType, TRUE);

+    if (SmiEntry == NULL) {

+      return EFI_OUT_OF_RESOURCES;

+    }

+

+    List = &SmiEntry->SmiHandlers;

+  }

+

+  SmiHandler->SmiEntry = SmiEntry;

+  InsertTailList (List, &SmiHandler->Link);

+

+  *DispatchHandle = (EFI_HANDLE) SmiHandler;

+

+  return EFI_SUCCESS;

+}

+

+/**

+  Unregister a handler in SMM.

+

+  @param  DispatchHandle  The handle that was specified when the handler was registered.

+

+  @retval EFI_SUCCESS           Handler function was successfully unregistered.

+  @retval EFI_INVALID_PARAMETER DispatchHandle does not refer to a valid handle.

+

+**/

+EFI_STATUS

+EFIAPI

+SmiHandlerUnRegister (

+  IN EFI_HANDLE  DispatchHandle

+  )

+{

+  SMI_HANDLER  *SmiHandler;

+  SMI_ENTRY    *SmiEntry;

+

+  SmiHandler = (SMI_HANDLER *) DispatchHandle;

+

+  if (SmiHandler == NULL) {

+    return EFI_INVALID_PARAMETER;

+  }

+

+  if (SmiHandler->Signature != SMI_HANDLER_SIGNATURE) {

+    return EFI_INVALID_PARAMETER;

+  }

+

+  SmiEntry = SmiHandler->SmiEntry;

+

+  RemoveEntryList (&SmiHandler->Link);

+  FreePool (SmiHandler);

+

+  if (SmiEntry == NULL) {

+    //

+    // This is root SMI handler

+    //

+    return EFI_SUCCESS;

+  }

+

+  if (IsListEmpty (&SmiEntry->SmiHandlers)) {

+    //

+    // No handler registered for this interrupt now, remove the SMI_ENTRY

+    //

+    RemoveEntryList (&SmiEntry->AllEntries);

+

+    FreePool (SmiEntry);

+  }

+

+  return EFI_SUCCESS;

+}