1 //*****************************************************************************
2 // LPC55S36 startup code for use with MCUXpresso IDE
3 //
4 // Version : 010623
5 //*****************************************************************************
6 //
7 // Copyright 2016-2023 NXP
8 // All rights reserved.
9 //
10 // SPDX-License-Identifier: BSD-3-Clause
11 //*****************************************************************************
12
13 #if defined (DEBUG)
14 #pragma GCC push_options
15 #pragma GCC optimize ("Og")
16 #endif // (DEBUG)
17
18 #if defined (__cplusplus)
19 #ifdef __REDLIB__
20 #error Redlib does not support C++
21 #else
22 //*****************************************************************************
23 //
24 // The entry point for the C++ library startup
25 //
26 //*****************************************************************************
27 extern "C" {
28 extern void __libc_init_array(void);
29 }
30 #endif
31 #endif
32
33 #define WEAK __attribute__ ((weak))
34 #define WEAK_AV __attribute__ ((weak, section(".after_vectors")))
35 #define ALIAS(f) __attribute__ ((weak, alias (#f)))
36
37 //*****************************************************************************
38 #if defined (__cplusplus)
39 extern "C" {
40 #endif
41
42 //*****************************************************************************
43 // Variable to store CRP value in. Will be placed automatically
44 // by the linker when "Enable Code Read Protect" selected.
45 // See crp.h header for more information
46 //*****************************************************************************
47 //*****************************************************************************
48 // Declaration of external SystemInit function
49 //*****************************************************************************
50 #if defined (__USE_CMSIS)
51 extern void SystemInit(void);
52 #endif // (__USE_CMSIS)
53
54 //*****************************************************************************
55 // Forward declaration of the core exception handlers.
56 // When the application defines a handler (with the same name), this will
57 // automatically take precedence over these weak definitions.
58 // If your application is a C++ one, then any interrupt handlers defined
59 // in C++ files within in your main application will need to have C linkage
60 // rather than C++ linkage. To do this, make sure that you are using extern "C"
61 // { .... } around the interrupt handler within your main application code.
62 //*****************************************************************************
63 void ResetISR(void);
64 WEAK void NMI_Handler(void);
65 WEAK void HardFault_Handler(void);
66 WEAK void MemManage_Handler(void);
67 WEAK void BusFault_Handler(void);
68 WEAK void UsageFault_Handler(void);
69 WEAK void SecureFault_Handler(void);
70 WEAK void SVC_Handler(void);
71 WEAK void DebugMon_Handler(void);
72 WEAK void PendSV_Handler(void);
73 WEAK void SysTick_Handler(void);
74 WEAK void IntDefaultHandler(void);
75
76 //*****************************************************************************
77 // Forward declaration of the application IRQ handlers. When the application
78 // defines a handler (with the same name), this will automatically take
79 // precedence over weak definitions below
80 //*****************************************************************************
81 WEAK void WDT_BOD_IRQHandler(void);
82 WEAK void DMA0_IRQHandler(void);
83 WEAK void GINT0_IRQHandler(void);
84 WEAK void GINT1_IRQHandler(void);
85 WEAK void PIN_INT0_IRQHandler(void);
86 WEAK void PIN_INT1_IRQHandler(void);
87 WEAK void PIN_INT2_IRQHandler(void);
88 WEAK void PIN_INT3_IRQHandler(void);
89 WEAK void UTICK0_IRQHandler(void);
90 WEAK void MRT0_IRQHandler(void);
91 WEAK void CTIMER0_IRQHandler(void);
92 WEAK void CTIMER1_IRQHandler(void);
93 WEAK void SCT0_IRQHandler(void);
94 WEAK void CTIMER3_IRQHandler(void);
95 WEAK void FLEXCOMM0_IRQHandler(void);
96 WEAK void FLEXCOMM1_IRQHandler(void);
97 WEAK void FLEXCOMM2_IRQHandler(void);
98 WEAK void FLEXCOMM3_IRQHandler(void);
99 WEAK void FLEXCOMM4_IRQHandler(void);
100 WEAK void FLEXCOMM5_IRQHandler(void);
101 WEAK void FLEXCOMM6_IRQHandler(void);
102 WEAK void FLEXCOMM7_IRQHandler(void);
103 WEAK void ADC0_IRQHandler(void);
104 WEAK void ADC1_IRQHandler(void);
105 WEAK void ACMP_IRQHandler(void);
106 WEAK void DMIC_IRQHandler(void);
107 WEAK void HWVAD0_IRQHandler(void);
108 WEAK void USB0_NEEDCLK_IRQHandler(void);
109 WEAK void USB0_IRQHandler(void);
110 WEAK void RTC_IRQHandler(void);
111 WEAK void EZH_ARCH_B0_IRQHandler(void);
112 WEAK void WAKEUP_IRQHandler(void);
113 WEAK void PIN_INT4_IRQHandler(void);
114 WEAK void PIN_INT5_IRQHandler(void);
115 WEAK void PIN_INT6_IRQHandler(void);
116 WEAK void PIN_INT7_IRQHandler(void);
117 WEAK void CTIMER2_IRQHandler(void);
118 WEAK void CTIMER4_IRQHandler(void);
119 WEAK void OS_EVENT_IRQHandler(void);
120 WEAK void FlexSPI0_IRQHandler(void);
121 WEAK void Reserved56_IRQHandler(void);
122 WEAK void Reserved57_IRQHandler(void);
123 WEAK void Reserved58_IRQHandler(void);
124 WEAK void CAN0_IRQ0_IRQHandler(void);
125 WEAK void CAN0_IRQ1_IRQHandler(void);
126 WEAK void SPI_FILTER_IRQHandler(void);
127 WEAK void Reserved62_IRQHandler(void);
128 WEAK void Reserved63_IRQHandler(void);
129 WEAK void Reserved64_IRQHandler(void);
130 WEAK void SEC_HYPERVISOR_CALL_IRQHandler(void);
131 WEAK void SEC_GPIO_INT0_IRQ0_IRQHandler(void);
132 WEAK void SEC_GPIO_INT0_IRQ1_IRQHandler(void);
133 WEAK void Freqme_IRQHandler(void);
134 WEAK void SEC_VIO_IRQHandler(void);
135 WEAK void ELS_IRQHandler(void);
136 WEAK void PKC_IRQHandler(void);
137 WEAK void PUF_IRQHandler(void);
138 WEAK void POWERQUAD_IRQHandler(void);
139 WEAK void DMA1_IRQHandler(void);
140 WEAK void FLEXCOMM8_IRQHandler(void);
141 WEAK void CDOG_IRQHandler(void);
142 WEAK void Reserved77_IRQHandler(void);
143 WEAK void I3C0_IRQHandler(void);
144 WEAK void Reserved79_IRQHandler(void);
145 WEAK void Reserved80_IRQHandler(void);
146 WEAK void ELS_IRQ1_IRQHandler(void);
147 WEAK void Tamper_IRQHandler(void);
148 WEAK void Reserved83_IRQHandler(void);
149 WEAK void Reserved84_IRQHandler(void);
150 WEAK void Reserved85_IRQHandler(void);
151 WEAK void Reserved86_IRQHandler(void);
152 WEAK void Reserved87_IRQHandler(void);
153 WEAK void Reserved88_IRQHandler(void);
154 WEAK void Reserved89_IRQHandler(void);
155 WEAK void DAC0_IRQHandler(void);
156 WEAK void DAC1_IRQHandler(void);
157 WEAK void DAC2_IRQHandler(void);
158 WEAK void HSCMP0_IRQHandler(void);
159 WEAK void HSCMP1_IRQHandler(void);
160 WEAK void HSCMP2_IRQHandler(void);
161 WEAK void FLEXPWM0_CAPTURE_IRQHandler(void);
162 WEAK void FLEXPWM0_FAULT_IRQHandler(void);
163 WEAK void FLEXPWM0_RELOAD_ERROR_IRQHandler(void);
164 WEAK void FLEXPWM0_COMPARE0_IRQHandler(void);
165 WEAK void FLEXPWM0_RELOAD0_IRQHandler(void);
166 WEAK void FLEXPWM0_COMPARE1_IRQHandler(void);
167 WEAK void FLEXPWM0_RELOAD1_IRQHandler(void);
168 WEAK void FLEXPWM0_COMPARE2_IRQHandler(void);
169 WEAK void FLEXPWM0_RELOAD2_IRQHandler(void);
170 WEAK void FLEXPWM0_COMPARE3_IRQHandler(void);
171 WEAK void FLEXPWM0_RELOAD3_IRQHandler(void);
172 WEAK void FLEXPWM1_CAPTURE_IRQHandler(void);
173 WEAK void FLEXPWM1_FAULT_IRQHandler(void);
174 WEAK void FLEXPWM1_RELOAD_ERROR_IRQHandler(void);
175 WEAK void FLEXPWM1_COMPARE0_IRQHandler(void);
176 WEAK void FLEXPWM1_RELOAD0_IRQHandler(void);
177 WEAK void FLEXPWM1_COMPARE1_IRQHandler(void);
178 WEAK void FLEXPWM1_RELOAD1_IRQHandler(void);
179 WEAK void FLEXPWM1_COMPARE2_IRQHandler(void);
180 WEAK void FLEXPWM1_RELOAD2_IRQHandler(void);
181 WEAK void FLEXPWM1_COMPARE3_IRQHandler(void);
182 WEAK void FLEXPWM1_RELOAD3_IRQHandler(void);
183 WEAK void ENC0_COMPARE_IRQHandler(void);
184 WEAK void ENC0_HOME_IRQHandler(void);
185 WEAK void ENC0_WDG_IRQHandler(void);
186 WEAK void ENC0_IDX_IRQHandler(void);
187 WEAK void ENC1_COMPARE_IRQHandler(void);
188 WEAK void ENC1_HOME_IRQHandler(void);
189 WEAK void ENC1_WDG_IRQHandler(void);
190 WEAK void ENC1_IDX_IRQHandler(void);
191 WEAK void ITRC0_IRQHandler(void);
192 WEAK void Reserved127_IRQHandler(void);
193 WEAK void ELS_ERR_IRQHandler(void);
194 WEAK void PKC_ERR_IRQHandler(void);
195 WEAK void Reserved130_IRQHandler(void);
196 WEAK void Reserved131_IRQHandler(void);
197 WEAK void Reserved132_IRQHandler(void);
198 WEAK void Reserved133_IRQHandler(void);
199 WEAK void FLASH_IRQHandler(void);
200 WEAK void RAM_PARITY_ECC_ERR_IRQHandler(void);
201
202 //*****************************************************************************
203 // Forward declaration of the driver IRQ handlers. These are aliased
204 // to the IntDefaultHandler, which is a 'forever' loop. When the driver
205 // defines a handler (with the same name), this will automatically take
206 // precedence over these weak definitions
207 //*****************************************************************************
208 void WDT_BOD_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
209 void DMA0_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
210 void GINT0_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
211 void GINT1_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
212 void PIN_INT0_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
213 void PIN_INT1_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
214 void PIN_INT2_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
215 void PIN_INT3_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
216 void UTICK0_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
217 void MRT0_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
218 void CTIMER0_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
219 void CTIMER1_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
220 void SCT0_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
221 void CTIMER3_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
222 void FLEXCOMM0_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
223 void FLEXCOMM1_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
224 void FLEXCOMM2_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
225 void FLEXCOMM3_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
226 void FLEXCOMM4_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
227 void FLEXCOMM5_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
228 void FLEXCOMM6_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
229 void FLEXCOMM7_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
230 void ADC0_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
231 void ADC1_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
232 void ACMP_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
233 void DMIC_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
234 void HWVAD0_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
235 void USB0_NEEDCLK_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
236 void USB0_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
237 void RTC_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
238 void EZH_ARCH_B0_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
239 void WAKEUP_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
240 void PIN_INT4_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
241 void PIN_INT5_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
242 void PIN_INT6_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
243 void PIN_INT7_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
244 void CTIMER2_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
245 void CTIMER4_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
246 void OS_EVENT_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
247 void FlexSPI0_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
248 void Reserved56_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
249 void Reserved57_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
250 void Reserved58_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
251 void CAN0_IRQ0_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
252 void CAN0_IRQ1_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
253 void SPI_FILTER_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
254 void Reserved62_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
255 void Reserved63_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
256 void Reserved64_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
257 void SEC_HYPERVISOR_CALL_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
258 void SEC_GPIO_INT0_IRQ0_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
259 void SEC_GPIO_INT0_IRQ1_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
260 void Freqme_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
261 void SEC_VIO_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
262 void ELS_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
263 void PKC_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
264 void PUF_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
265 void POWERQUAD_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
266 void DMA1_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
267 void FLEXCOMM8_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
268 void CDOG_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
269 void Reserved77_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
270 void I3C0_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
271 void Reserved79_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
272 void Reserved80_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
273 void ELS_IRQ1_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
274 void Tamper_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
275 void Reserved83_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
276 void Reserved84_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
277 void Reserved85_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
278 void Reserved86_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
279 void Reserved87_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
280 void Reserved88_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
281 void Reserved89_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
282 void DAC0_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
283 void DAC1_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
284 void DAC2_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
285 void HSCMP0_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
286 void HSCMP1_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
287 void HSCMP2_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
288 void FLEXPWM0_CAPTURE_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
289 void FLEXPWM0_FAULT_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
290 void FLEXPWM0_RELOAD_ERROR_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
291 void FLEXPWM0_COMPARE0_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
292 void FLEXPWM0_RELOAD0_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
293 void FLEXPWM0_COMPARE1_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
294 void FLEXPWM0_RELOAD1_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
295 void FLEXPWM0_COMPARE2_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
296 void FLEXPWM0_RELOAD2_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
297 void FLEXPWM0_COMPARE3_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
298 void FLEXPWM0_RELOAD3_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
299 void FLEXPWM1_CAPTURE_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
300 void FLEXPWM1_FAULT_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
301 void FLEXPWM1_RELOAD_ERROR_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
302 void FLEXPWM1_COMPARE0_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
303 void FLEXPWM1_RELOAD0_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
304 void FLEXPWM1_COMPARE1_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
305 void FLEXPWM1_RELOAD1_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
306 void FLEXPWM1_COMPARE2_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
307 void FLEXPWM1_RELOAD2_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
308 void FLEXPWM1_COMPARE3_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
309 void FLEXPWM1_RELOAD3_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
310 void ENC0_COMPARE_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
311 void ENC0_HOME_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
312 void ENC0_WDG_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
313 void ENC0_IDX_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
314 void ENC1_COMPARE_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
315 void ENC1_HOME_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
316 void ENC1_WDG_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
317 void ENC1_IDX_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
318 void ITRC0_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
319 void Reserved127_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
320 void ELS_ERR_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
321 void PKC_ERR_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
322 void Reserved130_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
323 void Reserved131_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
324 void Reserved132_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
325 void Reserved133_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
326 void FLASH_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
327 void RAM_PARITY_ECC_ERR_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
328
329 //*****************************************************************************
330 // The entry point for the application.
331 // __main() is the entry point for Redlib based applications
332 // main() is the entry point for Newlib based applications
333 //*****************************************************************************
334 #if defined (__REDLIB__)
335 extern void __main(void);
336 #endif
337 extern int main(void);
338
339 //*****************************************************************************
340 // External declaration for the pointer to the stack top from the Linker Script
341 //*****************************************************************************
342 extern void _vStackTop(void);
343 extern void _vStackBase(void);
344 //*****************************************************************************
345 // External declaration for LPC MCU vector table checksum from Linker Script
346 //*****************************************************************************
347 WEAK extern void __valid_user_code_checksum();
348
349 //*****************************************************************************
350 //*****************************************************************************
351 #if defined (__cplusplus)
352 } // extern "C"
353 #endif
354 //*****************************************************************************
355 // The vector table.
356 // This relies on the linker script to place at correct location in memory.
357 //*****************************************************************************
358
359 extern void (* const g_pfnVectors[])(void);
360 extern void * __Vectors __attribute__ ((alias ("g_pfnVectors")));
361
362 __attribute__ ((used, section(".isr_vector")))
363 void (* const g_pfnVectors[])(void) = {
364 // Core Level - CM33
365 &_vStackTop, // The initial stack pointer
366 ResetISR, // The reset handler
367 NMI_Handler, // NMI Handler
368 HardFault_Handler, // Hard Fault Handler
369 MemManage_Handler, // MPU Fault Handler
370 BusFault_Handler, // Bus Fault Handler
371 UsageFault_Handler, // Usage Fault Handler
372 SecureFault_Handler, // Secure Fault Handler
373 0, // ECRP
374 0, // Reserved
375 0, // Reserved
376 SVC_Handler, // SVCall Handler
377 DebugMon_Handler, // Debug Monitor Handler
378 0, // Reserved
379 PendSV_Handler, // PendSV Handler
380 SysTick_Handler, // SysTick Handler
381
382 // Chip Level - LPC55S36
383 WDT_BOD_IRQHandler, // 16 : Windowed watchdog timer, Brownout detect, Flash interrupt
384 DMA0_IRQHandler, // 17 : DMA0 controller
385 GINT0_IRQHandler, // 18 : GPIO group 0
386 GINT1_IRQHandler, // 19 : GPIO group 1
387 PIN_INT0_IRQHandler, // 20 : Pin interrupt 0 or pattern match engine slice 0
388 PIN_INT1_IRQHandler, // 21 : Pin interrupt 1or pattern match engine slice 1
389 PIN_INT2_IRQHandler, // 22 : Pin interrupt 2 or pattern match engine slice 2
390 PIN_INT3_IRQHandler, // 23 : Pin interrupt 3 or pattern match engine slice 3
391 UTICK0_IRQHandler, // 24 : Micro-tick Timer
392 MRT0_IRQHandler, // 25 : Multi-rate timer
393 CTIMER0_IRQHandler, // 26 : Standard counter/timer CTIMER0
394 CTIMER1_IRQHandler, // 27 : Standard counter/timer CTIMER1
395 SCT0_IRQHandler, // 28 : SCTimer/PWM
396 CTIMER3_IRQHandler, // 29 : Standard counter/timer CTIMER3
397 FLEXCOMM0_IRQHandler, // 30 : Flexcomm Interface 0 (USART, SPI, I2C, I2S, FLEXCOMM)
398 FLEXCOMM1_IRQHandler, // 31 : Flexcomm Interface 1 (USART, SPI, I2C, I2S, FLEXCOMM)
399 FLEXCOMM2_IRQHandler, // 32 : Flexcomm Interface 2 (USART, SPI, I2C, I2S, FLEXCOMM)
400 FLEXCOMM3_IRQHandler, // 33 : Flexcomm Interface 3 (USART, SPI, I2C, I2S, FLEXCOMM)
401 FLEXCOMM4_IRQHandler, // 34 : Flexcomm Interface 4 (USART, SPI, I2C, I2S, FLEXCOMM)
402 FLEXCOMM5_IRQHandler, // 35 : Flexcomm Interface 5 (USART, SPI, I2C, I2S, FLEXCOMM)
403 FLEXCOMM6_IRQHandler, // 36 : Flexcomm Interface 6 (USART, SPI, I2C, I2S, FLEXCOMM)
404 FLEXCOMM7_IRQHandler, // 37 : Flexcomm Interface 7 (USART, SPI, I2C, I2S, FLEXCOMM)
405 ADC0_IRQHandler, // 38 : ADC0
406 ADC1_IRQHandler, // 39 : ADC1
407 ACMP_IRQHandler, // 40 : ACMP interrupts
408 DMIC_IRQHandler, // 41 : Digital microphone and DMIC subsystem
409 HWVAD0_IRQHandler, // 42 : Hardware Voice Activity Detector
410 USB0_NEEDCLK_IRQHandler, // 43 : USB Activity Wake-up Interrupt
411 USB0_IRQHandler, // 44 : USB device
412 RTC_IRQHandler, // 45 : RTC alarm and wake-up interrupts
413 EZH_ARCH_B0_IRQHandler, // 46 : EZH interrupt
414 WAKEUP_IRQHandler, // 47 : Wakeup interrupt
415 PIN_INT4_IRQHandler, // 48 : Pin interrupt 4 or pattern match engine slice 4 int
416 PIN_INT5_IRQHandler, // 49 : Pin interrupt 5 or pattern match engine slice 5 int
417 PIN_INT6_IRQHandler, // 50 : Pin interrupt 6 or pattern match engine slice 6 int
418 PIN_INT7_IRQHandler, // 51 : Pin interrupt 7 or pattern match engine slice 7 int
419 CTIMER2_IRQHandler, // 52 : Standard counter/timer CTIMER2
420 CTIMER4_IRQHandler, // 53 : Standard counter/timer CTIMER4
421 OS_EVENT_IRQHandler, // 54 : OS_EVENT_TIMER and OS_EVENT_WAKEUP interrupts
422 FlexSPI0_IRQHandler, // 55 : FlexSPI interrupt
423 Reserved56_IRQHandler, // 56 : Reserved interrupt
424 Reserved57_IRQHandler, // 57 : Reserved interrupt
425 Reserved58_IRQHandler, // 58 : Reserved interrupt
426 CAN0_IRQ0_IRQHandler, // 59 : CAN0 interrupt0
427 CAN0_IRQ1_IRQHandler, // 60 : CAN0 interrupt1
428 SPI_FILTER_IRQHandler, // 61 : SPI Filter interrupt
429 Reserved62_IRQHandler, // 62 : Reserved interrupt
430 Reserved63_IRQHandler, // 63 : Reserved interrupt
431 Reserved64_IRQHandler, // 64 : Reserved interrupt
432 SEC_HYPERVISOR_CALL_IRQHandler, // 65 : SEC_HYPERVISOR_CALL interrupt
433 SEC_GPIO_INT0_IRQ0_IRQHandler, // 66 : SEC_GPIO_INT00 interrupt
434 SEC_GPIO_INT0_IRQ1_IRQHandler, // 67 : SEC_GPIO_INT01 interrupt
435 Freqme_IRQHandler, // 68 : frequency measure interrupt
436 SEC_VIO_IRQHandler, // 69 : SEC_VIO interrupt
437 ELS_IRQHandler, // 70 : ELS and ELS error interrupts
438 PKC_IRQHandler, // 71 : Public Key Cryptography interrupt
439 PUF_IRQHandler, // 72 : PUF interrupt
440 POWERQUAD_IRQHandler, // 73 : PowerQuad interrupt
441 DMA1_IRQHandler, // 74 : DMA1 interrupt
442 FLEXCOMM8_IRQHandler, // 75 : LSPI_HS interrupt
443 CDOG_IRQHandler, // 76 : CodeWDG interrupt
444 Reserved77_IRQHandler, // 77 : Reserved interrupt
445 I3C0_IRQHandler, // 78 : I3C interrupt
446 Reserved79_IRQHandler, // 79 : Reserved interrupt
447 Reserved80_IRQHandler, // 80 : Reserved interrupt
448 ELS_IRQ1_IRQHandler, // 81 : ELS_IRQ1
449 Tamper_IRQHandler, // 82 : Tamper
450 Reserved83_IRQHandler, // 83 : Reserved interrupt
451 Reserved84_IRQHandler, // 84 : Reserved interrupt
452 Reserved85_IRQHandler, // 85 : Reserved interrupt
453 Reserved86_IRQHandler, // 86 : Reserved interrupt
454 Reserved87_IRQHandler, // 87 : Reserved interrupt
455 Reserved88_IRQHandler, // 88 : Reserved interrupt
456 Reserved89_IRQHandler, // 89 : Reserved interrupt
457 DAC0_IRQHandler, // 90 : dac0 interrupt
458 DAC1_IRQHandler, // 91 : dac1 interrupt
459 DAC2_IRQHandler, // 92 : dac2 interrupt
460 HSCMP0_IRQHandler, // 93 : hscmp0 interrupt
461 HSCMP1_IRQHandler, // 94 : hscmp1 interrupt
462 HSCMP2_IRQHandler, // 95 : hscmp2 interrupt
463 FLEXPWM0_CAPTURE_IRQHandler, // 96 : flexpwm0_capture interrupt
464 FLEXPWM0_FAULT_IRQHandler, // 97 : flexpwm0_fault interrupt
465 FLEXPWM0_RELOAD_ERROR_IRQHandler, // 98 : flexpwm0_reload_error interrupt
466 FLEXPWM0_COMPARE0_IRQHandler, // 99 : flexpwm0_compare0 interrupt
467 FLEXPWM0_RELOAD0_IRQHandler, // 100: flexpwm0_reload0 interrupt
468 FLEXPWM0_COMPARE1_IRQHandler, // 101: flexpwm0_compare1 interrupt
469 FLEXPWM0_RELOAD1_IRQHandler, // 102: flexpwm0_reload1 interrupt
470 FLEXPWM0_COMPARE2_IRQHandler, // 103: flexpwm0_compare2 interrupt
471 FLEXPWM0_RELOAD2_IRQHandler, // 104: flexpwm0_reload2 interrupt
472 FLEXPWM0_COMPARE3_IRQHandler, // 105: flexpwm0_compare3 interrupt
473 FLEXPWM0_RELOAD3_IRQHandler, // 106: flexpwm0_reload3 interrupt
474 FLEXPWM1_CAPTURE_IRQHandler, // 107: flexpwm1_capture interrupt
475 FLEXPWM1_FAULT_IRQHandler, // 108: flexpwm1_fault interrupt
476 FLEXPWM1_RELOAD_ERROR_IRQHandler, // 109: flexpwm1_reload_error interrupt
477 FLEXPWM1_COMPARE0_IRQHandler, // 110: flexpwm1_compare0 interrupt
478 FLEXPWM1_RELOAD0_IRQHandler, // 111: flexpwm1_reload0 interrupt
479 FLEXPWM1_COMPARE1_IRQHandler, // 112: flexpwm1_compare1 interrupt
480 FLEXPWM1_RELOAD1_IRQHandler, // 113: flexpwm1_reload1 interrupt
481 FLEXPWM1_COMPARE2_IRQHandler, // 114: flexpwm1_compare2 interrupt
482 FLEXPWM1_RELOAD2_IRQHandler, // 115: flexpwm1_reload2 interrupt
483 FLEXPWM1_COMPARE3_IRQHandler, // 116: flexpwm1_compare3 interrupt
484 FLEXPWM1_RELOAD3_IRQHandler, // 117: flexpwm1_reload3 interrupt
485 ENC0_COMPARE_IRQHandler, // 118: enc0_compare interrupt
486 ENC0_HOME_IRQHandler, // 119: enc0_home interrupt
487 ENC0_WDG_IRQHandler, // 120: enc0_wdg interrupt
488 ENC0_IDX_IRQHandler, // 121: enc0_idx interrupt
489 ENC1_COMPARE_IRQHandler, // 122: enc1_compare interrupt
490 ENC1_HOME_IRQHandler, // 123: enc1_home interrupt
491 ENC1_WDG_IRQHandler, // 124: enc1_wdg interrupt
492 ENC1_IDX_IRQHandler, // 125: enc1_idx interrupt
493 ITRC0_IRQHandler, // 126: itrc0 interrupt
494 Reserved127_IRQHandler, // 127: Reserved interrupt
495 ELS_ERR_IRQHandler, // 128: ELS error interrupt
496 PKC_ERR_IRQHandler, // 129: PKC error interrupt
497 Reserved130_IRQHandler, // 130: Reserved interrupt
498 Reserved131_IRQHandler, // 131: Reserved interrupt
499 Reserved132_IRQHandler, // 132: Reserved interrupt
500 Reserved133_IRQHandler, // 133: Reserved interrupt
501 FLASH_IRQHandler, // 134: flash interrupt
502 RAM_PARITY_ECC_ERR_IRQHandler, // 135: ram_parity_ecc_err interrupt
503 }; /* End of g_pfnVectors */
504
505 //*****************************************************************************
506 // Functions to carry out the initialization of RW and BSS data sections. These
507 // are written as separate functions rather than being inlined within the
508 // ResetISR() function in order to cope with MCUs with multiple banks of
509 // memory.
510 //*****************************************************************************
511 __attribute__ ((section(".after_vectors.init_data")))
data_init(unsigned int romstart,unsigned int start,unsigned int len)512 void data_init(unsigned int romstart, unsigned int start, unsigned int len) {
513 unsigned int *pulDest = (unsigned int*) start;
514 unsigned int *pulSrc = (unsigned int*) romstart;
515 unsigned int loop;
516 for (loop = 0; loop < len; loop = loop + 4)
517 *pulDest++ = *pulSrc++;
518 }
519
520 __attribute__ ((section(".after_vectors.init_bss")))
bss_init(unsigned int start,unsigned int len)521 void bss_init(unsigned int start, unsigned int len) {
522 unsigned int *pulDest = (unsigned int*) start;
523 unsigned int loop;
524 for (loop = 0; loop < len; loop = loop + 4)
525 *pulDest++ = 0;
526 }
527
528 //*****************************************************************************
529 // The following symbols are constructs generated by the linker, indicating
530 // the location of various points in the "Global Section Table". This table is
531 // created by the linker via the Code Red managed linker script mechanism. It
532 // contains the load address, execution address and length of each RW data
533 // section and the execution and length of each BSS (zero initialized) section.
534 //*****************************************************************************
535 extern unsigned int __data_section_table;
536 extern unsigned int __data_section_table_end;
537 extern unsigned int __bss_section_table;
538 extern unsigned int __bss_section_table_end;
539
540 //*****************************************************************************
541 // Reset entry point for your code.
542 // Sets up a simple runtime environment and initializes the C/C++
543 // library.
544 //*****************************************************************************
545 __attribute__ ((naked, section(".after_vectors.reset")))
ResetISR(void)546 void ResetISR(void) {
547 // Disable interrupts
548 __asm volatile ("cpsid i");
549 // Config VTOR & MSPLIM register
550 __asm volatile ("LDR R0, =0xE000ED08 \n"
551 "STR %0, [R0] \n"
552 "LDR R1, [%0] \n"
553 "MSR MSP, R1 \n"
554 "MSR MSPLIM, %1 \n"
555 :
556 : "r"(g_pfnVectors), "r"(_vStackBase)
557 : "r0", "r1");
558
559
560 #if defined (__USE_CMSIS)
561 // If __USE_CMSIS defined, then call CMSIS SystemInit code
562 SystemInit();
563
564 #endif // (__USE_CMSIS)
565
566 //
567 // Copy the data sections from flash to SRAM.
568 //
569 unsigned int LoadAddr, ExeAddr, SectionLen;
570 unsigned int *SectionTableAddr;
571
572 // Load base address of Global Section Table
573 SectionTableAddr = &__data_section_table;
574
575 // Copy the data sections from flash to SRAM.
576 while (SectionTableAddr < &__data_section_table_end) {
577 LoadAddr = *SectionTableAddr++;
578 ExeAddr = *SectionTableAddr++;
579 SectionLen = *SectionTableAddr++;
580 data_init(LoadAddr, ExeAddr, SectionLen);
581 }
582
583 // At this point, SectionTableAddr = &__bss_section_table;
584 // Zero fill the bss segment
585 while (SectionTableAddr < &__bss_section_table_end) {
586 ExeAddr = *SectionTableAddr++;
587 SectionLen = *SectionTableAddr++;
588 bss_init(ExeAddr, SectionLen);
589 }
590
591 #if !defined (__USE_CMSIS)
592 // Assume that if __USE_CMSIS defined, then CMSIS SystemInit code
593 // will setup the VTOR register
594
595 // Check to see if we are running the code from a non-zero
596 // address (eg RAM, external flash), in which case we need
597 // to modify the VTOR register to tell the CPU that the
598 // vector table is located at a non-0x0 address.
599 unsigned int * pSCB_VTOR = (unsigned int *) 0xE000ED08;
600 if ((unsigned int *)g_pfnVectors!=(unsigned int *) 0x00000000) {
601 *pSCB_VTOR = (unsigned int)g_pfnVectors;
602 }
603 #endif // (__USE_CMSIS)
604 #if defined (__cplusplus)
605 //
606 // Call C++ library initialisation
607 //
608 __libc_init_array();
609 #endif
610
611 // Reenable interrupts
612 __asm volatile ("cpsie i");
613
614 #if defined (__REDLIB__)
615 // Call the Redlib library, which in turn calls main()
616 __main();
617 #else
618 main();
619 #endif
620
621 //
622 // main() shouldn't return, but if it does, we'll just enter an infinite loop
623 //
624 while (1) {
625 ;
626 }
627 }
628
629 //*****************************************************************************
630 // Default core exception handlers. Override the ones here by defining your own
631 // handler routines in your application code.
632 //*****************************************************************************
NMI_Handler(void)633 WEAK_AV void NMI_Handler(void)
634 { while(1) {}
635 }
636
HardFault_Handler(void)637 WEAK_AV void HardFault_Handler(void)
638 { while(1) {}
639 }
640
MemManage_Handler(void)641 WEAK_AV void MemManage_Handler(void)
642 { while(1) {}
643 }
644
BusFault_Handler(void)645 WEAK_AV void BusFault_Handler(void)
646 { while(1) {}
647 }
648
UsageFault_Handler(void)649 WEAK_AV void UsageFault_Handler(void)
650 { while(1) {}
651 }
652
SecureFault_Handler(void)653 WEAK_AV void SecureFault_Handler(void)
654 { while(1) {}
655 }
656
SVC_Handler(void)657 WEAK_AV void SVC_Handler(void)
658 { while(1) {}
659 }
660
DebugMon_Handler(void)661 WEAK_AV void DebugMon_Handler(void)
662 { while(1) {}
663 }
664
PendSV_Handler(void)665 WEAK_AV void PendSV_Handler(void)
666 { while(1) {}
667 }
668
SysTick_Handler(void)669 WEAK_AV void SysTick_Handler(void)
670 { while(1) {}
671 }
672
673 //*****************************************************************************
674 // Processor ends up here if an unexpected interrupt occurs or a specific
675 // handler is not present in the application code.
676 //*****************************************************************************
IntDefaultHandler(void)677 WEAK_AV void IntDefaultHandler(void)
678 { while(1) {}
679 }
680
681 //*****************************************************************************
682 // Default application exception handlers. Override the ones here by defining
683 // your own handler routines in your application code. These routines call
684 // driver exception handlers or IntDefaultHandler() if no driver exception
685 // handler is included.
686 //*****************************************************************************
WDT_BOD_IRQHandler(void)687 WEAK void WDT_BOD_IRQHandler(void)
688 { WDT_BOD_DriverIRQHandler();
689 }
690
DMA0_IRQHandler(void)691 WEAK void DMA0_IRQHandler(void)
692 { DMA0_DriverIRQHandler();
693 }
694
GINT0_IRQHandler(void)695 WEAK void GINT0_IRQHandler(void)
696 { GINT0_DriverIRQHandler();
697 }
698
GINT1_IRQHandler(void)699 WEAK void GINT1_IRQHandler(void)
700 { GINT1_DriverIRQHandler();
701 }
702
PIN_INT0_IRQHandler(void)703 WEAK void PIN_INT0_IRQHandler(void)
704 { PIN_INT0_DriverIRQHandler();
705 }
706
PIN_INT1_IRQHandler(void)707 WEAK void PIN_INT1_IRQHandler(void)
708 { PIN_INT1_DriverIRQHandler();
709 }
710
PIN_INT2_IRQHandler(void)711 WEAK void PIN_INT2_IRQHandler(void)
712 { PIN_INT2_DriverIRQHandler();
713 }
714
PIN_INT3_IRQHandler(void)715 WEAK void PIN_INT3_IRQHandler(void)
716 { PIN_INT3_DriverIRQHandler();
717 }
718
UTICK0_IRQHandler(void)719 WEAK void UTICK0_IRQHandler(void)
720 { UTICK0_DriverIRQHandler();
721 }
722
MRT0_IRQHandler(void)723 WEAK void MRT0_IRQHandler(void)
724 { MRT0_DriverIRQHandler();
725 }
726
CTIMER0_IRQHandler(void)727 WEAK void CTIMER0_IRQHandler(void)
728 { CTIMER0_DriverIRQHandler();
729 }
730
CTIMER1_IRQHandler(void)731 WEAK void CTIMER1_IRQHandler(void)
732 { CTIMER1_DriverIRQHandler();
733 }
734
SCT0_IRQHandler(void)735 WEAK void SCT0_IRQHandler(void)
736 { SCT0_DriverIRQHandler();
737 }
738
CTIMER3_IRQHandler(void)739 WEAK void CTIMER3_IRQHandler(void)
740 { CTIMER3_DriverIRQHandler();
741 }
742
FLEXCOMM0_IRQHandler(void)743 WEAK void FLEXCOMM0_IRQHandler(void)
744 { FLEXCOMM0_DriverIRQHandler();
745 }
746
FLEXCOMM1_IRQHandler(void)747 WEAK void FLEXCOMM1_IRQHandler(void)
748 { FLEXCOMM1_DriverIRQHandler();
749 }
750
FLEXCOMM2_IRQHandler(void)751 WEAK void FLEXCOMM2_IRQHandler(void)
752 { FLEXCOMM2_DriverIRQHandler();
753 }
754
FLEXCOMM3_IRQHandler(void)755 WEAK void FLEXCOMM3_IRQHandler(void)
756 { FLEXCOMM3_DriverIRQHandler();
757 }
758
FLEXCOMM4_IRQHandler(void)759 WEAK void FLEXCOMM4_IRQHandler(void)
760 { FLEXCOMM4_DriverIRQHandler();
761 }
762
FLEXCOMM5_IRQHandler(void)763 WEAK void FLEXCOMM5_IRQHandler(void)
764 { FLEXCOMM5_DriverIRQHandler();
765 }
766
FLEXCOMM6_IRQHandler(void)767 WEAK void FLEXCOMM6_IRQHandler(void)
768 { FLEXCOMM6_DriverIRQHandler();
769 }
770
FLEXCOMM7_IRQHandler(void)771 WEAK void FLEXCOMM7_IRQHandler(void)
772 { FLEXCOMM7_DriverIRQHandler();
773 }
774
ADC0_IRQHandler(void)775 WEAK void ADC0_IRQHandler(void)
776 { ADC0_DriverIRQHandler();
777 }
778
ADC1_IRQHandler(void)779 WEAK void ADC1_IRQHandler(void)
780 { ADC1_DriverIRQHandler();
781 }
782
ACMP_IRQHandler(void)783 WEAK void ACMP_IRQHandler(void)
784 { ACMP_DriverIRQHandler();
785 }
786
DMIC_IRQHandler(void)787 WEAK void DMIC_IRQHandler(void)
788 { DMIC_DriverIRQHandler();
789 }
790
HWVAD0_IRQHandler(void)791 WEAK void HWVAD0_IRQHandler(void)
792 { HWVAD0_DriverIRQHandler();
793 }
794
USB0_NEEDCLK_IRQHandler(void)795 WEAK void USB0_NEEDCLK_IRQHandler(void)
796 { USB0_NEEDCLK_DriverIRQHandler();
797 }
798
USB0_IRQHandler(void)799 WEAK void USB0_IRQHandler(void)
800 { USB0_DriverIRQHandler();
801 }
802
RTC_IRQHandler(void)803 WEAK void RTC_IRQHandler(void)
804 { RTC_DriverIRQHandler();
805 }
806
EZH_ARCH_B0_IRQHandler(void)807 WEAK void EZH_ARCH_B0_IRQHandler(void)
808 { EZH_ARCH_B0_DriverIRQHandler();
809 }
810
WAKEUP_IRQHandler(void)811 WEAK void WAKEUP_IRQHandler(void)
812 { WAKEUP_DriverIRQHandler();
813 }
814
PIN_INT4_IRQHandler(void)815 WEAK void PIN_INT4_IRQHandler(void)
816 { PIN_INT4_DriverIRQHandler();
817 }
818
PIN_INT5_IRQHandler(void)819 WEAK void PIN_INT5_IRQHandler(void)
820 { PIN_INT5_DriverIRQHandler();
821 }
822
PIN_INT6_IRQHandler(void)823 WEAK void PIN_INT6_IRQHandler(void)
824 { PIN_INT6_DriverIRQHandler();
825 }
826
PIN_INT7_IRQHandler(void)827 WEAK void PIN_INT7_IRQHandler(void)
828 { PIN_INT7_DriverIRQHandler();
829 }
830
CTIMER2_IRQHandler(void)831 WEAK void CTIMER2_IRQHandler(void)
832 { CTIMER2_DriverIRQHandler();
833 }
834
CTIMER4_IRQHandler(void)835 WEAK void CTIMER4_IRQHandler(void)
836 { CTIMER4_DriverIRQHandler();
837 }
838
OS_EVENT_IRQHandler(void)839 WEAK void OS_EVENT_IRQHandler(void)
840 { OS_EVENT_DriverIRQHandler();
841 }
842
FlexSPI0_IRQHandler(void)843 WEAK void FlexSPI0_IRQHandler(void)
844 { FlexSPI0_DriverIRQHandler();
845 }
846
Reserved56_IRQHandler(void)847 WEAK void Reserved56_IRQHandler(void)
848 { Reserved56_DriverIRQHandler();
849 }
850
Reserved57_IRQHandler(void)851 WEAK void Reserved57_IRQHandler(void)
852 { Reserved57_DriverIRQHandler();
853 }
854
Reserved58_IRQHandler(void)855 WEAK void Reserved58_IRQHandler(void)
856 { Reserved58_DriverIRQHandler();
857 }
858
CAN0_IRQ0_IRQHandler(void)859 WEAK void CAN0_IRQ0_IRQHandler(void)
860 { CAN0_IRQ0_DriverIRQHandler();
861 }
862
CAN0_IRQ1_IRQHandler(void)863 WEAK void CAN0_IRQ1_IRQHandler(void)
864 { CAN0_IRQ1_DriverIRQHandler();
865 }
866
SPI_FILTER_IRQHandler(void)867 WEAK void SPI_FILTER_IRQHandler(void)
868 { SPI_FILTER_DriverIRQHandler();
869 }
870
Reserved62_IRQHandler(void)871 WEAK void Reserved62_IRQHandler(void)
872 { Reserved62_DriverIRQHandler();
873 }
874
Reserved63_IRQHandler(void)875 WEAK void Reserved63_IRQHandler(void)
876 { Reserved63_DriverIRQHandler();
877 }
878
Reserved64_IRQHandler(void)879 WEAK void Reserved64_IRQHandler(void)
880 { Reserved64_DriverIRQHandler();
881 }
882
SEC_HYPERVISOR_CALL_IRQHandler(void)883 WEAK void SEC_HYPERVISOR_CALL_IRQHandler(void)
884 { SEC_HYPERVISOR_CALL_DriverIRQHandler();
885 }
886
SEC_GPIO_INT0_IRQ0_IRQHandler(void)887 WEAK void SEC_GPIO_INT0_IRQ0_IRQHandler(void)
888 { SEC_GPIO_INT0_IRQ0_DriverIRQHandler();
889 }
890
SEC_GPIO_INT0_IRQ1_IRQHandler(void)891 WEAK void SEC_GPIO_INT0_IRQ1_IRQHandler(void)
892 { SEC_GPIO_INT0_IRQ1_DriverIRQHandler();
893 }
894
Freqme_IRQHandler(void)895 WEAK void Freqme_IRQHandler(void)
896 { Freqme_DriverIRQHandler();
897 }
898
SEC_VIO_IRQHandler(void)899 WEAK void SEC_VIO_IRQHandler(void)
900 { SEC_VIO_DriverIRQHandler();
901 }
902
ELS_IRQHandler(void)903 WEAK void ELS_IRQHandler(void)
904 { ELS_DriverIRQHandler();
905 }
906
PKC_IRQHandler(void)907 WEAK void PKC_IRQHandler(void)
908 { PKC_DriverIRQHandler();
909 }
910
PUF_IRQHandler(void)911 WEAK void PUF_IRQHandler(void)
912 { PUF_DriverIRQHandler();
913 }
914
POWERQUAD_IRQHandler(void)915 WEAK void POWERQUAD_IRQHandler(void)
916 { POWERQUAD_DriverIRQHandler();
917 }
918
DMA1_IRQHandler(void)919 WEAK void DMA1_IRQHandler(void)
920 { DMA1_DriverIRQHandler();
921 }
922
FLEXCOMM8_IRQHandler(void)923 WEAK void FLEXCOMM8_IRQHandler(void)
924 { FLEXCOMM8_DriverIRQHandler();
925 }
926
CDOG_IRQHandler(void)927 WEAK void CDOG_IRQHandler(void)
928 { CDOG_DriverIRQHandler();
929 }
930
Reserved77_IRQHandler(void)931 WEAK void Reserved77_IRQHandler(void)
932 { Reserved77_DriverIRQHandler();
933 }
934
I3C0_IRQHandler(void)935 WEAK void I3C0_IRQHandler(void)
936 { I3C0_DriverIRQHandler();
937 }
938
Reserved79_IRQHandler(void)939 WEAK void Reserved79_IRQHandler(void)
940 { Reserved79_DriverIRQHandler();
941 }
942
Reserved80_IRQHandler(void)943 WEAK void Reserved80_IRQHandler(void)
944 { Reserved80_DriverIRQHandler();
945 }
946
ELS_IRQ1_IRQHandler(void)947 WEAK void ELS_IRQ1_IRQHandler(void)
948 { ELS_IRQ1_DriverIRQHandler();
949 }
950
Tamper_IRQHandler(void)951 WEAK void Tamper_IRQHandler(void)
952 { Tamper_DriverIRQHandler();
953 }
954
Reserved83_IRQHandler(void)955 WEAK void Reserved83_IRQHandler(void)
956 { Reserved83_DriverIRQHandler();
957 }
958
Reserved84_IRQHandler(void)959 WEAK void Reserved84_IRQHandler(void)
960 { Reserved84_DriverIRQHandler();
961 }
962
Reserved85_IRQHandler(void)963 WEAK void Reserved85_IRQHandler(void)
964 { Reserved85_DriverIRQHandler();
965 }
966
Reserved86_IRQHandler(void)967 WEAK void Reserved86_IRQHandler(void)
968 { Reserved86_DriverIRQHandler();
969 }
970
Reserved87_IRQHandler(void)971 WEAK void Reserved87_IRQHandler(void)
972 { Reserved87_DriverIRQHandler();
973 }
974
Reserved88_IRQHandler(void)975 WEAK void Reserved88_IRQHandler(void)
976 { Reserved88_DriverIRQHandler();
977 }
978
Reserved89_IRQHandler(void)979 WEAK void Reserved89_IRQHandler(void)
980 { Reserved89_DriverIRQHandler();
981 }
982
DAC0_IRQHandler(void)983 WEAK void DAC0_IRQHandler(void)
984 { DAC0_DriverIRQHandler();
985 }
986
DAC1_IRQHandler(void)987 WEAK void DAC1_IRQHandler(void)
988 { DAC1_DriverIRQHandler();
989 }
990
DAC2_IRQHandler(void)991 WEAK void DAC2_IRQHandler(void)
992 { DAC2_DriverIRQHandler();
993 }
994
HSCMP0_IRQHandler(void)995 WEAK void HSCMP0_IRQHandler(void)
996 { HSCMP0_DriverIRQHandler();
997 }
998
HSCMP1_IRQHandler(void)999 WEAK void HSCMP1_IRQHandler(void)
1000 { HSCMP1_DriverIRQHandler();
1001 }
1002
HSCMP2_IRQHandler(void)1003 WEAK void HSCMP2_IRQHandler(void)
1004 { HSCMP2_DriverIRQHandler();
1005 }
1006
FLEXPWM0_CAPTURE_IRQHandler(void)1007 WEAK void FLEXPWM0_CAPTURE_IRQHandler(void)
1008 { FLEXPWM0_CAPTURE_DriverIRQHandler();
1009 }
1010
FLEXPWM0_FAULT_IRQHandler(void)1011 WEAK void FLEXPWM0_FAULT_IRQHandler(void)
1012 { FLEXPWM0_FAULT_DriverIRQHandler();
1013 }
1014
FLEXPWM0_RELOAD_ERROR_IRQHandler(void)1015 WEAK void FLEXPWM0_RELOAD_ERROR_IRQHandler(void)
1016 { FLEXPWM0_RELOAD_ERROR_DriverIRQHandler();
1017 }
1018
FLEXPWM0_COMPARE0_IRQHandler(void)1019 WEAK void FLEXPWM0_COMPARE0_IRQHandler(void)
1020 { FLEXPWM0_COMPARE0_DriverIRQHandler();
1021 }
1022
FLEXPWM0_RELOAD0_IRQHandler(void)1023 WEAK void FLEXPWM0_RELOAD0_IRQHandler(void)
1024 { FLEXPWM0_RELOAD0_DriverIRQHandler();
1025 }
1026
FLEXPWM0_COMPARE1_IRQHandler(void)1027 WEAK void FLEXPWM0_COMPARE1_IRQHandler(void)
1028 { FLEXPWM0_COMPARE1_DriverIRQHandler();
1029 }
1030
FLEXPWM0_RELOAD1_IRQHandler(void)1031 WEAK void FLEXPWM0_RELOAD1_IRQHandler(void)
1032 { FLEXPWM0_RELOAD1_DriverIRQHandler();
1033 }
1034
FLEXPWM0_COMPARE2_IRQHandler(void)1035 WEAK void FLEXPWM0_COMPARE2_IRQHandler(void)
1036 { FLEXPWM0_COMPARE2_DriverIRQHandler();
1037 }
1038
FLEXPWM0_RELOAD2_IRQHandler(void)1039 WEAK void FLEXPWM0_RELOAD2_IRQHandler(void)
1040 { FLEXPWM0_RELOAD2_DriverIRQHandler();
1041 }
1042
FLEXPWM0_COMPARE3_IRQHandler(void)1043 WEAK void FLEXPWM0_COMPARE3_IRQHandler(void)
1044 { FLEXPWM0_COMPARE3_DriverIRQHandler();
1045 }
1046
FLEXPWM0_RELOAD3_IRQHandler(void)1047 WEAK void FLEXPWM0_RELOAD3_IRQHandler(void)
1048 { FLEXPWM0_RELOAD3_DriverIRQHandler();
1049 }
1050
FLEXPWM1_CAPTURE_IRQHandler(void)1051 WEAK void FLEXPWM1_CAPTURE_IRQHandler(void)
1052 { FLEXPWM1_CAPTURE_DriverIRQHandler();
1053 }
1054
FLEXPWM1_FAULT_IRQHandler(void)1055 WEAK void FLEXPWM1_FAULT_IRQHandler(void)
1056 { FLEXPWM1_FAULT_DriverIRQHandler();
1057 }
1058
FLEXPWM1_RELOAD_ERROR_IRQHandler(void)1059 WEAK void FLEXPWM1_RELOAD_ERROR_IRQHandler(void)
1060 { FLEXPWM1_RELOAD_ERROR_DriverIRQHandler();
1061 }
1062
FLEXPWM1_COMPARE0_IRQHandler(void)1063 WEAK void FLEXPWM1_COMPARE0_IRQHandler(void)
1064 { FLEXPWM1_COMPARE0_DriverIRQHandler();
1065 }
1066
FLEXPWM1_RELOAD0_IRQHandler(void)1067 WEAK void FLEXPWM1_RELOAD0_IRQHandler(void)
1068 { FLEXPWM1_RELOAD0_DriverIRQHandler();
1069 }
1070
FLEXPWM1_COMPARE1_IRQHandler(void)1071 WEAK void FLEXPWM1_COMPARE1_IRQHandler(void)
1072 { FLEXPWM1_COMPARE1_DriverIRQHandler();
1073 }
1074
FLEXPWM1_RELOAD1_IRQHandler(void)1075 WEAK void FLEXPWM1_RELOAD1_IRQHandler(void)
1076 { FLEXPWM1_RELOAD1_DriverIRQHandler();
1077 }
1078
FLEXPWM1_COMPARE2_IRQHandler(void)1079 WEAK void FLEXPWM1_COMPARE2_IRQHandler(void)
1080 { FLEXPWM1_COMPARE2_DriverIRQHandler();
1081 }
1082
FLEXPWM1_RELOAD2_IRQHandler(void)1083 WEAK void FLEXPWM1_RELOAD2_IRQHandler(void)
1084 { FLEXPWM1_RELOAD2_DriverIRQHandler();
1085 }
1086
FLEXPWM1_COMPARE3_IRQHandler(void)1087 WEAK void FLEXPWM1_COMPARE3_IRQHandler(void)
1088 { FLEXPWM1_COMPARE3_DriverIRQHandler();
1089 }
1090
FLEXPWM1_RELOAD3_IRQHandler(void)1091 WEAK void FLEXPWM1_RELOAD3_IRQHandler(void)
1092 { FLEXPWM1_RELOAD3_DriverIRQHandler();
1093 }
1094
ENC0_COMPARE_IRQHandler(void)1095 WEAK void ENC0_COMPARE_IRQHandler(void)
1096 { ENC0_COMPARE_DriverIRQHandler();
1097 }
1098
ENC0_HOME_IRQHandler(void)1099 WEAK void ENC0_HOME_IRQHandler(void)
1100 { ENC0_HOME_DriverIRQHandler();
1101 }
1102
ENC0_WDG_IRQHandler(void)1103 WEAK void ENC0_WDG_IRQHandler(void)
1104 { ENC0_WDG_DriverIRQHandler();
1105 }
1106
ENC0_IDX_IRQHandler(void)1107 WEAK void ENC0_IDX_IRQHandler(void)
1108 { ENC0_IDX_DriverIRQHandler();
1109 }
1110
ENC1_COMPARE_IRQHandler(void)1111 WEAK void ENC1_COMPARE_IRQHandler(void)
1112 { ENC1_COMPARE_DriverIRQHandler();
1113 }
1114
ENC1_HOME_IRQHandler(void)1115 WEAK void ENC1_HOME_IRQHandler(void)
1116 { ENC1_HOME_DriverIRQHandler();
1117 }
1118
ENC1_WDG_IRQHandler(void)1119 WEAK void ENC1_WDG_IRQHandler(void)
1120 { ENC1_WDG_DriverIRQHandler();
1121 }
1122
ENC1_IDX_IRQHandler(void)1123 WEAK void ENC1_IDX_IRQHandler(void)
1124 { ENC1_IDX_DriverIRQHandler();
1125 }
1126
ITRC0_IRQHandler(void)1127 WEAK void ITRC0_IRQHandler(void)
1128 { ITRC0_DriverIRQHandler();
1129 }
1130
Reserved127_IRQHandler(void)1131 WEAK void Reserved127_IRQHandler(void)
1132 { Reserved127_DriverIRQHandler();
1133 }
1134
ELS_ERR_IRQHandler(void)1135 WEAK void ELS_ERR_IRQHandler(void)
1136 { ELS_ERR_DriverIRQHandler();
1137 }
1138
PKC_ERR_IRQHandler(void)1139 WEAK void PKC_ERR_IRQHandler(void)
1140 { PKC_ERR_DriverIRQHandler();
1141 }
1142
Reserved130_IRQHandler(void)1143 WEAK void Reserved130_IRQHandler(void)
1144 { Reserved130_DriverIRQHandler();
1145 }
1146
Reserved131_IRQHandler(void)1147 WEAK void Reserved131_IRQHandler(void)
1148 { Reserved131_DriverIRQHandler();
1149 }
1150
Reserved132_IRQHandler(void)1151 WEAK void Reserved132_IRQHandler(void)
1152 { Reserved132_DriverIRQHandler();
1153 }
1154
Reserved133_IRQHandler(void)1155 WEAK void Reserved133_IRQHandler(void)
1156 { Reserved133_DriverIRQHandler();
1157 }
1158
FLASH_IRQHandler(void)1159 WEAK void FLASH_IRQHandler(void)
1160 { FLASH_DriverIRQHandler();
1161 }
1162
RAM_PARITY_ECC_ERR_IRQHandler(void)1163 WEAK void RAM_PARITY_ECC_ERR_IRQHandler(void)
1164 { RAM_PARITY_ECC_ERR_DriverIRQHandler();
1165 }
1166
1167 //*****************************************************************************
1168
1169 #if defined (DEBUG)
1170 #pragma GCC pop_options
1171 #endif // (DEBUG)
1172
