Fixed a bug in the HardwareInterrupt handler that would blow the stack if you reenabl...
[mirror_edk2.git] / 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 #include <Library/CacheMaintenanceLib.h>
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 CHAR8 *gExceptionTypeString[] = {
124 "Reset",
125 "Undefined Instruction",
126 "SWI",
127 "Prefetch Abort",
128 "Data Abort",
129 "Undefined",
130 "IRQ",
131 "FIQ"
132 };
133
134 VOID
135 EFIAPI
136 CommonCExceptionHandler (
137 IN EFI_EXCEPTION_TYPE ExceptionType,
138 IN OUT EFI_SYSTEM_CONTEXT SystemContext
139 )
140 {
141 BOOLEAN Dispatched = FALSE;
142
143
144 if (ExceptionType <= MAX_ARM_EXCEPTION) {
145 if (gDebuggerExceptionHandlers[ExceptionType]) {
146 //
147 // If DebugSupport hooked the interrupt call the handler. This does not disable
148 // the normal handler.
149 //
150 gDebuggerExceptionHandlers[ExceptionType] (ExceptionType, SystemContext);
151 Dispatched = TRUE;
152 }
153 if (gExceptionHandlers[ExceptionType]) {
154 gExceptionHandlers[ExceptionType] (ExceptionType, SystemContext);
155 Dispatched = TRUE;
156 }
157 } else {
158 DEBUG ((EFI_D_ERROR, "Unknown exception type %d from %08x\n", ExceptionType, SystemContext.SystemContextArm->PC));
159 ASSERT (FALSE);
160 }
161
162 if (Dispatched) {
163 //
164 // We did work so this was an expected ExceptionType
165 //
166 return;
167 }
168
169 if (ExceptionType == EXCEPT_ARM_SOFTWARE_INTERRUPT) {
170 //
171 // ARM JTAG debuggers some times use this vector, so it is not an error to get one
172 //
173 return;
174 }
175
176 //
177 // Code after here is the default exception handler...
178 //
179 DEBUG ((EFI_D_ERROR, "%a Exception from %08x\n", gExceptionTypeString[ExceptionType], SystemContext.SystemContextArm->PC));
180 ASSERT (FALSE);
181
182 }
183
184
185
186 EFI_STATUS
187 InitializeExceptions (
188 IN EFI_CPU_ARCH_PROTOCOL *Cpu
189 )
190 {
191 EFI_STATUS Status;
192 UINTN Offset;
193 UINTN Length;
194 UINTN Index;
195 BOOLEAN Enabled;
196 EFI_PHYSICAL_ADDRESS Base;
197
198 //
199 // Disable interrupts
200 //
201 Cpu->GetInterruptState (Cpu, &Enabled);
202 Cpu->DisableInterrupt (Cpu);
203
204 //
205 // Initialize the C entry points for interrupts
206 //
207 for (Index = 0; Index <= MAX_ARM_EXCEPTION; Index++) {
208 Status = RegisterInterruptHandler (Index, NULL);
209 ASSERT_EFI_ERROR (Status);
210
211 Status = RegisterDebuggerInterruptHandler (Index, NULL);
212 ASSERT_EFI_ERROR (Status);
213 }
214
215 //
216 // Copy an implementation of the ARM exception vectors to PcdCpuVectorBaseAddress.
217 //
218 Length = (UINTN)ExceptionHandlersEnd - (UINTN)ExceptionHandlersStart;
219
220 //
221 // Reserve space for the exception handlers
222 //
223 Base = (EFI_PHYSICAL_ADDRESS)PcdGet32 (PcdCpuVectorBaseAddress);
224 Status = gBS->AllocatePages (AllocateAddress, EfiBootServicesCode, EFI_SIZE_TO_PAGES (Length), &Base);
225 // If the request was for memory that's not in the memory map (which is often the case for 0x00000000
226 // on embedded systems, for example, we don't want to hang up. So we'll check here for a status of
227 // EFI_NOT_FOUND, and continue in that case.
228 if (EFI_ERROR(Status) && (Status != EFI_NOT_FOUND)) {
229 ASSERT_EFI_ERROR (Status);
230 }
231
232 CopyMem ((VOID *)(UINTN)PcdGet32 (PcdCpuVectorBaseAddress), (VOID *)ExceptionHandlersStart, Length);
233
234 //
235 // Patch in the common Assembly exception handler
236 //
237 Offset = (UINTN)CommonExceptionEntry - (UINTN)ExceptionHandlersStart;
238 *(UINTN *) ((UINT8 *)(UINTN)PcdGet32 (PcdCpuVectorBaseAddress) + Offset) = (UINTN)AsmCommonExceptionEntry;
239
240 // Flush Caches since we updated executable stuff
241 InvalidateInstructionCacheRange ((VOID *)PcdGet32(PcdCpuVectorBaseAddress), Length);
242
243 if (Enabled) {
244 //
245 // Restore interrupt state
246 //
247 Status = Cpu->EnableInterrupt (Cpu);
248 }
249
250 return Status;
251 }