embedded/arch/arm/mach-lpc17xx/libs/hal/startup.c

   1 /****************************************************************************//**
   2  * @file :    startup_LPC17xx.c
   3  * @brief : CMSIS Cortex-M3 Core Device Startup File
   4  * @version : V1.01
   5  * @date :    4. Feb. 2009
   6  *
   7  *----------------------------------------------------------------------------
   8  *
   9  * Copyright (C) 2009 ARM Limited. All rights reserved.
  10  *
  11  * ARM Limited (ARM) is supplying this software for use with Cortex-Mx
  12  * processor based microcontrollers.  This file can be freely distributed
  13  * within development tools that are supporting such ARM based processors.
  14  *
  15  * THIS SOFTWARE IS PROVIDED "AS IS".  NO WARRANTIES, WHETHER EXPRESS, IMPLIED
  16  * OR STATUTORY, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF
  17  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE.
  18  * ARM SHALL NOT, IN ANY CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR
  19  * CONSEQUENTIAL DAMAGES, FOR ANY REASON WHATSOEVER.
  20  *
  21  ******************************************************************************/
  22
  23 // Mod by nio for the .fastcode part
  24
  25 #include "cpu_def.h"
  26 #include "LPC17xx.h"
  27
  28 #define WEAK __attribute__ ((weak))
  29 //*****************************************************************************
  30 //
  31 // Forward declaration of the default fault handlers.
  32 //
  33 //*****************************************************************************
  34 /* System exception vector handler */
  35 void WEAK               Reset_Handler(void);             /* Reset Handler */
  36 void WEAK               NMI_Handler(void);               /* NMI Handler */
  37 void WEAK               HardFault_Handler(void);         /* Hard Fault Handler */
  38 void WEAK               MemManage_Handler(void);         /* MPU Fault Handler */
  39 void WEAK               BusFault_Handler(void);          /* Bus Fault Handler */
  40 void WEAK               UsageFault_Handler(void);        /* Usage Fault Handler */
  41 void WEAK               SVC_Handler(void);               /* SVCall Handler */
  42 void WEAK               DebugMon_Handler(void);          /* Debug Monitor Handler */
  43 void WEAK               PendSV_Handler(void);            /* PendSV Handler */
  44 void WEAK               SysTick_Handler(void);           /* SysTick Handler */
  45
  46 /* External interrupt vector handler */
  47 void WEAK       WDT_IRQHandler(void);            /* Watchdog Timer */
  48 void WEAK       TIMER0_IRQHandler(void);         /* Timer0 */
  49 void WEAK       TIMER1_IRQHandler(void);         /* Timer1 */
  50 void WEAK       TIMER2_IRQHandler(void);         /* Timer2 */
  51 void WEAK       TIMER3_IRQHandler(void);         /* Timer3 */
  52 void WEAK       UART0_IRQHandler(void);          /* UART0 */
  53 void WEAK       UART1_IRQHandler(void);          /* UART1 */
  54 void WEAK       UART2_IRQHandler(void);          /* UART2 */
  55 void WEAK       UART3_IRQHandler(void);          /* UART3 */
  56 void WEAK       PWM1_IRQHandler(void);           /* PWM1 */
  57 void WEAK       I2C0_IRQHandler(void);           /* I2C0 */
  58 void WEAK       I2C1_IRQHandler(void);           /* I2C1 */
  59 void WEAK       I2C2_IRQHandler(void);           /* I2C2 */
  60 void WEAK       SPI_IRQHandler(void);            /* SPI */
  61 void WEAK       SSP0_IRQHandler(void);           /* SSP0 */
  62 void WEAK       SSP1_IRQHandler(void);           /* SSP1 */
  63 void WEAK       PLL0_IRQHandler(void);           /* PLL0 (Main PLL) */
  64 void WEAK       RTC_IRQHandler(void);            /* Real Time Clock */
  65 void WEAK       EINT0_IRQHandler(void);          /* External Interrupt 0 */
  66 void WEAK       EINT1_IRQHandler(void);          /* External Interrupt 1 */
  67 void WEAK       EINT2_IRQHandler(void);          /* External Interrupt 2 */
  68 void WEAK       EINT3_IRQHandler(void);          /* External Interrupt 3 */
  69 void WEAK       ADC_IRQHandler(void);            /* A/D Converter */
  70 void WEAK       BOD_IRQHandler(void);            /* Brown Out Detect */
  71 void WEAK       USB_IRQHandler(void);            /* USB */
  72 void WEAK       CAN_IRQHandler(void);            /* CAN */
  73 void WEAK       DMA_IRQHandler(void);            /* GP DMA */
  74 void WEAK       I2S_IRQHandler(void);            /* I2S */
  75 void WEAK       ENET_IRQHandler(void);           /* Ethernet */
  76 void WEAK       RIT_IRQHandler(void);            /* Repetitive Interrupt Timer */
  77 void WEAK       MCPWM_IRQHandler(void);          /* Motor Control PWM */
  78 void WEAK       QEI_IRQHandler(void);            /* Quadrature Encoder Interface */
  79 void WEAK       PLL1_IRQHandler(void);           /* PLL1 (USB PLL) */
  80
  81
  82
  83 /* Exported types --------------------------------------------------------------*/
  84 /* Exported constants --------------------------------------------------------*/
  85 extern unsigned long _etext;
  86 extern unsigned long _sidata;           /* start address for the initialization values of the .data section. defined in linker script */
  87 extern unsigned long _sdata;            /* start address for the .data section. defined in linker script */
  88 extern unsigned long _edata;            /* end address for the .data section. defined in linker script */
  89
  90 extern unsigned long _sifastcode;               /* start address for the initialization values of the .fastcode section. defined in linker script */
  91 extern unsigned long _sfastcode;                /* start address for the .fastcode section. defined in linker script */
  92 extern unsigned long _efastcode;                /* end address for the .fastcode section. defined in linker script */
  93
  94 extern unsigned long _sbss;                     /* start address for the .bss section. defined in linker script */
  95 extern unsigned long _ebss;                     /* end address for the .bss section. defined in linker script */
  96
  97 extern void _estack;            /* init value for the stack pointer. defined in linker script */
  98
  99 extern void (_setup_board)(void);               /* setup_board adress function */
 100 extern unsigned long _mem_app_start;
 101
 102
 103
 104 /* Private typedef -----------------------------------------------------------*/
 105 /* function prototypes ------------------------------------------------------*/
 106 void Reset_Handler(void) __attribute__((__interrupt__));
 107 extern int main(void);
 108
 109 typedef void (*FNC)(void);
 110 FNC fnc_entry;
 111
 112 /******************************************************************************
 113 *
 114 * The minimal vector table for a Cortex M3.  Note that the proper constructs
 115 * must be placed on this to ensure that it ends up at physical address
 116 * 0x0000.0000.
 117 *
 118 ******************************************************************************/
 119
 120 extern unsigned long _stack;
 121
 122 __attribute__ ((section(".isr_vector")))
 123 void (* const g_pfnVectors[])(void) =
 124 {
 125         (void (*)(void))&_stack,   /* The initial stack pointer */
 126         Reset_Handler,             /* Reset Handler */
 127         NMI_Handler,               /* NMI Handler */
 128         HardFault_Handler,         /* Hard Fault Handler */
 129         MemManage_Handler,         /* MPU Fault Handler */
 130         BusFault_Handler,          /* Bus Fault Handler */
 131         UsageFault_Handler,        /* Usage Fault Handler */
 132         0,                         /* Reserved */
 133         0,                         /* Reserved */
 134         0,                         /* Reserved */
 135         0,                         /* Reserved */
 136         SVC_Handler,               /* SVCall Handler */
 137         DebugMon_Handler,          /* Debug Monitor Handler */
 138         0,                         /* Reserved */
 139         PendSV_Handler,            /* PendSV Handler */
 140         SysTick_Handler,           /* SysTick Handler */
 141
 142                 // External Interrupts
 143         WDT_IRQHandler,            /* Watchdog Timer */
 144         TIMER0_IRQHandler,         /* Timer0 */
 145         TIMER1_IRQHandler,         /* Timer1 */
 146         TIMER2_IRQHandler,         /* Timer2 */
 147         TIMER3_IRQHandler,         /* Timer3 */
 148         UART0_IRQHandler,          /* UART0 */
 149         UART1_IRQHandler,          /* UART1 */
 150         UART2_IRQHandler,          /* UART2 */
 151         UART3_IRQHandler,          /* UART3 */
 152         PWM1_IRQHandler,           /* PWM1 */
 153         I2C0_IRQHandler,           /* I2C0 */
 154         I2C1_IRQHandler,           /* I2C1 */
 155         I2C2_IRQHandler,           /* I2C2 */
 156         SPI_IRQHandler,            /* SPI */
 157         SSP0_IRQHandler,           /* SSP0 */
 158         SSP1_IRQHandler,           /* SSP1 */
 159         PLL0_IRQHandler,           /* PLL0 (Main PLL) */
 160         RTC_IRQHandler,            /* Real Time Clock */
 161         EINT0_IRQHandler,          /* External Interrupt 0 */
 162         EINT1_IRQHandler,          /* External Interrupt 1 */
 163         EINT2_IRQHandler,          /* External Interrupt 2 */
 164         EINT3_IRQHandler,          /* External Interrupt 3 */
 165         ADC_IRQHandler,            /* A/D Converter */
 166         BOD_IRQHandler,            /* Brown Out Detect */
 167         USB_IRQHandler,            /* USB */
 168         CAN_IRQHandler,            /* CAN */
 169         DMA_IRQHandler,            /* GP DMA */
 170         I2S_IRQHandler,            /* I2S */
 171         ENET_IRQHandler,           /* Ethernet */
 172         RIT_IRQHandler,            /* Repetitive Interrupt Timer */
 173         MCPWM_IRQHandler,          /* Motor Control PWM */
 174         QEI_IRQHandler,            /* Quadrature Encoder Interface */
 175         PLL1_IRQHandler,           /* PLL1 (USB PLL) */
 176 };
 177
 178 /*******************************************************************************
 179 * Function Name  : Reset_Handler
 180 * Description    : This is the code that gets called when the processor first starts execution
 181 *                      following a reset event.  Only the absolutely necessary set is performed,
 182 *                      after which the application supplied main() routine is called.
 183 * Input          :
 184 * Output         :
 185 * Return         :
 186 *******************************************************************************/
 187
 188 void Reset_Handler(void)
 189 {
 190     unsigned long *pulDest;
 191     unsigned long *pulSrc;
 192
 193     //
 194     // Copy the data segment initializers from flash to SRAM in ROM mode
 195     //
 196
 197     if (&_sidata != &_sdata) {  // only if needed
 198                 pulSrc = &_sidata;
 199                 for(pulDest = &_sdata; pulDest < &_edata; ) {
 200                         *(pulDest++) = *(pulSrc++);
 201                 }
 202     }
 203
 204     // Copy the .fastcode code from ROM to SRAM
 205
 206     if (&_sifastcode != &_sfastcode) {  // only if needed
 207         pulSrc = &_sifastcode;
 208                 for(pulDest = &_sfastcode; pulDest < &_efastcode; ) {
 209                         *(pulDest++) = *(pulSrc++);
 210                 }
 211     }
 212
 213     //
 214     // Zero fill the bss segment.
 215     //
 216     for(pulDest = &_sbss; pulDest < &_ebss; )
 217     {
 218         *(pulDest++) = 0;
 219     }
 220
 221     // copy initial values and set irq table
 222     if(irq_handler_table && irq_table_size) {
 223         int i;
 224         pulSrc = (unsigned long*)g_pfnVectors;
 225         pulDest = (unsigned long*)irq_handler_table;
 226         for(i = irq_table_size; i--; ) {
 227             *(pulDest++) = *(pulSrc++);
 228         }
 229         /*SCB->VTOR=0x10000000;*/
 230         SCB->VTOR=(uint32_t)irq_handler_table;
 231     }
 232
 233     //if (_setup_board!=0)
 234       _setup_board();
 235
 236     //
 237     // Call the application's entry point.
 238     //
 239     main();
 240
 241     /* disable interrupts */
 242     NVIC->ICER[0] = 0xffffffff;
 243     NVIC->ICER[1] = 0x00000007;
 244     __set_MSP(*(unsigned long *)(&_mem_app_start));         /* Stack pointer */
 245     fnc_entry = (FNC)*(unsigned long *)(&_mem_app_start+1); /* Reset handler */
 246     fnc_entry();
 247 }
 248
 249 //*****************************************************************************
 250 //
 251 // Provide weak aliases for each Exception handler to the Default_Handler.
 252 // As they are weak aliases, any function with the same name will override
 253 // this definition.
 254 //
 255 //*****************************************************************************
 256 #pragma weak MemManage_Handler = Default_Handler          /* MPU Fault Handler */
 257 #pragma weak BusFault_Handler = Default_Handler           /* Bus Fault Handler */
 258 #pragma weak UsageFault_Handler = Default_Handler         /* Usage Fault Handler */
 259 #pragma weak SVC_Handler = Default_Handler                /* SVCall Handler */
 260 #pragma weak DebugMon_Handler = Default_Handler           /* Debug Monitor Handler */
 261 #pragma weak PendSV_Handler = Default_Handler             /* PendSV Handler */
 262 #pragma weak SysTick_Handler = Default_Handler            /* SysTick Handler */
 263
 264 /* External interrupt vector handler */
 265 #pragma weak WDT_IRQHandler = Default_Handler            /* Watchdog Timer */
 266 #pragma weak TIMER0_IRQHandler = Default_Handler         /* Timer0 */
 267 #pragma weak TIMER1_IRQHandler = Default_Handler         /* Timer1 */
 268 #pragma weak TIMER2_IRQHandler = Default_Handler         /* Timer2 */
 269 #pragma weak TIMER3_IRQHandler = Default_Handler         /* Timer3 */
 270 #pragma weak UART0_IRQHandler = Default_Handler          /* UART0 */
 271 #pragma weak UART1_IRQHandler = Default_Handler          /* UART1 */
 272 #pragma weak UART2_IRQHandler = Default_Handler          /* UART2 */
 273 #pragma weak UART3_IRQHandler = Default_Handler          /* UART3 */
 274 #pragma weak PWM1_IRQHandler = Default_Handler           /* PWM1 */
 275 #pragma weak I2C0_IRQHandler = Default_Handler           /* I2C0 */
 276 #pragma weak I2C1_IRQHandler = Default_Handler           /* I2C1 */
 277 #pragma weak I2C2_IRQHandler = Default_Handler           /* I2C2 */
 278 #pragma weak SPI_IRQHandler = Default_Handler            /* SPI */
 279 #pragma weak SSP0_IRQHandler = Default_Handler           /* SSP0 */
 280 #pragma weak SSP1_IRQHandler = Default_Handler           /* SSP1 */
 281 #pragma weak PLL0_IRQHandler = Default_Handler           /* PLL0 (Main PLL) */
 282 #pragma weak RTC_IRQHandler = Default_Handler            /* Real Time Clock */
 283 #pragma weak EINT0_IRQHandler = Default_Handler          /* External Interrupt 0 */
 284 #pragma weak EINT1_IRQHandler = Default_Handler          /* External Interrupt 1 */
 285 #pragma weak EINT2_IRQHandler = Default_Handler          /* External Interrupt 2 */
 286 #pragma weak EINT3_IRQHandler = Default_Handler          /* External Interrupt 3 */
 287 #pragma weak ADC_IRQHandler = Default_Handler            /* A/D Converter */
 288 #pragma weak BOD_IRQHandler = Default_Handler            /* Brown Out Detect */
 289 #pragma weak USB_IRQHandler = Default_Handler            /* USB */
 290 #pragma weak CAN_IRQHandler = Default_Handler            /* CAN */
 291 #pragma weak DMA_IRQHandler = Default_Handler            /* GP DMA */
 292 #pragma weak I2S_IRQHandler = Default_Handler            /* I2S */
 293 #pragma weak ENET_IRQHandler = Default_Handler           /* Ethernet */
 294 #pragma weak RIT_IRQHandler = Default_Handler            /* Repetitive Interrupt Timer */
 295 #pragma weak MCPWM_IRQHandler = Default_Handler          /* Motor Control PWM */
 296 #pragma weak QEI_IRQHandler = Default_Handler            /* Quadrature Encoder Interface */
 297 #pragma weak PLL1_IRQHandler = Default_Handler           /* PLL1 (USB PLL) */
 298
 299 //*****************************************************************************
 300 //
 301 // This is the code that gets called when the processor receives an unexpected
 302 // interrupt.  This simply enters an infinite loop, preserving the system state
 303 // for examination by a debugger.
 304 //
 305 //*****************************************************************************
 306 void Default_Handler(void) {
 307         // Go into an infinite loop.
 308         //
 309         while (1) {
 310         }
 311 }