CpuExceptionHandlerLib.c

Go to the documentation of this file.

 
#include <PiPei.h>
#include <Library/CpuExceptionHandlerLib.h>
#include <Library/DebugLib.h>
#include <Library/BaseLib.h>
#include <Library/SerialPortLib.h>
#include <Library/PrintLib.h>
#include <Register/RiscV64/RiscVEncoding.h>
#include "CpuExceptionHandlerLib.h"
 
//
// Define the maximum message length
//
#define MAX_DEBUG_MESSAGE_LENGTH  0x100
 
STATIC EFI_CPU_INTERRUPT_HANDLER  mExceptionHandlers[EXCEPT_RISCV_MAX_EXCEPTIONS + 1];
STATIC EFI_CPU_INTERRUPT_HANDLER  mIrqHandlers[EXCEPT_RISCV_MAX_IRQS + 1];
 
STATIC CONST CHAR8  mExceptionOrIrqUnknown[]                            = "Unknown";
STATIC CONST CHAR8  *mExceptionNameStr[EXCEPT_RISCV_MAX_EXCEPTIONS + 1] = {
  "EXCEPT_RISCV_INST_MISALIGNED",
  "EXCEPT_RISCV_INST_ACCESS_FAULT",
  "EXCEPT_RISCV_ILLEGAL_INST",
  "EXCEPT_RISCV_BREAKPOINT",
  "EXCEPT_RISCV_LOAD_ADDRESS_MISALIGNED",
  "EXCEPT_RISCV_LOAD_ACCESS_FAULT",
  "EXCEPT_RISCV_STORE_AMO_ADDRESS_MISALIGNED",
  "EXCEPT_RISCV_STORE_AMO_ACCESS_FAULT",
  "EXCEPT_RISCV_ENV_CALL_FROM_UMODE",
  "EXCEPT_RISCV_ENV_CALL_FROM_SMODE",
  "EXCEPT_RISCV_ENV_CALL_FROM_VS_MODE",
  "EXCEPT_RISCV_ENV_CALL_FROM_MMODE",
  "EXCEPT_RISCV_INST_ACCESS_PAGE_FAULT",
  "EXCEPT_RISCV_LOAD_ACCESS_PAGE_FAULT",
  "EXCEPT_RISCV_14",
  "EXCEPT_RISCV_STORE_ACCESS_PAGE_FAULT",
  "EXCEPT_RISCV_16",
  "EXCEPT_RISCV_17",
  "EXCEPT_RISCV_18",
  "EXCEPT_RISCV_19",
  "EXCEPT_RISCV_INST_GUEST_PAGE_FAULT",
  "EXCEPT_RISCV_LOAD_GUEST_PAGE_FAULT",
  "EXCEPT_RISCV_VIRTUAL_INSTRUCTION",
  "EXCEPT_RISCV_STORE_GUEST_PAGE_FAULT"
};
 
STATIC CONST CHAR8  *mIrqNameStr[EXCEPT_RISCV_MAX_IRQS + 1] = {
  "EXCEPT_RISCV_IRQ_0",
  "EXCEPT_RISCV_IRQ_SOFT_FROM_SMODE",
  "EXCEPT_RISCV_IRQ_SOFT_FROM_VSMODE",
  "EXCEPT_RISCV_IRQ_SOFT_FROM_MMODE",
  "EXCEPT_RISCV_IRQ_4",
  "EXCEPT_RISCV_IRQ_TIMER_FROM_SMODE",
};
 
STATIC
VOID
EFIAPI
InternalPrintMessage (
  IN  CONST CHAR8  *Format,
  ...
  )
{
  CHAR8    Buffer[MAX_DEBUG_MESSAGE_LENGTH];
  VA_LIST  Marker;
 
  //
  // Convert the message to an ASCII String
  //
  VA_START (Marker, Format);
  AsciiVSPrint (Buffer, sizeof (Buffer), Format, Marker);
  VA_END (Marker);
 
  //
  // Send the print string to a Serial Port
  //
  SerialPortWrite ((UINT8 *)Buffer, AsciiStrLen (Buffer));
}
 
STATIC
CONST CHAR8 *
GetExceptionNameStr (
  IN EFI_EXCEPTION_TYPE  ExceptionType
  )
{
  if (EXCEPT_RISCV_IS_IRQ (ExceptionType)) {
    if (EXCEPT_RISCV_IRQ_INDEX (ExceptionType) > EXCEPT_RISCV_MAX_IRQS) {
      return mExceptionOrIrqUnknown;
    }
 
    return mIrqNameStr[EXCEPT_RISCV_IRQ_INDEX (ExceptionType)];
  }
 
  if (ExceptionType > EXCEPT_RISCV_MAX_EXCEPTIONS) {
    return mExceptionOrIrqUnknown;
  }
 
  return mExceptionNameStr[ExceptionType];
}
 
VOID
EFIAPI
DumpCpuContext (
  IN EFI_EXCEPTION_TYPE  ExceptionType,
  IN EFI_SYSTEM_CONTEXT  SystemContext
  )
{
  UINTN                 Printed;
  SMODE_TRAP_REGISTERS  *Regs;
 
  Printed = 0;
  Regs    = (SMODE_TRAP_REGISTERS *)SystemContext.SystemContextRiscV64;
 
  InternalPrintMessage (
    "!!!! RISCV64 Exception Type - %016x(%a) !!!!\n",
    ExceptionType,
    GetExceptionNameStr (ExceptionType)
    );
 
  DEBUG_CODE_BEGIN ();
 
  #define REGS()                                                          \
  REG (t0); REG (t1); REG (t2); REG (t3); REG (t4); REG (t5); REG (t6); \
  REG (s0); REG (s1); REG (s2); REG (s3); REG (s4); REG (s5); REG (s6); \
  REG (s7); REG (s8); REG (s9); REG (s10); REG (s11);                   \
  REG (a0); REG (a1); REG (a2); REG (a3); REG (a4); REG (a5); REG (a6); \
  REG (a7);                                                             \
  REG (zero); REG (ra); REG (sp); REG (gp); REG (tp);                   \
  REG (sepc); REG (sstatus); REG (stval);
 
  #define REG(x)  do {                                      \
    InternalPrintMessage ("%7a = 0x%017lx%c", #x, Regs->x,  \
                          (++Printed % 2) ? L'\t' : L'\n'); \
  } while (0);
 
  REGS ();
  if (Printed % 2 != 0) {
    InternalPrintMessage ("\n");
  }
 
  #undef REG
  #undef REGS
 
  DEBUG_CODE_END ();
}
 
EFI_STATUS
EFIAPI
InitializeCpuExceptionHandlers (
  IN EFI_VECTOR_HANDOFF_INFO  *VectorInfo OPTIONAL
  )
{
  RiscVSetSupervisorStvec ((UINT64)SupervisorModeTrap);
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
RegisterCpuInterruptHandler (
  IN EFI_EXCEPTION_TYPE         ExceptionType,
  IN EFI_CPU_INTERRUPT_HANDLER  InterruptHandler
  )
{
  DEBUG ((DEBUG_INFO, "%a: Type:%x Handler: %x\n", __func__, ExceptionType, InterruptHandler));
  if (EXCEPT_RISCV_IS_IRQ (ExceptionType)) {
    if (EXCEPT_RISCV_IRQ_INDEX (ExceptionType) > EXCEPT_RISCV_MAX_IRQS) {
      return EFI_UNSUPPORTED;
    }
 
    if (mIrqHandlers[EXCEPT_RISCV_IRQ_INDEX (ExceptionType)] != NULL) {
      return EFI_ALREADY_STARTED;
    } else if (InterruptHandler == NULL) {
      return EFI_INVALID_PARAMETER;
    }
 
    mIrqHandlers[EXCEPT_RISCV_IRQ_INDEX (ExceptionType)] = InterruptHandler;
  } else {
    if (ExceptionType > EXCEPT_RISCV_MAX_EXCEPTIONS) {
      return EFI_UNSUPPORTED;
    }
 
    if (mExceptionHandlers[ExceptionType] != NULL) {
      return EFI_ALREADY_STARTED;
    } else if (InterruptHandler == NULL) {
      return EFI_INVALID_PARAMETER;
    }
 
    mExceptionHandlers[ExceptionType] = InterruptHandler;
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
InitializeSeparateExceptionStacks (
  IN     VOID   *Buffer,
  IN OUT UINTN  *BufferSize
  )
{
  return EFI_SUCCESS;
}
 
VOID
RiscVSupervisorModeTrapHandler (
  SMODE_TRAP_REGISTERS  *SmodeTrapReg
  )
{
  EFI_EXCEPTION_TYPE  ExceptionType;
  EFI_SYSTEM_CONTEXT  RiscVSystemContext;
  UINTN               IrqIndex;
 
  RiscVSystemContext.SystemContextRiscV64 = (EFI_SYSTEM_CONTEXT_RISCV64 *)SmodeTrapReg;
  ExceptionType                           = (UINTN)RiscVGetSupervisorTrapCause ();
 
  if (EXCEPT_RISCV_IS_IRQ (ExceptionType)) {
    IrqIndex = EXCEPT_RISCV_IRQ_INDEX (ExceptionType);
 
    if ((IrqIndex <= EXCEPT_RISCV_MAX_IRQS) &&
        (mIrqHandlers[IrqIndex] != NULL))
    {
      mIrqHandlers[IrqIndex](ExceptionType, RiscVSystemContext);
      return;
    }
  } else {
    if ((ExceptionType <= EXCEPT_RISCV_MAX_EXCEPTIONS) &&
        (mExceptionHandlers[ExceptionType] != 0))
    {
      mExceptionHandlers[ExceptionType](ExceptionType, RiscVSystemContext);
      return;
    }
  }
 
  DumpCpuContext (ExceptionType, RiscVSystemContext);
  CpuDeadLoop ();
}