path: root/Features/Intel/Debugging/AcpiDebugFeaturePkg/AcpiDebugDxeSmm/AcpiDebug.c

/** @file
  ACPI Debug feature driver implementation.

Copyright (c) 2019, Intel Corporation. All rights reserved.<BR>
SPDX-License-Identifier: BSD-2-Clause-Patent

**/
#include <Uefi.h>
#include <Library/BaseLib.h>
#include <Library/BaseMemoryLib.h>
#include <Library/UefiBootServicesTableLib.h>
#include <Library/DebugLib.h>
#include <Library/PcdLib.h>
#include <Library/DxeServicesLib.h>
#include <Protocol/AcpiTable.h>
#include <IndustryStandard/Acpi.h>

#include <Protocol/SmmBase2.h>
#include <Protocol/SmmEndOfDxe.h>
#include <Protocol/SmmSwDispatch2.h>

#define ACPI_DEBUG_STR      "INTEL ACPI DEBUG"

//
// ASL NAME structure
//
#pragma pack(1)
typedef struct {
  UINT8  NameOp;            // Byte [0]=0x08:NameOp.
  UINT32 NameString;        // Byte [4:1]=Name of object.
  UINT8  DWordPrefix;       // Byte [5]=0x0C:DWord Prefix.
  UINT32 Value;             // 0 ; Value of named object.
} NAME_LAYOUT;
#pragma pack()

#pragma pack(1)
typedef struct {
  UINT8  Signature[16];     // "INTEL ACPI DEBUG"
  UINT32 BufferSize;        // Total size of Acpi Debug buffer including header structure
  UINT32 Head;              // Current buffer pointer for SMM to print out
  UINT32 Tail;              // Current buffer pointer for ASL to input
  UINT8  SmiTrigger;        // Value to trigger the SMI via B2 port
  UINT8  Wrap;              // If current Tail < Head
  UINT8  SmmVersion;        // If SMM version
  UINT8  Truncate;          // If the input from ASL > MAX_BUFFER_SIZE
} ACPI_DEBUG_HEAD;
#pragma pack()

#define AD_SIZE             sizeof (ACPI_DEBUG_HEAD) // This is 0x20

#define MAX_BUFFER_SIZE     32

UINT32                      mBufferEnd = 0;
ACPI_DEBUG_HEAD             *mAcpiDebug = NULL;

EFI_SMM_SYSTEM_TABLE2       *mSmst = NULL;

/**
  Patch and load ACPI table.

  @param[in] AcpiDebugAddress   Address of Acpi debug memory buffer.
  @param[in] BufferIndex        Index that starts after the Acpi Debug head.
  @param[in] BufferEnd          End of Acpi debug memory buffer.

**/
VOID
PatchAndLoadAcpiTable (
  IN ACPI_DEBUG_HEAD            *AcpiDebugAddress,
  IN UINT32                     BufferIndex,
  IN UINT32                     BufferEnd
  )
{
  EFI_STATUS                    Status;
  EFI_ACPI_TABLE_PROTOCOL       *AcpiTable;
  UINTN                         Size;
  EFI_ACPI_DESCRIPTION_HEADER   *TableHeader;
  UINTN                         TableKey;
  UINT8                         *CurrPtr;
  UINT32                        *Signature;
  NAME_LAYOUT                   *NamePtr;
  UINT8                         UpdateCounter;

  Status = GetSectionFromFv (
             &gEfiCallerIdGuid,
             EFI_SECTION_RAW,
             0,
             (VOID **) &TableHeader,
             &Size
             );
  ASSERT_EFI_ERROR (Status);
  if (EFI_ERROR (Status)) {
    return;
  }

  //
  // This is Acpi Debug SSDT. Acpi Debug should be enabled if we reach here so load the table.
  //
  ASSERT (((EFI_ACPI_DESCRIPTION_HEADER *) TableHeader)->OemTableId == SIGNATURE_64 ('A', 'D', 'e', 'b', 'T', 'a', 'b', 'l'));

  //
  // Patch some pointers for the ASL code before loading the SSDT.
  //

  //
  // Count pointer updates, so we can stop after all three pointers are patched.
  //
  UpdateCounter = 1;
  for (CurrPtr = (UINT8 *) TableHeader; CurrPtr <= ((UINT8 *) TableHeader + TableHeader->Length) && UpdateCounter < 4; CurrPtr++) {
    Signature = (UINT32 *) (CurrPtr + 1);
    //
    // patch DPTR (address of Acpi debug memory buffer)
    //
    if ((*CurrPtr == AML_NAME_OP) && *Signature == SIGNATURE_32 ('D', 'P', 'T', 'R')) {
      NamePtr = (NAME_LAYOUT *) CurrPtr;
      NamePtr->Value  = (UINT32) (UINTN) AcpiDebugAddress;
      UpdateCounter++;
    }
    //
    // patch EPTR (end of Acpi debug memory buffer)
    //
    if ((*CurrPtr == AML_NAME_OP) && *Signature == SIGNATURE_32 ('E', 'P', 'T', 'R')) {
      NamePtr = (NAME_LAYOUT *) CurrPtr;
      NamePtr->Value  = BufferEnd;
      UpdateCounter++;
    }
    //
    // patch CPTR (used as an index that starts after the Acpi Debug head)
    //
    if ((*CurrPtr == AML_NAME_OP) && *Signature == SIGNATURE_32 ('C', 'P', 'T', 'R')) {
      NamePtr = (NAME_LAYOUT *) CurrPtr;
      NamePtr->Value  = BufferIndex;
      UpdateCounter++;
    }
  }

  //
  // Add the table
  //
  Status = gBS->LocateProtocol (&gEfiAcpiTableProtocolGuid, NULL, (VOID **)&AcpiTable);
  ASSERT_EFI_ERROR (Status);
  if (EFI_ERROR (Status)) {
    goto Done;
  }

  TableKey = 0;
  Status = AcpiTable->InstallAcpiTable (
                        AcpiTable,
                        TableHeader,
                        Size,
                        &TableKey
                        );
  ASSERT_EFI_ERROR (Status);
  if (EFI_ERROR (Status)) {
    goto Done;
  }

Done:
  gBS->FreePool (TableHeader);
  return ;
}

/**
  Allocate Acpi Debug memory.

  @param[out] BufferSize    Pointer to Acpi debug memory buffer size.

  @return Address of Acpi debug memory buffer.

**/
EFI_PHYSICAL_ADDRESS
AllocateAcpiDebugMemory (
  OUT UINT32           *BufferSize
  )
{
  EFI_STATUS           Status;
  EFI_PHYSICAL_ADDRESS AcpiDebugAddress;
  UINTN                PagesNum;

  AcpiDebugAddress = 0;
  *BufferSize = 0;

  //
  // Reserve memory to store Acpi Debug data.
  //
  AcpiDebugAddress = 0xFFFFFFFF;
  PagesNum = EFI_SIZE_TO_PAGES (PcdGet32 (PcdAcpiDebugBufferSize));
  Status = gBS->AllocatePages (
                  AllocateMaxAddress,
                  EfiReservedMemoryType,
                  PagesNum,
                  &AcpiDebugAddress
                  );
  ASSERT_EFI_ERROR (Status);
  if (EFI_ERROR (Status)) {
    return 0;
  }

  DEBUG ((DEBUG_INFO, "AcpiDebugAddress - 0x%08x\n", AcpiDebugAddress));

  Status = PcdSet32S (PcdAcpiDebugAddress, (UINT32) AcpiDebugAddress);
  ASSERT_EFI_ERROR (Status);

  if (EFI_ERROR (Status)) {
    gBS->FreePages (AcpiDebugAddress, PagesNum);
    return 0;
  }

  *BufferSize = PcdGet32 (PcdAcpiDebugBufferSize);

  return AcpiDebugAddress;
}

/**
  Acpi Debug EndOfDxe notification.

  @param[in] Event      Event whose notification function is being invoked.
  @param[in] Context    Pointer to the notification function's context.

**/
VOID
EFIAPI
AcpiDebugEndOfDxeNotification (
  IN EFI_EVENT  Event,
  IN VOID       *Context
  )
{
  UINT32        BufferSize;
  UINT32        BufferIndex;

  mAcpiDebug = (ACPI_DEBUG_HEAD *) (UINTN) AllocateAcpiDebugMemory (&BufferSize);
  if (mAcpiDebug != NULL) {
    //
    // Init ACPI DEBUG buffer to lower case 'x'.
    //
    SetMem ((VOID *) mAcpiDebug, BufferSize, 0x78);

    //
    // Clear header of AD_SIZE bytes.
    //
    ZeroMem ((VOID *) mAcpiDebug, AD_SIZE);

    //
    // Write a signature to the first line of the buffer, "INTEL ACPI DEBUG".
    //
    CopyMem ((VOID *) mAcpiDebug, ACPI_DEBUG_STR, sizeof (ACPI_DEBUG_STR) - 1);

    BufferIndex = (UINT32) (UINTN) mAcpiDebug;
    mBufferEnd = BufferIndex + BufferSize;

    //
    // Leave the Index after the Acpi Debug head.
    //
    BufferIndex += AD_SIZE;

    //
    // Patch and Load the SSDT ACPI Tables.
    //
    PatchAndLoadAcpiTable (mAcpiDebug, BufferIndex, mBufferEnd);

    mAcpiDebug->Head = BufferIndex;
    mAcpiDebug->Tail = BufferIndex;
    mAcpiDebug->BufferSize = BufferSize;
  }

  //
  // Close event, so it will not be invoked again.
  //
  gBS->CloseEvent (Event);

  return ;
}

/**
  Initialize ACPI Debug.

  @param[in] ImageHandle    The firmware allocated handle for the EFI image.
  @param[in] SystemTable    A pointer to the EFI System Table.

  @retval EFI_SUCCESS       The driver initializes correctly.

**/
EFI_STATUS
EFIAPI
InitializeAcpiDebugDxe (
  IN EFI_HANDLE         ImageHandle,
  IN EFI_SYSTEM_TABLE   *SystemTable
  )
{
  EFI_STATUS            Status;
  EFI_EVENT             EndOfDxeEvent;

  if (!PcdGetBool (PcdAcpiDebugFeatureActive)) {
    return EFI_SUCCESS;
  }

  //
  // Register EndOfDxe notification
  // that point could ensure the Acpi Debug related PCDs initialized.
  //
  Status = gBS->CreateEventEx (
                  EVT_NOTIFY_SIGNAL,
                  TPL_CALLBACK,
                  AcpiDebugEndOfDxeNotification,
                  NULL,
                  &gEfiEndOfDxeEventGroupGuid,
                  &EndOfDxeEvent
                  );
  ASSERT_EFI_ERROR (Status);

  return Status;
}

/**
  Software SMI callback for ACPI Debug which is called from ACPI method.

  @param[in]      DispatchHandle    The unique handle assigned to this handler by SmiHandlerRegister().
  @param[in]      Context           Points to an optional handler context which was specified when the
                                    handler was registered.
  @param[in, out] CommBuffer        A pointer to a collection of data in memory that will
                                    be conveyed from a non-SMM environment into an SMM environment.
  @param[in, out] CommBufferSize    The size of the CommBuffer.

  @retval EFI_SUCCESS               The interrupt was handled successfully.

**/
EFI_STATUS
EFIAPI
AcpiDebugSmmCallback (
  IN EFI_HANDLE     DispatchHandle,
  IN CONST VOID     *Context,
  IN OUT VOID       *CommBuffer,
  IN OUT UINTN      *CommBufferSize
  )
{
  UINT8             Buffer[MAX_BUFFER_SIZE];

  //
  // Validate the fields in mAcpiDebug to ensure there is no harm to SMI handler.
  // mAcpiDebug is below 4GB and the start address of whole buffer.
  //
  if ((mAcpiDebug->BufferSize != (mBufferEnd - (UINT32) (UINTN) mAcpiDebug)) ||
      (mAcpiDebug->Head < (UINT32) ((UINTN) mAcpiDebug + AD_SIZE)) ||
      (mAcpiDebug->Head > mBufferEnd) ||
      (mAcpiDebug->Tail < (UINT32) ((UINTN) mAcpiDebug + AD_SIZE)) ||
      (mAcpiDebug->Tail > mBufferEnd)) {
    //
    // If some fields in mAcpiDebug are invaid, return directly.
    //
    return EFI_SUCCESS;
  }

  if (!(BOOLEAN)mAcpiDebug->Wrap && ((mAcpiDebug->Head >= (UINT32) ((UINTN) mAcpiDebug + AD_SIZE))
    && (mAcpiDebug->Head < mAcpiDebug->Tail))){
    //
    // If curent ----- buffer + 020
    //                 ...
    //                 ... Head
    //                 ... Data for SMM print
    //                 ... Tail
    //                 ... Vacant for ASL input
    //           ----- buffer end
    //
    // skip NULL block
    //
    while ((*(CHAR8 *) (UINTN) mAcpiDebug->Head == '\0') && (mAcpiDebug->Head < mAcpiDebug->Tail)) {
      mAcpiDebug->Head ++;
    }

    if (mAcpiDebug->Head < mAcpiDebug->Tail) {
      ZeroMem (Buffer, MAX_BUFFER_SIZE);
      AsciiStrnCpyS ((CHAR8 *) Buffer, MAX_BUFFER_SIZE, (CHAR8 *) (UINTN) mAcpiDebug->Head, MAX_BUFFER_SIZE - 1);

      DEBUG ((DEBUG_INFO | DEBUG_ERROR, "%a%a\n", Buffer, (BOOLEAN) mAcpiDebug->Truncate ? "..." : ""));
      mAcpiDebug->Head += MAX_BUFFER_SIZE;

      if (mAcpiDebug->Head >= (mAcpiDebug->Tail)) {
        //
        // When head == tail, we do nothing in handler.
        //
        mAcpiDebug->Head = mAcpiDebug->Tail;
      }
    }
  } else if ((BOOLEAN) mAcpiDebug->Wrap && ((mAcpiDebug->Head > mAcpiDebug->Tail)
    && (mAcpiDebug->Head < (UINT32) ((UINTN) mAcpiDebug + mAcpiDebug->BufferSize)))){
    //
    // If curent ----- buffer + 020
    //                 ... Tail
    //                 ... Vacant for ASL input
    //                 ... Head
    //                 ... Data for SMM print
    //           ----- buffer end
    //
    while ((*(CHAR8 *) (UINTN) mAcpiDebug->Head == '\0') && (mAcpiDebug->Head < (UINT32) ((UINTN) mAcpiDebug + mAcpiDebug->BufferSize))) {
      mAcpiDebug->Head ++;
    }
    if (mAcpiDebug->Head < (UINT32) ((UINTN) mAcpiDebug + mAcpiDebug->BufferSize)){
      ZeroMem (Buffer, MAX_BUFFER_SIZE);
      AsciiStrnCpyS ((CHAR8 *) Buffer, MAX_BUFFER_SIZE, (CHAR8 *) (UINTN) mAcpiDebug->Head, MAX_BUFFER_SIZE - 1);
      DEBUG ((DEBUG_INFO | DEBUG_ERROR, "%a%a\n", Buffer, (BOOLEAN) mAcpiDebug->Truncate ? "..." : ""));
      mAcpiDebug->Head += MAX_BUFFER_SIZE;

      if (mAcpiDebug->Head >= (UINT32) ((UINTN) mAcpiDebug + mAcpiDebug->BufferSize)) {
        //
        // We met end of buffer.
        //
        mAcpiDebug->Wrap = 0;
        mAcpiDebug->Head = (UINT32) ((UINTN) mAcpiDebug + AD_SIZE);
      }
    }
  }

  return EFI_SUCCESS;
}

/**
  Acpi Debug SmmEndOfDxe notification.

  @param[in] Protocol   Points to the protocol's unique identifier.
  @param[in] Interface  Points to the interface instance.
  @param[in] Handle     The handle on which the interface was installed.

  @retval EFI_SUCCESS   Notification runs successfully.

 **/
EFI_STATUS
EFIAPI
AcpiDebugSmmEndOfDxeNotification (
  IN CONST EFI_GUID     *Protocol,
  IN VOID               *Interface,
  IN EFI_HANDLE         Handle
  )
{
  EFI_STATUS                        Status;
  EFI_SMM_SW_DISPATCH2_PROTOCOL     *SwDispatch;
  EFI_SMM_SW_REGISTER_CONTEXT       SwContext;
  EFI_HANDLE                        SwHandle;

  AcpiDebugEndOfDxeNotification (NULL, NULL);

  if (mAcpiDebug != NULL) {
    //
    // Get the Sw dispatch protocol and register SMI callback function.
    //
    SwDispatch = NULL;
    Status = mSmst->SmmLocateProtocol (&gEfiSmmSwDispatch2ProtocolGuid, NULL, (VOID **) &SwDispatch);
    ASSERT_EFI_ERROR (Status);
    if (EFI_ERROR (Status)) {
      return Status;
    }

    SwContext.SwSmiInputValue = (UINTN) -1;
    Status = SwDispatch->Register (SwDispatch, AcpiDebugSmmCallback, &SwContext, &SwHandle);
    ASSERT_EFI_ERROR (Status);
    if (EFI_ERROR (Status)) {
      return Status;
    }

    mAcpiDebug->SmiTrigger = (UINT8) SwContext.SwSmiInputValue;
    mAcpiDebug->SmmVersion = 1;
  }

  return EFI_SUCCESS;
}

/**
  Initialize ACPI Debug.

  @param[in] ImageHandle    The firmware allocated handle for the EFI image.
  @param[in] SystemTable    A pointer to the EFI System Table.

  @retval EFI_SUCCESS       The driver initializes correctly.

**/
EFI_STATUS
EFIAPI
InitializeAcpiDebugSmm (
  IN EFI_HANDLE         ImageHandle,
  IN EFI_SYSTEM_TABLE   *SystemTable
  )
{
  EFI_STATUS                Status;
  VOID                      *Registration;
  EFI_SMM_BASE2_PROTOCOL    *SmmBase2;
  BOOLEAN                   InSmm;

  if (!PcdGetBool (PcdAcpiDebugFeatureActive)) {
    return EFI_SUCCESS;
  }

  Status = gBS->LocateProtocol (&gEfiSmmBase2ProtocolGuid, NULL, (VOID **) &SmmBase2);
  ASSERT_EFI_ERROR (Status);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  Status = SmmBase2->InSmm (SmmBase2, &InSmm);
  ASSERT_EFI_ERROR (Status);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  ASSERT (InSmm);

  if (!InSmm) {
    return EFI_UNSUPPORTED;
  }

  Status = SmmBase2->GetSmstLocation (SmmBase2, &mSmst);
  ASSERT_EFI_ERROR (Status);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  //
  // Register SmmEndOfDxe notification
  // that point could ensure the Acpi Debug related PCDs initialized.
  //
  Registration = NULL;
  Status = mSmst->SmmRegisterProtocolNotify (
                    &gEfiSmmEndOfDxeProtocolGuid,
                    AcpiDebugSmmEndOfDxeNotification,
                    &Registration
                    );
  ASSERT_EFI_ERROR (Status);

  return Status;
}