git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/CORTEX_M4F_MSP432_LaunchPad_IAR_CCS_Keil/driverlib/cs.c

   1 /*
   2  * -------------------------------------------
   3  *    MSP432 DriverLib - v01_04_00_18
   4  * -------------------------------------------
   5  *
   6  * --COPYRIGHT--,BSD,BSD
   7  * Copyright (c) 2015, Texas Instruments Incorporated
   8  * All rights reserved.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  *
  14  * *  Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  *
  17  * *  Redistributions in binary form must reproduce the above copyright
  18  *    notice, this list of conditions and the following disclaimer in the
  19  *    documentation and/or other materials provided with the distribution.
  20  *
  21  * *  Neither the name of Texas Instruments Incorporated nor the names of
  22  *    its contributors may be used to endorse or promote products derived
  23  *    from this software without specific prior written permission.
  24  *
  25  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  26  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  27  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  28  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  29  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  30  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  31  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  32  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  33  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  34  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  35  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  36  * --/COPYRIGHT--*/
  37 /* Standard Includes */
  38 #include <stdint.h>
  39
  40 /* DriverLib Includes */
  41 #include <cs.h>
  42 #include <debug.h>
  43 #include <sysctl.h>
  44 #include <interrupt.h>
  45
  46 /* Statics */
  47 static uint32_t hfxtFreq;
  48 static uint32_t lfxtFreq;
  49
  50 #ifdef DEBUG
  51
  52 bool _CSIsClockDividerValid(uint8_t divider)
  53 {
  54     return ((divider == CS_CLOCK_DIVIDER_1) || (divider == CS_CLOCK_DIVIDER_2)
  55             || (divider == CS_CLOCK_DIVIDER_4) || (divider == CS_CLOCK_DIVIDER_8)
  56             || (divider == CS_CLOCK_DIVIDER_16) || (divider == CS_CLOCK_DIVIDER_32)
  57             || (divider == CS_CLOCK_DIVIDER_64) || (divider == CS_CLOCK_DIVIDER_128));
  58 }
  59
  60 #endif
  61
  62 static uint32_t _CSGetHFXTFrequency()
  63 {
  64     if (hfxtFreq >= CS_1MHZ && hfxtFreq <= CS_4MHZ)
  65         return HFXTFREQ_0;
  66     else if (hfxtFreq > CS_4MHZ && hfxtFreq <= CS_8MHZ)
  67         return HFXTFREQ_1;
  68     else if (hfxtFreq > CS_8MHZ && hfxtFreq <= CS_16MHZ)
  69         return HFXTFREQ_2;
  70     else if (hfxtFreq > CS_16MHZ && hfxtFreq <= CS_24MHZ)
  71         return HFXTFREQ_3;
  72     else if (hfxtFreq > CS_24MHZ && hfxtFreq <= CS_32MHZ)
  73         return HFXTFREQ_4;
  74     else if (hfxtFreq > CS_32MHZ && hfxtFreq <= CS_40MHZ)
  75         return HFXTFREQ_5;
  76     else if (hfxtFreq > CS_40MHZ && hfxtFreq <= CS_48MHZ)
  77         return HFXTFREQ_5;
  78     else
  79     {
  80         ASSERT(false);
  81         return 0;
  82     }
  83
  84 }
  85
  86 static uint32_t _CSGetDividerValue(uint32_t wDivider)
  87 {
  88     switch (wDivider)
  89     {
  90     case CS_CLOCK_DIVIDER_1:
  91         return 1;
  92     case CS_CLOCK_DIVIDER_2:
  93         return 2;
  94     case CS_CLOCK_DIVIDER_4:
  95         return 4;
  96     case CS_CLOCK_DIVIDER_8:
  97         return 8;
  98     case CS_CLOCK_DIVIDER_16:
  99         return 16;
 100     case CS_CLOCK_DIVIDER_32:
 101         return 32;
 102     case CS_CLOCK_DIVIDER_64:
 103         return 64;
 104     case CS_CLOCK_DIVIDER_128:
 105         return 128;
 106     default:
 107         ASSERT(false);
 108         return 1;
 109     }
 110 }
 111
 112 static uint32_t _CSComputeCLKFrequency(uint32_t wClockSource, uint32_t wDivider)
 113 {
 114     uint8_t bDivider;
 115
 116     bDivider = _CSGetDividerValue(wDivider);
 117
 118     switch (wClockSource)
 119     {
 120     case CS_LFXTCLK_SELECT:
 121     {
 122         if (BITBAND_PERI(CS->rIFG.r, LFXTIFG_OFS))
 123         {
 124             CS_clearInterruptFlag(CS_LFXT_FAULT);
 125
 126             if (BITBAND_PERI(CS->rIFG.r, LFXTIFG_OFS))
 127             {
 128                 if (BITBAND_PERI(CS->rCLKEN.r, REFOFSEL_OFS))
 129                     return (128000 / bDivider);
 130                 else
 131                     return (32000 / bDivider);
 132             }
 133         }
 134         return lfxtFreq / bDivider;
 135     }
 136     case CS_HFXTCLK_SELECT:
 137     {
 138         if (BITBAND_PERI(CS->rIFG.r, HFXTIFG_OFS))
 139         {
 140             CS_clearInterruptFlag(CS_HFXT_FAULT);
 141
 142             if (BITBAND_PERI(CS->rIFG.r, HFXTIFG_OFS))
 143             {
 144                 if (BITBAND_PERI(CS->rCLKEN.r, REFOFSEL_OFS))
 145                     return (128000 / bDivider);
 146                 else
 147                     return (32000 / bDivider);
 148             }
 149         }
 150         return hfxtFreq / bDivider;
 151     }
 152     case CS_VLOCLK_SELECT:
 153         return CS_VLOCLK_FREQUENCY / bDivider;
 154     case CS_REFOCLK_SELECT:
 155     {
 156         if (BITBAND_PERI(CS->rCLKEN.r, REFOFSEL_OFS))
 157             return (128000 / bDivider);
 158         else
 159             return (32000 / bDivider);
 160     }
 161     case CS_DCOCLK_SELECT:
 162         return (CS_getDCOFrequency() / bDivider);
 163     case CS_MODOSC_SELECT:
 164         return CS_MODCLK_FREQUENCY / bDivider;
 165     default:
 166         ASSERT(false);
 167         return 0;
 168     }
 169 }
 170
 171 //******************************************************************************
 172 // Internal function for getting DCO nominal frequency
 173 //******************************************************************************
 174 static uint32_t _CSGetDOCFrequency(void)
 175 {
 176     uint32_t dcoFreq;
 177
 178     switch (CS->rCTL0.r & DCORSEL_M)
 179     {
 180     case DCORSEL_0:
 181         dcoFreq = 1500000;
 182         break;
 183     case DCORSEL_1:
 184         dcoFreq = 3000000;
 185         break;
 186     case DCORSEL_2:
 187         dcoFreq = 6000000;
 188         break;
 189     case DCORSEL_3:
 190         dcoFreq = 12000000;
 191         break;
 192     case DCORSEL_4:
 193         dcoFreq = 24000000;
 194         break;
 195     case DCORSEL_5:
 196         dcoFreq = 48000000;
 197         break;
 198     default:
 199         dcoFreq = 0;
 200     }
 201
 202     return (dcoFreq);
 203 }
 204
 205 void CS_setExternalClockSourceFrequency(uint32_t lfxt_XT_CLK_frequency,
 206         uint32_t hfxt_XT_CLK_frequency)
 207 {
 208     hfxtFreq = hfxt_XT_CLK_frequency;
 209     lfxtFreq = lfxt_XT_CLK_frequency;
 210 }
 211
 212 void CS_initClockSignal(uint32_t selectedClockSignal, uint32_t clockSource,
 213         uint32_t clockSourceDivider)
 214 {
 215     ASSERT(_CSIsClockDividerValid(clockSourceDivider));
 216
 217     /* Unlocking the CS Module */
 218     CS->rKEY.r = CS_KEY;
 219
 220     switch (selectedClockSignal)
 221     {
 222     case CS_ACLK:
 223     {
 224         /* Making sure that the clock signal for ACLK isn't set to anything
 225          * invalid
 226          */
 227         ASSERT(
 228                 (selectedClockSignal != CS_DCOCLK_SELECT)
 229                 && (selectedClockSignal != CS_MODOSC_SELECT)
 230                 && (selectedClockSignal != CS_HFXTCLK_SELECT));
 231
 232         /* Waiting for the clock source ready bit to be valid before
 233          * changing */
 234         while (!BITBAND_PERI(CS->rSTAT.r, ACLK_READY_OFS))
 235             ;
 236
 237         /* Setting the divider and source */
 238         CS->rCTL1.r = ((clockSourceDivider >> CS_ACLK_DIV_BITPOS)
 239                 | (clockSource << CS_ACLK_SRC_BITPOS))
 240                 | (CS->rCTL1.r & ~(SELA_M | DIVA_M));
 241
 242         /* Waiting for ACLK to be ready again */
 243         while (!BITBAND_PERI(CS->rSTAT.r, ACLK_READY_OFS))
 244             ;
 245
 246         break;
 247     }
 248     case CS_MCLK:
 249     {
 250
 251         /* Waiting for the clock source ready bit to be valid before
 252          * changing */
 253         while (!BITBAND_PERI(CS->rSTAT.r, MCLK_READY_OFS))
 254             ;
 255
 256         CS->rCTL1.r = ((clockSourceDivider >> CS_MCLK_DIV_BITPOS)
 257                 | (clockSource << CS_MCLK_SRC_BITPOS))
 258                 | (CS->rCTL1.r & ~(SELM_M | DIVM_M));
 259
 260         /* Waiting for MCLK to be ready */
 261         while (!BITBAND_PERI(CS->rSTAT.r, MCLK_READY_OFS))
 262             ;
 263
 264         break;
 265     }
 266     case CS_SMCLK:
 267     {
 268         /* Waiting for the clock source ready bit to be valid before
 269          * changing */
 270         while (!BITBAND_PERI(CS->rSTAT.r, SMCLK_READY_OFS))
 271             ;
 272
 273         CS->rCTL1.r = ((clockSourceDivider >> CS_SMCLK_DIV_BITPOS)
 274                 | (clockSource << CS_HSMCLK_SRC_BITPOS))
 275                 | (CS->rCTL1.r & ~(DIVS_M | SELS_M));
 276
 277         /* Waiting for SMCLK to be ready */
 278         while (!BITBAND_PERI(CS->rSTAT.r, SMCLK_READY_OFS))
 279             ;
 280
 281         break;
 282     }
 283     case CS_HSMCLK:
 284     {
 285         /* Waiting for the clock source ready bit to be valid before
 286          * changing */
 287         while (!BITBAND_PERI(CS->rSTAT.r, HSMCLK_READY_OFS))
 288             ;
 289
 290         CS->rCTL1.r = ((clockSourceDivider >> CS_HSMCLK_DIV_BITPOS)
 291                 | (clockSource << CS_HSMCLK_SRC_BITPOS))
 292                 | (CS->rCTL1.r & ~(DIVHS_M | SELS_M));
 293
 294         /* Waiting for HSMCLK to be ready */
 295         while (!BITBAND_PERI(CS->rSTAT.r, HSMCLK_READY_OFS))
 296             ;
 297
 298         break;
 299     }
 300     case CS_BCLK:
 301     {
 302
 303         /* Waiting for the clock source ready bit to be valid before
 304          * changing */
 305         while (!BITBAND_PERI(CS->rSTAT.r, BCLK_READY_OFS))
 306             ;
 307
 308         /* Setting the clock source and then returning
 309          * (cannot divide CLK)
 310          */
 311         if (clockSource == CS_LFXTCLK_SELECT)
 312             BITBAND_PERI(CS->rCTL1.r, SELB_OFS) = 0;
 313         else if (clockSource == CS_REFOCLK_SELECT)
 314             BITBAND_PERI(CS->rCTL1.r, SELB_OFS) = 1;
 315         else
 316             ASSERT(false);
 317
 318         /* Waiting for BCLK to be ready */
 319         while (!BITBAND_PERI(CS->rSTAT.r, BCLK_READY_OFS))
 320             ;
 321
 322         break;
 323     }
 324     default:
 325     {
 326         /* Should never get here */
 327         ASSERT(false);
 328     }
 329     }
 330
 331     /* Locking the module */
 332     BITBAND_PERI(CS->rKEY.r, CSKEY_OFS) = 1;
 333 }
 334
 335 void CS_startHFXT(bool bypassMode)
 336 {
 337     CS_startHFXTWithTimeout(bypassMode, 0);
 338 }
 339
 340 void CS_startHFXTWithTimeout(bool bypassMode, uint32_t timeout)
 341 {
 342     uint32_t wHFFreqRange;
 343     uint8_t bNMIStatus;
 344     bool boolTimeout;
 345
 346     /* Unlocking the CS Module */
 347     CS->rKEY.r = CS_KEY;
 348
 349     /* Saving status and temporarily disabling NMIs for UCS faults */
 350     bNMIStatus = SysCtl_getNMISourceStatus() & SYSCTL_CS_SRC;
 351     SysCtl_disableNMISource(SYSCTL_CS_SRC);
 352
 353     /* Determining which frequency range to use */
 354     wHFFreqRange = _CSGetHFXTFrequency();
 355     boolTimeout = (timeout == 0) ? false : true;
 356
 357     /* Setting to maximum drive strength  */
 358     BITBAND_PERI(CS->rCTL2.r, HFXTDRIVE_OFS) = 1;
 359     CS->rCTL2.r = (CS->rCTL2.r & (~HFXTFREQ_M)) | (wHFFreqRange);
 360
 361     if (bypassMode)
 362     {
 363         BITBAND_PERI(CS->rCTL2.r, HFXTBYPASS_OFS) = 1;
 364     } else
 365     {
 366         BITBAND_PERI(CS->rCTL2.r, HFXTBYPASS_OFS) = 0;
 367     }
 368
 369     /* Starting and Waiting for frequency stabilization */
 370     BITBAND_PERI(CS->rCTL2.r, HFXT_EN_OFS) = 1;
 371     while (BITBAND_PERI(CS->rIFG.r, HFXTIFG_OFS))
 372     {
 373         if (boolTimeout && ((--timeout) == 0))
 374             break;
 375
 376         BITBAND_PERI(CS->rCLRIFG.r,CLR_HFXTIFG_OFS) = 1;
 377     }
 378
 379     /* Setting the drive strength */
 380     if (!bypassMode)
 381     {
 382         if (wHFFreqRange != HFXTFREQ_0)
 383             BITBAND_PERI(CS->rCTL2.r, HFXTDRIVE_OFS) = 1;
 384         else
 385             BITBAND_PERI(CS->rCTL2.r, HFXTDRIVE_OFS) = 0;
 386     }
 387
 388     /* Locking the module */
 389     BITBAND_PERI(CS->rKEY.r, CSKEY_OFS) = 1;
 390
 391     /* Enabling the NMI state */
 392     SysCtl_enableNMISource(bNMIStatus);
 393
 394 }
 395
 396 void CS_startLFXT(uint32_t xtDrive)
 397 {
 398     CS_startLFXTWithTimeout(xtDrive, 0);
 399 }
 400
 401 void CS_startLFXTWithTimeout(uint32_t xtDrive, uint32_t timeout)
 402 {
 403     uint8_t bNMIStatus;
 404     bool boolBypassMode, boolTimeout;
 405
 406     ASSERT(lfxtFreq != 0)
 407     ASSERT(
 408             (xtDrive == CS_LFXT_DRIVE0) || (xtDrive == CS_LFXT_DRIVE1)
 409             || (xtDrive == CS_LFXT_DRIVE2)
 410             || (xtDrive == CS_LFXT_DRIVE3)
 411             || (xtDrive == CS_LFXT_BYPASS));
 412
 413     /* Unlocking the CS Module */
 414     CS->rKEY.r = CS_KEY;
 415
 416     /* Saving status and temporarily disabling NMIs for UCS faults */
 417     bNMIStatus = SysCtl_getNMISourceStatus() & SYSCTL_CS_SRC;
 418     SysCtl_disableNMISource(SYSCTL_CS_SRC);
 419     boolBypassMode = (xtDrive == CS_LFXT_BYPASS) ? true : false;
 420     boolTimeout = (timeout == 0) ? false : true;
 421
 422     /* Setting to maximum drive strength  */
 423     if (boolBypassMode)
 424     {
 425         BITBAND_PERI(CS->rCTL2.r, LFXTBYPASS_OFS) = 1;
 426     } else
 427     {
 428         CS->rCTL2.r |= (CS_LFXT_DRIVE3);
 429         BITBAND_PERI(CS->rCTL2.r, LFXTBYPASS_OFS) = 0;
 430     }
 431
 432     /* Waiting for frequency stabilization */
 433     BITBAND_PERI(CS->rCTL2.r, LFXT_EN_OFS) = 1;
 434
 435     while (BITBAND_PERI(CS->rIFG.r, LFXTIFG_OFS))
 436     {
 437         if (boolTimeout && ((--timeout) == 0))
 438             break;
 439
 440         BITBAND_PERI(CS->rCLRIFG.r,CLR_LFXTIFG_OFS) = 1;
 441     }
 442
 443     /* Setting the drive strength */
 444     if (!boolBypassMode)
 445     {
 446         CS->rCTL2.r = ((CS->rCTL2.r & ~CS_LFXT_DRIVE3) | xtDrive);
 447     }
 448
 449     /* Locking the module */
 450     BITBAND_PERI(CS->rKEY.r, CSKEY_OFS) = 1;
 451
 452     /* Enabling the NMI state */
 453     SysCtl_enableNMISource(bNMIStatus);
 454 }
 455
 456 void CS_enableClockRequest(uint32_t selectClock)
 457 {
 458     ASSERT(
 459             selectClock == CS_ACLK || selectClock == CS_HSMCLK
 460             || selectClock == CS_SMCLK || selectClock == CS_MCLK);
 461
 462     /* Unlocking the module */
 463     CS->rKEY.r = CS_KEY;
 464
 465     CS->rCLKEN.r |= selectClock;
 466
 467     /* Locking the module */
 468     BITBAND_PERI(CS->rKEY.r, CSKEY_OFS) = 1;
 469 }
 470
 471 void CS_disableClockRequest(uint32_t selectClock)
 472 {
 473     ASSERT(
 474             selectClock == CS_ACLK || selectClock == CS_HSMCLK
 475             || selectClock == CS_SMCLK || selectClock == CS_MCLK);
 476
 477     /* Unlocking the module */
 478     CS->rKEY.r = CS_KEY;
 479
 480     CS->rCLKEN.r &= ~selectClock;
 481
 482     /* Locking the module */
 483     BITBAND_PERI(CS->rKEY.r, CSKEY_OFS) = 1;
 484 }
 485
 486 void CS_setReferenceOscillatorFrequency(uint8_t referenceFrequency)
 487 {
 488     ASSERT(
 489             referenceFrequency == CS_REFO_32KHZ
 490             || referenceFrequency == CS_REFO_128KHZ);
 491
 492     /* Unlocking the module */
 493     CS->rKEY.r = CS_KEY;
 494
 495     BITBAND_PERI(CS->rCLKEN.r, REFOFSEL_OFS) = referenceFrequency;
 496
 497     /* Locking the module */
 498     BITBAND_PERI(CS->rKEY.r, CSKEY_OFS) = 1;
 499 }
 500
 501 void CS_enableDCOExternalResistor(void)
 502 {
 503     /* Unlocking the module */
 504     CS->rKEY.r = CS_KEY;
 505
 506     BITBAND_PERI(CS->rCTL0.r,DCORES_OFS) = 1;
 507
 508     /* Locking the module */
 509     BITBAND_PERI(CS->rKEY.r, CSKEY_OFS) = 1;
 510 }
 511
 512 void CS_setDCOExternalResistorCalibration(uint_fast8_t uiCalData)
 513 {
 514     CS->rDCOERCAL.r = (uiCalData);
 515 }
 516
 517 void CS_disableDCOExternalResistor(void)
 518 {
 519     /* Unlocking the module */
 520     CS->rKEY.r = CS_KEY;
 521
 522     BITBAND_PERI(CS->rCTL0.r,DCORES_OFS) = 0;
 523
 524     /* Locking the module */
 525     BITBAND_PERI(CS->rKEY.r, CSKEY_OFS) = 1;
 526 }
 527
 528 void CS_setDCOCenteredFrequency(uint32_t dcoFreq)
 529 {
 530     ASSERT(
 531             dcoFreq == CS_DCO_FREQUENCY_1_5 || dcoFreq == CS_DCO_FREQUENCY_3
 532             || dcoFreq == CS_DCO_FREQUENCY_6
 533             || dcoFreq == CS_DCO_FREQUENCY_12
 534             || dcoFreq == CS_DCO_FREQUENCY_24
 535             || dcoFreq == CS_DCO_FREQUENCY_48);
 536
 537     /* Unlocking the CS Module */
 538     CS->rKEY.r = CS_KEY;
 539
 540     /* Resetting Tuning Parameters and Setting the frequency */
 541     CS->rCTL0.r = ((CS->rCTL0.r & ~DCORSEL_M) | dcoFreq);
 542
 543     /* Locking the CS Module */
 544     BITBAND_PERI(CS->rKEY.r, CSKEY_OFS) = 1;
 545 }
 546
 547 void CS_tuneDCOFrequency(int16_t tuneParameter)
 548 {
 549     CS->rKEY.r = CS_KEY;
 550
 551     if (tuneParameter < 0)
 552     {
 553          CS->rCTL0.r = ((CS->rCTL0.r & ~DCOTUNE_M) | (tuneParameter & DCOTUNE_M)
 554                  | 0x1000);
 555     }
 556     else
 557     {
 558         CS->rCTL0.r =
 559                 ((CS->rCTL0.r & ~DCOTUNE_M) | (tuneParameter & DCOTUNE_M));
 560
 561     }
 562
 563      BITBAND_PERI(CS->rKEY.r, CSKEY_OFS) = 1;
 564 }
 565
 566 uint32_t CS_getDCOFrequency(void)
 567 {
 568     float dcoConst;
 569     int32_t calVal;
 570     uint32_t centeredFreq;
 571     int16_t dcoTune;
 572
 573     dcoTune = CS->rCTL0.b.bDCOTUNE;
 574     centeredFreq = _CSGetDOCFrequency();
 575
 576     if (dcoTune == 0)
 577         return (uint32_t) centeredFreq;
 578
 579     /* Checking to see if we need to do signed conversion */
 580     if (dcoTune & 0x1000)
 581     {
 582         dcoTune = dcoTune | 0xF000;
 583     }
 584
 585     /* DCORSEL = 5, in final silicon this will have a different calibration
 586         value, but currently DCORSEL5 calibration is not populated
 587     if (centeredFreq == 48000000)
 588     {
 589          External Resistor
 590         if (BITBAND_PERI(CS->rCTL0.r, DCORES_OFS))
 591         {
 592             dcoConst = *((float *) &TLV->rDCOER_CONSTK_RSEL5);
 593             calVal = TLV->rDCOER_FCAL_RSEL5;
 594         }
 595         Internal Resistor
 596         else
 597         {
 598             dcoConst = *((float *) &TLV->rDCOIR_CONSTK_RSEL5);
 599             calVal = TLV->rDCOIR_FCAL_RSEL5;
 600         }
 601     }
 602      DCORSEL = 4
 603     else
 604     {*/
 605         /* External Resistor */
 606         if (BITBAND_PERI(CS->rCTL0.r, DCORES_OFS))
 607         {
 608             dcoConst = *((float *) &TLV->rDCOER_CONSTK_RSEL04);
 609             calVal = TLV->rDCOER_FCAL_RSEL04;
 610         }
 611         /* Internal Resistor */
 612         else
 613         {
 614             dcoConst = *((float *) &TLV->rDCOIR_CONSTK_RSEL04);
 615             calVal = TLV->rDCOIR_FCAL_RSEL04;
 616         }
 617     /*}*/
 618
 619     return (uint32_t) ((centeredFreq)
 620             / (1
 621                     - ((dcoConst * dcoTune)
 622                             / (8 * (1 + dcoConst * (768 - calVal))))));
 623 }
 624
 625 void CS_setDCOFrequency(uint32_t dcoFrequency)
 626 {
 627     int32_t nomFreq, calVal, dcoSigned;
 628     int16_t dcoTune;
 629     float dcoConst;
 630  // bool rsel5 = false;
 631     dcoSigned = (int32_t) dcoFrequency;
 632
 633     if (dcoFrequency < 2000000)
 634     {
 635         nomFreq = CS_15MHZ;
 636         CS_setDCOCenteredFrequency(CS_DCO_FREQUENCY_1_5);
 637     } else if (dcoFrequency < 4000000)
 638     {
 639         nomFreq = CS_3MHZ;
 640         CS_setDCOCenteredFrequency(CS_DCO_FREQUENCY_3);
 641     } else if (dcoFrequency < 8000000)
 642     {
 643         nomFreq = CS_6MHZ;
 644         CS_setDCOCenteredFrequency(CS_DCO_FREQUENCY_6);
 645     } else if (dcoFrequency < 16000000)
 646     {
 647         nomFreq = CS_12MHZ;
 648         CS_setDCOCenteredFrequency(CS_DCO_FREQUENCY_12);
 649     } else if (dcoFrequency < 32000000)
 650     {
 651         nomFreq = CS_24MHZ;
 652         CS_setDCOCenteredFrequency(CS_DCO_FREQUENCY_24);
 653     } else if (dcoFrequency < 640000001)
 654     {
 655         nomFreq = CS_48MHZ;
 656         CS_setDCOCenteredFrequency(CS_DCO_FREQUENCY_48);
 657       //  rsel5 = true;
 658     } else
 659     {
 660         ASSERT(false);
 661         return;
 662     }
 663
 664     if(dcoFrequency == nomFreq)
 665     {
 666        CS_tuneDCOFrequency(0);
 667        return;
 668     }
 669
 670     /* DCORSEL = 5, in final silicon this will have a different calibration
 671         value, but currently DCORSEL5 calibration is not populated
 672     if (rsel5)
 673     {
 674         External Resistor
 675         if (BITBAND_PERI(CS->rCTL0.r, DCORES_OFS))
 676         {
 677             dcoConst = *((float *) &TLV->rDCOER_CONSTK_RSEL5);
 678             calVal = TLV->rDCOER_FCAL_RSEL5;
 679         }
 680         Internal Resistor
 681         else
 682         {
 683             dcoConst = *((float *) &TLV->rDCOIR_CONSTK_RSEL5);
 684             calVal = TLV->rDCOIR_FCAL_RSEL5;
 685         }
 686     }
 687     DCORSEL = 4
 688     else
 689     {*/
 690         /* External Resistor */
 691         if (BITBAND_PERI(CS->rCTL0.r, DCORES_OFS))
 692         {
 693             dcoConst = *((float *) &TLV->rDCOER_CONSTK_RSEL04);
 694             calVal = TLV->rDCOER_FCAL_RSEL04;
 695         }
 696         /* Internal Resistor */
 697         else
 698         {
 699             dcoConst = *((float *) &TLV->rDCOIR_CONSTK_RSEL04);
 700             calVal = TLV->rDCOIR_FCAL_RSEL04;
 701         }
 702     /*}*/
 703
 704     dcoTune = (int16_t) (((dcoSigned - nomFreq)
 705             * (1.0 + dcoConst * (768.0 - calVal)) * 8.0)
 706             / (dcoSigned * dcoConst));
 707
 708     CS_tuneDCOFrequency(dcoTune);
 709
 710 }
 711
 712 uint32_t CS_getBCLK(void)
 713 {
 714     if (BITBAND_PERI(CS->rCTL1.r, SELB_OFS))
 715         return _CSComputeCLKFrequency(CS_REFOCLK_SELECT, CS_CLOCK_DIVIDER_1);
 716     else
 717         return _CSComputeCLKFrequency(CS_LFXTCLK_SELECT, CS_CLOCK_DIVIDER_1);
 718 }
 719
 720 uint32_t CS_getHSMCLK(void)
 721 {
 722     uint32_t wSource, wDivider;
 723
 724     wSource = (CS->rCTL1.r & SELS_M) >> CS_HSMCLK_SRC_BITPOS;
 725     wDivider = ((CS->rCTL1.r & DIVHS_M) << CS_HSMCLK_DIV_BITPOS);
 726
 727     return _CSComputeCLKFrequency(wSource, wDivider);
 728 }
 729
 730 uint32_t CS_getACLK(void)
 731 {
 732     uint32_t wSource, wDivider;
 733
 734     wSource = (CS->rCTL1.r & SELA_M) >> CS_ACLK_SRC_BITPOS;
 735     wDivider = ((CS->rCTL1.r & DIVA_M) << CS_ACLK_DIV_BITPOS);
 736
 737     return _CSComputeCLKFrequency(wSource, wDivider);
 738 }
 739
 740 uint32_t CS_getSMCLK(void)
 741 {
 742     uint32_t wDivider, wSource;
 743
 744     wSource = (CS->rCTL1.r & SELS_M) >> CS_HSMCLK_SRC_BITPOS;
 745     wDivider = ((CS->rCTL1.r & DIVS_M));
 746
 747     return _CSComputeCLKFrequency(wSource, wDivider);
 748
 749 }
 750
 751 uint32_t CS_getMCLK(void)
 752 {
 753     uint32_t wSource, wDivider;
 754
 755     wSource = (CS->rCTL1.r & SELM_M) << CS_MCLK_SRC_BITPOS;
 756     wDivider = ((CS->rCTL1.r & DIVM_M) << CS_MCLK_DIV_BITPOS);
 757
 758     return _CSComputeCLKFrequency(wSource, wDivider);
 759 }
 760
 761 void CS_enableFaultCounter(uint_fast8_t counterSelect)
 762 {
 763     ASSERT(counterSelect == CS_HFXT_FAULT_COUNTER ||
 764             counterSelect == CS_HFXT_FAULT_COUNTER);
 765
 766     /* Unlocking the module */
 767     CS->rKEY.r = CS_KEY;
 768
 769     if (counterSelect == CS_HFXT_FAULT_COUNTER)
 770     {
 771         BITBAND_PERI(CS->rCTL3.r, FCNTHF_EN_OFS) = 1;
 772     } else
 773     {
 774         BITBAND_PERI(CS->rCTL3.r, FCNTLF_EN_OFS) = 1;
 775     }
 776
 777     /* Locking the module */
 778     BITBAND_PERI(CS->rKEY.r, CSKEY_OFS) = 1;
 779 }
 780
 781 void CS_disableFaultCounter(uint_fast8_t counterSelect)
 782 {
 783     ASSERT(counterSelect == CS_HFXT_FAULT_COUNTER ||
 784             counterSelect == CS_HFXT_FAULT_COUNTER);
 785
 786     /* Unlocking the module */
 787     CS->rKEY.r = CS_KEY;
 788
 789     if (counterSelect == CS_HFXT_FAULT_COUNTER)
 790     {
 791         BITBAND_PERI(CS->rCTL3.r, FCNTHF_EN_OFS) = 0;
 792     } else
 793     {
 794         BITBAND_PERI(CS->rCTL3.r, FCNTLF_EN_OFS) = 0;
 795     }
 796
 797     /* Locking the module */
 798     BITBAND_PERI(CS->rKEY.r, CSKEY_OFS) = 1;
 799 }
 800
 801 void CS_resetFaultCounter(uint_fast8_t counterSelect)
 802 {
 803     ASSERT(counterSelect == CS_HFXT_FAULT_COUNTER ||
 804             counterSelect == CS_HFXT_FAULT_COUNTER);
 805
 806     /* Unlocking the module */
 807     CS->rKEY.r = CS_KEY;
 808
 809     if (counterSelect == CS_HFXT_FAULT_COUNTER)
 810     {
 811         BITBAND_PERI(CS->rCTL3.r, RFCNTHF_OFS) = 1;
 812     } else
 813     {
 814         BITBAND_PERI(CS->rCTL3.r, RFCNTLF_OFS) = 1;
 815     }
 816
 817     /* Locking the module */
 818     BITBAND_PERI(CS->rKEY.r, CSKEY_OFS) = 1;
 819 }
 820
 821 void CS_startFaultCounter(uint_fast8_t counterSelect, uint_fast8_t countValue)
 822 {
 823     ASSERT(counterSelect == CS_HFXT_FAULT_COUNTER ||
 824             counterSelect == CS_HFXT_FAULT_COUNTER);
 825
 826     ASSERT(countValue == CS_FAULT_COUNTER_4096_CYCLES ||
 827             countValue == CS_FAULT_COUNTER_8192_CYCLES ||
 828             countValue == CS_FAULT_COUNTER_16384_CYCLES ||
 829             countValue == CS_FAULT_COUNTER_32768_CYCLES);
 830
 831     /* Unlocking the module */
 832     CS->rKEY.r = CS_KEY;
 833
 834     if (counterSelect == CS_HFXT_FAULT_COUNTER)
 835     {
 836         CS->rCTL3.r = ((CS->rCTL3.r & ~FCNTHF_M) | (countValue << 4));
 837     } else
 838     {
 839         CS->rCTL3.r = ((CS->rCTL3.r & ~FCNTLF_M) | (countValue));
 840     }
 841
 842     /* Locking the module */
 843     BITBAND_PERI(CS->rKEY.r, CSKEY_OFS) = 1;
 844 }
 845
 846 void CS_enableInterrupt(uint32_t flags)
 847 {
 848     /* Unlocking the module */
 849     CS->rKEY.r = CS_KEY;
 850
 851     CS->rIE.r |= flags;
 852
 853     /* Locking the module */
 854     BITBAND_PERI(CS->rKEY.r, CSKEY_OFS) = 1;
 855 }
 856
 857 void CS_disableInterrupt(uint32_t flags)
 858 {
 859     /* Unlocking the module */
 860     CS->rKEY.r = CS_KEY;
 861
 862     CS->rIE.r &= ~flags;
 863
 864     /* Locking the module */
 865     BITBAND_PERI(CS->rKEY.r, CSKEY_OFS) = 1;
 866 }
 867
 868 uint32_t CS_getInterruptStatus(void)
 869 {
 870     return CS->rIFG.r;
 871 }
 872
 873 uint32_t CS_getEnabledInterruptStatus(void)
 874 {
 875     return CS_getInterruptStatus() & CS->rIE.r;
 876 }
 877
 878 void CS_clearInterruptFlag(uint32_t flags)
 879 {
 880     /* Unlocking the module */
 881     CS->rKEY.r = CS_KEY;
 882
 883     CS->rCLRIFG.r |= flags;
 884
 885     /* Locking the module */
 886     BITBAND_PERI(CS->rKEY.r, CSKEY_OFS) = 1;
 887 }
 888
 889 void CS_registerInterrupt(void (*intHandler)(void))
 890 {
 891     //
 892     // Register the interrupt handler, returning an error if an error occurs.
 893     //
 894     Interrupt_registerInterrupt(INT_CS, intHandler);
 895
 896     //
 897     // Enable the system control interrupt.
 898     //
 899     Interrupt_enableInterrupt(INT_CS);
 900 }
 901
 902 void CS_unregisterInterrupt(void)
 903 {
 904     //
 905     // Disable the interrupt.
 906     //
 907     Interrupt_disableInterrupt(INT_CS);
 908
 909     //
 910     // Unregister the interrupt handler.
 911     //
 912     Interrupt_unregisterInterrupt(INT_CS);
 913 }
 914