Make these drivers more compatible with a projected Debug Agent Library implementation.
[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
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 Enabled;
182 EFI_PHYSICAL_ADDRESS Base;
183 UINT32 *VectorBase;
184
185 //
186 // Disable interrupts
187 //
188 Cpu->GetInterruptState (Cpu, &Enabled);
189 Cpu->DisableInterrupt (Cpu);
190
191
192 //
193 // Copy an implementation of the ARM exception vectors to PcdCpuVectorBaseAddress.
194 //
195 Length = (UINTN)ExceptionHandlersEnd - (UINTN)ExceptionHandlersStart;
196
197 //
198 // Reserve space for the exception handlers
199 //
200 Base = (EFI_PHYSICAL_ADDRESS)PcdGet32 (PcdCpuVectorBaseAddress);
201 VectorBase = (UINT32 *)(UINTN)Base;
202 Status = gBS->AllocatePages (AllocateAddress, EfiBootServicesCode, EFI_SIZE_TO_PAGES (Length), &Base);
203 // If the request was for memory that's not in the memory map (which is often the case for 0x00000000
204 // on embedded systems, for example, we don't want to hang up. So we'll check here for a status of
205 // EFI_NOT_FOUND, and continue in that case.
206 if (EFI_ERROR(Status) && (Status != EFI_NOT_FOUND)) {
207 ASSERT_EFI_ERROR (Status);
208 }
209
210 // Save existing vector table, in case debugger is already hooked in
211 CopyMem ((VOID *)gDebuggerExceptionHandlers, (VOID *)VectorBase, sizeof (gDebuggerExceptionHandlers));
212
213 //
214 // Initialize the C entry points for interrupts
215 //
216 for (Index = 0; Index <= MAX_ARM_EXCEPTION; Index++) {
217 Status = RegisterInterruptHandler (Index, NULL);
218 ASSERT_EFI_ERROR (Status);
219
220 if (VectorBase[Index] == 0xEAFFFFFE) {
221 // Exception handler contains branch to vector location (jmp $) so no handler
222 // NOTE: This code assumes vectors are ARM and not Thumb code
223 gDebuggerExceptionHandlers[Index] = NULL;
224 }
225 }
226
227 // Copy our assembly code into the page that contains the exception vectors.
228 CopyMem ((VOID *)VectorBase, (VOID *)ExceptionHandlersStart, Length);
229
230 //
231 // Patch in the common Assembly exception handler
232 //
233 Offset = (UINTN)CommonExceptionEntry - (UINTN)ExceptionHandlersStart;
234 *(UINTN *) ((UINT8 *)(UINTN)PcdGet32 (PcdCpuVectorBaseAddress) + Offset) = (UINTN)AsmCommonExceptionEntry;
235
236 // Flush Caches since we updated executable stuff
237 InvalidateInstructionCacheRange ((VOID *)PcdGet32(PcdCpuVectorBaseAddress), Length);
238
239 if (Enabled) {
240 //
241 // Restore interrupt state
242 //
243 Status = Cpu->EnableInterrupt (Cpu);
244 }
245
246 return Status;
247 }