ArmPkg/Drivers/CpuDxe/Exception.c

   1 /** @file
   2
   3   Copyright (c) 2008-2009, Apple Inc. All rights reserved.
   4
   5   All rights reserved. This program and the accompanying materials
   6   are licensed and made available under the terms and conditions of the BSD License
   7   which accompanies this distribution.  The full text of the license may be found at
   8   http://opensource.org/licenses/bsd-license.php
   9
  10   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12
  13 **/
  14
  15 #include "CpuDxe.h"
  16
  17
  18 VOID
  19 ExceptionHandlersStart (
  20   VOID
  21   );
  22
  23 VOID
  24 ExceptionHandlersEnd (
  25   VOID
  26   );
  27
  28 VOID
  29 CommonExceptionEntry (
  30   VOID
  31   );
  32
  33 VOID
  34 AsmCommonExceptionEntry (
  35   VOID
  36   );
  37
  38
  39 EFI_EXCEPTION_CALLBACK  gExceptionHandlers[MAX_ARM_EXCEPTION + 1];
  40 EFI_EXCEPTION_CALLBACK  gDebuggerExceptionHandlers[MAX_ARM_EXCEPTION + 1];
  41
  42
  43
  44 /**
  45   This function registers and enables the handler specified by InterruptHandler for a processor
  46   interrupt or exception type specified by InterruptType. If InterruptHandler is NULL, then the
  47   handler for the processor interrupt or exception type specified by InterruptType is uninstalled.
  48   The installed handler is called once for each processor interrupt or exception.
  49
  50   @param  InterruptType    A pointer to the processor's current interrupt state. Set to TRUE if interrupts
  51                            are enabled and FALSE if interrupts are disabled.
  52   @param  InterruptHandler A pointer to a function of type EFI_CPU_INTERRUPT_HANDLER that is called
  53                            when a processor interrupt occurs. If this parameter is NULL, then the handler
  54                            will be uninstalled.
  55
  56   @retval EFI_SUCCESS           The handler for the processor interrupt was successfully installed or uninstalled.
  57   @retval EFI_ALREADY_STARTED   InterruptHandler is not NULL, and a handler for InterruptType was
  58                                 previously installed.
  59   @retval EFI_INVALID_PARAMETER InterruptHandler is NULL, and a handler for InterruptType was not
  60                                 previously installed.
  61   @retval EFI_UNSUPPORTED       The interrupt specified by InterruptType is not supported.
  62
  63 **/
  64 EFI_STATUS
  65 RegisterInterruptHandler (
  66   IN EFI_EXCEPTION_TYPE             InterruptType,
  67   IN EFI_CPU_INTERRUPT_HANDLER      InterruptHandler
  68   )
  69 {
  70   if (InterruptType > MAX_ARM_EXCEPTION) {
  71     return EFI_UNSUPPORTED;
  72   }
  73
  74   if ((InterruptHandler != NULL) && (gExceptionHandlers[InterruptType] != NULL)) {
  75     return EFI_ALREADY_STARTED;
  76   }
  77
  78   gExceptionHandlers[InterruptType] = InterruptHandler;
  79
  80   return EFI_SUCCESS;
  81 }
  82
  83
  84 /**
  85   This function registers and enables the handler specified by InterruptHandler for a processor
  86   interrupt or exception type specified by InterruptType. If InterruptHandler is NULL, then the
  87   handler for the processor interrupt or exception type specified by InterruptType is uninstalled.
  88   The installed handler is called once for each processor interrupt or exception.
  89
  90   @param  InterruptType    A pointer to the processor's current interrupt state. Set to TRUE if interrupts
  91                            are enabled and FALSE if interrupts are disabled.
  92   @param  InterruptHandler A pointer to a function of type EFI_CPU_INTERRUPT_HANDLER that is called
  93                            when a processor interrupt occurs. If this parameter is NULL, then the handler
  94                            will be uninstalled.
  95
  96   @retval EFI_SUCCESS           The handler for the processor interrupt was successfully installed or uninstalled.
  97   @retval EFI_ALREADY_STARTED   InterruptHandler is not NULL, and a handler for InterruptType was
  98                                 previously installed.
  99   @retval EFI_INVALID_PARAMETER InterruptHandler is NULL, and a handler for InterruptType was not
 100                                 previously installed.
 101   @retval EFI_UNSUPPORTED       The interrupt specified by InterruptType is not supported.
 102
 103 **/
 104 EFI_STATUS
 105 RegisterDebuggerInterruptHandler (
 106   IN EFI_EXCEPTION_TYPE             InterruptType,
 107   IN EFI_CPU_INTERRUPT_HANDLER      InterruptHandler
 108   )
 109 {
 110   if (InterruptType > MAX_ARM_EXCEPTION) {
 111     return EFI_UNSUPPORTED;
 112   }
 113
 114   if ((InterruptHandler != NULL) && (gDebuggerExceptionHandlers[InterruptType] != NULL)) {
 115     return EFI_ALREADY_STARTED;
 116   }
 117
 118   gDebuggerExceptionHandlers[InterruptType] = InterruptHandler;
 119
 120   return EFI_SUCCESS;
 121 }
 122
 123
 124
 125 VOID
 126 EFIAPI
 127 CommonCExceptionHandler (
 128   IN     EFI_EXCEPTION_TYPE           ExceptionType,
 129   IN OUT EFI_SYSTEM_CONTEXT           SystemContext
 130   )
 131 {
 132   BOOLEAN Dispatched = FALSE;
 133
 134
 135   if (ExceptionType <= MAX_ARM_EXCEPTION) {
 136     if (gDebuggerExceptionHandlers[ExceptionType]) {
 137       //
 138       // If DebugSupport hooked the interrupt call the handler. This does not disable
 139       // the normal handler.
 140       //
 141       gDebuggerExceptionHandlers[ExceptionType] (ExceptionType, SystemContext);
 142       Dispatched = TRUE;
 143     }
 144     if (gExceptionHandlers[ExceptionType]) {
 145       gExceptionHandlers[ExceptionType] (ExceptionType, SystemContext);
 146       Dispatched = TRUE;
 147     }
 148   } else {
 149     DEBUG ((EFI_D_ERROR, "Unknown exception type %d from %08x\n", ExceptionType, SystemContext.SystemContextArm->PC));
 150     ASSERT (FALSE);
 151   }
 152
 153   if (Dispatched) {
 154     //
 155     // We did work so this was an expected ExceptionType
 156     //
 157     return;
 158   }
 159
 160   if (ExceptionType == EXCEPT_ARM_SOFTWARE_INTERRUPT) {
 161     //
 162     // ARM JTAG debuggers some times use this vector, so it is not an error to get one
 163     //
 164     return;
 165   }
 166
 167   DefaultExceptionHandler (ExceptionType, SystemContext);
 168 }
 169
 170
 171
 172 EFI_STATUS
 173 InitializeExceptions (
 174   IN EFI_CPU_ARCH_PROTOCOL    *Cpu
 175   )
 176 {
 177   EFI_STATUS           Status;
 178   UINTN                Offset;
 179   UINTN                Length;
 180   UINTN                Index;
 181   BOOLEAN              IrqEnabled;
 182   BOOLEAN              FiqEnabled;
 183   EFI_PHYSICAL_ADDRESS Base;
 184   UINT32               *VectorBase;
 185
 186   //
 187   // Disable interrupts
 188   //
 189   Cpu->GetInterruptState (Cpu, &IrqEnabled);
 190   Cpu->DisableInterrupt (Cpu);
 191
 192   //
 193   // EFI does not use the FIQ, but a debugger might so we must disable
 194   // as we take over the exception vectors.
 195   //
 196   FiqEnabled = ArmGetFiqState ();
 197   ArmDisableFiq ();
 198
 199   //
 200   // Copy an implementation of the ARM exception vectors to PcdCpuVectorBaseAddress.
 201   //
 202   Length = (UINTN)ExceptionHandlersEnd - (UINTN)ExceptionHandlersStart;
 203
 204   //
 205   // Reserve space for the exception handlers
 206   //
 207   Base = (EFI_PHYSICAL_ADDRESS)PcdGet32 (PcdCpuVectorBaseAddress);
 208   VectorBase = (UINT32 *)(UINTN)Base;
 209   Status = gBS->AllocatePages (AllocateAddress, EfiBootServicesCode, EFI_SIZE_TO_PAGES (Length), &Base);
 210   // If the request was for memory that's not in the memory map (which is often the case for 0x00000000
 211   // on embedded systems, for example, we don't want to hang up.  So we'll check here for a status of
 212   // EFI_NOT_FOUND, and continue in that case.
 213   if (EFI_ERROR(Status) && (Status != EFI_NOT_FOUND)) {
 214     ASSERT_EFI_ERROR (Status);
 215   }
 216
 217   // Save existing vector table, in case debugger is already hooked in
 218   CopyMem ((VOID *)gDebuggerExceptionHandlers, (VOID *)VectorBase, sizeof (gDebuggerExceptionHandlers));
 219
 220   //
 221   // Initialize the C entry points for interrupts
 222   //
 223   for (Index = 0; Index <= MAX_ARM_EXCEPTION; Index++) {
 224     Status = RegisterInterruptHandler (Index, NULL);
 225     ASSERT_EFI_ERROR (Status);
 226
 227     if (VectorBase[Index] == 0xEAFFFFFE) {
 228       // Exception handler contains branch to vector location (jmp $) so no handler
 229       // NOTE: This code assumes vectors are ARM and not Thumb code
 230       gDebuggerExceptionHandlers[Index] = NULL;
 231     }
 232   }
 233
 234   // Copy our assembly code into the page that contains the exception vectors.
 235   CopyMem ((VOID *)VectorBase, (VOID *)ExceptionHandlersStart, Length);
 236
 237   //
 238   // Patch in the common Assembly exception handler
 239   //
 240   Offset = (UINTN)CommonExceptionEntry - (UINTN)ExceptionHandlersStart;
 241   *(UINTN *) ((UINT8 *)(UINTN)PcdGet32 (PcdCpuVectorBaseAddress) + Offset) = (UINTN)AsmCommonExceptionEntry;
 242
 243   // Flush Caches since we updated executable stuff
 244   InvalidateInstructionCacheRange ((VOID *)PcdGet32(PcdCpuVectorBaseAddress), Length);
 245
 246   if (FiqEnabled) {
 247     ArmEnableFiq ();
 248   }
 249
 250   if (IrqEnabled) {
 251     //
 252     // Restore interrupt state
 253     //
 254     Status = Cpu->EnableInterrupt (Cpu);
 255   }
 256
 257   return Status;
 258 }