ArmPkg/Drivers/CpuDxe/Exception.c

   1 /** @file
   2
   3   Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
   4
   5   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
  86 VOID
  87 EFIAPI
  88 CommonCExceptionHandler (
  89   IN     EFI_EXCEPTION_TYPE           ExceptionType,
  90   IN OUT EFI_SYSTEM_CONTEXT           SystemContext
  91   )
  92 {
  93
  94   if (ExceptionType <= MAX_ARM_EXCEPTION) {
  95     if (gExceptionHandlers[ExceptionType]) {
  96       gExceptionHandlers[ExceptionType] (ExceptionType, SystemContext);
  97       return;
  98     }
  99   } else {
 100     DEBUG ((EFI_D_ERROR, "Unknown exception type %d from %08x\n", ExceptionType, SystemContext.SystemContextArm->PC));
 101     ASSERT (FALSE);
 102   }
 103
 104   if (ExceptionType == EXCEPT_ARM_SOFTWARE_INTERRUPT) {
 105     //
 106     // ARM JTAG debuggers some times use this vector, so it is not an error to get one
 107     //
 108     return;
 109   }
 110
 111   DefaultExceptionHandler (ExceptionType, SystemContext);
 112 }
 113
 114
 115
 116 EFI_STATUS
 117 InitializeExceptions (
 118   IN EFI_CPU_ARCH_PROTOCOL    *Cpu
 119   )
 120 {
 121   EFI_STATUS           Status;
 122   UINTN                Offset;
 123   UINTN                Length;
 124   UINTN                Index;
 125   BOOLEAN              IrqEnabled;
 126   BOOLEAN              FiqEnabled;
 127   EFI_PHYSICAL_ADDRESS Base;
 128   UINT32               *VectorBase;
 129
 130   //
 131   // Disable interrupts
 132   //
 133   Cpu->GetInterruptState (Cpu, &IrqEnabled);
 134   Cpu->DisableInterrupt (Cpu);
 135
 136   //
 137   // EFI does not use the FIQ, but a debugger might so we must disable
 138   // as we take over the exception vectors.
 139   //
 140   FiqEnabled = ArmGetFiqState ();
 141   ArmDisableFiq ();
 142
 143   //
 144   // Copy an implementation of the ARM exception vectors to PcdCpuVectorBaseAddress.
 145   //
 146   Length = (UINTN)ExceptionHandlersEnd - (UINTN)ExceptionHandlersStart;
 147
 148   //
 149   // Reserve space for the exception handlers
 150   //
 151   Base = (EFI_PHYSICAL_ADDRESS)PcdGet32 (PcdCpuVectorBaseAddress);
 152   VectorBase = (UINT32 *)(UINTN)Base;
 153   Status = gBS->AllocatePages (AllocateAddress, EfiBootServicesCode, EFI_SIZE_TO_PAGES (Length), &Base);
 154   // If the request was for memory that's not in the memory map (which is often the case for 0x00000000
 155   // on embedded systems, for example, we don't want to hang up.  So we'll check here for a status of
 156   // EFI_NOT_FOUND, and continue in that case.
 157   if (EFI_ERROR(Status) && (Status != EFI_NOT_FOUND)) {
 158     ASSERT_EFI_ERROR (Status);
 159   }
 160
 161   // Save existing vector table, in case debugger is already hooked in
 162   CopyMem ((VOID *)gDebuggerExceptionHandlers, (VOID *)VectorBase, sizeof (gDebuggerExceptionHandlers));
 163
 164   // Copy our assembly code into the page that contains the exception vectors.
 165   CopyMem ((VOID *)VectorBase, (VOID *)ExceptionHandlersStart, Length);
 166
 167   //
 168   // Patch in the common Assembly exception handler
 169   //
 170   Offset = (UINTN)CommonExceptionEntry - (UINTN)ExceptionHandlersStart;
 171   *(UINTN *) ((UINT8 *)(UINTN)PcdGet32 (PcdCpuVectorBaseAddress) + Offset) = (UINTN)AsmCommonExceptionEntry;
 172
 173   //
 174   // Initialize the C entry points for interrupts
 175   //
 176   for (Index = 0; Index <= MAX_ARM_EXCEPTION; Index++) {
 177     if ((gDebuggerExceptionHandlers[Index] == 0) || (gDebuggerExceptionHandlers[Index] == (VOID *)(UINTN)0xEAFFFFFE)) {
 178       // Exception handler contains branch to vector location (jmp $) so no handler
 179       // NOTE: This code assumes vectors are ARM and not Thumb code
 180       Status = RegisterInterruptHandler (Index, NULL);
 181       ASSERT_EFI_ERROR (Status);
 182     } else {
 183       // If the debugger has alread hooked put its vector back
 184       VectorBase[Index] = (UINT32)(UINTN)gDebuggerExceptionHandlers[Index];
 185     }
 186   }
 187
 188   // Flush Caches since we updated executable stuff
 189   InvalidateInstructionCacheRange ((VOID *)PcdGet32(PcdCpuVectorBaseAddress), Length);
 190
 191   if (FiqEnabled) {
 192     ArmEnableFiq ();
 193   }
 194
 195   if (IrqEnabled) {
 196     //
 197     // Restore interrupt state
 198     //
 199     Status = Cpu->EnableInterrupt (Cpu);
 200   }
 201
 202   return Status;
 203 }