//***************************************************************************** | |
// LPC55S69_cm33_core0 startup code for use with MCUXpresso IDE | |
// | |
// Version : 220119 | |
//***************************************************************************** | |
// | |
// Copyright 2016-2019 NXP | |
// All rights reserved. | |
// | |
// SPDX-License-Identifier: BSD-3-Clause | |
//***************************************************************************** | |
#if defined (DEBUG) | |
#pragma GCC push_options | |
#pragma GCC optimize ("Og") | |
#endif // (DEBUG) | |
#if defined (__cplusplus) | |
#ifdef __REDLIB__ | |
#error Redlib does not support C++ | |
#else | |
//***************************************************************************** | |
// | |
// The entry point for the C++ library startup | |
// | |
//***************************************************************************** | |
extern "C" { | |
extern void __libc_init_array(void); | |
} | |
#endif | |
#endif | |
#define WEAK __attribute__ ((weak)) | |
#define WEAK_AV __attribute__ ((weak, section(".after_vectors"))) | |
#define ALIAS(f) __attribute__ ((weak, alias (#f))) | |
//***************************************************************************** | |
#if defined (__cplusplus) | |
extern "C" { | |
#endif | |
//***************************************************************************** | |
// Variable to store CRP value in. Will be placed automatically | |
// by the linker when "Enable Code Read Protect" selected. | |
// See crp.h header for more information | |
//***************************************************************************** | |
//***************************************************************************** | |
// Declaration of external SystemInit function | |
//***************************************************************************** | |
#if defined (__USE_CMSIS) | |
extern void SystemInit(void); | |
#endif // (__USE_CMSIS) | |
//***************************************************************************** | |
// Forward declaration of the core exception handlers. | |
// When the application defines a handler (with the same name), this will | |
// automatically take precedence over these weak definitions. | |
// If your application is a C++ one, then any interrupt handlers defined | |
// in C++ files within in your main application will need to have C linkage | |
// rather than C++ linkage. To do this, make sure that you are using extern "C" | |
// { .... } around the interrupt handler within your main application code. | |
//***************************************************************************** | |
void ResetISR(void); | |
WEAK void NMI_Handler(void); | |
WEAK void HardFault_Handler(void); | |
WEAK void MemManage_Handler(void); | |
WEAK void BusFault_Handler(void); | |
WEAK void UsageFault_Handler(void); | |
WEAK void SVC_Handler(void); | |
WEAK void DebugMon_Handler(void); | |
WEAK void PendSV_Handler(void); | |
WEAK void SysTick_Handler(void); | |
WEAK void IntDefaultHandler(void); | |
//***************************************************************************** | |
// Forward declaration of the application IRQ handlers. When the application | |
// defines a handler (with the same name), this will automatically take | |
// precedence over weak definitions below | |
//***************************************************************************** | |
WEAK void WDT_BOD_IRQHandler(void); | |
WEAK void DMA0_IRQHandler(void); | |
WEAK void GINT0_IRQHandler(void); | |
WEAK void GINT1_IRQHandler(void); | |
WEAK void PIN_INT0_IRQHandler(void); | |
WEAK void PIN_INT1_IRQHandler(void); | |
WEAK void PIN_INT2_IRQHandler(void); | |
WEAK void PIN_INT3_IRQHandler(void); | |
WEAK void UTICK0_IRQHandler(void); | |
WEAK void MRT0_IRQHandler(void); | |
WEAK void CTIMER0_IRQHandler(void); | |
WEAK void CTIMER1_IRQHandler(void); | |
WEAK void SCT0_IRQHandler(void); | |
WEAK void CTIMER3_IRQHandler(void); | |
WEAK void FLEXCOMM0_IRQHandler(void); | |
WEAK void FLEXCOMM1_IRQHandler(void); | |
WEAK void FLEXCOMM2_IRQHandler(void); | |
WEAK void FLEXCOMM3_IRQHandler(void); | |
WEAK void FLEXCOMM4_IRQHandler(void); | |
WEAK void FLEXCOMM5_IRQHandler(void); | |
WEAK void FLEXCOMM6_IRQHandler(void); | |
WEAK void FLEXCOMM7_IRQHandler(void); | |
WEAK void ADC0_IRQHandler(void); | |
WEAK void Reserved39_IRQHandler(void); | |
WEAK void ACMP_IRQHandler(void); | |
WEAK void Reserved41_IRQHandler(void); | |
WEAK void Reserved42_IRQHandler(void); | |
WEAK void USB0_NEEDCLK_IRQHandler(void); | |
WEAK void USB0_IRQHandler(void); | |
WEAK void RTC_IRQHandler(void); | |
WEAK void Reserved46_IRQHandler(void); | |
WEAK void MAILBOX_IRQHandler(void); | |
WEAK void PIN_INT4_IRQHandler(void); | |
WEAK void PIN_INT5_IRQHandler(void); | |
WEAK void PIN_INT6_IRQHandler(void); | |
WEAK void PIN_INT7_IRQHandler(void); | |
WEAK void CTIMER2_IRQHandler(void); | |
WEAK void CTIMER4_IRQHandler(void); | |
WEAK void OS_EVENT_IRQHandler(void); | |
WEAK void Reserved55_IRQHandler(void); | |
WEAK void Reserved56_IRQHandler(void); | |
WEAK void Reserved57_IRQHandler(void); | |
WEAK void SDIO_IRQHandler(void); | |
WEAK void Reserved59_IRQHandler(void); | |
WEAK void Reserved60_IRQHandler(void); | |
WEAK void Reserved61_IRQHandler(void); | |
WEAK void USB1_UTMI_IRQHandler(void); | |
WEAK void USB1_IRQHandler(void); | |
WEAK void USB1_NEEDCLK_IRQHandler(void); | |
WEAK void SEC_HYPERVISOR_CALL_IRQHandler(void); | |
WEAK void SEC_GPIO_INT0_IRQ0_IRQHandler(void); | |
WEAK void SEC_GPIO_INT0_IRQ1_IRQHandler(void); | |
WEAK void PLU_IRQHandler(void); | |
WEAK void SEC_VIO_IRQHandler(void); | |
WEAK void HASHCRYPT_IRQHandler(void); | |
WEAK void CASER_IRQHandler(void); | |
WEAK void PUF_IRQHandler(void); | |
WEAK void PQ_IRQHandler(void); | |
WEAK void DMA1_IRQHandler(void); | |
WEAK void LSPI_HS_IRQHandler(void); | |
//***************************************************************************** | |
// Forward declaration of the driver IRQ handlers. These are aliased | |
// to the IntDefaultHandler, which is a 'forever' loop. When the driver | |
// defines a handler (with the same name), this will automatically take | |
// precedence over these weak definitions | |
//***************************************************************************** | |
void WDT_BOD_DriverIRQHandler(void) ALIAS(IntDefaultHandler); | |
void DMA0_DriverIRQHandler(void) ALIAS(IntDefaultHandler); | |
void GINT0_DriverIRQHandler(void) ALIAS(IntDefaultHandler); | |
void GINT1_DriverIRQHandler(void) ALIAS(IntDefaultHandler); | |
void PIN_INT0_DriverIRQHandler(void) ALIAS(IntDefaultHandler); | |
void PIN_INT1_DriverIRQHandler(void) ALIAS(IntDefaultHandler); | |
void PIN_INT2_DriverIRQHandler(void) ALIAS(IntDefaultHandler); | |
void PIN_INT3_DriverIRQHandler(void) ALIAS(IntDefaultHandler); | |
void UTICK0_DriverIRQHandler(void) ALIAS(IntDefaultHandler); | |
void MRT0_DriverIRQHandler(void) ALIAS(IntDefaultHandler); | |
void CTIMER0_DriverIRQHandler(void) ALIAS(IntDefaultHandler); | |
void CTIMER1_DriverIRQHandler(void) ALIAS(IntDefaultHandler); | |
void SCT0_DriverIRQHandler(void) ALIAS(IntDefaultHandler); | |
void CTIMER3_DriverIRQHandler(void) ALIAS(IntDefaultHandler); | |
void FLEXCOMM0_DriverIRQHandler(void) ALIAS(IntDefaultHandler); | |
void FLEXCOMM1_DriverIRQHandler(void) ALIAS(IntDefaultHandler); | |
void FLEXCOMM2_DriverIRQHandler(void) ALIAS(IntDefaultHandler); | |
void FLEXCOMM3_DriverIRQHandler(void) ALIAS(IntDefaultHandler); | |
void FLEXCOMM4_DriverIRQHandler(void) ALIAS(IntDefaultHandler); | |
void FLEXCOMM5_DriverIRQHandler(void) ALIAS(IntDefaultHandler); | |
void FLEXCOMM6_DriverIRQHandler(void) ALIAS(IntDefaultHandler); | |
void FLEXCOMM7_DriverIRQHandler(void) ALIAS(IntDefaultHandler); | |
void ADC0_DriverIRQHandler(void) ALIAS(IntDefaultHandler); | |
void Reserved39_DriverIRQHandler(void) ALIAS(IntDefaultHandler); | |
void ACMP_DriverIRQHandler(void) ALIAS(IntDefaultHandler); | |
void Reserved41_DriverIRQHandler(void) ALIAS(IntDefaultHandler); | |
void Reserved42_DriverIRQHandler(void) ALIAS(IntDefaultHandler); | |
void USB0_NEEDCLK_DriverIRQHandler(void) ALIAS(IntDefaultHandler); | |
void USB0_DriverIRQHandler(void) ALIAS(IntDefaultHandler); | |
void RTC_DriverIRQHandler(void) ALIAS(IntDefaultHandler); | |
void Reserved46_DriverIRQHandler(void) ALIAS(IntDefaultHandler); | |
void MAILBOX_DriverIRQHandler(void) ALIAS(IntDefaultHandler); | |
void PIN_INT4_DriverIRQHandler(void) ALIAS(IntDefaultHandler); | |
void PIN_INT5_DriverIRQHandler(void) ALIAS(IntDefaultHandler); | |
void PIN_INT6_DriverIRQHandler(void) ALIAS(IntDefaultHandler); | |
void PIN_INT7_DriverIRQHandler(void) ALIAS(IntDefaultHandler); | |
void CTIMER2_DriverIRQHandler(void) ALIAS(IntDefaultHandler); | |
void CTIMER4_DriverIRQHandler(void) ALIAS(IntDefaultHandler); | |
void OS_EVENT_DriverIRQHandler(void) ALIAS(IntDefaultHandler); | |
void Reserved55_DriverIRQHandler(void) ALIAS(IntDefaultHandler); | |
void Reserved56_DriverIRQHandler(void) ALIAS(IntDefaultHandler); | |
void Reserved57_DriverIRQHandler(void) ALIAS(IntDefaultHandler); | |
void SDIO_DriverIRQHandler(void) ALIAS(IntDefaultHandler); | |
void Reserved59_DriverIRQHandler(void) ALIAS(IntDefaultHandler); | |
void Reserved60_DriverIRQHandler(void) ALIAS(IntDefaultHandler); | |
void Reserved61_DriverIRQHandler(void) ALIAS(IntDefaultHandler); | |
void USB1_UTMI_DriverIRQHandler(void) ALIAS(IntDefaultHandler); | |
void USB1_DriverIRQHandler(void) ALIAS(IntDefaultHandler); | |
void USB1_NEEDCLK_DriverIRQHandler(void) ALIAS(IntDefaultHandler); | |
void SEC_HYPERVISOR_CALL_DriverIRQHandler(void) ALIAS(IntDefaultHandler); | |
void SEC_GPIO_INT0_IRQ0_DriverIRQHandler(void) ALIAS(IntDefaultHandler); | |
void SEC_GPIO_INT0_IRQ1_DriverIRQHandler(void) ALIAS(IntDefaultHandler); | |
void PLU_DriverIRQHandler(void) ALIAS(IntDefaultHandler); | |
void SEC_VIO_DriverIRQHandler(void) ALIAS(IntDefaultHandler); | |
void HASHCRYPT_DriverIRQHandler(void) ALIAS(IntDefaultHandler); | |
void CASER_DriverIRQHandler(void) ALIAS(IntDefaultHandler); | |
void PUF_DriverIRQHandler(void) ALIAS(IntDefaultHandler); | |
void PQ_DriverIRQHandler(void) ALIAS(IntDefaultHandler); | |
void DMA1_DriverIRQHandler(void) ALIAS(IntDefaultHandler); | |
void LSPI_HS_DriverIRQHandler(void) ALIAS(IntDefaultHandler); | |
//***************************************************************************** | |
// The entry point for the application. | |
// __main() is the entry point for Redlib based applications | |
// main() is the entry point for Newlib based applications | |
//***************************************************************************** | |
#if defined (__REDLIB__) | |
extern void __main(void); | |
#endif | |
extern int main(void); | |
//***************************************************************************** | |
// External declaration for the pointer to the stack top from the Linker Script | |
//***************************************************************************** | |
extern void _vStackTop(void); | |
//***************************************************************************** | |
// External declaration for LPC MCU vector table checksum from Linker Script | |
//***************************************************************************** | |
WEAK extern void __valid_user_code_checksum(); | |
//***************************************************************************** | |
//***************************************************************************** | |
#if defined (__cplusplus) | |
} // extern "C" | |
#endif | |
//***************************************************************************** | |
// The vector table. | |
// This relies on the linker script to place at correct location in memory. | |
//***************************************************************************** | |
extern void (* const g_pfnVectors[])(void); | |
extern void * __Vectors __attribute__ ((alias ("g_pfnVectors"))); | |
__attribute__ ((used, section(".isr_vector"))) | |
void (* const g_pfnVectors[])(void) = { | |
// Core Level - CM33 | |
&_vStackTop, // The initial stack pointer | |
ResetISR, // The reset handler | |
NMI_Handler, // The NMI handler | |
HardFault_Handler, // The hard fault handler | |
MemManage_Handler, // The MPU fault handler | |
BusFault_Handler, // The bus fault handler | |
UsageFault_Handler, // The usage fault handler | |
__valid_user_code_checksum, // LPC MCU checksum | |
0, // ECRP | |
0, // Reserved | |
0, // Reserved | |
SVC_Handler, // SVCall handler | |
DebugMon_Handler, // Debug monitor handler | |
0, // Reserved | |
PendSV_Handler, // The PendSV handler | |
SysTick_Handler, // The SysTick handler | |
// Chip Level - LPC55S69_cm33_core0 | |
WDT_BOD_IRQHandler, // 16: Windowed watchdog timer, Brownout detect, Flash interrupt | |
DMA0_IRQHandler, // 17: DMA0 controller | |
GINT0_IRQHandler, // 18: GPIO group 0 | |
GINT1_IRQHandler, // 19: GPIO group 1 | |
PIN_INT0_IRQHandler, // 20: Pin interrupt 0 or pattern match engine slice 0 | |
PIN_INT1_IRQHandler, // 21: Pin interrupt 1or pattern match engine slice 1 | |
PIN_INT2_IRQHandler, // 22: Pin interrupt 2 or pattern match engine slice 2 | |
PIN_INT3_IRQHandler, // 23: Pin interrupt 3 or pattern match engine slice 3 | |
UTICK0_IRQHandler, // 24: Micro-tick Timer | |
MRT0_IRQHandler, // 25: Multi-rate timer | |
CTIMER0_IRQHandler, // 26: Standard counter/timer CTIMER0 | |
CTIMER1_IRQHandler, // 27: Standard counter/timer CTIMER1 | |
SCT0_IRQHandler, // 28: SCTimer/PWM | |
CTIMER3_IRQHandler, // 29: Standard counter/timer CTIMER3 | |
FLEXCOMM0_IRQHandler, // 30: Flexcomm Interface 0 (USART, SPI, I2C, I2S, FLEXCOMM) | |
FLEXCOMM1_IRQHandler, // 31: Flexcomm Interface 1 (USART, SPI, I2C, I2S, FLEXCOMM) | |
FLEXCOMM2_IRQHandler, // 32: Flexcomm Interface 2 (USART, SPI, I2C, I2S, FLEXCOMM) | |
FLEXCOMM3_IRQHandler, // 33: Flexcomm Interface 3 (USART, SPI, I2C, I2S, FLEXCOMM) | |
FLEXCOMM4_IRQHandler, // 34: Flexcomm Interface 4 (USART, SPI, I2C, I2S, FLEXCOMM) | |
FLEXCOMM5_IRQHandler, // 35: Flexcomm Interface 5 (USART, SPI, I2C, I2S, FLEXCOMM) | |
FLEXCOMM6_IRQHandler, // 36: Flexcomm Interface 6 (USART, SPI, I2C, I2S, FLEXCOMM) | |
FLEXCOMM7_IRQHandler, // 37: Flexcomm Interface 7 (USART, SPI, I2C, I2S, FLEXCOMM) | |
ADC0_IRQHandler, // 38: ADC0 | |
Reserved39_IRQHandler, // 39: Reserved interrupt | |
ACMP_IRQHandler, // 40: ACMP interrupts | |
Reserved41_IRQHandler, // 41: Reserved interrupt | |
Reserved42_IRQHandler, // 42: Reserved interrupt | |
USB0_NEEDCLK_IRQHandler, // 43: USB Activity Wake-up Interrupt | |
USB0_IRQHandler, // 44: USB device | |
RTC_IRQHandler, // 45: RTC alarm and wake-up interrupts | |
Reserved46_IRQHandler, // 46: Reserved interrupt | |
MAILBOX_IRQHandler, // 47: WAKEUP,Mailbox interrupt (present on selected devices) | |
PIN_INT4_IRQHandler, // 48: Pin interrupt 4 or pattern match engine slice 4 int | |
PIN_INT5_IRQHandler, // 49: Pin interrupt 5 or pattern match engine slice 5 int | |
PIN_INT6_IRQHandler, // 50: Pin interrupt 6 or pattern match engine slice 6 int | |
PIN_INT7_IRQHandler, // 51: Pin interrupt 7 or pattern match engine slice 7 int | |
CTIMER2_IRQHandler, // 52: Standard counter/timer CTIMER2 | |
CTIMER4_IRQHandler, // 53: Standard counter/timer CTIMER4 | |
OS_EVENT_IRQHandler, // 54: OSEVTIMER0 and OSEVTIMER0_WAKEUP interrupts | |
Reserved55_IRQHandler, // 55: Reserved interrupt | |
Reserved56_IRQHandler, // 56: Reserved interrupt | |
Reserved57_IRQHandler, // 57: Reserved interrupt | |
SDIO_IRQHandler, // 58: SD/MMC | |
Reserved59_IRQHandler, // 59: Reserved interrupt | |
Reserved60_IRQHandler, // 60: Reserved interrupt | |
Reserved61_IRQHandler, // 61: Reserved interrupt | |
USB1_UTMI_IRQHandler, // 62: USB1_UTMI | |
USB1_IRQHandler, // 63: USB1 interrupt | |
USB1_NEEDCLK_IRQHandler, // 64: USB1 activity | |
SEC_HYPERVISOR_CALL_IRQHandler, // 65: SEC_HYPERVISOR_CALL interrupt | |
SEC_GPIO_INT0_IRQ0_IRQHandler, // 66: SEC_GPIO_INT0_IRQ0 interrupt | |
SEC_GPIO_INT0_IRQ1_IRQHandler, // 67: SEC_GPIO_INT0_IRQ1 interrupt | |
PLU_IRQHandler, // 68: PLU interrupt | |
SEC_VIO_IRQHandler, // 69: SEC_VIO interrupt | |
HASHCRYPT_IRQHandler, // 70: HASHCRYPT interrupt | |
CASER_IRQHandler, // 71: CASPER interrupt | |
PUF_IRQHandler, // 72: PUF interrupt | |
PQ_IRQHandler, // 73: PQ interrupt | |
DMA1_IRQHandler, // 74: DMA1 interrupt | |
LSPI_HS_IRQHandler, // 75: Flexcomm Interface 8 (SPI, , FLEXCOMM) | |
}; /* End of g_pfnVectors */ | |
//***************************************************************************** | |
// Functions to carry out the initialization of RW and BSS data sections. These | |
// are written as separate functions rather than being inlined within the | |
// ResetISR() function in order to cope with MCUs with multiple banks of | |
// memory. | |
//***************************************************************************** | |
__attribute__ ((section(".after_vectors.init_data"))) | |
void data_init(unsigned int romstart, unsigned int start, unsigned int len) { | |
unsigned int *pulDest = (unsigned int*) start; | |
unsigned int *pulSrc = (unsigned int*) romstart; | |
unsigned int loop; | |
for (loop = 0; loop < len; loop = loop + 4) | |
*pulDest++ = *pulSrc++; | |
} | |
__attribute__ ((section(".after_vectors.init_bss"))) | |
void bss_init(unsigned int start, unsigned int len) { | |
unsigned int *pulDest = (unsigned int*) start; | |
unsigned int loop; | |
for (loop = 0; loop < len; loop = loop + 4) | |
*pulDest++ = 0; | |
} | |
//***************************************************************************** | |
// The following symbols are constructs generated by the linker, indicating | |
// the location of various points in the "Global Section Table". This table is | |
// created by the linker via the Code Red managed linker script mechanism. It | |
// contains the load address, execution address and length of each RW data | |
// section and the execution and length of each BSS (zero initialized) section. | |
//***************************************************************************** | |
extern unsigned int __data_section_table; | |
extern unsigned int __data_section_table_end; | |
extern unsigned int __bss_section_table; | |
extern unsigned int __bss_section_table_end; | |
//***************************************************************************** | |
// Reset entry point for your code. | |
// Sets up a simple runtime environment and initializes the C/C++ | |
// library. | |
//***************************************************************************** | |
__attribute__ ((section(".after_vectors.reset"))) | |
void ResetISR(void) { | |
// Disable interrupts | |
__asm volatile ("cpsid i"); | |
#if defined (__USE_CMSIS) | |
// If __USE_CMSIS defined, then call CMSIS SystemInit code | |
SystemInit(); | |
#endif // (__USE_CMSIS) | |
// | |
// Copy the data sections from flash to SRAM. | |
// | |
unsigned int LoadAddr, ExeAddr, SectionLen; | |
unsigned int *SectionTableAddr; | |
// Load base address of Global Section Table | |
SectionTableAddr = &__data_section_table; | |
// Copy the data sections from flash to SRAM. | |
while (SectionTableAddr < &__data_section_table_end) { | |
LoadAddr = *SectionTableAddr++; | |
ExeAddr = *SectionTableAddr++; | |
SectionLen = *SectionTableAddr++; | |
data_init(LoadAddr, ExeAddr, SectionLen); | |
} | |
// At this point, SectionTableAddr = &__bss_section_table; | |
// Zero fill the bss segment | |
while (SectionTableAddr < &__bss_section_table_end) { | |
ExeAddr = *SectionTableAddr++; | |
SectionLen = *SectionTableAddr++; | |
bss_init(ExeAddr, SectionLen); | |
} | |
#if !defined (__USE_CMSIS) | |
// Assume that if __USE_CMSIS defined, then CMSIS SystemInit code | |
// will setup the VTOR register | |
// Check to see if we are running the code from a non-zero | |
// address (eg RAM, external flash), in which case we need | |
// to modify the VTOR register to tell the CPU that the | |
// vector table is located at a non-0x0 address. | |
unsigned int * pSCB_VTOR = (unsigned int *) 0xE000ED08; | |
if ((unsigned int *)g_pfnVectors!=(unsigned int *) 0x00000000) { | |
*pSCB_VTOR = (unsigned int)g_pfnVectors; | |
} | |
#endif // (__USE_CMSIS) | |
#if defined (__cplusplus) | |
// | |
// Call C++ library initialisation | |
// | |
__libc_init_array(); | |
#endif | |
// Reenable interrupts | |
__asm volatile ("cpsie i"); | |
#if defined (__REDLIB__) | |
// Call the Redlib library, which in turn calls main() | |
__main(); | |
#else | |
main(); | |
#endif | |
// | |
// main() shouldn't return, but if it does, we'll just enter an infinite loop | |
// | |
while (1) { | |
; | |
} | |
} | |
//***************************************************************************** | |
// Default core exception handlers. Override the ones here by defining your own | |
// handler routines in your application code. | |
//***************************************************************************** | |
WEAK_AV void NMI_Handler(void) | |
{ while(1) {} | |
} | |
WEAK_AV void HardFault_Handler(void) | |
{ while(1) {} | |
} | |
WEAK_AV void MemManage_Handler(void) | |
{ while(1) {} | |
} | |
WEAK_AV void BusFault_Handler(void) | |
{ while(1) {} | |
} | |
WEAK_AV void UsageFault_Handler(void) | |
{ while(1) {} | |
} | |
WEAK_AV void SVC_Handler(void) | |
{ while(1) {} | |
} | |
WEAK_AV void DebugMon_Handler(void) | |
{ while(1) {} | |
} | |
WEAK_AV void PendSV_Handler(void) | |
{ while(1) {} | |
} | |
WEAK_AV void SysTick_Handler(void) | |
{ while(1) {} | |
} | |
//***************************************************************************** | |
// Processor ends up here if an unexpected interrupt occurs or a specific | |
// handler is not present in the application code. | |
//***************************************************************************** | |
WEAK_AV void IntDefaultHandler(void) | |
{ while(1) {} | |
} | |
//***************************************************************************** | |
// Default application exception handlers. Override the ones here by defining | |
// your own handler routines in your application code. These routines call | |
// driver exception handlers or IntDefaultHandler() if no driver exception | |
// handler is included. | |
//***************************************************************************** | |
WEAK void WDT_BOD_IRQHandler(void) | |
{ WDT_BOD_DriverIRQHandler(); | |
} | |
WEAK void DMA0_IRQHandler(void) | |
{ DMA0_DriverIRQHandler(); | |
} | |
WEAK void GINT0_IRQHandler(void) | |
{ GINT0_DriverIRQHandler(); | |
} | |
WEAK void GINT1_IRQHandler(void) | |
{ GINT1_DriverIRQHandler(); | |
} | |
WEAK void PIN_INT0_IRQHandler(void) | |
{ PIN_INT0_DriverIRQHandler(); | |
} | |
WEAK void PIN_INT1_IRQHandler(void) | |
{ PIN_INT1_DriverIRQHandler(); | |
} | |
WEAK void PIN_INT2_IRQHandler(void) | |
{ PIN_INT2_DriverIRQHandler(); | |
} | |
WEAK void PIN_INT3_IRQHandler(void) | |
{ PIN_INT3_DriverIRQHandler(); | |
} | |
WEAK void UTICK0_IRQHandler(void) | |
{ UTICK0_DriverIRQHandler(); | |
} | |
WEAK void MRT0_IRQHandler(void) | |
{ MRT0_DriverIRQHandler(); | |
} | |
WEAK void CTIMER0_IRQHandler(void) | |
{ CTIMER0_DriverIRQHandler(); | |
} | |
WEAK void CTIMER1_IRQHandler(void) | |
{ CTIMER1_DriverIRQHandler(); | |
} | |
WEAK void SCT0_IRQHandler(void) | |
{ SCT0_DriverIRQHandler(); | |
} | |
WEAK void CTIMER3_IRQHandler(void) | |
{ CTIMER3_DriverIRQHandler(); | |
} | |
WEAK void FLEXCOMM0_IRQHandler(void) | |
{ FLEXCOMM0_DriverIRQHandler(); | |
} | |
WEAK void FLEXCOMM1_IRQHandler(void) | |
{ FLEXCOMM1_DriverIRQHandler(); | |
} | |
WEAK void FLEXCOMM2_IRQHandler(void) | |
{ FLEXCOMM2_DriverIRQHandler(); | |
} | |
WEAK void FLEXCOMM3_IRQHandler(void) | |
{ FLEXCOMM3_DriverIRQHandler(); | |
} | |
WEAK void FLEXCOMM4_IRQHandler(void) | |
{ FLEXCOMM4_DriverIRQHandler(); | |
} | |
WEAK void FLEXCOMM5_IRQHandler(void) | |
{ FLEXCOMM5_DriverIRQHandler(); | |
} | |
WEAK void FLEXCOMM6_IRQHandler(void) | |
{ FLEXCOMM6_DriverIRQHandler(); | |
} | |
WEAK void FLEXCOMM7_IRQHandler(void) | |
{ FLEXCOMM7_DriverIRQHandler(); | |
} | |
WEAK void ADC0_IRQHandler(void) | |
{ ADC0_DriverIRQHandler(); | |
} | |
WEAK void Reserved39_IRQHandler(void) | |
{ Reserved39_DriverIRQHandler(); | |
} | |
WEAK void ACMP_IRQHandler(void) | |
{ ACMP_DriverIRQHandler(); | |
} | |
WEAK void Reserved41_IRQHandler(void) | |
{ Reserved41_DriverIRQHandler(); | |
} | |
WEAK void Reserved42_IRQHandler(void) | |
{ Reserved42_DriverIRQHandler(); | |
} | |
WEAK void USB0_NEEDCLK_IRQHandler(void) | |
{ USB0_NEEDCLK_DriverIRQHandler(); | |
} | |
WEAK void USB0_IRQHandler(void) | |
{ USB0_DriverIRQHandler(); | |
} | |
WEAK void RTC_IRQHandler(void) | |
{ RTC_DriverIRQHandler(); | |
} | |
WEAK void Reserved46_IRQHandler(void) | |
{ Reserved46_DriverIRQHandler(); | |
} | |
WEAK void MAILBOX_IRQHandler(void) | |
{ MAILBOX_DriverIRQHandler(); | |
} | |
WEAK void PIN_INT4_IRQHandler(void) | |
{ PIN_INT4_DriverIRQHandler(); | |
} | |
WEAK void PIN_INT5_IRQHandler(void) | |
{ PIN_INT5_DriverIRQHandler(); | |
} | |
WEAK void PIN_INT6_IRQHandler(void) | |
{ PIN_INT6_DriverIRQHandler(); | |
} | |
WEAK void PIN_INT7_IRQHandler(void) | |
{ PIN_INT7_DriverIRQHandler(); | |
} | |
WEAK void CTIMER2_IRQHandler(void) | |
{ CTIMER2_DriverIRQHandler(); | |
} | |
WEAK void CTIMER4_IRQHandler(void) | |
{ CTIMER4_DriverIRQHandler(); | |
} | |
WEAK void OS_EVENT_IRQHandler(void) | |
{ OS_EVENT_DriverIRQHandler(); | |
} | |
WEAK void Reserved55_IRQHandler(void) | |
{ Reserved55_DriverIRQHandler(); | |
} | |
WEAK void Reserved56_IRQHandler(void) | |
{ Reserved56_DriverIRQHandler(); | |
} | |
WEAK void Reserved57_IRQHandler(void) | |
{ Reserved57_DriverIRQHandler(); | |
} | |
WEAK void SDIO_IRQHandler(void) | |
{ SDIO_DriverIRQHandler(); | |
} | |
WEAK void Reserved59_IRQHandler(void) | |
{ Reserved59_DriverIRQHandler(); | |
} | |
WEAK void Reserved60_IRQHandler(void) | |
{ Reserved60_DriverIRQHandler(); | |
} | |
WEAK void Reserved61_IRQHandler(void) | |
{ Reserved61_DriverIRQHandler(); | |
} | |
WEAK void USB1_UTMI_IRQHandler(void) | |
{ USB1_UTMI_DriverIRQHandler(); | |
} | |
WEAK void USB1_IRQHandler(void) | |
{ USB1_DriverIRQHandler(); | |
} | |
WEAK void USB1_NEEDCLK_IRQHandler(void) | |
{ USB1_NEEDCLK_DriverIRQHandler(); | |
} | |
WEAK void SEC_HYPERVISOR_CALL_IRQHandler(void) | |
{ SEC_HYPERVISOR_CALL_DriverIRQHandler(); | |
} | |
WEAK void SEC_GPIO_INT0_IRQ0_IRQHandler(void) | |
{ SEC_GPIO_INT0_IRQ0_DriverIRQHandler(); | |
} | |
WEAK void SEC_GPIO_INT0_IRQ1_IRQHandler(void) | |
{ SEC_GPIO_INT0_IRQ1_DriverIRQHandler(); | |
} | |
WEAK void PLU_IRQHandler(void) | |
{ PLU_DriverIRQHandler(); | |
} | |
WEAK void SEC_VIO_IRQHandler(void) | |
{ SEC_VIO_DriverIRQHandler(); | |
} | |
WEAK void HASHCRYPT_IRQHandler(void) | |
{ HASHCRYPT_DriverIRQHandler(); | |
} | |
WEAK void CASER_IRQHandler(void) | |
{ CASER_DriverIRQHandler(); | |
} | |
WEAK void PUF_IRQHandler(void) | |
{ PUF_DriverIRQHandler(); | |
} | |
WEAK void PQ_IRQHandler(void) | |
{ PQ_DriverIRQHandler(); | |
} | |
WEAK void DMA1_IRQHandler(void) | |
{ DMA1_DriverIRQHandler(); | |
} | |
WEAK void LSPI_HS_IRQHandler(void) | |
{ LSPI_HS_DriverIRQHandler(); | |
} | |
//***************************************************************************** | |
#if defined (DEBUG) | |
#pragma GCC pop_options | |
#endif // (DEBUG) |