reform/reform2-lpc-fw/cmsis/startup_lpc11u_gnumake.c

/*================================*/
/*=====LPC11XX GNU STARTUP========*/
/*==A CODERED COMPATIBLE STARTUP==*/
/*================================*/
#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 ALIAS(f) __attribute__ ((weak, alias (#f)))

#include "LPC11Uxx.h"

//*****************************************************************************
#if defined (__cplusplus)
extern "C" {
#endif

extern unsigned int __data_load_addr;
extern unsigned int __data_start;
extern unsigned int __data_end;
extern unsigned int __bss_start;
extern unsigned int __bss_end;
extern unsigned int __StackTop;
#ifdef FIXED_STACKHEAP_SIZE
#define STACK_SIZE  (800)
#define HEAP_SIZE  (200)
unsigned char StackMem[STACK_SIZE] __attribute__ ((section(".stack")));
unsigned char HeapMem[HEAP_SIZE] __attribute__ ((section(".heap"), align(8)));
#endif
//*****************************************************************************
//
// Forward declaration of the default handlers. These are aliased.
// When the application defines a handler (with the same name), this will
// automatically take precedence over these weak definitions
//
//*****************************************************************************
     void Reset_Handler(void);
WEAK void NMI_Handler(void);
WEAK void HardFault_Handler(void);
WEAK void SVC_Handler(void);
WEAK void PendSV_Handler(void);
WEAK void SysTick_Handler(void);
WEAK void IntDefaultHandler(void);
//*****************************************************************************
//
// Forward declaration of the specific IRQ handlers. These are aliased
// to the IntDefaultHandler, which is a 'forever' loop. When the application
// defines a handler (with the same name), this will automatically take
// precedence over these weak definitions
//
//*****************************************************************************

void FLEX_INT0_IRQHandler (void) ALIAS(IntDefaultHandler);
void FLEX_INT1_IRQHandler (void) ALIAS(IntDefaultHandler);
void FLEX_INT2_IRQHandler (void) ALIAS(IntDefaultHandler);
void FLEX_INT3_IRQHandler (void) ALIAS(IntDefaultHandler);
void FLEX_INT4_IRQHandler (void) ALIAS(IntDefaultHandler);
void FLEX_INT5_IRQHandler (void) ALIAS(IntDefaultHandler);
void FLEX_INT6_IRQHandler (void) ALIAS(IntDefaultHandler);
void FLEX_INT7_IRQHandler (void) ALIAS(IntDefaultHandler);
void GINT0_IRQHandler     (void) ALIAS(IntDefaultHandler);
void GINT1_IRQHandler     (void) ALIAS(IntDefaultHandler);
void SSP1_IRQHandler      (void) ALIAS(IntDefaultHandler);
void I2C_IRQHandler       (void) ALIAS(IntDefaultHandler);
void TIMER16_0_IRQHandler (void) ALIAS(IntDefaultHandler);
void TIMER16_1_IRQHandler (void) ALIAS(IntDefaultHandler);
void TIMER32_0_IRQHandler (void) ALIAS(IntDefaultHandler);
void TIMER32_1_IRQHandler (void) ALIAS(IntDefaultHandler);
void SSP0_IRQHandler      (void) ALIAS(IntDefaultHandler);
void UART_IRQHandler      (void) ALIAS(IntDefaultHandler);
void USB_IRQHandler       (void) ALIAS(IntDefaultHandler);
void USB_FIQHandler       (void) ALIAS(IntDefaultHandler);
void ADC_IRQHandler       (void) ALIAS(IntDefaultHandler);
void WDT_IRQHandler       (void) ALIAS(IntDefaultHandler);
void BOD_IRQHandler       (void) ALIAS(IntDefaultHandler);
void FMC_IRQHandler       (void) ALIAS(IntDefaultHandler);
void USBWakeup_IRQHandler (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);
#else
extern int main(void);
#endif

//*****************************************************************************
#if defined (__cplusplus)
} // extern "C"
#endif

__attribute__ ((section(".isr_vector_table")))
void (* const Vectors[])(void) = {
#ifdef FIXED_STACKHEAP_SIZE
  (void (*)(void))(StackMem + STACK_SIZE),          // The initial stack pointer
#else
  (void (*)(void))&__StackTop,
#endif
  Reset_Handler,                    // The reset handler
  NMI_Handler,                      // The NMI handler
  HardFault_Handler,                // The hard fault handler
  0,                                // Reserved
  0,                                // Reserved
  0,                                // Reserved
  0,                                // Reserved
  0,                                // Reserved
  0,                                // Reserved
  0,                                // Reserved
  SVC_Handler,                      // SVCall handler
  0,                                // Reserved
  0,                                // Reserved
  PendSV_Handler,                   // The PendSV handler
  SysTick_Handler,                  // The SysTick handler

  // LPC11U specific handlers
  FLEX_INT0_IRQHandler,             //  0 - GPIO pin interrupt 0
  FLEX_INT1_IRQHandler,             //  1 - GPIO pin interrupt 1
  FLEX_INT2_IRQHandler,             //  2 - GPIO pin interrupt 2
  FLEX_INT3_IRQHandler,             //  3 - GPIO pin interrupt 3
  FLEX_INT4_IRQHandler,             //  4 - GPIO pin interrupt 4
  FLEX_INT5_IRQHandler,             //  5 - GPIO pin interrupt 5
  FLEX_INT6_IRQHandler,             //  6 - GPIO pin interrupt 6
  FLEX_INT7_IRQHandler,             //  7 - GPIO pin interrupt 7
  GINT0_IRQHandler,                 //  8 - GPIO GROUP0 interrupt
  GINT1_IRQHandler,                 //  9 - GPIO GROUP1 interrupt
  0,                                // 10 - Reserved
  0,                                // 11 - Reserved
  0,                                // 12 - Reserved
  0,                                // 13 - Reserved
  SSP1_IRQHandler,                  // 14 - SPI/SSP1 Interrupt
  I2C_IRQHandler,                   // 15 - I2C0
  TIMER16_0_IRQHandler,             // 16 - CT16B0 (16-bit Timer 0)
  TIMER16_1_IRQHandler,             // 17 - CT16B1 (16-bit Timer 1)
  TIMER32_0_IRQHandler,             // 18 - CT32B0 (32-bit Timer 0)
  TIMER32_1_IRQHandler,             // 19 - CT32B1 (32-bit Timer 1)
  SSP0_IRQHandler,                  // 20 - SPI/SSP0 Interrupt
  UART_IRQHandler,                  // 21 - UART0
  USB_IRQHandler,                   // 22 - USB IRQ
  USB_FIQHandler,                   // 23 - USB FIQ
  ADC_IRQHandler,                   // 24 - ADC (A/D Converter)
  WDT_IRQHandler,                   // 25 - WDT (Watchdog Timer)
  BOD_IRQHandler,                   // 26 - BOD (Brownout Detect)
  FMC_IRQHandler,                   // 27 - IP2111 Flash Memory Controller
  0,                                // 28 - Reserved
  0,                                // 29 - Reserved
  USBWakeup_IRQHandler,             // 30 - USB wake-up interrupt
  0,                                // 31 - Reserved
};

//*****************************************************************************
// Reset entry point for your code.
// Sets up a simple runtime environment and initializes the C/C++
// library.
//*****************************************************************************
__attribute__ ((section(".after_vectors")))
void Reset_Handler(void)
{
  /*
   * Only Initialize Internal SRAM
   * USB RAM is used for USB purpose
   */
  unsigned int *src, *dst;

  /* Copy data section from flash to RAM */
  src = &__data_load_addr;
  dst = &__data_start;
  while (dst < &__data_end)
    *dst++ = *src++;

  /* Zero fill the bss section */
  dst = &__bss_start;
  while (dst < &__bss_end)
    *dst++ = 0;

  SystemInit();

#if defined (__cplusplus)
  //
  // Call C++ library initialisation
  //
  __libc_init_array();
#endif

#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 exception handlers. Override the ones here by defining your own
// handler routines in your application code.
//*****************************************************************************
__attribute__ ((section(".after_vectors")))
void NMI_Handler(void)
{
    while(1)
    {
    }
}

__attribute__ ((section(".after_vectors")))
void HardFault_Handler(void)
{
    while(1)
    {
    }
}

__attribute__ ((section(".after_vectors")))
void SVC_Handler(void)
{
    while(1)
    {
    }
}

__attribute__ ((section(".after_vectors")))
void PendSV_Handler(void)
{
    while(1)
    {
    }
}

__attribute__ ((section(".after_vectors")))
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.
//
//*****************************************************************************
__attribute__ ((section(".after_vectors")))
void IntDefaultHandler(void)
{
    while(1)
    {
    }
}