git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/CORTEX_LPC1768_GCC_RedSuite/src/cr_startup_lpc17.c

   1 //*****************************************************************************\r
   2 //   +--+       \r
   3 //   | ++----+   \r
   4 //   +-++    |  \r
   5 //     |     |  \r
   6 //   +-+--+  |   \r
   7 //   | +--+--+  \r
   8 //   +----+    Copyright (c) 2009-10 Code Red Technologies Ltd.\r
   9 //\r
  10 // Microcontroller Startup code for use with Red Suite\r
  11 //\r
  12 // Software License Agreement\r
  13 // \r
  14 // The software is owned by Code Red Technologies and/or its suppliers, and is \r
  15 // protected under applicable copyright laws.  All rights are reserved.  Any \r
  16 // use in violation of the foregoing restrictions may subject the user to criminal \r
  17 // sanctions under applicable laws, as well as to civil liability for the breach \r
  18 // of the terms and conditions of this license.\r
  19 // \r
  20 // THIS SOFTWARE IS PROVIDED "AS IS".  NO WARRANTIES, WHETHER EXPRESS, IMPLIED\r
  21 // OR STATUTORY, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF\r
  22 // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE.\r
  23 // USE OF THIS SOFTWARE FOR COMMERCIAL DEVELOPMENT AND/OR EDUCATION IS SUBJECT\r
  24 // TO A CURRENT END USER LICENSE AGREEMENT (COMMERCIAL OR EDUCATIONAL) WITH\r
  25 // CODE RED TECHNOLOGIES LTD. \r
  26 //\r
  27 //*****************************************************************************\r
  28 #if defined (__cplusplus)\r
  29 #ifdef __REDLIB__\r
  30 #error Redlib does not support C++\r
  31 #else\r
  32 //*****************************************************************************\r
  33 //\r
  34 // The entry point for the C++ library startup\r
  35 //\r
  36 //*****************************************************************************\r
  37 extern "C" {\r
  38         extern void __libc_init_array(void);\r
  39 }\r
  40 #endif\r
  41 #endif\r
  42 \r
  43 #define WEAK __attribute__ ((weak))\r
  44 #define ALIAS(f) __attribute__ ((weak, alias (#f)))\r
  45 \r
  46 // Code Red - if CMSIS is being used, then SystemInit() routine\r
  47 // will be called by startup code rather than in application's main()\r
  48 #if defined (__USE_CMSIS)\r
  49 #include "system_LPC17xx.h"\r
  50 #endif\r
  51 \r
  52 //*****************************************************************************\r
  53 #if defined (__cplusplus)\r
  54 extern "C" {\r
  55 #endif\r
  56 \r
  57 //*****************************************************************************\r
  58 //\r
  59 // Forward declaration of the default handlers. These are aliased.\r
  60 // When the application defines a handler (with the same name), this will \r
  61 // automatically take precedence over these weak definitions\r
  62 //\r
  63 //*****************************************************************************\r
  64      void ResetISR(void);\r
  65 WEAK void NMI_Handler(void);\r
  66 WEAK void HardFault_Handler(void);\r
  67 WEAK void MemManage_Handler(void);\r
  68 WEAK void BusFault_Handler(void);\r
  69 WEAK void UsageFault_Handler(void);\r
  70 WEAK void SVCall_Handler(void);\r
  71 WEAK void DebugMon_Handler(void);\r
  72 WEAK void PendSV_Handler(void);\r
  73 WEAK void SysTick_Handler(void);\r
  74 WEAK void IntDefaultHandler(void);\r
  75 \r
  76 //*****************************************************************************\r
  77 //\r
  78 // Forward declaration of the specific IRQ handlers. These are aliased\r
  79 // to the IntDefaultHandler, which is a 'forever' loop. When the application\r
  80 // defines a handler (with the same name), this will automatically take \r
  81 // precedence over these weak definitions\r
  82 //\r
  83 //*****************************************************************************\r
  84 void WDT_IRQHandler(void) ALIAS(IntDefaultHandler);\r
  85 void TIMER0_IRQHandler(void) ALIAS(IntDefaultHandler);\r
  86 void TIMER1_IRQHandler(void) ALIAS(IntDefaultHandler);\r
  87 void TIMER2_IRQHandler(void) ALIAS(IntDefaultHandler);\r
  88 void TIMER3_IRQHandler(void) ALIAS(IntDefaultHandler);\r
  89 void UART0_IRQHandler(void) ALIAS(IntDefaultHandler);\r
  90 void UART1_IRQHandler(void) ALIAS(IntDefaultHandler);\r
  91 void UART2_IRQHandler(void) ALIAS(IntDefaultHandler);\r
  92 void UART3_IRQHandler(void) ALIAS(IntDefaultHandler);\r
  93 void PWM1_IRQHandler(void) ALIAS(IntDefaultHandler);\r
  94 void I2C0_IRQHandler(void) ALIAS(IntDefaultHandler);\r
  95 void I2C1_IRQHandler(void) ALIAS(IntDefaultHandler);\r
  96 void I2C2_IRQHandler(void) ALIAS(IntDefaultHandler);\r
  97 void SPI_IRQHandler(void) ALIAS(IntDefaultHandler);\r
  98 void SSP0_IRQHandler(void) ALIAS(IntDefaultHandler);\r
  99 void SSP1_IRQHandler(void) ALIAS(IntDefaultHandler);\r
 100 void PLL0_IRQHandler(void) ALIAS(IntDefaultHandler);\r
 101 void RTC_IRQHandler(void) ALIAS(IntDefaultHandler);\r
 102 void EINT0_IRQHandler(void) ALIAS(IntDefaultHandler);\r
 103 void EINT1_IRQHandler(void) ALIAS(IntDefaultHandler);\r
 104 void EINT2_IRQHandler(void) ALIAS(IntDefaultHandler);\r
 105 void EINT3_IRQHandler(void) ALIAS(IntDefaultHandler);\r
 106 void ADC_IRQHandler(void) ALIAS(IntDefaultHandler);\r
 107 void BOD_IRQHandler(void) ALIAS(IntDefaultHandler);\r
 108 void USB_IRQHandler(void) ALIAS(IntDefaultHandler);\r
 109 void CAN_IRQHandler(void) ALIAS(IntDefaultHandler);\r
 110 void DMA_IRQHandler(void) ALIAS(IntDefaultHandler);\r
 111 void I2S_IRQHandler(void) ALIAS(IntDefaultHandler);\r
 112 void ENET_IRQHandler(void) ALIAS(IntDefaultHandler);\r
 113 void RIT_IRQHandler(void) ALIAS(IntDefaultHandler);\r
 114 void MCPWM_IRQHandler(void) ALIAS(IntDefaultHandler);\r
 115 void QEI_IRQHandler(void) ALIAS(IntDefaultHandler);\r
 116 void PLL1_IRQHandler(void) ALIAS(IntDefaultHandler);\r
 117 void USBActivity_IRQHandler(void) ALIAS(IntDefaultHandler);\r
 118 void CANActivity_IRQHandler(void) ALIAS(IntDefaultHandler);\r
 119 \r
 120 extern void xPortSysTickHandler(void);\r
 121 extern void xPortPendSVHandler(void);\r
 122 extern void vPortSVCHandler( void );\r
 123 extern void vEMAC_ISR( void );\r
 124 \r
 125 //*****************************************************************************\r
 126 //\r
 127 // The entry point for the application.\r
 128 // __main() is the entry point for Redlib based applications\r
 129 // main() is the entry point for Newlib based applications\r
 130 //\r
 131 //*****************************************************************************\r
 132 #if defined (__REDLIB__)\r
 133 extern void __main(void);\r
 134 #endif\r
 135 extern int main(void);\r
 136 //*****************************************************************************\r
 137 //\r
 138 // External declaration for the pointer to the stack top from the Linker Script\r
 139 //\r
 140 //*****************************************************************************\r
 141 extern void _vStackTop(void);\r
 142 \r
 143 //*****************************************************************************\r
 144 #if defined (__cplusplus)\r
 145 } // extern "C"\r
 146 #endif\r
 147 //*****************************************************************************\r
 148 //\r
 149 // The vector table.\r
 150 // This relies on the linker script to place at correct location in memory.\r
 151 //\r
 152 //*****************************************************************************\r
 153 extern void (* const g_pfnVectors[])(void);\r
 154 __attribute__ ((section(".isr_vector")))\r
 155 void (* const g_pfnVectors[])(void) =\r
 156 {\r
 157         // Core Level - CM3\r
 158         (void *)&_vStackTop,                                    // The initial stack pointer\r
 159         ResetISR,                                                               // The reset handler\r
 160         NMI_Handler,                                                    // The NMI handler\r
 161         HardFault_Handler,                                              // The hard fault handler\r
 162         MemManage_Handler,                                              // The MPU fault handler\r
 163         BusFault_Handler,                                               // The bus fault handler\r
 164         UsageFault_Handler,                                             // The usage fault handler\r
 165         0,                                                                              // Reserved\r
 166         0,                                                                              // Reserved\r
 167         0,                                                                              // Reserved\r
 168         0,                                                                              // Reserved\r
 169         vPortSVCHandler,                        // SVCall handler\r
 170         DebugMon_Handler,                                               // Debug monitor handler\r
 171         0,                                                                              // Reserved\r
 172         xPortPendSVHandler,                     // The PendSV handler\r
 173         xPortSysTickHandler,                    // The SysTick handler\r
 174 \r
 175         // Chip Level - LPC17\r
 176         WDT_IRQHandler,                                                 // 16, 0x40 - WDT\r
 177         TIMER0_IRQHandler,                                              // 17, 0x44 - TIMER0\r
 178         TIMER1_IRQHandler,                                              // 18, 0x48 - TIMER1\r
 179         TIMER2_IRQHandler,                                              // 19, 0x4c - TIMER2\r
 180         TIMER3_IRQHandler,                                              // 20, 0x50 - TIMER3\r
 181         UART0_IRQHandler,                                               // 21, 0x54 - UART0\r
 182         UART1_IRQHandler,                                               // 22, 0x58 - UART1\r
 183         UART2_IRQHandler,                                               // 23, 0x5c - UART2\r
 184         UART3_IRQHandler,                                               // 24, 0x60 - UART3\r
 185         PWM1_IRQHandler,                                                // 25, 0x64 - PWM1\r
 186         I2C0_IRQHandler,                                                // 26, 0x68 - I2C0\r
 187         I2C1_IRQHandler,                                                // 27, 0x6c - I2C1\r
 188         I2C2_IRQHandler,                                                // 28, 0x70 - I2C2\r
 189         SPI_IRQHandler,                                                 // 29, 0x74 - SPI\r
 190         SSP0_IRQHandler,                                                // 30, 0x78 - SSP0\r
 191         SSP1_IRQHandler,                                                // 31, 0x7c - SSP1\r
 192         PLL0_IRQHandler,                                                // 32, 0x80 - PLL0 (Main PLL)\r
 193         RTC_IRQHandler,                                                 // 33, 0x84 - RTC\r
 194         EINT0_IRQHandler,                                               // 34, 0x88 - EINT0\r
 195         EINT1_IRQHandler,                                               // 35, 0x8c - EINT1\r
 196         EINT2_IRQHandler,                                               // 36, 0x90 - EINT2\r
 197         EINT3_IRQHandler,                                               // 37, 0x94 - EINT3\r
 198         ADC_IRQHandler,                                                 // 38, 0x98 - ADC\r
 199         BOD_IRQHandler,                                                 // 39, 0x9c - BOD\r
 200         USB_IRQHandler,                                                 // 40, 0xA0 - USB\r
 201         CAN_IRQHandler,                                                 // 41, 0xa4 - CAN\r
 202         DMA_IRQHandler,                                                 // 42, 0xa8 - GP DMA\r
 203         I2S_IRQHandler,                                                 // 43, 0xac - I2S\r
 204             vEMAC_ISR,                                  // Ethernet.\r
 205         RIT_IRQHandler,                                                 // 45, 0xb4 - RITINT\r
 206         MCPWM_IRQHandler,                                               // 46, 0xb8 - Motor Control PWM\r
 207         QEI_IRQHandler,                                                 // 47, 0xbc - Quadrature Encoder\r
 208         PLL1_IRQHandler,                                                // 48, 0xc0 - PLL1 (USB PLL)\r
 209         USBActivity_IRQHandler,                                 // 49, 0xc4 - USB Activity interrupt to wakeup\r
 210         CANActivity_IRQHandler,                                 // 50, 0xc8 - CAN Activity interrupt to wakeup\r
 211 };\r
 212 \r
 213 //*****************************************************************************\r
 214 //\r
 215 // The following are constructs created by the linker, indicating where the\r
 216 // the "data" and "bss" segments reside in memory.  The initializers for the\r
 217 // for the "data" segment resides immediately following the "text" segment.\r
 218 //\r
 219 //*****************************************************************************\r
 220 extern unsigned long _etext;\r
 221 extern unsigned long _data;\r
 222 extern unsigned long _edata;\r
 223 extern unsigned long _bss;\r
 224 extern unsigned long _ebss;\r
 225 \r
 226 //*****************************************************************************\r
 227 // Reset entry point for your code.\r
 228 // Sets up a simple runtime environment and initializes the C/C++\r
 229 // library.\r
 230 //\r
 231 //*****************************************************************************\r
 232 void\r
 233 ResetISR(void) {\r
 234     unsigned long *pulSrc, *pulDest;\r
 235 \r
 236     //\r
 237     // Copy the data segment initializers from flash to SRAM.\r
 238     //\r
 239     pulSrc = &_etext;\r
 240     for(pulDest = &_data; pulDest < &_edata; )\r
 241     {\r
 242         *pulDest++ = *pulSrc++;\r
 243     }\r
 244 \r
 245     //\r
 246     // Zero fill the bss segment.  This is done with inline assembly since this\r
 247     // will clear the value of pulDest if it is not kept in a register.\r
 248     //\r
 249     __asm("    ldr     r0, =_bss\n"\r
 250           "    ldr     r1, =_ebss\n"\r
 251           "    mov     r2, #0\n"\r
 252           "    .thumb_func\n"\r
 253           "zero_loop:\n"\r
 254           "        cmp     r0, r1\n"\r
 255           "        it      lt\n"\r
 256           "        strlt   r2, [r0], #4\n"\r
 257           "        blt     zero_loop");\r
 258 \r
 259 #ifdef __USE_CMSIS\r
 260         SystemInit();\r
 261 #endif\r
 262 \r
 263 #if defined (__cplusplus)\r
 264         //\r
 265         // Call C++ library initialisation\r
 266         //\r
 267         __libc_init_array();\r
 268 #endif\r
 269 \r
 270 #if defined (__REDLIB__)\r
 271         // Call the Redlib library, which in turn calls main()\r
 272         __main() ;\r
 273 #else\r
 274         main();\r
 275 #endif\r
 276 \r
 277         //\r
 278         // main() shouldn't return, but if it does, we'll just enter an infinite loop \r
 279         //\r
 280         while (1) {\r
 281                 ;\r
 282         }\r
 283 }\r
 284 \r
 285 //*****************************************************************************\r
 286 //\r
 287 // This is the code that gets called when the processor receives a NMI.  This\r
 288 // simply enters an infinite loop, preserving the system state for examination\r
 289 // by a debugger.\r
 290 //\r
 291 //*****************************************************************************\r
 292 void NMI_Handler(void)\r
 293 {\r
 294     while(1)\r
 295     {\r
 296     }\r
 297 }\r
 298 \r
 299 void HardFault_Handler(void)\r
 300 {\r
 301     while(1)\r
 302     {\r
 303     }\r
 304 }\r
 305 \r
 306 void MemManage_Handler(void)\r
 307 {\r
 308     while(1)\r
 309     {\r
 310     }\r
 311 }\r
 312 \r
 313 void BusFault_Handler(void)\r
 314 {\r
 315     while(1)\r
 316     {\r
 317     }\r
 318 }\r
 319 \r
 320 void UsageFault_Handler(void)\r
 321 {\r
 322     while(1)\r
 323     {\r
 324     }\r
 325 }\r
 326 \r
 327 \r
 328 void DebugMon_Handler(void)\r
 329 {\r
 330     while(1)\r
 331     {\r
 332     }\r
 333 }\r
 334 \r
 335 //*****************************************************************************\r
 336 //\r
 337 // Processor ends up here if an unexpected interrupt occurs or a handler\r
 338 // is not present in the application code.\r
 339 //\r
 340 //*****************************************************************************\r
 341 void IntDefaultHandler(void)\r
 342 {\r
 343     //\r
 344     // Go into an infinite loop.\r
 345     //\r
 346     while(1)\r
 347     {\r
 348     }\r
 349 }\r