aboutsummaryrefslogtreecommitdiff
path: root/lib/chibios-contrib/ext/mcux-sdk/devices/MIMXRT633S/mcuxpresso/startup_mimxrt633s.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'lib/chibios-contrib/ext/mcux-sdk/devices/MIMXRT633S/mcuxpresso/startup_mimxrt633s.cpp')
-rw-r--r--lib/chibios-contrib/ext/mcux-sdk/devices/MIMXRT633S/mcuxpresso/startup_mimxrt633s.cpp758
1 files changed, 758 insertions, 0 deletions
diff --git a/lib/chibios-contrib/ext/mcux-sdk/devices/MIMXRT633S/mcuxpresso/startup_mimxrt633s.cpp b/lib/chibios-contrib/ext/mcux-sdk/devices/MIMXRT633S/mcuxpresso/startup_mimxrt633s.cpp
new file mode 100644
index 000000000..51486711e
--- /dev/null
+++ b/lib/chibios-contrib/ext/mcux-sdk/devices/MIMXRT633S/mcuxpresso/startup_mimxrt633s.cpp
@@ -0,0 +1,758 @@
1//*****************************************************************************
2// MIMXRT633S_cm33 startup code for use with MCUXpresso IDE
3//
4// Version : 160420
5//*****************************************************************************
6//
7// Copyright 2016-2020 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//*****************************************************************************
27extern "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)
39extern "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)
51extern 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);
64WEAK void NMI_Handler(void);
65WEAK void HardFault_Handler(void);
66WEAK void MemManage_Handler(void);
67WEAK void BusFault_Handler(void);
68WEAK void UsageFault_Handler(void);
69WEAK void SecureFault_Handler(void);
70WEAK void SVC_Handler(void);
71WEAK void DebugMon_Handler(void);
72WEAK void PendSV_Handler(void);
73WEAK void SysTick_Handler(void);
74WEAK 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//*****************************************************************************
81WEAK void WDT0_IRQHandler(void);
82WEAK void DMA0_IRQHandler(void);
83WEAK void GPIO_INTA_IRQHandler(void);
84WEAK void GPIO_INTB_IRQHandler(void);
85WEAK void PIN_INT0_IRQHandler(void);
86WEAK void PIN_INT1_IRQHandler(void);
87WEAK void PIN_INT2_IRQHandler(void);
88WEAK void PIN_INT3_IRQHandler(void);
89WEAK void UTICK0_IRQHandler(void);
90WEAK void MRT0_IRQHandler(void);
91WEAK void CTIMER0_IRQHandler(void);
92WEAK void CTIMER1_IRQHandler(void);
93WEAK void SCT0_IRQHandler(void);
94WEAK void CTIMER3_IRQHandler(void);
95WEAK void FLEXCOMM0_IRQHandler(void);
96WEAK void FLEXCOMM1_IRQHandler(void);
97WEAK void FLEXCOMM2_IRQHandler(void);
98WEAK void FLEXCOMM3_IRQHandler(void);
99WEAK void FLEXCOMM4_IRQHandler(void);
100WEAK void FLEXCOMM5_IRQHandler(void);
101WEAK void FLEXCOMM14_IRQHandler(void);
102WEAK void FLEXCOMM15_IRQHandler(void);
103WEAK void ADC0_IRQHandler(void);
104WEAK void Reserved39_IRQHandler(void);
105WEAK void ACMP_IRQHandler(void);
106WEAK void DMIC0_IRQHandler(void);
107WEAK void Reserved42_IRQHandler(void);
108WEAK void HYPERVISOR_IRQHandler(void);
109WEAK void SECUREVIOLATION_IRQHandler(void);
110WEAK void HWVAD0_IRQHandler(void);
111WEAK void Reserved46_IRQHandler(void);
112WEAK void RNG_IRQHandler(void);
113WEAK void RTC_IRQHandler(void);
114WEAK void DSPWAKE_IRQHandler(void);
115WEAK void MU_A_IRQHandler(void);
116WEAK void PIN_INT4_IRQHandler(void);
117WEAK void PIN_INT5_IRQHandler(void);
118WEAK void PIN_INT6_IRQHandler(void);
119WEAK void PIN_INT7_IRQHandler(void);
120WEAK void CTIMER2_IRQHandler(void);
121WEAK void CTIMER4_IRQHandler(void);
122WEAK void OS_EVENT_IRQHandler(void);
123WEAK void FLEXSPI_IRQHandler(void);
124WEAK void FLEXCOMM6_IRQHandler(void);
125WEAK void FLEXCOMM7_IRQHandler(void);
126WEAK void USDHC0_IRQHandler(void);
127WEAK void USDHC1_IRQHandler(void);
128WEAK void SGPIO_INTA_IRQHandler(void);
129WEAK void SGPIO_INTB_IRQHandler(void);
130WEAK void I3C0_IRQHandler(void);
131WEAK void USB_IRQHandler(void);
132WEAK void USB_WAKEUP_IRQHandler(void);
133WEAK void WDT1_IRQHandler(void);
134WEAK void USBPHY_DCD_IRQHandler(void);
135WEAK void DMA1_IRQHandler(void);
136WEAK void PUF_IRQHandler(void);
137WEAK void POWERQUAD_IRQHandler(void);
138WEAK void CASPER_IRQHandler(void);
139WEAK void PMC_PMIC_IRQHandler(void);
140WEAK void HASHCRYPT_IRQHandler(void);
141
142//*****************************************************************************
143// Forward declaration of the driver IRQ handlers. These are aliased
144// to the IntDefaultHandler, which is a 'forever' loop. When the driver
145// defines a handler (with the same name), this will automatically take
146// precedence over these weak definitions
147//*****************************************************************************
148void WDT0_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
149void DMA0_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
150void GPIO_INTA_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
151void GPIO_INTB_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
152void PIN_INT0_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
153void PIN_INT1_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
154void PIN_INT2_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
155void PIN_INT3_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
156void UTICK0_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
157void MRT0_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
158void CTIMER0_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
159void CTIMER1_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
160void SCT0_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
161void CTIMER3_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
162void FLEXCOMM0_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
163void FLEXCOMM1_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
164void FLEXCOMM2_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
165void FLEXCOMM3_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
166void FLEXCOMM4_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
167void FLEXCOMM5_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
168void FLEXCOMM14_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
169void FLEXCOMM15_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
170void ADC0_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
171void Reserved39_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
172void ACMP_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
173void DMIC0_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
174void Reserved42_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
175void HYPERVISOR_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
176void SECUREVIOLATION_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
177void HWVAD0_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
178void Reserved46_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
179void RNG_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
180void RTC_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
181void DSPWAKE_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
182void MU_A_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
183void PIN_INT4_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
184void PIN_INT5_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
185void PIN_INT6_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
186void PIN_INT7_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
187void CTIMER2_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
188void CTIMER4_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
189void OS_EVENT_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
190void FLEXSPI_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
191void FLEXCOMM6_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
192void FLEXCOMM7_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
193void USDHC0_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
194void USDHC1_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
195void SGPIO_INTA_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
196void SGPIO_INTB_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
197void I3C0_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
198void USB_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
199void USB_WAKEUP_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
200void WDT1_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
201void USBPHY_DCD_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
202void DMA1_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
203void PUF_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
204void POWERQUAD_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
205void CASPER_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
206void PMC_PMIC_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
207void HASHCRYPT_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
208
209//*****************************************************************************
210// The entry point for the application.
211// __main() is the entry point for Redlib based applications
212// main() is the entry point for Newlib based applications
213//*****************************************************************************
214#if defined (__REDLIB__)
215extern void __main(void);
216#endif
217extern int main(void);
218
219//*****************************************************************************
220// External declaration for the pointer to the stack top from the Linker Script
221//*****************************************************************************
222extern void _vStackTop(void);
223extern void _image_size(void);
224//*****************************************************************************
225// External declaration for the pointer to the stack base from the Linker Script
226//*****************************************************************************
227extern void _vStackBase(void);
228//*****************************************************************************
229// External declaration for image type and load address from Linker Script
230//*****************************************************************************
231WEAK extern void __imghdr_loadaddress();
232WEAK extern void __imghdr_imagetype();
233
234//*****************************************************************************
235#if defined (__cplusplus)
236} // extern "C"
237#endif
238//*****************************************************************************
239// The vector table.
240// This relies on the linker script to place at correct location in memory.
241//*****************************************************************************
242
243
244
245extern void (* const g_pfnVectors[])(void);
246extern void * __Vectors __attribute__ ((alias ("g_pfnVectors")));
247
248__attribute__ ((used, section(".isr_vector")))
249void (* const g_pfnVectors[])(void) = {
250 // Core Level - CM33
251 &_vStackTop, // The initial stack pointer
252 ResetISR, // The reset handler
253 NMI_Handler, // The NMI handler
254 HardFault_Handler, // The hard fault handler
255 MemManage_Handler, // The MPU fault handler
256 BusFault_Handler, // The bus fault handler
257 UsageFault_Handler, // The usage fault handler
258 SecureFault_Handler, // The secure fault handler
259#if (__ARM_FEATURE_CMSE & 0x2)
260 (void (*)())0x180000, // Image length
261#else
262 (void (*)())((unsigned)_image_size), // Image length
263#endif
264 __imghdr_imagetype, // Image type
265 0, // Reserved
266 SVC_Handler, // SVCall handler
267 DebugMon_Handler, // Debug monitor handler
268 (void (*)())g_pfnVectors, // Image load address
269 PendSV_Handler, // The PendSV handler
270 SysTick_Handler, // The SysTick handler
271
272 // Chip Level - MIMXRT633S_cm33
273 WDT0_IRQHandler, // 16: Windowed watchdog timer 0 (CM33 watchdog)
274 DMA0_IRQHandler, // 17: DMA controller 0 (secure or CM33 DMA)
275 GPIO_INTA_IRQHandler, // 18: GPIO interrupt A
276 GPIO_INTB_IRQHandler, // 19: GPIO interrupt B
277 PIN_INT0_IRQHandler, // 20: Pin interrupt 0 or pattern match engine slice 0 int
278 PIN_INT1_IRQHandler, // 21: Pin interrupt 1 or pattern match engine slice 1 int
279 PIN_INT2_IRQHandler, // 22: Pin interrupt 2 or pattern match engine slice 2 int
280 PIN_INT3_IRQHandler, // 23: Pin interrupt 3 or pattern match engine slice 3 int
281 UTICK0_IRQHandler, // 24: Micro-tick Timer
282 MRT0_IRQHandler, // 25: Multi-Rate Timer
283 CTIMER0_IRQHandler, // 26: Standard counter/timer CTIMER0
284 CTIMER1_IRQHandler, // 27: Standard counter/timer CTIMER1
285 SCT0_IRQHandler, // 28: SCTimer/PWM
286 CTIMER3_IRQHandler, // 29: Standard counter/timer CTIMER3
287 FLEXCOMM0_IRQHandler, // 30: Flexcomm Interface 0 (USART, SPI, I2C, I2S)
288 FLEXCOMM1_IRQHandler, // 31: Flexcomm Interface 1 (USART, SPI, I2C, I2S)
289 FLEXCOMM2_IRQHandler, // 32: Flexcomm Interface 2 (USART, SPI, I2C, I2S)
290 FLEXCOMM3_IRQHandler, // 33: Flexcomm Interface 3 (USART, SPI, I2C, I2S)
291 FLEXCOMM4_IRQHandler, // 34: Flexcomm Interface 4 (USART, SPI, I2C, I2S)
292 FLEXCOMM5_IRQHandler, // 35: Flexcomm Interface 5 (USART, SPI, I2C, I2S)
293 FLEXCOMM14_IRQHandler, // 36: Flexcomm Interface 14 (SPI only)
294 FLEXCOMM15_IRQHandler, // 37: Flexcomm Interface 15 (I2C only)
295 ADC0_IRQHandler, // 38: ADC0
296 Reserved39_IRQHandler, // 39: Reserved interrupt
297 ACMP_IRQHandler, // 40: Analog comparator
298 DMIC0_IRQHandler, // 41: Digital microphone and DMIC subsystem
299 Reserved42_IRQHandler, // 42: Reserved interrupt
300 HYPERVISOR_IRQHandler, // 43: Hypervisor
301 SECUREVIOLATION_IRQHandler, // 44: Secure violation
302 HWVAD0_IRQHandler, // 45: Hardware Voice Activity Detector
303 Reserved46_IRQHandler, // 46: Reserved interrupt
304 RNG_IRQHandler, // 47: Random number Generator
305 RTC_IRQHandler, // 48: RTC alarm and wake-up
306 DSPWAKE_IRQHandler, // 49: Wake-up from DSP
307 MU_A_IRQHandler, // 50: Messaging Unit port A for CM33
308 PIN_INT4_IRQHandler, // 51: Pin interrupt 4 or pattern match engine slice 4 int
309 PIN_INT5_IRQHandler, // 52: Pin interrupt 5 or pattern match engine slice 5 int
310 PIN_INT6_IRQHandler, // 53: Pin interrupt 6 or pattern match engine slice 6 int
311 PIN_INT7_IRQHandler, // 54: Pin interrupt 7 or pattern match engine slice 7 int
312 CTIMER2_IRQHandler, // 55: Standard counter/timer CTIMER2
313 CTIMER4_IRQHandler, // 56: Standard counter/timer CTIMER4
314 OS_EVENT_IRQHandler, // 57: OS event timer
315 FLEXSPI_IRQHandler, // 58: FLEXSPI interface
316 FLEXCOMM6_IRQHandler, // 59: Flexcomm Interface 6 (USART, SPI, I2C, I2S)
317 FLEXCOMM7_IRQHandler, // 60: Flexcomm Interface 7 (USART, SPI, I2C, I2S)
318 USDHC0_IRQHandler, // 61: USDHC0 (Enhanced SDHC) interrupt request
319 USDHC1_IRQHandler, // 62: USDHC1 (Enhanced SDHC) interrupt request
320 SGPIO_INTA_IRQHandler, // 63: Secure GPIO interrupt A
321 SGPIO_INTB_IRQHandler, // 64: Secure GPIO interrupt B
322 I3C0_IRQHandler, // 65: I3C interface 0
323 USB_IRQHandler, // 66: High-speed USB device/host
324 USB_WAKEUP_IRQHandler, // 67: USB Activity Wake-up Interrupt
325 WDT1_IRQHandler, // 68: Windowed watchdog timer 1 (HiFi 4 watchdog)
326 USBPHY_DCD_IRQHandler, // 69: USBPHY DCD
327 DMA1_IRQHandler, // 70: DMA controller 1 (non-secure or HiFi 4 DMA)
328 PUF_IRQHandler, // 71: Physical Unclonable Function
329 POWERQUAD_IRQHandler, // 72: PowerQuad math coprocessor
330 CASPER_IRQHandler, // 73: Casper cryptographic coprocessor
331 PMC_PMIC_IRQHandler, // 74: Power management IC
332 HASHCRYPT_IRQHandler, // 75: Hash-AES unit
333
334
335}; /* End of g_pfnVectors */
336
337#if defined(ENABLE_RAM_VECTOR_TABLE)
338extern void * __VECTOR_TABLE __attribute__ ((alias ("g_pfnVectors")));
339void (* __VECTOR_RAM[sizeof(g_pfnVectors) / 4])(void) __attribute__((aligned(128)));
340unsigned int __RAM_VECTOR_TABLE_SIZE_BYTES = sizeof(g_pfnVectors);
341#endif
342
343//*****************************************************************************
344// Functions to carry out the initialization of RW and BSS data sections. These
345// are written as separate functions rather than being inlined within the
346// ResetISR() function in order to cope with MCUs with multiple banks of
347// memory.
348//*****************************************************************************
349__attribute__ ((section(".after_vectors.init_data")))
350void data_init(unsigned int romstart, unsigned int start, unsigned int len) {
351 unsigned int *pulDest = (unsigned int*) start;
352 unsigned int *pulSrc = (unsigned int*) romstart;
353 unsigned int loop;
354 for (loop = 0; loop < len; loop = loop + 4)
355 *pulDest++ = *pulSrc++;
356}
357
358__attribute__ ((section(".after_vectors.init_bss")))
359void bss_init(unsigned int start, unsigned int len) {
360 unsigned int *pulDest = (unsigned int*) start;
361 unsigned int loop;
362 for (loop = 0; loop < len; loop = loop + 4)
363 *pulDest++ = 0;
364}
365
366//*****************************************************************************
367// The following symbols are constructs generated by the linker, indicating
368// the location of various points in the "Global Section Table". This table is
369// created by the linker via the Code Red managed linker script mechanism. It
370// contains the load address, execution address and length of each RW data
371// section and the execution and length of each BSS (zero initialized) section.
372//*****************************************************************************
373extern unsigned int __data_section_table;
374extern unsigned int __data_section_table_end;
375extern unsigned int __bss_section_table;
376extern unsigned int __bss_section_table_end;
377
378//*****************************************************************************
379// Reset entry point for your code.
380// Sets up a simple runtime environment and initializes the C/C++
381// library.
382//*****************************************************************************
383__attribute__ ((section(".after_vectors.reset")))
384void ResetISR(void) {
385
386 // Disable interrupts
387 __asm volatile ("cpsid i");
388
389 // Config VTOR & MSPLIM register
390 __asm volatile ("LDR R0, =0xE000ED08 \n"
391 "STR %0, [R0] \n"
392 "LDR R1, [%0] \n"
393 "MSR MSP, R1 \n"
394 "MSR MSPLIM, %1 \n"
395 :
396 : "r"(g_pfnVectors), "r"(_vStackBase)
397 : "r0", "r1");
398
399#if defined (__USE_CMSIS)
400// If __USE_CMSIS defined, then call CMSIS SystemInit code
401 SystemInit();
402
403#endif // (__USE_CMSIS)
404
405 //
406 // Copy the data sections from flash to SRAM.
407 //
408 unsigned int LoadAddr, ExeAddr, SectionLen;
409 unsigned int *SectionTableAddr;
410
411 // Load base address of Global Section Table
412 SectionTableAddr = &__data_section_table;
413
414 // Copy the data sections from flash to SRAM.
415 while (SectionTableAddr < &__data_section_table_end) {
416 LoadAddr = *SectionTableAddr++;
417 ExeAddr = *SectionTableAddr++;
418 SectionLen = *SectionTableAddr++;
419 data_init(LoadAddr, ExeAddr, SectionLen);
420 }
421
422 // At this point, SectionTableAddr = &__bss_section_table;
423 // Zero fill the bss segment
424 while (SectionTableAddr < &__bss_section_table_end) {
425 ExeAddr = *SectionTableAddr++;
426 SectionLen = *SectionTableAddr++;
427 bss_init(ExeAddr, SectionLen);
428 }
429
430
431#if defined (__cplusplus)
432 //
433 // Call C++ library initialisation
434 //
435 __libc_init_array();
436#endif
437
438 // Reenable interrupts
439 __asm volatile ("cpsie i");
440
441#if defined (__REDLIB__)
442 // Call the Redlib library, which in turn calls main()
443 __main();
444#else
445 main();
446#endif
447
448 //
449 // main() shouldn't return, but if it does, we'll just enter an infinite loop
450 //
451 while (1) {
452 ;
453 }
454}
455
456//*****************************************************************************
457// Default core exception handlers. Override the ones here by defining your own
458// handler routines in your application code.
459//*****************************************************************************
460WEAK_AV void NMI_Handler(void)
461{ while(1) {}
462}
463
464WEAK_AV void HardFault_Handler(void)
465{ while(1) {}
466}
467
468WEAK_AV void MemManage_Handler(void)
469{ while(1) {}
470}
471
472WEAK_AV void BusFault_Handler(void)
473{ while(1) {}
474}
475
476WEAK_AV void UsageFault_Handler(void)
477{ while(1) {}
478}
479
480WEAK_AV void SecureFault_Handler(void)
481{ while(1) {}
482}
483
484WEAK_AV void SVC_Handler(void)
485{ while(1) {}
486}
487
488WEAK_AV void DebugMon_Handler(void)
489{ while(1) {}
490}
491
492WEAK_AV void PendSV_Handler(void)
493{ while(1) {}
494}
495
496WEAK_AV void SysTick_Handler(void)
497{ while(1) {}
498}
499
500//*****************************************************************************
501// Processor ends up here if an unexpected interrupt occurs or a specific
502// handler is not present in the application code.
503//*****************************************************************************
504WEAK_AV void IntDefaultHandler(void)
505{ while(1) {}
506}
507
508//*****************************************************************************
509// Default application exception handlers. Override the ones here by defining
510// your own handler routines in your application code. These routines call
511// driver exception handlers or IntDefaultHandler() if no driver exception
512// handler is included.
513//*****************************************************************************
514WEAK void WDT0_IRQHandler(void)
515{ WDT0_DriverIRQHandler();
516}
517
518WEAK void DMA0_IRQHandler(void)
519{ DMA0_DriverIRQHandler();
520}
521
522WEAK void GPIO_INTA_IRQHandler(void)
523{ GPIO_INTA_DriverIRQHandler();
524}
525
526WEAK void GPIO_INTB_IRQHandler(void)
527{ GPIO_INTB_DriverIRQHandler();
528}
529
530WEAK void PIN_INT0_IRQHandler(void)
531{ PIN_INT0_DriverIRQHandler();
532}
533
534WEAK void PIN_INT1_IRQHandler(void)
535{ PIN_INT1_DriverIRQHandler();
536}
537
538WEAK void PIN_INT2_IRQHandler(void)
539{ PIN_INT2_DriverIRQHandler();
540}
541
542WEAK void PIN_INT3_IRQHandler(void)
543{ PIN_INT3_DriverIRQHandler();
544}
545
546WEAK void UTICK0_IRQHandler(void)
547{ UTICK0_DriverIRQHandler();
548}
549
550WEAK void MRT0_IRQHandler(void)
551{ MRT0_DriverIRQHandler();
552}
553
554WEAK void CTIMER0_IRQHandler(void)
555{ CTIMER0_DriverIRQHandler();
556}
557
558WEAK void CTIMER1_IRQHandler(void)
559{ CTIMER1_DriverIRQHandler();
560}
561
562WEAK void SCT0_IRQHandler(void)
563{ SCT0_DriverIRQHandler();
564}
565
566WEAK void CTIMER3_IRQHandler(void)
567{ CTIMER3_DriverIRQHandler();
568}
569
570WEAK void FLEXCOMM0_IRQHandler(void)
571{ FLEXCOMM0_DriverIRQHandler();
572}
573
574WEAK void FLEXCOMM1_IRQHandler(void)
575{ FLEXCOMM1_DriverIRQHandler();
576}
577
578WEAK void FLEXCOMM2_IRQHandler(void)
579{ FLEXCOMM2_DriverIRQHandler();
580}
581
582WEAK void FLEXCOMM3_IRQHandler(void)
583{ FLEXCOMM3_DriverIRQHandler();
584}
585
586WEAK void FLEXCOMM4_IRQHandler(void)
587{ FLEXCOMM4_DriverIRQHandler();
588}
589
590WEAK void FLEXCOMM5_IRQHandler(void)
591{ FLEXCOMM5_DriverIRQHandler();
592}
593
594WEAK void FLEXCOMM14_IRQHandler(void)
595{ FLEXCOMM14_DriverIRQHandler();
596}
597
598WEAK void FLEXCOMM15_IRQHandler(void)
599{ FLEXCOMM15_DriverIRQHandler();
600}
601
602WEAK void ADC0_IRQHandler(void)
603{ ADC0_DriverIRQHandler();
604}
605
606WEAK void Reserved39_IRQHandler(void)
607{ Reserved39_DriverIRQHandler();
608}
609
610WEAK void ACMP_IRQHandler(void)
611{ ACMP_DriverIRQHandler();
612}
613
614WEAK void DMIC0_IRQHandler(void)
615{ DMIC0_DriverIRQHandler();
616}
617
618WEAK void Reserved42_IRQHandler(void)
619{ Reserved42_DriverIRQHandler();
620}
621
622WEAK void HYPERVISOR_IRQHandler(void)
623{ HYPERVISOR_DriverIRQHandler();
624}
625
626WEAK void SECUREVIOLATION_IRQHandler(void)
627{ SECUREVIOLATION_DriverIRQHandler();
628}
629
630WEAK void HWVAD0_IRQHandler(void)
631{ HWVAD0_DriverIRQHandler();
632}
633
634WEAK void Reserved46_IRQHandler(void)
635{ Reserved46_DriverIRQHandler();
636}
637
638WEAK void RNG_IRQHandler(void)
639{ RNG_DriverIRQHandler();
640}
641
642WEAK void RTC_IRQHandler(void)
643{ RTC_DriverIRQHandler();
644}
645
646WEAK void DSPWAKE_IRQHandler(void)
647{ DSPWAKE_DriverIRQHandler();
648}
649
650WEAK void MU_A_IRQHandler(void)
651{ MU_A_DriverIRQHandler();
652}
653
654WEAK void PIN_INT4_IRQHandler(void)
655{ PIN_INT4_DriverIRQHandler();
656}
657
658WEAK void PIN_INT5_IRQHandler(void)
659{ PIN_INT5_DriverIRQHandler();
660}
661
662WEAK void PIN_INT6_IRQHandler(void)
663{ PIN_INT6_DriverIRQHandler();
664}
665
666WEAK void PIN_INT7_IRQHandler(void)
667{ PIN_INT7_DriverIRQHandler();
668}
669
670WEAK void CTIMER2_IRQHandler(void)
671{ CTIMER2_DriverIRQHandler();
672}
673
674WEAK void CTIMER4_IRQHandler(void)
675{ CTIMER4_DriverIRQHandler();
676}
677
678WEAK void OS_EVENT_IRQHandler(void)
679{ OS_EVENT_DriverIRQHandler();
680}
681
682WEAK void FLEXSPI_IRQHandler(void)
683{ FLEXSPI_DriverIRQHandler();
684}
685
686WEAK void FLEXCOMM6_IRQHandler(void)
687{ FLEXCOMM6_DriverIRQHandler();
688}
689
690WEAK void FLEXCOMM7_IRQHandler(void)
691{ FLEXCOMM7_DriverIRQHandler();
692}
693
694WEAK void USDHC0_IRQHandler(void)
695{ USDHC0_DriverIRQHandler();
696}
697
698WEAK void USDHC1_IRQHandler(void)
699{ USDHC1_DriverIRQHandler();
700}
701
702WEAK void SGPIO_INTA_IRQHandler(void)
703{ SGPIO_INTA_DriverIRQHandler();
704}
705
706WEAK void SGPIO_INTB_IRQHandler(void)
707{ SGPIO_INTB_DriverIRQHandler();
708}
709
710WEAK void I3C0_IRQHandler(void)
711{ I3C0_DriverIRQHandler();
712}
713
714WEAK void USB_IRQHandler(void)
715{ USB_DriverIRQHandler();
716}
717
718WEAK void USB_WAKEUP_IRQHandler(void)
719{ USB_WAKEUP_DriverIRQHandler();
720}
721
722WEAK void WDT1_IRQHandler(void)
723{ WDT1_DriverIRQHandler();
724}
725
726WEAK void USBPHY_DCD_IRQHandler(void)
727{ USBPHY_DCD_DriverIRQHandler();
728}
729
730WEAK void DMA1_IRQHandler(void)
731{ DMA1_DriverIRQHandler();
732}
733
734WEAK void PUF_IRQHandler(void)
735{ PUF_DriverIRQHandler();
736}
737
738WEAK void POWERQUAD_IRQHandler(void)
739{ POWERQUAD_DriverIRQHandler();
740}
741
742WEAK void CASPER_IRQHandler(void)
743{ CASPER_DriverIRQHandler();
744}
745
746WEAK void PMC_PMIC_IRQHandler(void)
747{ PMC_PMIC_DriverIRQHandler();
748}
749
750WEAK void HASHCRYPT_IRQHandler(void)
751{ HASHCRYPT_DriverIRQHandler();
752}
753
754//*****************************************************************************
755
756#if defined (DEBUG)
757#pragma GCC pop_options
758#endif // (DEBUG)
generated by cgit v1.2.3 (git 2.25.1) at 2025-08-30 20:16:59 +0100