1 //*****************************************************************************
2 // K32L2A41A startup code for use with MCUXpresso IDE
3 //
4 // Version : 220823
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 // Flash Configuration block : 16-byte flash configuration field that stores
44 // default protection settings (loaded on reset) and security information that
45 // allows the MCU to restrict access to the Flash Memory module.
46 // Placed at address 0x400 by the linker script.
47 //*****************************************************************************
48 __attribute__ ((used,section(".FlashConfig"))) const struct {
49 unsigned int word1;
50 unsigned int word2;
51 unsigned int word3;
52 unsigned int word4;
53 } Flash_Config = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFF3DFE};
54 //*****************************************************************************
55 // Declaration of external SystemInit function
56 //*****************************************************************************
57 #if defined (__USE_CMSIS)
58 extern void SystemInit(void);
59 #endif // (__USE_CMSIS)
60
61 //*****************************************************************************
62 // Forward declaration of the core exception handlers.
63 // When the application defines a handler (with the same name), this will
64 // automatically take precedence over these weak definitions.
65 // If your application is a C++ one, then any interrupt handlers defined
66 // in C++ files within in your main application will need to have C linkage
67 // rather than C++ linkage. To do this, make sure that you are using extern "C"
68 // { .... } around the interrupt handler within your main application code.
69 //*****************************************************************************
70 void ResetISR(void);
71 WEAK void NMI_Handler(void);
72 WEAK void HardFault_Handler(void);
73 WEAK void SVC_Handler(void);
74 WEAK void PendSV_Handler(void);
75 WEAK void SysTick_Handler(void);
76 WEAK void IntDefaultHandler(void);
77
78 //*****************************************************************************
79 // Forward declaration of the application IRQ handlers. When the application
80 // defines a handler (with the same name), this will automatically take
81 // precedence over weak definitions below
82 //*****************************************************************************
83 WEAK void DMA0_04_IRQHandler(void);
84 WEAK void DMA0_15_IRQHandler(void);
85 WEAK void DMA0_26_IRQHandler(void);
86 WEAK void DMA0_37_IRQHandler(void);
87 WEAK void CTI0_DMA0_Error_IRQHandler(void);
88 WEAK void FLEXIO0_IRQHandler(void);
89 WEAK void TPM0_IRQHandler(void);
90 WEAK void TPM1_IRQHandler(void);
91 WEAK void TPM2_IRQHandler(void);
92 WEAK void LPIT0_IRQHandler(void);
93 WEAK void LPSPI0_IRQHandler(void);
94 WEAK void LPSPI1_IRQHandler(void);
95 WEAK void LPUART0_IRQHandler(void);
96 WEAK void LPUART1_IRQHandler(void);
97 WEAK void LPI2C0_IRQHandler(void);
98 WEAK void LPI2C1_IRQHandler(void);
99 WEAK void Reserved32_IRQHandler(void);
100 WEAK void PORTA_IRQHandler(void);
101 WEAK void PORTB_IRQHandler(void);
102 WEAK void PORTC_IRQHandler(void);
103 WEAK void PORTD_IRQHandler(void);
104 WEAK void PORTE_IRQHandler(void);
105 WEAK void LLWU_IRQHandler(void);
106 WEAK void Reserved39_IRQHandler(void);
107 WEAK void USB0_IRQHandler(void);
108 WEAK void ADC0_IRQHandler(void);
109 WEAK void LPTMR0_IRQHandler(void);
110 WEAK void RTC_Seconds_IRQHandler(void);
111 WEAK void INTMUX0_0_IRQHandler(void);
112 WEAK void INTMUX0_1_IRQHandler(void);
113 WEAK void INTMUX0_2_IRQHandler(void);
114 WEAK void INTMUX0_3_IRQHandler(void);
115 WEAK void LPTMR1_IRQHandler(void);
116 WEAK void Reserved49_IRQHandler(void);
117 WEAK void Reserved50_IRQHandler(void);
118 WEAK void Reserved51_IRQHandler(void);
119 WEAK void LPSPI2_IRQHandler(void);
120 WEAK void LPUART2_IRQHandler(void);
121 WEAK void EMVSIM0_IRQHandler(void);
122 WEAK void LPI2C2_IRQHandler(void);
123 WEAK void TSI0_IRQHandler(void);
124 WEAK void PMC_IRQHandler(void);
125 WEAK void FTFA_IRQHandler(void);
126 WEAK void SCG_IRQHandler(void);
127 WEAK void WDOG0_IRQHandler(void);
128 WEAK void DAC0_IRQHandler(void);
129 WEAK void TRNG_IRQHandler(void);
130 WEAK void RCM_IRQHandler(void);
131 WEAK void CMP0_IRQHandler(void);
132 WEAK void CMP1_IRQHandler(void);
133 WEAK void RTC_IRQHandler(void);
134
135 //*****************************************************************************
136 // Forward declaration of the driver IRQ handlers. These are aliased
137 // to the IntDefaultHandler, which is a 'forever' loop. When the driver
138 // defines a handler (with the same name), this will automatically take
139 // precedence over these weak definitions
140 //*****************************************************************************
141 void DMA0_04_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
142 void DMA0_15_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
143 void DMA0_26_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
144 void DMA0_37_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
145 void CTI0_DMA0_Error_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
146 void FLEXIO0_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
147 void TPM0_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
148 void TPM1_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
149 void TPM2_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
150 void LPIT0_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
151 void LPSPI0_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
152 void LPSPI1_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
153 void LPUART0_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
154 void LPUART1_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
155 void LPI2C0_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
156 void LPI2C1_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
157 void Reserved32_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
158 void PORTA_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
159 void PORTB_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
160 void PORTC_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
161 void PORTD_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
162 void PORTE_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
163 void LLWU_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
164 void Reserved39_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
165 void USB0_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
166 void ADC0_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
167 void LPTMR0_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
168 void RTC_Seconds_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
169 void INTMUX0_0_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
170 void INTMUX0_1_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
171 void INTMUX0_2_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
172 void INTMUX0_3_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
173 void LPTMR1_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
174 void Reserved49_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
175 void Reserved50_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
176 void Reserved51_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
177 void LPSPI2_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
178 void LPUART2_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
179 void EMVSIM0_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
180 void LPI2C2_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
181 void TSI0_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
182 void PMC_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
183 void FTFA_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
184 void SCG_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
185 void WDOG0_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
186 void DAC0_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
187 void TRNG_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
188 void RCM_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
189 void CMP0_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
190 void CMP1_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
191 void RTC_DriverIRQHandler(void) ALIAS(IntDefaultHandler);
192
193 //*****************************************************************************
194 // The entry point for the application.
195 // __main() is the entry point for Redlib based applications
196 // main() is the entry point for Newlib based applications
197 //*****************************************************************************
198 #if defined (__REDLIB__)
199 extern void __main(void);
200 #endif
201 extern int main(void);
202
203 //*****************************************************************************
204 // External declaration for the pointer to the stack top from the Linker Script
205 //*****************************************************************************
206 extern void _vStackTop(void);
207 //*****************************************************************************
208 #if defined (__cplusplus)
209 } // extern "C"
210 #endif
211 //*****************************************************************************
212 // The vector table.
213 // This relies on the linker script to place at correct location in memory.
214 //*****************************************************************************
215
216 extern void (* const g_pfnVectors[])(void);
217 extern void * __Vectors __attribute__ ((alias ("g_pfnVectors")));
218
219 __attribute__ ((used, section(".isr_vector")))
220 void (* const g_pfnVectors[])(void) = {
221 // Core Level - CM0P
222 &_vStackTop, // The initial stack pointer
223 ResetISR, // The reset handler
224 NMI_Handler, // NMI Handler
225 HardFault_Handler, // Hard Fault Handler
226 0, // Reserved
227 0, // Reserved
228 0, // Reserved
229 0, // Reserved
230 0, // Reserved
231 0, // Reserved
232 0, // Reserved
233 SVC_Handler, // SVCall Handler
234 0, // Reserved
235 0, // Reserved
236 PendSV_Handler, // PendSV Handler
237 SysTick_Handler, // SysTick Handler
238
239 // Chip Level - K32L2A41A
240 DMA0_04_IRQHandler, // 16: DMA0 channel 0/4 transfer complete
241 DMA0_15_IRQHandler, // 17: DMA0 channel 1/5 transfer complete
242 DMA0_26_IRQHandler, // 18: DMA0 channel 2/6 transfer complete
243 DMA0_37_IRQHandler, // 19: DMA0 channel 3/7 transfer complete
244 CTI0_DMA0_Error_IRQHandler, // 20: CTI0 or DMA0 error
245 FLEXIO0_IRQHandler, // 21: FLEXIO0
246 TPM0_IRQHandler, // 22: TPM0 single interrupt vector for all sources
247 TPM1_IRQHandler, // 23: TPM1 single interrupt vector for all sources
248 TPM2_IRQHandler, // 24: TPM2 single interrupt vector for all sources
249 LPIT0_IRQHandler, // 25: LPIT0 interrupt
250 LPSPI0_IRQHandler, // 26: LPSPI0 single interrupt vector for all sources
251 LPSPI1_IRQHandler, // 27: LPSPI1 single interrupt vector for all sources
252 LPUART0_IRQHandler, // 28: LPUART0 status and error
253 LPUART1_IRQHandler, // 29: LPUART1 status and error
254 LPI2C0_IRQHandler, // 30: LPI2C0 interrupt
255 LPI2C1_IRQHandler, // 31: LPI2C1 interrupt
256 Reserved32_IRQHandler, // 32: Reserved interrupt
257 PORTA_IRQHandler, // 33: PORTA Pin detect
258 PORTB_IRQHandler, // 34: PORTB Pin detect
259 PORTC_IRQHandler, // 35: PORTC Pin detect
260 PORTD_IRQHandler, // 36: PORTD Pin detect
261 PORTE_IRQHandler, // 37: PORTE Pin detect
262 LLWU_IRQHandler, // 38: Low leakage wakeup
263 Reserved39_IRQHandler, // 39: Reserved interrupt
264 USB0_IRQHandler, // 40: USB0 interrupt
265 ADC0_IRQHandler, // 41: ADC0 interrupt
266 LPTMR0_IRQHandler, // 42: LPTMR0 interrupt
267 RTC_Seconds_IRQHandler, // 43: RTC seconds
268 INTMUX0_0_IRQHandler, // 44: INTMUX0 channel 0 interrupt
269 INTMUX0_1_IRQHandler, // 45: INTMUX0 channel 1 interrupt
270 INTMUX0_2_IRQHandler, // 46: INTMUX0 channel 2 interrupt
271 INTMUX0_3_IRQHandler, // 47: INTMUX0 channel 3 interrupt
272 LPTMR1_IRQHandler, // 48: LPTMR1 interrupt (INTMUX source IRQ0)
273 Reserved49_IRQHandler, // 49: Reserved interrupt
274 Reserved50_IRQHandler, // 50: Reserved interrupt
275 Reserved51_IRQHandler, // 51: Reserved interrupt
276 LPSPI2_IRQHandler, // 52: LPSPI2 single interrupt vector for all sources (INTMUX source IRQ4)
277 LPUART2_IRQHandler, // 53: LPUART2 status and error (INTMUX source IRQ5)
278 EMVSIM0_IRQHandler, // 54: EMVSIM0 interrupt (INTMUX source IRQ6)
279 LPI2C2_IRQHandler, // 55: LPI2C2 interrupt (INTMUX source IRQ7)
280 TSI0_IRQHandler, // 56: TSI0 interrupt (INTMUX source IRQ8)
281 PMC_IRQHandler, // 57: PMC interrupt (INTMUX source IRQ9)
282 FTFA_IRQHandler, // 58: FTFA interrupt (INTMUX source IRQ10)
283 SCG_IRQHandler, // 59: SCG interrupt (INTMUX source IRQ11)
284 WDOG0_IRQHandler, // 60: WDOG0 interrupt (INTMUX source IRQ12)
285 DAC0_IRQHandler, // 61: DAC0 interrupt (INTMUX source IRQ13)
286 TRNG_IRQHandler, // 62: TRNG interrupt (INTMUX source IRQ14)
287 RCM_IRQHandler, // 63: RCM interrupt (INTMUX source IRQ15)
288 CMP0_IRQHandler, // 64: CMP0 interrupt (INTMUX source IRQ16)
289 CMP1_IRQHandler, // 65: CMP1 interrupt (INTMUX source IRQ17)
290 RTC_IRQHandler, // 66: RTC Alarm interrupt (INTMUX source IRQ18)
291 }; /* End of g_pfnVectors */
292
293 //*****************************************************************************
294 // Functions to carry out the initialization of RW and BSS data sections. These
295 // are written as separate functions rather than being inlined within the
296 // ResetISR() function in order to cope with MCUs with multiple banks of
297 // memory.
298 //*****************************************************************************
299 __attribute__ ((section(".after_vectors.init_data")))
data_init(unsigned int romstart,unsigned int start,unsigned int len)300 void data_init(unsigned int romstart, unsigned int start, unsigned int len) {
301 unsigned int *pulDest = (unsigned int*) start;
302 unsigned int *pulSrc = (unsigned int*) romstart;
303 unsigned int loop;
304 for (loop = 0; loop < len; loop = loop + 4)
305 *pulDest++ = *pulSrc++;
306 }
307
308 __attribute__ ((section(".after_vectors.init_bss")))
bss_init(unsigned int start,unsigned int len)309 void bss_init(unsigned int start, unsigned int len) {
310 unsigned int *pulDest = (unsigned int*) start;
311 unsigned int loop;
312 for (loop = 0; loop < len; loop = loop + 4)
313 *pulDest++ = 0;
314 }
315
316 //*****************************************************************************
317 // The following symbols are constructs generated by the linker, indicating
318 // the location of various points in the "Global Section Table". This table is
319 // created by the linker via the Code Red managed linker script mechanism. It
320 // contains the load address, execution address and length of each RW data
321 // section and the execution and length of each BSS (zero initialized) section.
322 //*****************************************************************************
323 extern unsigned int __data_section_table;
324 extern unsigned int __data_section_table_end;
325 extern unsigned int __bss_section_table;
326 extern unsigned int __bss_section_table_end;
327
328 //*****************************************************************************
329 // Reset entry point for your code.
330 // Sets up a simple runtime environment and initializes the C/C++
331 // library.
332 //*****************************************************************************
333 __attribute__ ((naked, section(".after_vectors.reset")))
ResetISR(void)334 void ResetISR(void) {
335 // Disable interrupts
336 __asm volatile ("cpsid i");
337
338 #if defined (__USE_CMSIS)
339 // If __USE_CMSIS defined, then call CMSIS SystemInit code
340 SystemInit();
341
342 #else
343 #if (DISABLE_WDOG)
344 // Disable Watchdog
345 // Write watchdog update key to unlock
346 *((volatile unsigned int *)0x40076004) = 0xD928C520;
347 // Set timeout value
348 *((volatile unsigned int *)0x40076008) = 0xFFFF;
349 // Now disable watchdog via control register
350 volatile unsigned int *WDOG_CS = (unsigned int *) 0x40076000;
351 *WDOG_CS = (*WDOG_CS & ~(1 << 7)) | (1 << 5);
352 #endif // (DISABLE_WDOG)
353 #endif // (__USE_CMSIS)
354
355 //
356 // Copy the data sections from flash to SRAM.
357 //
358 unsigned int LoadAddr, ExeAddr, SectionLen;
359 unsigned int *SectionTableAddr;
360
361 // Load base address of Global Section Table
362 SectionTableAddr = &__data_section_table;
363
364 // Copy the data sections from flash to SRAM.
365 while (SectionTableAddr < &__data_section_table_end) {
366 LoadAddr = *SectionTableAddr++;
367 ExeAddr = *SectionTableAddr++;
368 SectionLen = *SectionTableAddr++;
369 data_init(LoadAddr, ExeAddr, SectionLen);
370 }
371
372 // At this point, SectionTableAddr = &__bss_section_table;
373 // Zero fill the bss segment
374 while (SectionTableAddr < &__bss_section_table_end) {
375 ExeAddr = *SectionTableAddr++;
376 SectionLen = *SectionTableAddr++;
377 bss_init(ExeAddr, SectionLen);
378 }
379
380 #if !defined (__USE_CMSIS)
381 // Assume that if __USE_CMSIS defined, then CMSIS SystemInit code
382 // will setup the VTOR register
383
384 // Check to see if we are running the code from a non-zero
385 // address (eg RAM, external flash), in which case we need
386 // to modify the VTOR register to tell the CPU that the
387 // vector table is located at a non-0x0 address.
388 unsigned int * pSCB_VTOR = (unsigned int *) 0xE000ED08;
389 if ((unsigned int *)g_pfnVectors!=(unsigned int *) 0x00000000) {
390 *pSCB_VTOR = (unsigned int)g_pfnVectors;
391 }
392 #endif // (__USE_CMSIS)
393 #if defined (__cplusplus)
394 //
395 // Call C++ library initialisation
396 //
397 __libc_init_array();
398 #endif
399
400 // Reenable interrupts
401 __asm volatile ("cpsie i");
402
403 #if defined (__REDLIB__)
404 // Call the Redlib library, which in turn calls main()
405 __main();
406 #else
407 main();
408 #endif
409
410 //
411 // main() shouldn't return, but if it does, we'll just enter an infinite loop
412 //
413 while (1) {
414 ;
415 }
416 }
417
418 //*****************************************************************************
419 // Default core exception handlers. Override the ones here by defining your own
420 // handler routines in your application code.
421 //*****************************************************************************
NMI_Handler(void)422 WEAK_AV void NMI_Handler(void)
423 { while(1) {}
424 }
425
HardFault_Handler(void)426 WEAK_AV void HardFault_Handler(void)
427 { while(1) {}
428 }
429
SVC_Handler(void)430 WEAK_AV void SVC_Handler(void)
431 { while(1) {}
432 }
433
PendSV_Handler(void)434 WEAK_AV void PendSV_Handler(void)
435 { while(1) {}
436 }
437
SysTick_Handler(void)438 WEAK_AV void SysTick_Handler(void)
439 { while(1) {}
440 }
441
442 //*****************************************************************************
443 // Processor ends up here if an unexpected interrupt occurs or a specific
444 // handler is not present in the application code.
445 //*****************************************************************************
IntDefaultHandler(void)446 WEAK_AV void IntDefaultHandler(void)
447 { while(1) {}
448 }
449
450 //*****************************************************************************
451 // Default application exception handlers. Override the ones here by defining
452 // your own handler routines in your application code. These routines call
453 // driver exception handlers or IntDefaultHandler() if no driver exception
454 // handler is included.
455 //*****************************************************************************
DMA0_04_IRQHandler(void)456 WEAK_AV void DMA0_04_IRQHandler(void)
457 { DMA0_04_DriverIRQHandler();
458 }
459
DMA0_15_IRQHandler(void)460 WEAK_AV void DMA0_15_IRQHandler(void)
461 { DMA0_15_DriverIRQHandler();
462 }
463
DMA0_26_IRQHandler(void)464 WEAK_AV void DMA0_26_IRQHandler(void)
465 { DMA0_26_DriverIRQHandler();
466 }
467
DMA0_37_IRQHandler(void)468 WEAK_AV void DMA0_37_IRQHandler(void)
469 { DMA0_37_DriverIRQHandler();
470 }
471
CTI0_DMA0_Error_IRQHandler(void)472 WEAK_AV void CTI0_DMA0_Error_IRQHandler(void)
473 { CTI0_DMA0_Error_DriverIRQHandler();
474 }
475
FLEXIO0_IRQHandler(void)476 WEAK_AV void FLEXIO0_IRQHandler(void)
477 { FLEXIO0_DriverIRQHandler();
478 }
479
TPM0_IRQHandler(void)480 WEAK_AV void TPM0_IRQHandler(void)
481 { TPM0_DriverIRQHandler();
482 }
483
TPM1_IRQHandler(void)484 WEAK_AV void TPM1_IRQHandler(void)
485 { TPM1_DriverIRQHandler();
486 }
487
TPM2_IRQHandler(void)488 WEAK_AV void TPM2_IRQHandler(void)
489 { TPM2_DriverIRQHandler();
490 }
491
LPIT0_IRQHandler(void)492 WEAK_AV void LPIT0_IRQHandler(void)
493 { LPIT0_DriverIRQHandler();
494 }
495
LPSPI0_IRQHandler(void)496 WEAK_AV void LPSPI0_IRQHandler(void)
497 { LPSPI0_DriverIRQHandler();
498 }
499
LPSPI1_IRQHandler(void)500 WEAK_AV void LPSPI1_IRQHandler(void)
501 { LPSPI1_DriverIRQHandler();
502 }
503
LPUART0_IRQHandler(void)504 WEAK_AV void LPUART0_IRQHandler(void)
505 { LPUART0_DriverIRQHandler();
506 }
507
LPUART1_IRQHandler(void)508 WEAK_AV void LPUART1_IRQHandler(void)
509 { LPUART1_DriverIRQHandler();
510 }
511
LPI2C0_IRQHandler(void)512 WEAK_AV void LPI2C0_IRQHandler(void)
513 { LPI2C0_DriverIRQHandler();
514 }
515
LPI2C1_IRQHandler(void)516 WEAK_AV void LPI2C1_IRQHandler(void)
517 { LPI2C1_DriverIRQHandler();
518 }
519
Reserved32_IRQHandler(void)520 WEAK_AV void Reserved32_IRQHandler(void)
521 { Reserved32_DriverIRQHandler();
522 }
523
PORTA_IRQHandler(void)524 WEAK_AV void PORTA_IRQHandler(void)
525 { PORTA_DriverIRQHandler();
526 }
527
PORTB_IRQHandler(void)528 WEAK_AV void PORTB_IRQHandler(void)
529 { PORTB_DriverIRQHandler();
530 }
531
PORTC_IRQHandler(void)532 WEAK_AV void PORTC_IRQHandler(void)
533 { PORTC_DriverIRQHandler();
534 }
535
PORTD_IRQHandler(void)536 WEAK_AV void PORTD_IRQHandler(void)
537 { PORTD_DriverIRQHandler();
538 }
539
PORTE_IRQHandler(void)540 WEAK_AV void PORTE_IRQHandler(void)
541 { PORTE_DriverIRQHandler();
542 }
543
LLWU_IRQHandler(void)544 WEAK_AV void LLWU_IRQHandler(void)
545 { LLWU_DriverIRQHandler();
546 }
547
Reserved39_IRQHandler(void)548 WEAK_AV void Reserved39_IRQHandler(void)
549 { Reserved39_DriverIRQHandler();
550 }
551
USB0_IRQHandler(void)552 WEAK_AV void USB0_IRQHandler(void)
553 { USB0_DriverIRQHandler();
554 }
555
ADC0_IRQHandler(void)556 WEAK_AV void ADC0_IRQHandler(void)
557 { ADC0_DriverIRQHandler();
558 }
559
LPTMR0_IRQHandler(void)560 WEAK_AV void LPTMR0_IRQHandler(void)
561 { LPTMR0_DriverIRQHandler();
562 }
563
RTC_Seconds_IRQHandler(void)564 WEAK_AV void RTC_Seconds_IRQHandler(void)
565 { RTC_Seconds_DriverIRQHandler();
566 }
567
INTMUX0_0_IRQHandler(void)568 WEAK_AV void INTMUX0_0_IRQHandler(void)
569 { INTMUX0_0_DriverIRQHandler();
570 }
571
INTMUX0_1_IRQHandler(void)572 WEAK_AV void INTMUX0_1_IRQHandler(void)
573 { INTMUX0_1_DriverIRQHandler();
574 }
575
INTMUX0_2_IRQHandler(void)576 WEAK_AV void INTMUX0_2_IRQHandler(void)
577 { INTMUX0_2_DriverIRQHandler();
578 }
579
INTMUX0_3_IRQHandler(void)580 WEAK_AV void INTMUX0_3_IRQHandler(void)
581 { INTMUX0_3_DriverIRQHandler();
582 }
583
LPTMR1_IRQHandler(void)584 WEAK_AV void LPTMR1_IRQHandler(void)
585 { LPTMR1_DriverIRQHandler();
586 }
587
Reserved49_IRQHandler(void)588 WEAK_AV void Reserved49_IRQHandler(void)
589 { Reserved49_DriverIRQHandler();
590 }
591
Reserved50_IRQHandler(void)592 WEAK_AV void Reserved50_IRQHandler(void)
593 { Reserved50_DriverIRQHandler();
594 }
595
Reserved51_IRQHandler(void)596 WEAK_AV void Reserved51_IRQHandler(void)
597 { Reserved51_DriverIRQHandler();
598 }
599
LPSPI2_IRQHandler(void)600 WEAK_AV void LPSPI2_IRQHandler(void)
601 { LPSPI2_DriverIRQHandler();
602 }
603
LPUART2_IRQHandler(void)604 WEAK_AV void LPUART2_IRQHandler(void)
605 { LPUART2_DriverIRQHandler();
606 }
607
EMVSIM0_IRQHandler(void)608 WEAK_AV void EMVSIM0_IRQHandler(void)
609 { EMVSIM0_DriverIRQHandler();
610 }
611
LPI2C2_IRQHandler(void)612 WEAK_AV void LPI2C2_IRQHandler(void)
613 { LPI2C2_DriverIRQHandler();
614 }
615
TSI0_IRQHandler(void)616 WEAK_AV void TSI0_IRQHandler(void)
617 { TSI0_DriverIRQHandler();
618 }
619
PMC_IRQHandler(void)620 WEAK_AV void PMC_IRQHandler(void)
621 { PMC_DriverIRQHandler();
622 }
623
FTFA_IRQHandler(void)624 WEAK_AV void FTFA_IRQHandler(void)
625 { FTFA_DriverIRQHandler();
626 }
627
SCG_IRQHandler(void)628 WEAK_AV void SCG_IRQHandler(void)
629 { SCG_DriverIRQHandler();
630 }
631
WDOG0_IRQHandler(void)632 WEAK_AV void WDOG0_IRQHandler(void)
633 { WDOG0_DriverIRQHandler();
634 }
635
DAC0_IRQHandler(void)636 WEAK_AV void DAC0_IRQHandler(void)
637 { DAC0_DriverIRQHandler();
638 }
639
TRNG_IRQHandler(void)640 WEAK_AV void TRNG_IRQHandler(void)
641 { TRNG_DriverIRQHandler();
642 }
643
RCM_IRQHandler(void)644 WEAK_AV void RCM_IRQHandler(void)
645 { RCM_DriverIRQHandler();
646 }
647
CMP0_IRQHandler(void)648 WEAK_AV void CMP0_IRQHandler(void)
649 { CMP0_DriverIRQHandler();
650 }
651
CMP1_IRQHandler(void)652 WEAK_AV void CMP1_IRQHandler(void)
653 { CMP1_DriverIRQHandler();
654 }
655
RTC_IRQHandler(void)656 WEAK_AV void RTC_IRQHandler(void)
657 { RTC_DriverIRQHandler();
658 }
659
660 //*****************************************************************************
661
662 #if defined (DEBUG)
663 #pragma GCC pop_options
664 #endif // (DEBUG)
665
