git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/CORTEX_M4F_MSP432_LaunchPad_IAR_CCS_Keil/system/CCS/system_msp432p401r.c

   1 /**************************************************************************//**\r
   2 * @file     system_msp432p401r.c\r
   3 * @brief    CMSIS Cortex-M4F Device Peripheral Access Layer Source File for\r
   4 *           MSP432P401R\r
   5 * @version  V2.1.0\r
   6 * @date     2016-01-26\r
   7 *\r
   8 * @note     View configuration instructions embedded in comments\r
   9 *\r
  10 ******************************************************************************/\r
  11 //*****************************************************************************\r
  12 //\r
  13 // Copyright (C) 2015 - 2016 Texas Instruments Incorporated - http://www.ti.com/\r
  14 //\r
  15 // Redistribution and use in source and binary forms, with or without\r
  16 // modification, are permitted provided that the following conditions\r
  17 // are met:\r
  18 //\r
  19 //  Redistributions of source code must retain the above copyright\r
  20 //  notice, this list of conditions and the following disclaimer.\r
  21 //\r
  22 //  Redistributions in binary form must reproduce the above copyright\r
  23 //  notice, this list of conditions and the following disclaimer in the\r
  24 //  documentation and/or other materials provided with the\r
  25 //  distribution.\r
  26 //\r
  27 //  Neither the name of Texas Instruments Incorporated nor the names of\r
  28 //  its contributors may be used to endorse or promote products derived\r
  29 //  from this software without specific prior written permission.\r
  30 //\r
  31 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\r
  32 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\r
  33 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\r
  34 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\r
  35 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\r
  36 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\r
  37 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\r
  38 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\r
  39 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r
  40 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\r
  41 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
  42 //\r
  43 //*****************************************************************************\r
  44 \r
  45 #include <stdint.h>\r
  46 #include "msp.h"\r
  47 \r
  48 /*--------------------- Configuration Instructions ----------------------------\r
  49    1. If you prefer to halt the Watchdog Timer, set __HALT_WDT to 1:\r
  50    #define __HALT_WDT       1\r
  51    2. Insert your desired CPU frequency in Hz at:\r
  52    #define __SYSTEM_CLOCK   12000000\r
  53    3. If you prefer the DC-DC power regulator (more efficient at higher\r
  54        frequencies), set the __REGULATOR to 1:\r
  55    #define __REGULATOR      1\r
  56  *---------------------------------------------------------------------------*/\r
  57 \r
  58 /*--------------------- Watchdog Timer Configuration ------------------------*/\r
  59 //  Halt the Watchdog Timer\r
  60 //     <0> Do not halt the WDT\r
  61 //     <1> Halt the WDT\r
  62 #define __HALT_WDT         1\r
  63 \r
  64 /*--------------------- CPU Frequency Configuration -------------------------*/\r
  65 //  CPU Frequency\r
  66 //     <1500000> 1.5 MHz\r
  67 //     <3000000> 3 MHz\r
  68 //     <12000000> 12 MHz\r
  69 //     <24000000> 24 MHz\r
  70 //     <48000000> 48 MHz\r
  71 #define  __SYSTEM_CLOCK    3000000\r
  72 \r
  73 /*--------------------- Power Regulator Configuration -----------------------*/\r
  74 //  Power Regulator Mode\r
  75 //     <0> LDO\r
  76 //     <1> DC-DC\r
  77 #define __REGULATOR        0\r
  78 \r
  79 /*----------------------------------------------------------------------------\r
  80    Define clocks, used for SystemCoreClockUpdate()\r
  81  *---------------------------------------------------------------------------*/\r
  82 #define __VLOCLK           10000\r
  83 #define __MODCLK           24000000\r
  84 #define __LFXT             32768\r
  85 #define __HFXT             48000000\r
  86 \r
  87 /*----------------------------------------------------------------------------\r
  88    Clock Variable definitions\r
  89  *---------------------------------------------------------------------------*/\r
  90 uint32_t SystemCoreClock = __SYSTEM_CLOCK;  /*!< System Clock Frequency (Core Clock)*/\r
  91 \r
  92 /**\r
  93  * Update SystemCoreClock variable\r
  94  *\r
  95  * @param  none\r
  96  * @return none\r
  97  *\r
  98  * @brief  Updates the SystemCoreClock with current core Clock\r
  99  *         retrieved from cpu registers.\r
 100  */\r
 101 void SystemCoreClockUpdate(void)\r
 102 {\r
 103     uint32_t source, divider;\r
 104     uint8_t dividerValue;\r
 105 \r
 106     float dcoConst;\r
 107     int32_t calVal;\r
 108     uint32_t centeredFreq;\r
 109     int16_t dcoTune;\r
 110 \r
 111     divider = (CS->CTL1 & CS_CTL1_DIVM_MASK) >> CS_CTL1_DIVM_OFS;\r
 112     dividerValue = 1 << divider;\r
 113     source = CS->CTL1 & CS_CTL1_SELM_MASK;\r
 114 \r
 115     switch(source)\r
 116     {\r
 117     case CS_CTL1_SELM__LFXTCLK:\r
 118         if(BITBAND_PERI(CS->IFG, CS_IFG_LFXTIFG_OFS))\r
 119         {\r
 120             // Clear interrupt flag\r
 121             CS->KEY = CS_KEY_VAL;\r
 122             CS->CLRIFG |= CS_CLRIFG_CLR_LFXTIFG;\r
 123             CS->KEY = 1;\r
 124 \r
 125             if(BITBAND_PERI(CS->IFG, CS_IFG_LFXTIFG_OFS))\r
 126             {\r
 127                 if(BITBAND_PERI(CS->CLKEN, CS_CLKEN_REFOFSEL_OFS))\r
 128                 {\r
 129                     SystemCoreClock = (128000 / dividerValue);\r
 130                 }\r
 131                 else\r
 132                 {\r
 133                     SystemCoreClock = (32000 / dividerValue);\r
 134                 }\r
 135             }\r
 136             else\r
 137             {\r
 138                 SystemCoreClock = __LFXT / dividerValue;\r
 139             }\r
 140         }\r
 141         else\r
 142         {\r
 143             SystemCoreClock = __LFXT / dividerValue;\r
 144         }\r
 145         break;\r
 146     case CS_CTL1_SELM__VLOCLK:\r
 147         SystemCoreClock = __VLOCLK / dividerValue;\r
 148         break;\r
 149     case CS_CTL1_SELM__REFOCLK:\r
 150         if (BITBAND_PERI(CS->CLKEN, CS_CLKEN_REFOFSEL_OFS))\r
 151         {\r
 152             SystemCoreClock = (128000 / dividerValue);\r
 153         }\r
 154         else\r
 155         {\r
 156             SystemCoreClock = (32000 / dividerValue);\r
 157         }\r
 158         break;\r
 159     case CS_CTL1_SELM__DCOCLK:\r
 160         dcoTune = (CS->CTL0 & CS_CTL0_DCOTUNE_MASK) >> CS_CTL0_DCOTUNE_OFS;\r
 161     \r
 162         switch(CS->CTL0 & CS_CTL0_DCORSEL_MASK)\r
 163         {\r
 164         case CS_CTL0_DCORSEL_0:\r
 165             centeredFreq = 1500000;\r
 166             break;\r
 167         case CS_CTL0_DCORSEL_1:\r
 168             centeredFreq = 3000000;\r
 169             break;\r
 170         case CS_CTL0_DCORSEL_2:\r
 171             centeredFreq = 6000000;\r
 172             break;\r
 173         case CS_CTL0_DCORSEL_3:\r
 174             centeredFreq = 12000000;\r
 175             break;\r
 176         case CS_CTL0_DCORSEL_4:\r
 177             centeredFreq = 24000000;\r
 178             break;\r
 179         case CS_CTL0_DCORSEL_5:\r
 180             centeredFreq = 48000000;\r
 181             break;\r
 182         }\r
 183 \r
 184         if(dcoTune == 0)\r
 185         {\r
 186             SystemCoreClock = centeredFreq;\r
 187         }\r
 188         else\r
 189         {\r
 190 \r
 191             if(dcoTune & 0x1000)\r
 192             {\r
 193                 dcoTune = dcoTune | 0xF000;\r
 194             }\r
 195 \r
 196             if (BITBAND_PERI(CS->CTL0, CS_CTL0_DCORES_OFS))\r
 197             {\r
 198                 dcoConst = *((float *) &TLV->DCOER_CONSTK_RSEL04);\r
 199                 calVal = TLV->DCOER_FCAL_RSEL04;\r
 200             }\r
 201             /* Internal Resistor */\r
 202             else\r
 203             {\r
 204                 dcoConst = *((float *) &TLV->DCOIR_CONSTK_RSEL04);\r
 205                 calVal = TLV->DCOIR_FCAL_RSEL04;\r
 206             }\r
 207 \r
 208             SystemCoreClock = (uint32_t) ((centeredFreq)\r
 209                                / (1\r
 210                                     - ((dcoConst * dcoTune)\r
 211                                             / (8 * (1 + dcoConst * (768 - calVal))))));\r
 212         }\r
 213         break;\r
 214     case CS_CTL1_SELM__MODOSC:\r
 215         SystemCoreClock = __MODCLK / dividerValue;\r
 216         break;\r
 217     case CS_CTL1_SELM__HFXTCLK:\r
 218         if(BITBAND_PERI(CS->IFG, CS_IFG_HFXTIFG_OFS))\r
 219         {\r
 220             // Clear interrupt flag\r
 221             CS->KEY = CS_KEY_VAL;\r
 222             CS->CLRIFG |= CS_CLRIFG_CLR_HFXTIFG;\r
 223             CS->KEY = 1;\r
 224 \r
 225             if(BITBAND_PERI(CS->IFG, CS_IFG_HFXTIFG_OFS))\r
 226             {\r
 227                 if(BITBAND_PERI(CS->CLKEN, CS_CLKEN_REFOFSEL_OFS))\r
 228                 {\r
 229                     SystemCoreClock = (128000 / dividerValue);\r
 230                 }\r
 231                 else\r
 232                 {\r
 233                     SystemCoreClock = (32000 / dividerValue);\r
 234                 }\r
 235             }\r
 236             else\r
 237             {\r
 238                 SystemCoreClock = __HFXT / dividerValue;\r
 239             }\r
 240         }\r
 241         else\r
 242         {\r
 243             SystemCoreClock = __HFXT / dividerValue;\r
 244         }\r
 245         break;\r
 246     }\r
 247 }\r
 248 \r
 249 /**\r
 250  * Initialize the system\r
 251  *\r
 252  * @param  none\r
 253  * @return none\r
 254  *\r
 255  * @brief  Setup the microcontroller system.\r
 256  *\r
 257  * Performs the following initialization steps:\r
 258  *     1. Enables the FPU\r
 259  *     2. Halts the WDT if requested\r
 260  *     3. Enables all SRAM banks\r
 261  *     4. Sets up power regulator and VCORE\r
 262  *     5. Enable Flash wait states if needed\r
 263  *     6. Change MCLK to desired frequency\r
 264  *     7. Enable Flash read buffering\r
 265  */\r
 266 void SystemInit(void)\r
 267 {\r
 268     // Enable FPU if used\r
 269     #if (__FPU_USED == 1)                              /* __FPU_USED is defined in core_cm4.h */\r
 270     SCB->CPACR |= ((3UL << 10 * 2) |                   /* Set CP10 Full Access */\r
 271                    (3UL << 11 * 2));                   /* Set CP11 Full Access */\r
 272     #endif\r
 273 \r
 274     #if (__HALT_WDT == 1)\r
 275     WDT_A->CTL = WDT_A_CTL_PW | WDT_A_CTL_HOLD;         // Halt the WDT\r
 276     #endif\r
 277 \r
 278     SYSCTL->SRAM_BANKEN = SYSCTL_SRAM_BANKEN_BNK7_EN;   // Enable all SRAM banks\r
 279 \r
 280     #if (__SYSTEM_CLOCK == 1500000)                                  // 1.5 MHz\r
 281     // Default VCORE is LDO VCORE0 so no change necessary\r
 282 \r
 283     // Switches LDO VCORE0 to DCDC VCORE0 if requested\r
 284     #if __REGULATOR\r
 285     while((PCM->CTL1 & PCM_CTL1_PMR_BUSY));\r
 286     PCM->CTL0 = PCM_CTL0_KEY_VAL | PCM_CTL0_AMR_4;\r
 287     while((PCM->CTL1 & PCM_CTL1_PMR_BUSY));\r
 288     #endif\r
 289 \r
 290     // No flash wait states necessary\r
 291 \r
 292     // DCO = 1.5 MHz; MCLK = source\r
 293     CS->KEY = CS_KEY_VAL;                                 // Unlock CS module for register access\r
 294     CS->CTL0 = CS_CTL0_DCORSEL_0;                                // Set DCO to 1.5MHz\r
 295     CS->CTL1 &= ~(CS_CTL1_SELM_MASK | CS_CTL1_DIVM_MASK) | CS_CTL1_SELM__DCOCLK;  // Select MCLK as DCO source\r
 296     CS->KEY = 0;\r
 297 \r
 298     // Set Flash Bank read buffering\r
 299     FLCTL->BANK0_RDCTL &= ~(FLCTL_BANK0_RDCTL_BUFD | FLCTL_BANK0_RDCTL_BUFI);\r
 300     FLCTL->BANK1_RDCTL &= ~(FLCTL_BANK0_RDCTL_BUFD | FLCTL_BANK0_RDCTL_BUFI);\r
 301 \r
 302     #elif (__SYSTEM_CLOCK == 3000000)                                  // 3 MHz\r
 303     // Default VCORE is LDO VCORE0 so no change necessary\r
 304 \r
 305     // Switches LDO VCORE0 to DCDC VCORE0 if requested\r
 306     #if __REGULATOR\r
 307     while(PCM->CTL1 & PCM_CTL1_PMR_BUSY);\r
 308     PCM->CTL0 = PCM_CTL0_KEY_VAL | PCM_CTL0_AMR_4;\r
 309     while(PCM->CTL1 & PCM_CTL1_PMR_BUSY);\r
 310     #endif\r
 311 \r
 312     // No flash wait states necessary\r
 313 \r
 314     // DCO = 3 MHz; MCLK = source\r
 315     CS->KEY = CS_KEY_VAL;                                                         // Unlock CS module for register access\r
 316     CS->CTL0 = CS_CTL0_DCORSEL_1;                                                  // Set DCO to 1.5MHz\r
 317     CS->CTL1 &= ~(CS_CTL1_SELM_MASK | CS_CTL1_DIVM_MASK) | CS_CTL1_SELM__DCOCLK;  // Select MCLK as DCO source\r
 318     CS->KEY = 0;\r
 319 \r
 320     // Set Flash Bank read buffering\r
 321     FLCTL->BANK0_RDCTL &= ~(FLCTL_BANK0_RDCTL_BUFD | FLCTL_BANK0_RDCTL_BUFI);\r
 322     FLCTL->BANK1_RDCTL &= ~(FLCTL_BANK0_RDCTL_BUFD | FLCTL_BANK0_RDCTL_BUFI);\r
 323 \r
 324     #elif (__SYSTEM_CLOCK == 12000000)                                // 12 MHz\r
 325     // Default VCORE is LDO VCORE0 so no change necessary\r
 326 \r
 327     // Switches LDO VCORE0 to DCDC VCORE0 if requested\r
 328     #if __REGULATOR\r
 329     while((PCM->CTL1 & PCM_CTL1_PMR_BUSY));\r
 330     PCM->CTL0 = PCM_CTL0_KEY_VAL | PCM_CTL0_AMR_4;\r
 331     while((PCM->CTL1 & PCM_CTL1_PMR_BUSY));\r
 332     #endif\r
 333 \r
 334     // No flash wait states necessary\r
 335 \r
 336     // DCO = 12 MHz; MCLK = source\r
 337     CS->KEY = CS_KEY_VAL;                                                         // Unlock CS module for register access\r
 338     CS->CTL0 = CS_CTL0_DCORSEL_3;                                                  // Set DCO to 12MHz\r
 339     CS->CTL1 &= ~(CS_CTL1_SELM_MASK | CS_CTL1_DIVM_MASK) | CS_CTL1_SELM__DCOCLK;  // Select MCLK as DCO source\r
 340     CS->KEY = 0;\r
 341 \r
 342     // Set Flash Bank read buffering\r
 343     FLCTL->BANK0_RDCTL &= ~(FLCTL_BANK0_RDCTL_BUFD | FLCTL_BANK0_RDCTL_BUFI);\r
 344     FLCTL->BANK1_RDCTL &= ~(FLCTL_BANK0_RDCTL_BUFD | FLCTL_BANK0_RDCTL_BUFI);\r
 345 \r
 346     #elif (__SYSTEM_CLOCK == 24000000)                                // 24 MHz\r
 347     // Default VCORE is LDO VCORE0 so no change necessary\r
 348 \r
 349     // Switches LDO VCORE0 to DCDC VCORE0 if requested\r
 350     #if __REGULATOR\r
 351     while((PCM->CTL1 & PCM_CTL1_PMR_BUSY));\r
 352     PCM->CTL0 = PCM_CTL0_KEY_VAL | PCM_CTL0_AMR_4;\r
 353     while((PCM->CTL1 & PCM_CTL1_PMR_BUSY));\r
 354     #endif\r
 355 \r
 356     // 1 flash wait state (BANK0 VCORE0 max is 12 MHz)\r
 357     FLCTL->BANK0_RDCTL &= ~FLCTL_BANK0_RDCTL_WAIT_MASK | FLCTL_BANK0_RDCTL_WAIT_1;\r
 358     FLCTL->BANK1_RDCTL &= ~FLCTL_BANK0_RDCTL_WAIT_MASK | FLCTL_BANK0_RDCTL_WAIT_1;\r
 359 \r
 360     // DCO = 24 MHz; MCLK = source\r
 361     CS->KEY = CS_KEY_VAL;                                                         // Unlock CS module for register access\r
 362     CS->CTL0 = CS_CTL0_DCORSEL_4;                                                  // Set DCO to 24MHz\r
 363     CS->CTL1 &= ~(CS_CTL1_SELM_MASK | CS_CTL1_DIVM_MASK) | CS_CTL1_SELM__DCOCLK;  // Select MCLK as DCO source\r
 364     CS->KEY = 0;\r
 365 \r
 366     // Set Flash Bank read buffering\r
 367     FLCTL->BANK0_RDCTL |= (FLCTL_BANK0_RDCTL_BUFD | FLCTL_BANK0_RDCTL_BUFI);\r
 368     FLCTL->BANK1_RDCTL &= ~(FLCTL_BANK0_RDCTL_BUFD | FLCTL_BANK0_RDCTL_BUFI);\r
 369 \r
 370     #elif (__SYSTEM_CLOCK == 48000000)                                // 48 MHz\r
 371     // Switches LDO VCORE0 to LDO VCORE1; mandatory for 48 MHz setting\r
 372     while((PCM->CTL1 & PCM_CTL1_PMR_BUSY));\r
 373     PCM->CTL0 = PCM_CTL0_KEY_VAL | PCM_CTL0_AMR_1;\r
 374     while((PCM->CTL1 & PCM_CTL1_PMR_BUSY));\r
 375 \r
 376     // Switches LDO VCORE1 to DCDC VCORE1 if requested\r
 377     #if __REGULATOR\r
 378     while((PCM->CTL1 & PCM_CTL1_PMR_BUSY));\r
 379     PCM->CTL0 = PCM_CTL0_KEY_VAL | PCM_CTL0_AMR_5;\r
 380     while((PCM->CTL1 & PCM_CTL1_PMR_BUSY));\r
 381     #endif\r
 382 \r
 383     // 2 flash wait states (BANK0 VCORE1 max is 16 MHz, BANK1 VCORE1 max is 32 MHz)\r
 384     FLCTL->BANK0_RDCTL &= ~FLCTL_BANK0_RDCTL_WAIT_MASK | FLCTL_BANK0_RDCTL_WAIT_2;\r
 385     FLCTL->BANK1_RDCTL &= ~FLCTL_BANK1_RDCTL_WAIT_MASK | FLCTL_BANK1_RDCTL_WAIT_2;\r
 386 \r
 387     // DCO = 48 MHz; MCLK = source\r
 388     CS->KEY = CS_KEY_VAL;                                                         // Unlock CS module for register access\r
 389     CS->CTL0 = CS_CTL0_DCORSEL_5;                                                  // Set DCO to 48MHz\r
 390     CS->CTL1 &= ~(CS_CTL1_SELM_MASK | CS_CTL1_DIVM_MASK) | CS_CTL1_SELM__DCOCLK;  // Select MCLK as DCO source\r
 391     CS->KEY = 0;\r
 392 \r
 393     // Set Flash Bank read buffering\r
 394     FLCTL->BANK0_RDCTL |= (FLCTL_BANK0_RDCTL_BUFD | FLCTL_BANK0_RDCTL_BUFI);\r
 395     FLCTL->BANK1_RDCTL |= (FLCTL_BANK1_RDCTL_BUFD | FLCTL_BANK1_RDCTL_BUFI);\r
 396     #endif\r
 397 \r
 398 }\r
 399 \r