tool/mbed/mbed-sdk/libraries/mbed/targets/hal/TARGET_Freescale/TARGET_KPSDK_MCUS/TARGET_KPSDK_CODE/hal/sim/fsl_sim_hal.c

   1 /*
   2  * Copyright (c) 2013 - 2014, Freescale Semiconductor, Inc.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without modification,
   6  * are permitted provided that the following conditions are met:
   7  *
   8  * o Redistributions of source code must retain the above copyright notice, this list
   9  *   of conditions and the following disclaimer.
  10  *
  11  * o Redistributions in binary form must reproduce the above copyright notice, this
  12  *   list of conditions and the following disclaimer in the documentation and/or
  13  *   other materials provided with the distribution.
  14  *
  15  * o Neither the name of Freescale Semiconductor, Inc. nor the names of its
  16  *   contributors may be used to endorse or promote products derived from this
  17  *   software without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  21  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  22  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
  23  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  24  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  25  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
  26  * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  28  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31 #include "fsl_sim_hal.h"
  32
  33 /*******************************************************************************
  34  * Definitions
  35  ******************************************************************************/
  36
  37 /*******************************************************************************
  38  * Code
  39  ******************************************************************************/
  40
  41 /*FUNCTION**********************************************************************
  42  *
  43  * Function Name : CLOCK_HAL_SetSource
  44  * Description   : Set clock source setting
  45  * This function will set the settings for specified clock source. Each clock
  46  * source has its clock selection settings. Refer to reference manual for
  47  * details of settings for each clock source. Refer to clock_source_names_t
  48  * for clock sources.
  49  *
  50  *END**************************************************************************/
  51 sim_hal_status_t CLOCK_HAL_SetSource(uint32_t baseAddr,
  52                                      clock_source_names_t clockSource,
  53                                      uint8_t setting)
  54 {
  55     sim_hal_status_t status = kSimHalSuccess;
  56     assert(clockSource < kClockSourceMax);
  57
  58     switch (clockSource)
  59     {
  60 #if FSL_FEATURE_SIM_OPT_HAS_NFCSRC
  61     case kClockNfcSrc:                   /* NFCSRC*/
  62         BW_SIM_SOPT2_NFCSRC(baseAddr, setting);
  63         break;
  64     case kClockNfcSel:                   /* NFC_CLKSEL*/
  65         BW_SIM_SOPT2_NFC_CLKSEL(baseAddr, setting);
  66         break;
  67 #endif
  68
  69 #if FSL_FEATURE_SIM_OPT_HAS_ESDHCSRC
  70     case kClockEsdhcSrc:                 /* ESDHCSRC*/
  71         BW_SIM_SOPT2_ESDHCSRC(baseAddr, setting);
  72         break;
  73 #endif
  74
  75 #if FSL_FEATURE_SIM_OPT_HAS_SDHCSRC
  76     case kClockSdhcSrc:                  /* SDHCSRC*/
  77         BW_SIM_SOPT2_SDHCSRC(baseAddr, setting);
  78         break;
  79 #endif
  80
  81 #if FSL_FEATURE_SIM_OPT_HAS_LCDCSRC
  82     case kClockLcdcSrc:                  /* LCDCSRC*/
  83         BW_SIM_SOPT2_LCDCSRC(baseAddr, setting);
  84         break;
  85     case kClockLcdcSel:                  /* LCDC_CLKSEL*/
  86         BW_SIM_SOPT2_LCDC_CLKSEL(baseAddr, setting);
  87         break;
  88 #endif
  89
  90 #if FSL_FEATURE_SIM_OPT_HAS_TIMESRC
  91     case kClockTimeSrc:                  /* TIMESRC*/
  92         BW_SIM_SOPT2_TIMESRC(baseAddr, setting);
  93         break;
  94 #endif
  95
  96 #if FSL_FEATURE_SIM_OPT_HAS_RMIISRC
  97     case kClockRmiiSrc:                  /* RMIISRC*/
  98         BW_SIM_SOPT2_RMIISRC(baseAddr, setting);
  99         break;
 100 #endif
 101
 102 #if FSL_FEATURE_SIM_OPT_HAS_USBSRC
 103     case kClockUsbSrc:                    /* USBSRC*/
 104         BW_SIM_SOPT2_USBSRC(baseAddr, setting);
 105         break;
 106 #endif
 107
 108 #if FSL_FEATURE_SIM_OPT_HAS_USBFSRC
 109     case kClockUsbfSrc:                   /* USBFSRC*/
 110         BW_SIM_SOPT2_USBFSRC(baseAddr, setting);
 111         break;
 112     case kClockUsbfSel:                  /* USBF_CLKSEL*/
 113         BW_SIM_SOPT2_USBF_CLKSEL(baseAddr, setting);
 114         break;
 115 #endif
 116
 117 #if FSL_FEATURE_SIM_OPT_HAS_USBHSRC
 118     case kClockUsbhSrc:                  /* USBHSRC*/
 119         BW_SIM_SOPT2_USBHSRC(baseAddr, setting);
 120         break;
 121 #endif
 122
 123 #if FSL_FEATURE_SIM_OPT_HAS_UART0SRC
 124     case kClockUart0Src:                 /* UART0SRC*/
 125         BW_SIM_SOPT2_UART0SRC(baseAddr, setting);
 126         break;
 127 #endif
 128
 129 #if FSL_FEATURE_SIM_OPT_HAS_TPMSRC
 130     case kClockTpmSrc:                   /* TPMSRC*/
 131         BW_SIM_SOPT2_TPMSRC(baseAddr, setting);
 132         break;
 133 #endif
 134
 135 #if FSL_FEATURE_SIM_OPT_HAS_LPUARTSRC
 136     case kClockLpuartSrc:                /* LPUARTSRC*/
 137         BW_SIM_SOPT2_LPUARTSRC(baseAddr, setting);
 138         break;
 139 #endif
 140
 141     case kClockOsc32kSel:                /* OSC32KSEL*/
 142         BW_SIM_SOPT1_OSC32KSEL(baseAddr, setting);
 143         break;
 144
 145     case kClockPllfllSel:                /* PLLFLLSEL*/
 146         BW_SIM_SOPT2_PLLFLLSEL(baseAddr, setting);
 147         break;
 148
 149 #if FSL_FEATURE_SIM_OPT_HAS_TRACE_CLKSEL
 150     case kClockTraceSel:                 /* TRACE_CLKSEL*/
 151         BW_SIM_SOPT2_TRACECLKSEL(baseAddr, setting);
 152         break;
 153 #endif
 154
 155     case kClockClkoutSel:                /* CLKOUTSEL*/
 156         BW_SIM_SOPT2_CLKOUTSEL(baseAddr, setting);
 157         break;
 158
 159 #if FSL_FEATURE_SIM_OPT_HAS_RTC_CLOCK_OUT_SELECTION
 160     case kClockRtcClkoutSel:                /* RTCCLKOUTSEL*/
 161         BW_SIM_SOPT2_RTCCLKOUTSEL(baseAddr, setting);
 162         break;
 163 #endif
 164
 165     default:
 166         status = kSimHalNoSuchClockSrc;
 167         break;
 168     }
 169
 170     return status;
 171 }
 172
 173 /*FUNCTION**********************************************************************
 174  *
 175  * Function Name : CLOCK_HAL_GetSource
 176  * Description   : Get clock source setting
 177  * This function will get the settings for specified clock source. Each clock
 178  * source has its clock selection settings. Refer to reference manual for
 179  * details of settings for each clock source. Refer to clock_source_names_t
 180  * for clock sources.
 181  *
 182  *END**************************************************************************/
 183 sim_hal_status_t CLOCK_HAL_GetSource(uint32_t baseAddr,
 184                                      clock_source_names_t clockSource,
 185                                      uint8_t *setting)
 186 {
 187     sim_hal_status_t status = kSimHalSuccess;
 188     assert(clockSource < kClockSourceMax);
 189
 190     switch (clockSource)
 191     {
 192 #if FSL_FEATURE_SIM_OPT_HAS_NFCSRC
 193     case kClockNfcSrc:                   /* NFCSRC*/
 194         *setting = BR_SIM_SOPT2_NFCSRC(baseAddr);
 195         break;
 196     case kClockNfcSel:                   /* NFC_CLKSEL*/
 197         *setting = BR_SIM_SOPT2_NFC_CLKSEL(baseAddr);
 198         break;
 199 #endif
 200
 201 #if FSL_FEATURE_SIM_OPT_HAS_ESDHCSRC
 202     case kClockEsdhcSrc:                 /* ESDHCSRC*/
 203         *setting = BR_SIM_SOPT2_ESDHCSRC(baseAddr);
 204         break;
 205 #endif
 206
 207 #if FSL_FEATURE_SIM_OPT_HAS_SDHCSRC
 208     case kClockSdhcSrc:                  /* SDHCSRC*/
 209         *setting = BR_SIM_SOPT2_SDHCSRC(baseAddr);
 210         break;
 211 #endif
 212
 213 #if FSL_FEATURE_SIM_OPT_HAS_LCDCSRC
 214     case kClockLcdcSrc:                  /* LCDCSRC*/
 215         *setting = BR_SIM_SOPT2_LCDCSRC(baseAddr);
 216         break;
 217     case kClockLcdcSel:                  /* LCDC_CLKSEL*/
 218         *setting = BR_SIM_SOPT2_LCDC_CLKSEL(baseAddr);
 219         break;
 220 #endif
 221
 222 #if FSL_FEATURE_SIM_OPT_HAS_TIMESRC
 223     case kClockTimeSrc:                  /* TIMESRC*/
 224         *setting = BR_SIM_SOPT2_TIMESRC(baseAddr);
 225         break;
 226 #endif
 227
 228 #if FSL_FEATURE_SIM_OPT_HAS_RMIISRC
 229     case kClockRmiiSrc:                  /* RMIISRC*/
 230         *setting = BR_SIM_SOPT2_RMIISRC(baseAddr);
 231         break;
 232 #endif
 233
 234 #if FSL_FEATURE_SIM_OPT_HAS_USBSRC
 235     case kClockUsbSrc:                    /* USBSRC*/
 236         *setting = BR_SIM_SOPT2_USBSRC(baseAddr);
 237         break;
 238 #endif
 239
 240 #if FSL_FEATURE_SIM_OPT_HAS_USBFSRC
 241     case kClockUsbfSrc:                   /* USBFSRC*/
 242         *setting = BR_SIM_SOPT2_USBFSRC(baseAddr);
 243         break;
 244     case kClockUsbfSel:                  /* USBF_CLKSEL*/
 245         *setting = BR_SIM_SOPT2_USBF_CLKSEL(baseAddr);
 246         break;
 247 #endif
 248
 249 #if FSL_FEATURE_SIM_OPT_HAS_USBHSRC
 250     case kClockUsbhSrc:                  /* USBHSRC*/
 251         *setting = BR_SIM_SOPT2_USBHSRC(baseAddr);
 252         break;
 253 #endif
 254
 255 #if FSL_FEATURE_SIM_OPT_HAS_UART0SRC
 256     case kClockUart0Src:                 /* UART0SRC*/
 257         *setting = BR_SIM_SOPT2_UART0SRC(baseAddr);
 258         break;
 259 #endif
 260
 261 #if FSL_FEATURE_SIM_OPT_HAS_TPMSRC
 262     case kClockTpmSrc:                   /* TPMSRC*/
 263         *setting = BR_SIM_SOPT2_TPMSRC(baseAddr);
 264         break;
 265 #endif
 266
 267 #if FSL_FEATURE_SIM_OPT_HAS_LPUARTSRC
 268     case kClockLpuartSrc:                /* LPUARTSRC*/
 269         *setting = BR_SIM_SOPT2_LPUARTSRC(baseAddr);
 270         break;
 271 #endif
 272
 273     case kClockOsc32kSel:                /* OSC32KSEL*/
 274         *setting = BR_SIM_SOPT1_OSC32KSEL(baseAddr);
 275         break;
 276
 277     case kClockPllfllSel:                /* PLLFLLSEL*/
 278         *setting = BR_SIM_SOPT2_PLLFLLSEL(baseAddr);
 279         break;
 280
 281 #if FSL_FEATURE_SIM_OPT_HAS_TRACE_CLKSEL
 282     case kClockTraceSel:                 /* TRACE_CLKSEL*/
 283         *setting = BR_SIM_SOPT2_TRACECLKSEL(baseAddr);
 284         break;
 285 #endif
 286
 287     case kClockClkoutSel:                /* CLKOUTSEL */
 288         *setting = BR_SIM_SOPT2_CLKOUTSEL(baseAddr);
 289         break;
 290
 291 #if FSL_FEATURE_SIM_OPT_HAS_RTC_CLOCK_OUT_SELECTION
 292     case kClockRtcClkoutSel:                /* RTCCLKOUTSEL */
 293         *setting = BR_SIM_SOPT2_RTCCLKOUTSEL(baseAddr);
 294         break;
 295 #endif
 296
 297     default:
 298         status = kSimHalNoSuchClockSrc;
 299         break;
 300     }
 301
 302     return status;
 303 }
 304
 305 /*FUNCTION**********************************************************************
 306  *
 307  * Function Name : CLOCK_HAL_SetDivider
 308  * Description   : Set clock divider setting
 309  * This function will set the setting for specified clock divider. Refer to
 310  * reference manual for supported clock divider and value range. Refer to
 311  * clock_divider_names_t for dividers.
 312  *
 313  *END**************************************************************************/
 314 sim_hal_status_t CLOCK_HAL_SetDivider(uint32_t baseAddr,
 315                                       clock_divider_names_t clockDivider,
 316                                       uint32_t setting)
 317 {
 318     sim_hal_status_t status = kSimHalSuccess;
 319     assert(clockDivider < kClockDividerMax);
 320
 321     switch (clockDivider)
 322     {
 323     case kClockDividerOutdiv1:           /* OUTDIV1*/
 324         BW_SIM_CLKDIV1_OUTDIV1(baseAddr, setting);
 325         break;
 326
 327 #if FSL_FEATURE_SIM_DIVIDER_HAS_OUTDIV2
 328     case kClockDividerOutdiv2:           /* OUTDIV2*/
 329         BW_SIM_CLKDIV1_OUTDIV2(baseAddr, setting);
 330         break;
 331 #endif
 332
 333 #if FSL_FEATURE_SIM_DIVIDER_HAS_OUTDIV3
 334     case kClockDividerOutdiv3:           /* OUTDIV3*/
 335         BW_SIM_CLKDIV1_OUTDIV3(baseAddr, setting);
 336         break;
 337 #endif
 338
 339     case kClockDividerOutdiv4:           /* OUTDIV4*/
 340         BW_SIM_CLKDIV1_OUTDIV4(baseAddr, setting);
 341         break;
 342
 343 #if FSL_FEATURE_SIM_DIVIDER_HAS_USBDIV
 344     case kClockDividerUsbFrac:           /* USBFRAC*/
 345         BW_SIM_CLKDIV2_USBFRAC(baseAddr, setting);
 346         break;
 347     case kClockDividerUsbDiv:            /* USBDIV*/
 348         BW_SIM_CLKDIV2_USBDIV(baseAddr, setting);
 349         break;
 350 #endif
 351
 352 #if FSL_FEATURE_SIM_DIVIDER_HAS_USBFSDIV
 353     case kClockDividerUsbfsFrac:         /* USBFSFRAC*/
 354         BW_SIM_CLKDIV2_USBFSFRAC(baseAddr, setting);
 355         break;
 356     case kClockDividerUsbfsDiv:          /* USBFSDIV*/
 357         BW_SIM_CLKDIV2_USBFSDIV(baseAddr, setting);
 358         break;
 359 #endif
 360
 361 #if FSL_FEATURE_SIM_DIVIDER_HAS_USBHSDIV
 362     case kClockDividerUsbhsFrac:         /* USBHSFRAC*/
 363         BW_SIM_CLKDIV2_USBHSFRAC(baseAddr, setting);
 364         break;
 365     case kClockDividerUsbhsDiv:          /* USBHSDIV*/
 366         BW_SIM_CLKDIV2_USBHSDIV(baseAddr, setting);
 367         break;
 368 #endif
 369
 370 #if FSL_FEATURE_SIM_OPT_HAS_LCDCSRC
 371     case kClockDividerLcdcFrac:          /* LCDCFRAC*/
 372         BW_SIM_CLKDIV3_LCDCFRAC(baseAddr, setting);
 373         break;
 374     case kClockDividerLcdcDiv:           /* LCDCDIV*/
 375         BW_SIM_CLKDIV3_LCDCDIV(baseAddr, setting);
 376         break;
 377 #endif
 378
 379 #if FSL_FEATURE_SIM_OPT_HAS_NFCSRC
 380     case kClockDividerNfcFrac:           /* NFCFRAC*/
 381         BW_SIM_CLKDIV4_NFCFRAC(baseAddr, setting);
 382         break;
 383     case kClockDividerNfcDiv:            /* NFCDIV*/
 384         BW_SIM_CLKDIV4_NFCDIV(baseAddr, setting);
 385         break;
 386 #endif
 387
 388     case kClockDividerSpecial1:          /* special divider 1   */
 389         break;
 390
 391     default:
 392         status = kSimHalNoSuchDivider;
 393         break;
 394     }
 395
 396     return status;
 397 }
 398
 399 /*FUNCTION**********************************************************************
 400  *
 401  * Function Name : CLOCK_HAL_SetOutDividers
 402  * Description   : Set all clock out dividers setting at the same time
 403  * This function will set the setting for all clock out dividers. Refer to
 404  * reference manual for supported clock divider and value range. Refer to
 405  * clock_divider_names_t for dividers.
 406  *
 407  *END**************************************************************************/
 408 void CLOCK_HAL_SetOutDividers(uint32_t baseAddr, uint32_t outdiv1, uint32_t outdiv2,
 409                                  uint32_t outdiv3, uint32_t outdiv4)
 410 {
 411     uint32_t clkdiv1 = 0;
 412
 413     clkdiv1 |= BF_SIM_CLKDIV1_OUTDIV1(outdiv1);
 414 #if FSL_FEATURE_SIM_DIVIDER_HAS_OUTDIV2
 415     clkdiv1 |= BF_SIM_CLKDIV1_OUTDIV2(outdiv2);
 416 #endif
 417 #if FSL_FEATURE_SIM_DIVIDER_HAS_OUTDIV3
 418     clkdiv1 |= BF_SIM_CLKDIV1_OUTDIV3(outdiv3);
 419 #endif
 420     clkdiv1 |= BF_SIM_CLKDIV1_OUTDIV4(outdiv4);
 421
 422     HW_SIM_CLKDIV1_WR(baseAddr, clkdiv1);
 423 }
 424
 425 /*FUNCTION**********************************************************************
 426  *
 427  * Function Name : CLOCK_HAL_GetDivider
 428  * Description   : Get clock divider setting
 429  * This function will get the setting for specified clock divider. Refer to
 430  * reference manual for supported clock divider and value range. Refer to
 431  * clock_divider_names_t for dividers.
 432  *
 433  *END**************************************************************************/
 434 sim_hal_status_t CLOCK_HAL_GetDivider(uint32_t baseAddr,
 435                                       clock_divider_names_t clockDivider,
 436                                       uint32_t *setting)
 437 {
 438     sim_hal_status_t status = kSimHalSuccess;
 439     assert(clockDivider < kClockDividerMax);
 440
 441     *setting = 0;
 442
 443     switch (clockDivider)
 444     {
 445     case kClockDividerOutdiv1:           /* OUTDIV1*/
 446         *setting = BR_SIM_CLKDIV1_OUTDIV1(baseAddr);
 447         break;
 448
 449 #if FSL_FEATURE_SIM_DIVIDER_HAS_OUTDIV2
 450     case kClockDividerOutdiv2:           /* OUTDIV2*/
 451         *setting = BR_SIM_CLKDIV1_OUTDIV2(baseAddr);
 452         break;
 453 #endif
 454
 455 #if FSL_FEATURE_SIM_DIVIDER_HAS_OUTDIV3
 456     case kClockDividerOutdiv3:           /* OUTDIV3*/
 457         *setting = BR_SIM_CLKDIV1_OUTDIV3(baseAddr);
 458         break;
 459 #endif
 460
 461     case kClockDividerOutdiv4:           /* OUTDIV4*/
 462         *setting = BR_SIM_CLKDIV1_OUTDIV4(baseAddr);
 463         break;
 464
 465 #if FSL_FEATURE_SIM_DIVIDER_HAS_USBDIV
 466     case kClockDividerUsbFrac:           /* USBFRAC*/
 467         *setting = BR_SIM_CLKDIV2_USBFRAC(baseAddr);
 468         break;
 469     case kClockDividerUsbDiv:            /* USBDIV*/
 470         *setting = BR_SIM_CLKDIV2_USBDIV(baseAddr);
 471         break;
 472 #endif
 473
 474 #if FSL_FEATURE_SIM_DIVIDER_HAS_USBFSDIV
 475     case kClockDividerUsbfsFrac:         /* USBFSFRAC*/
 476         *setting = BR_SIM_CLKDIV2_USBFSFRAC(baseAddr);
 477         break;
 478     case kClockDividerUsbfsDiv:          /* USBFSDIV*/
 479         *setting = BR_SIM_CLKDIV2_USBFSDIV(baseAddr);
 480         break;
 481 #endif
 482
 483 #if FSL_FEATURE_SIM_DIVIDER_HAS_USBHSDIV
 484     case kClockDividerUsbhsFrac:         /* USBHSFRAC*/
 485         *setting = BR_SIM_CLKDIV2_USBHSFRAC(baseAddr);
 486         break;
 487     case kClockDividerUsbhsDiv:          /* USBHSDIV*/
 488         *setting = BR_SIM_CLKDIV2_USBHSDIV(baseAddr);
 489         break;
 490 #endif
 491
 492 #if FSL_FEATURE_SIM_OPT_HAS_LCDCSRC
 493     case kClockDividerLcdcFrac:          /* LCDCFRAC*/
 494         *setting = BR_SIM_CLKDIV3_LCDCFRAC(baseAddr);
 495         break;
 496     case kClockDividerLcdcDiv:           /* LCDCDIV*/
 497         *setting = BR_SIM_CLKDIV3_LCDCDIV(baseAddr);
 498         break;
 499 #endif
 500
 501 #if FSL_FEATURE_SIM_OPT_HAS_NFCSRC
 502     case kClockDividerNfcFrac:           /* NFCFRAC*/
 503         *setting = BR_SIM_CLKDIV4_NFCFRAC(baseAddr);
 504         break;
 505     case kClockDividerNfcDiv:            /* NFCDIV*/
 506         *setting = BR_SIM_CLKDIV4_NFCDIV(baseAddr);
 507         break;
 508 #endif
 509
 510     case kClockDividerSpecial1:          /* special divider 1    */
 511         *setting = 1;
 512         break;
 513
 514     default:
 515         status = kSimHalNoSuchDivider;
 516         break;
 517     }
 518
 519     return status;
 520 }
 521
 522 /*FUNCTION**********************************************************************
 523  *
 524  * Function Name : SIM_HAL_SetAdcAlternativeTriggerCmd
 525  * Description   : Set ADCx alternate trigger enable setting
 526  * This function will enable/disable alternative conversion triggers for ADCx.
 527  *
 528  *END**************************************************************************/
 529 void SIM_HAL_SetAdcAlternativeTriggerCmd(uint32_t baseAddr, uint8_t instance, bool enable)
 530 {
 531     assert(instance < HW_ADC_INSTANCE_COUNT);
 532
 533     switch (instance)
 534     {
 535     case 0:
 536         BW_SIM_SOPT7_ADC0ALTTRGEN(baseAddr, enable ? 1 : 0);
 537         break;
 538 #if (HW_ADC_INSTANCE_COUNT > 1)
 539     case 1:
 540         BW_SIM_SOPT7_ADC1ALTTRGEN(baseAddr, enable ? 1 : 0);
 541         break;
 542 #if (HW_ADC_INSTANCE_COUNT > 2)
 543     case 2:
 544         BW_SIM_SOPT7_ADC2ALTTRGEN(baseAddr, enable ? 1 : 0);
 545         break;
 546     case 3:
 547         BW_SIM_SOPT7_ADC3ALTTRGEN(baseAddr, enable ? 1 : 0);
 548         break;
 549 #endif
 550 #endif
 551     default:
 552         break;
 553     }
 554 }
 555
 556 /*FUNCTION**********************************************************************
 557  *
 558  * Function Name : SIM_HAL_GetAdcAlternativeTriggerCmd
 559  * Description   : Get ADCx alternate trigger enable settingg
 560  * This function will get ADCx alternate trigger enable setting.
 561  *
 562  *END**************************************************************************/
 563 bool SIM_HAL_GetAdcAlternativeTriggerCmd(uint32_t baseAddr, uint8_t instance)
 564 {
 565     bool retValue = false;
 566
 567     assert(instance < HW_ADC_INSTANCE_COUNT);
 568
 569     switch (instance)
 570     {
 571     case 0:
 572         retValue = BR_SIM_SOPT7_ADC0ALTTRGEN(baseAddr);
 573         break;
 574 #if (HW_ADC_INSTANCE_COUNT > 1)
 575     case 1:
 576         retValue = BR_SIM_SOPT7_ADC1ALTTRGEN(baseAddr);
 577         break;
 578 #if (HW_ADC_INSTANCE_COUNT > 2)
 579     case 2:
 580         retValue = BR_SIM_SOPT7_ADC2ALTTRGEN(baseAddr);
 581         break;
 582     case 3:
 583         retValue = BR_SIM_SOPT7_ADC3ALTTRGEN(baseAddr);
 584         break;
 585 #endif
 586 #endif
 587     default:
 588         retValue = false;
 589         break;
 590     }
 591
 592     return retValue;
 593 }
 594
 595 /*FUNCTION**********************************************************************
 596  *
 597  * Function Name : SIM_HAL_SetAdcPreTriggerMode
 598  * Description   : Set ADCx pre-trigger select setting
 599  * This function will select the ADCx pre-trigger source when alternative
 600  * triggers are enabled through ADCxALTTRGEN
 601  *
 602  *END**************************************************************************/
 603 void SIM_HAL_SetAdcPreTriggerMode(uint32_t baseAddr, uint8_t instance, sim_pretrgsel_t select)
 604 {
 605     assert(instance < HW_ADC_INSTANCE_COUNT);
 606
 607     switch (instance)
 608     {
 609     case 0:
 610         BW_SIM_SOPT7_ADC0PRETRGSEL(baseAddr, select);
 611         break;
 612 #if (HW_ADC_INSTANCE_COUNT > 1)
 613     case 1:
 614         BW_SIM_SOPT7_ADC1PRETRGSEL(baseAddr, select);
 615         break;
 616 #if (HW_ADC_INSTANCE_COUNT > 2)
 617     case 2:
 618         BW_SIM_SOPT7_ADC2PRETRGSEL(baseAddr, select);
 619         break;
 620     case 3:
 621         BW_SIM_SOPT7_ADC3PRETRGSEL(baseAddr, select);
 622         break;
 623 #endif
 624 #endif
 625     default:
 626         break;
 627     }
 628 }
 629
 630 /*FUNCTION**********************************************************************
 631  *
 632  * Function Name : SIM_HAL_GetAdcPreTriggerMode
 633  * Description   : Get ADCx pre-trigger select setting
 634  * This function will get ADCx pre-trigger select setting.
 635  *
 636  *END**************************************************************************/
 637 sim_pretrgsel_t SIM_HAL_GetAdcPreTriggerMode(uint32_t baseAddr, uint8_t instance)
 638 {
 639     sim_pretrgsel_t retValue = (sim_pretrgsel_t)0;
 640
 641     assert(instance < HW_ADC_INSTANCE_COUNT);
 642
 643     switch (instance)
 644     {
 645     case 0:
 646         retValue = (sim_pretrgsel_t)BR_SIM_SOPT7_ADC0PRETRGSEL(baseAddr);
 647         break;
 648 #if (HW_ADC_INSTANCE_COUNT > 1)
 649     case 1:
 650         retValue = (sim_pretrgsel_t)BR_SIM_SOPT7_ADC1PRETRGSEL(baseAddr);
 651         break;
 652 #if (HW_ADC_INSTANCE_COUNT > 2)
 653     case 2:
 654         retValue = (sim_pretrgsel_t)BR_SIM_SOPT7_ADC2PRETRGSEL(baseAddr);
 655         break;
 656     case 3:
 657         retValue = (sim_pretrgsel_t)BR_SIM_SOPT7_ADC3PRETRGSEL(baseAddr);
 658         break;
 659 #endif
 660 #endif
 661     default:
 662         break;
 663     }
 664
 665     return retValue;
 666 }
 667
 668 /*FUNCTION**********************************************************************
 669  *
 670  * Function Name : SIM_HAL_SetAdcTriggerMode
 671  * Description   : Set ADCx trigger select setting
 672  * This function will select the ADCx trigger source when alternative triggers
 673  * are enabled through ADCxALTTRGEN
 674  *
 675  *END**************************************************************************/
 676 void SIM_HAL_SetAdcTriggerMode(uint32_t baseAddr, uint8_t instance, sim_trgsel_t select)
 677 {
 678     assert(instance < HW_ADC_INSTANCE_COUNT);
 679
 680     switch (instance)
 681     {
 682     case 0:
 683         BW_SIM_SOPT7_ADC0TRGSEL(baseAddr, select);
 684         break;
 685 #if (HW_ADC_INSTANCE_COUNT > 1)
 686     case 1:
 687         BW_SIM_SOPT7_ADC1TRGSEL(baseAddr, select);
 688         break;
 689 #if (HW_ADC_INSTANCE_COUNT > 2)
 690     case 2:
 691         BW_SIM_SOPT7_ADC2TRGSEL(baseAddr, select);
 692         break;
 693     case 3:
 694         BW_SIM_SOPT7_ADC3TRGSEL(baseAddr, select);
 695         break;
 696 #endif
 697 #endif
 698     default:
 699         break;
 700     }
 701 }
 702
 703 /*FUNCTION**********************************************************************
 704  *
 705  * Function Name : SIM_HAL_GetAdcTriggerMode
 706  * Description   : Get ADCx trigger select setting
 707  * This function will get ADCx trigger select setting.
 708  *
 709  *END**************************************************************************/
 710 sim_pretrgsel_t SIM_HAL_GetAdcTriggerMode(uint32_t baseAddr, uint8_t instance)
 711 {
 712     sim_pretrgsel_t retValue =(sim_pretrgsel_t)0;
 713
 714     assert(instance < HW_ADC_INSTANCE_COUNT);
 715
 716     switch (instance)
 717     {
 718     case 0:
 719         retValue = (sim_pretrgsel_t)BR_SIM_SOPT7_ADC0TRGSEL(baseAddr);
 720         break;
 721 #if (HW_ADC_INSTANCE_COUNT > 1)
 722     case 1:
 723         retValue = (sim_pretrgsel_t)BR_SIM_SOPT7_ADC1TRGSEL(baseAddr);
 724         break;
 725 #if (HW_ADC_INSTANCE_COUNT > 2)
 726     case 2:
 727         retValue = (sim_pretrgsel_t)BR_SIM_SOPT7_ADC2TRGSEL(baseAddr);
 728         break;
 729     case 3:
 730         retValue = (sim_pretrgsel_t)BR_SIM_SOPT7_ADC3TRGSEL(baseAddr);
 731         break;
 732 #endif
 733 #endif
 734     default:
 735         break;
 736     }
 737
 738     return retValue;
 739 }
 740
 741 /*FUNCTION**********************************************************************
 742  *
 743  * Function Name : SIM_HAL_SetUartRxSrcMode
 744  * Description   : Set UARTx receive data source select setting
 745  * This function will select the source for the UART1 receive data.
 746  *
 747  *END**************************************************************************/
 748 void SIM_HAL_SetUartRxSrcMode(uint32_t baseAddr, uint8_t instance, sim_uart_rxsrc_t select)
 749 {
 750     assert(instance < FSL_FEATURE_SIM_OPT_UART_COUNT);
 751
 752     switch (instance)
 753     {
 754     case 0:
 755         BW_SIM_SOPT5_UART0RXSRC(baseAddr, select);
 756         break;
 757     case 1:
 758         BW_SIM_SOPT5_UART1RXSRC(baseAddr, select);
 759         break;
 760     default:
 761         break;
 762     }
 763 }
 764
 765 /*FUNCTION**********************************************************************
 766  *
 767  * Function Name : SIM_HAL_GetAdcPreTriggerMode
 768  * Description   : Get UARTx receive data source select setting
 769  * This function will get UARTx receive data source select setting.
 770  *
 771  *END**************************************************************************/
 772 sim_uart_rxsrc_t SIM_HAL_GetUartRxSrcMode(uint32_t baseAddr, uint8_t instance)
 773 {
 774     sim_uart_rxsrc_t retValue = (sim_uart_rxsrc_t)0;
 775
 776     assert(instance < FSL_FEATURE_SIM_OPT_UART_COUNT);
 777
 778     switch (instance)
 779     {
 780     case 0:
 781         retValue = (sim_uart_rxsrc_t)BR_SIM_SOPT5_UART0RXSRC(baseAddr);
 782         break;
 783     case 1:
 784         retValue = (sim_uart_rxsrc_t)BR_SIM_SOPT5_UART1RXSRC(baseAddr);
 785         break;
 786     default:
 787         break;
 788     }
 789
 790     return retValue;
 791 }
 792
 793 /*FUNCTION**********************************************************************
 794  *
 795  * Function Name : SIM_HAL_SetUartTxSrcMode
 796  * Description   : Set UARTx transmit data source select setting
 797  * This function will select the source for the UARTx transmit data.
 798  *
 799  *END**************************************************************************/
 800 void SIM_HAL_SetUartTxSrcMode(uint32_t baseAddr, uint8_t instance, sim_uart_txsrc_t select)
 801 {
 802     assert(instance < FSL_FEATURE_SIM_OPT_UART_COUNT);
 803
 804     switch (instance)
 805     {
 806     case 0:
 807         BW_SIM_SOPT5_UART0TXSRC(baseAddr, select);
 808         break;
 809     case 1:
 810         BW_SIM_SOPT5_UART1TXSRC(baseAddr, select);
 811         break;
 812     default:
 813         break;
 814     }
 815 }
 816
 817 /*FUNCTION**********************************************************************
 818  *
 819  * Function Name : SIM_HAL_GetUartTxSrcMode
 820  * Description   : Get UARTx transmit data source select setting
 821  * This function will get UARTx transmit data source select setting.
 822  *
 823  *END**************************************************************************/
 824 sim_uart_txsrc_t SIM_HAL_GetUartTxSrcMode(uint32_t baseAddr, uint8_t instance)
 825 {
 826     sim_uart_txsrc_t retValue =(sim_uart_txsrc_t)0;
 827
 828     assert(instance < FSL_FEATURE_SIM_OPT_UART_COUNT);
 829
 830     switch (instance)
 831     {
 832     case 0:
 833         retValue = (sim_uart_txsrc_t)BR_SIM_SOPT5_UART0TXSRC(baseAddr);
 834         break;
 835     case 1:
 836         retValue = (sim_uart_txsrc_t)BR_SIM_SOPT5_UART1TXSRC(baseAddr);
 837         break;
 838     default:
 839         break;
 840     }
 841
 842     return retValue;
 843 }
 844
 845 #if FSL_FEATURE_SIM_OPT_HAS_ODE
 846 /*FUNCTION**********************************************************************
 847  *
 848  * Function Name : SIM_HAL_SetUartOpenDrainCmd
 849  * Description   : Set UARTx Open Drain Enable setting
 850  * This function will enable/disable the UARTx Open Drain.
 851  *
 852  *END**************************************************************************/
 853 void SIM_HAL_SetUartOpenDrainCmd(uint32_t baseAddr, uint8_t instance, bool enable)
 854 {
 855     assert(instance < FSL_FEATURE_SIM_OPT_UART_COUNT);
 856
 857     switch (instance)
 858     {
 859     case 0:
 860         BW_SIM_SOPT5_UART0ODE(baseAddr, enable ? 1 : 0);
 861         break;
 862     case 1:
 863         BW_SIM_SOPT5_UART1ODE(baseAddr, enable ? 1 : 0);
 864         break;
 865     case 2:
 866         BW_SIM_SOPT5_UART2ODE(baseAddr, enable ? 1 : 0);
 867         break;
 868     default:
 869         break;
 870     }
 871 }
 872
 873 /*FUNCTION**********************************************************************
 874  *
 875  * Function Name : SIM_HAL_GetUartOpenDrainCmd
 876  * Description   : Get UARTx Open Drain Enable setting
 877  * This function will get UARTx Open Drain Enable setting.
 878  *
 879  *END**************************************************************************/
 880 bool SIM_HAL_GetUartOpenDrainCmd(uint32_t baseAddr, uint8_t instance)
 881 {
 882     bool retValue = false;
 883
 884     assert(instance < FSL_FEATURE_SIM_OPT_UART_COUNT);
 885
 886     switch (instance)
 887     {
 888     case 0:
 889         retValue = BR_SIM_SOPT5_UART0ODE(baseAddr);
 890         break;
 891     case 1:
 892         retValue = BR_SIM_SOPT5_UART1ODE(baseAddr);
 893         break;
 894     case 2:
 895         retValue = BR_SIM_SOPT5_UART2ODE(baseAddr);
 896         break;
 897     default:
 898         break;
 899     }
 900
 901     return retValue;
 902 }
 903 #endif
 904
 905 #if FSL_FEATURE_SIM_OPT_HAS_FTM
 906 /*FUNCTION**********************************************************************
 907  *
 908  * Function Name : SIM_HAL_SetFtmTriggerSrcMode
 909  * Description   : Set FlexTimer x hardware trigger y source select setting
 910  * This function will select the source of FTMx hardware trigger y.
 911  *
 912  *END**************************************************************************/
 913 void SIM_HAL_SetFtmTriggerSrcMode(uint32_t baseAddr,
 914                                   uint8_t  instance,
 915                                   uint8_t  trigger,
 916                                   sim_ftm_trg_src_t select)
 917 {
 918     assert (instance < HW_FTM_INSTANCE_COUNT);
 919     assert (trigger < FSL_FEATURE_SIM_OPT_FTM_TRIGGER_COUNT);
 920
 921     switch (instance)
 922     {
 923 #if FSL_FEATURE_SIM_OPT_HAS_FTM0_TRIGGER
 924     case 0:
 925         switch (trigger)
 926         {
 927         case 0:
 928             BW_SIM_SOPT4_FTM0TRG0SRC(baseAddr, select);
 929             break;
 930         case 1:
 931             BW_SIM_SOPT4_FTM0TRG1SRC(baseAddr, select);
 932             break;
 933         default:
 934             break;
 935         }
 936         break;
 937 #endif
 938 #if FSL_FEATURE_SIM_OPT_HAS_FTM3_TRIGGER
 939     case 3:
 940         switch (trigger)
 941         {
 942         case 0:
 943             BW_SIM_SOPT4_FTM3TRG0SRC(baseAddr, select);
 944             break;
 945         case 1:
 946             BW_SIM_SOPT4_FTM3TRG1SRC(baseAddr, select);
 947             break;
 948         default:
 949             break;
 950         }
 951         break;
 952 #endif
 953     default:
 954         break;
 955     }
 956 }
 957
 958 /*FUNCTION**********************************************************************
 959  *
 960  * Function Name : SIM_HAL_GetFtmTriggerSrcMode
 961  * Description   : Get FlexTimer x hardware trigger y source select setting
 962  * This function will get FlexTimer x hardware trigger y source select setting.
 963  *
 964  *END**************************************************************************/
 965 sim_ftm_trg_src_t SIM_HAL_GetFtmTriggerSrcMode(uint32_t baseAddr, uint8_t instance, uint8_t trigger)
 966 {
 967     sim_ftm_trg_src_t retValue = (sim_ftm_trg_src_t)0;
 968
 969     assert (instance < HW_FTM_INSTANCE_COUNT);
 970     assert (trigger < FSL_FEATURE_SIM_OPT_FTM_TRIGGER_COUNT);
 971
 972     switch (instance)
 973     {
 974 #if FSL_FEATURE_SIM_OPT_HAS_FTM0_TRIGGER
 975     case 0:
 976         switch (trigger)
 977         {
 978         case 0:
 979             retValue = (sim_ftm_trg_src_t)BR_SIM_SOPT4_FTM0TRG0SRC(baseAddr);
 980             break;
 981         case 1:
 982             retValue = (sim_ftm_trg_src_t)BR_SIM_SOPT4_FTM0TRG1SRC(baseAddr);
 983             break;
 984         default:
 985             break;
 986         }
 987         break;
 988 #endif
 989 #if FSL_FEATURE_SIM_OPT_HAS_FTM3_TRIGGER
 990     case 3:
 991         switch (trigger)
 992         {
 993         case 0:
 994             retValue = (sim_ftm_trg_src_t)BR_SIM_SOPT4_FTM3TRG0SRC(baseAddr);
 995             break;
 996         case 1:
 997             retValue = (sim_ftm_trg_src_t)BR_SIM_SOPT4_FTM3TRG1SRC(baseAddr);
 998             break;
 999         default:
1000             break;
1001         }
1002         break;
1003 #endif
1004     default:
1005         break;
1006     }
1007
1008     return retValue;
1009 }
1010
1011 /*FUNCTION**********************************************************************
1012  *
1013  * Function Name : SIM_HAL_SetFtmExternalClkPinMode
1014  * Description   : Set FlexTimer x external clock pin select setting
1015  * This function will select the source of FTMx external clock pin select
1016  *
1017  *END**************************************************************************/
1018 void SIM_HAL_SetFtmExternalClkPinMode(uint32_t baseAddr, uint8_t instance, sim_ftm_clk_sel_t select)
1019 {
1020     assert (instance < HW_FTM_INSTANCE_COUNT);
1021
1022     switch (instance)
1023     {
1024     case 0:
1025         BW_SIM_SOPT4_FTM0CLKSEL(baseAddr, select);
1026         break;
1027     case 1:
1028         BW_SIM_SOPT4_FTM1CLKSEL(baseAddr, select);
1029         break;
1030     case 2:
1031         BW_SIM_SOPT4_FTM2CLKSEL(baseAddr, select);
1032         break;
1033 #if (HW_FTM_INSTANCE_COUNT > 3)
1034     case 3:
1035         BW_SIM_SOPT4_FTM3CLKSEL(baseAddr, select);
1036         break;
1037 #endif
1038     default:
1039         break;
1040     }
1041 }
1042
1043 /*FUNCTION**********************************************************************
1044  *
1045  * Function Name : SIM_HAL_GetFtmExternalClkPinMode
1046  * Description   : Get FlexTimer x external clock pin select setting
1047  * This function will get FlexTimer x external clock pin select setting.
1048  *
1049  *END**************************************************************************/
1050 sim_ftm_clk_sel_t SIM_HAL_GetFtmExternalClkPinMode(uint32_t baseAddr, uint8_t instance)
1051 {
1052     sim_ftm_clk_sel_t retValue = (sim_ftm_clk_sel_t)0;
1053
1054     assert (instance < HW_FTM_INSTANCE_COUNT);
1055
1056     switch (instance)
1057     {
1058     case 0:
1059         retValue = (sim_ftm_clk_sel_t)BR_SIM_SOPT4_FTM0CLKSEL(baseAddr);
1060         break;
1061     case 1:
1062         retValue = (sim_ftm_clk_sel_t)BR_SIM_SOPT4_FTM1CLKSEL(baseAddr);
1063         break;
1064     case 2:
1065         retValue = (sim_ftm_clk_sel_t)BR_SIM_SOPT4_FTM2CLKSEL(baseAddr);
1066         break;
1067 #if (HW_FTM_INSTANCE_COUNT > 3)
1068     case 3:
1069         retValue = (sim_ftm_clk_sel_t)BR_SIM_SOPT4_FTM3CLKSEL(baseAddr);
1070         break;
1071 #endif
1072     default:
1073         break;
1074     }
1075
1076     return retValue;
1077 }
1078
1079 /*FUNCTION**********************************************************************
1080  *
1081  * Function Name : SIM_HAL_SetFtmChSrcMode
1082  * Description   : FlexTimer x channel y input capture source select setting
1083  * This function will select FlexTimer x channel y input capture source
1084  *
1085  *END**************************************************************************/
1086 void SIM_HAL_SetFtmChSrcMode(uint32_t baseAddr,
1087                              uint8_t  instance,
1088                              uint8_t  channel,
1089                              sim_ftm_ch_src_t select)
1090 {
1091     assert (instance < HW_FTM_INSTANCE_COUNT);
1092
1093     switch (instance)
1094     {
1095 #if FSL_FEATURE_SIM_OPT_HAS_FTM1_CHANNELS
1096     case 1:
1097         switch (channel)
1098         {
1099         case 0:
1100             BW_SIM_SOPT4_FTM1CH0SRC(baseAddr, select);
1101             break;
1102         default:
1103             break;
1104         }
1105         break;
1106 #endif
1107 #if FSL_FEATURE_SIM_OPT_HAS_FTM2_CHANNELS
1108     case 2:
1109         switch (channel)
1110         {
1111         case 0:
1112             BW_SIM_SOPT4_FTM2CH0SRC(baseAddr, select);
1113             break;
1114 #if FSL_FEATURE_SIM_OPT_HAS_FTM2_CHANNEL1
1115         case 1:
1116             BW_SIM_SOPT4_FTM2CH1SRC(baseAddr, select);
1117             break;
1118 #endif
1119         default:
1120             break;
1121         }
1122         break;
1123 #endif
1124 #if FSL_FEATURE_SIM_OPT_HAS_FTM3_CHANNELS
1125     case 3:
1126         switch (channel)
1127         {
1128         case 0:
1129             BW_SIM_SOPT4_FTM3CH0SRC(baseAddr, select);
1130             break;
1131         default:
1132             break;
1133         }
1134         break;
1135 #endif
1136     default:
1137         break;
1138     }
1139 }
1140
1141 /*FUNCTION**********************************************************************
1142  *
1143  * Function Name : SIM_HAL_GetFtmChSrcMode
1144  * Description   : Get FlexTimer x channel y input capture source select setting
1145  * This function will get FlexTimer x channel y input capture source select
1146  * setting.
1147  *
1148  *END**************************************************************************/
1149 sim_ftm_ch_src_t SIM_HAL_GetFtmChSrcMode(uint32_t baseAddr, uint8_t instance, uint8_t channel)
1150 {
1151     sim_ftm_ch_src_t retValue = (sim_ftm_ch_src_t)0;
1152
1153     assert (instance < HW_FTM_INSTANCE_COUNT);
1154
1155     switch (instance)
1156     {
1157 #if FSL_FEATURE_SIM_OPT_HAS_FTM1_CHANNELS
1158     case 1:
1159         switch (channel)
1160         {
1161         case 0:
1162             retValue = (sim_ftm_ch_src_t)BR_SIM_SOPT4_FTM1CH0SRC(baseAddr);
1163             break;
1164         default:
1165             break;
1166         }
1167         break;
1168 #endif
1169 #if FSL_FEATURE_SIM_OPT_HAS_FTM2_CHANNELS
1170     case 2:
1171         switch (channel)
1172         {
1173         case 0:
1174             retValue = (sim_ftm_ch_src_t)BR_SIM_SOPT4_FTM2CH0SRC(baseAddr);
1175             break;
1176 #if FSL_FEATURE_SIM_OPT_HAS_FTM2_CHANNEL1
1177         case 1:
1178             retValue = (sim_ftm_ch_src_t)BR_SIM_SOPT4_FTM2CH1SRC(baseAddr);
1179             break;
1180 #endif
1181         default:
1182             break;
1183         }
1184         break;
1185 #endif
1186 #if FSL_FEATURE_SIM_OPT_HAS_FTM3_CHANNELS
1187     case 3:
1188         switch (channel)
1189         {
1190         case 0:
1191             retValue = (sim_ftm_ch_src_t)BR_SIM_SOPT4_FTM3CH0SRC(baseAddr);
1192             break;
1193         default:
1194             break;
1195         }
1196         break;
1197 #endif
1198     default:
1199         break;
1200     }
1201
1202     return retValue;
1203 }
1204
1205 /*FUNCTION**********************************************************************
1206  *
1207  * Function Name : SIM_HAL_SetFtmFaultSelMode
1208  * Description   : Set FlexTimer x fault y select setting
1209  * This function will set the FlexTimer x fault y select setting.
1210  *
1211  *END**************************************************************************/
1212 void SIM_HAL_SetFtmFaultSelMode(uint32_t baseAddr,
1213                                 uint8_t  instance,
1214                                 uint8_t  fault,
1215                                 sim_ftm_flt_sel_t select)
1216 {
1217     assert (instance < HW_FTM_INSTANCE_COUNT);
1218
1219     switch (instance)
1220     {
1221     case 0:
1222         switch (fault)
1223         {
1224         case 0:
1225             BW_SIM_SOPT4_FTM0FLT0(baseAddr, select);
1226             break;
1227         case 1:
1228             BW_SIM_SOPT4_FTM0FLT1(baseAddr, select);
1229             break;
1230 #if (FSL_FEATURE_SIM_OPT_FTM0_FAULT_COUNT > 2)
1231         case 2:
1232             BW_SIM_SOPT4_FTM0FLT2(baseAddr, select);
1233             break;
1234 #if (FSL_FEATURE_SIM_OPT_FTM0_FAULT_COUNT > 3)
1235         case 3:
1236             BW_SIM_SOPT4_FTM0FLT3(baseAddr, select);
1237             break;
1238 #endif
1239 #endif
1240         default:
1241             break;
1242         }
1243         break;
1244     case 1:
1245         BW_SIM_SOPT4_FTM1FLT0(baseAddr, select);
1246         break;
1247     case 2:
1248         BW_SIM_SOPT4_FTM2FLT0(baseAddr, select);
1249         break;
1250 #if (HW_FTM_INSTANCE_COUNT > 3)
1251     case 3:
1252         BW_SIM_SOPT4_FTM3FLT0(baseAddr, select);
1253         break;
1254 #endif
1255     default:
1256         break;
1257     }
1258 }
1259
1260 /*FUNCTION**********************************************************************
1261  *
1262  * Function Name : SIM_HAL_GetFtmFaultSelMode
1263  * Description   : Get FlexTimer x fault y select setting
1264  * This function will get FlexTimer x fault y select setting.
1265  *
1266  *END**************************************************************************/
1267 sim_ftm_flt_sel_t SIM_HAL_GetFtmFaultSelMode(uint32_t baseAddr, uint8_t instance, uint8_t fault)
1268 {
1269     sim_ftm_flt_sel_t retValue = (sim_ftm_flt_sel_t)0;
1270
1271     assert (instance < HW_FTM_INSTANCE_COUNT);
1272
1273     switch (instance)
1274     {
1275     case 0:
1276         switch (fault)
1277         {
1278         case 0:
1279             retValue = (sim_ftm_flt_sel_t)BR_SIM_SOPT4_FTM0FLT0(baseAddr);
1280             break;
1281         case 1:
1282             retValue = (sim_ftm_flt_sel_t)BR_SIM_SOPT4_FTM0FLT1(baseAddr);
1283             break;
1284 #if (FSL_FEATURE_SIM_OPT_FTM0_FAULT_COUNT > 2)
1285         case 2:
1286             retValue = (sim_ftm_flt_sel_t)BR_SIM_SOPT4_FTM0FLT2(baseAddr);
1287             break;
1288 #if (FSL_FEATURE_SIM_OPT_FTM0_FAULT_COUNT > 3)
1289         case 3:
1290             retValue = (sim_ftm_flt_sel_t)BR_SIM_SOPT4_FTM0FLT3(baseAddr);
1291             break;
1292 #endif
1293 #endif
1294         default:
1295             break;
1296         }
1297         break;
1298     case 1:
1299         retValue = (sim_ftm_flt_sel_t)BR_SIM_SOPT4_FTM1FLT0(baseAddr);
1300         break;
1301     case 2:
1302         retValue = (sim_ftm_flt_sel_t)BR_SIM_SOPT4_FTM2FLT0(baseAddr);
1303         break;
1304 #if (HW_FTM_INSTANCE_COUNT > 3)
1305     case 3:
1306         retValue = (sim_ftm_flt_sel_t)BR_SIM_SOPT4_FTM3FLT0(baseAddr);
1307         break;
1308 #endif
1309     default:
1310         break;
1311     }
1312
1313     return retValue;
1314 }
1315 #endif
1316
1317 #if FSL_FEATURE_SIM_OPT_HAS_TPM
1318 /*FUNCTION**********************************************************************
1319  *
1320  * Function Name : SIM_HAL_SetTpmExternalClkPinSelMode
1321  * Description   : Set Timer/PWM x external clock pin select setting
1322  * This function will select the source of Timer/PWM x external clock pin select
1323  *
1324  *END**************************************************************************/
1325 void SIM_HAL_SetTpmExternalClkPinSelMode(uint32_t baseAddr,
1326                                          uint8_t instance,
1327                                          sim_tpm_clk_sel_t select)
1328 {
1329     assert (instance < HW_TPM_INSTANCE_COUNT);
1330
1331     switch (instance)
1332     {
1333     case 0:
1334         BW_SIM_SOPT4_TPM0CLKSEL(baseAddr, select);
1335         break;
1336     case 1:
1337         BW_SIM_SOPT4_TPM1CLKSEL(baseAddr, select);
1338         break;
1339     case 2:
1340         BW_SIM_SOPT4_TPM2CLKSEL(baseAddr, select);
1341         break;
1342     default:
1343         break;
1344     }
1345 }
1346
1347 /*FUNCTION**********************************************************************
1348  *
1349  * Function Name : SIM_HAL_GetTpmExternalClkPinSelMode
1350  * Description   : Get Timer/PWM x external clock pin select setting
1351  * This function will get Timer/PWM x external clock pin select setting.
1352  *
1353  *END**************************************************************************/
1354 sim_tpm_clk_sel_t SIM_HAL_GetTpmExternalClkPinSelMode(uint32_t baseAddr, uint8_t instance)
1355 {
1356     sim_tpm_clk_sel_t retValue = (sim_tpm_clk_sel_t)0;
1357
1358     assert (instance < HW_TPM_INSTANCE_COUNT);
1359
1360     switch (instance)
1361     {
1362     case 0:
1363         retValue = (sim_tpm_clk_sel_t)BR_SIM_SOPT4_TPM0CLKSEL(baseAddr);
1364         break;
1365     case 1:
1366         retValue = (sim_tpm_clk_sel_t)BR_SIM_SOPT4_TPM1CLKSEL(baseAddr);
1367         break;
1368     case 2:
1369         retValue = (sim_tpm_clk_sel_t)BR_SIM_SOPT4_TPM2CLKSEL(baseAddr);
1370         break;
1371     default:
1372         break;
1373     }
1374
1375     return retValue;
1376 }
1377
1378 /*FUNCTION**********************************************************************
1379  *
1380  * Function Name : SIM_HAL_SetTpmChSrcMode
1381  * Description   : Timer/PWM x channel y input capture source select setting
1382  * This function will select Timer/PWM x channel y input capture source
1383  *
1384  *END**************************************************************************/
1385 void SIM_HAL_SetTpmChSrcMode(uint32_t baseAddr,
1386                              uint8_t instance,
1387                              uint8_t channel,
1388                              sim_tpm_ch_src_t select)
1389 {
1390     assert (instance < HW_TPM_INSTANCE_COUNT);
1391
1392     switch (instance)
1393     {
1394     case 1:
1395         switch (channel)
1396         {
1397         case 0:
1398             BW_SIM_SOPT4_TPM1CH0SRC(baseAddr, select);
1399             break;
1400         default:
1401             break;
1402         }
1403         break;
1404     case 2:
1405         switch (channel)
1406         {
1407         case 0:
1408             BW_SIM_SOPT4_TPM2CH0SRC(baseAddr, select);
1409             break;
1410         default:
1411             break;
1412         }
1413         break;
1414     default:
1415         break;
1416     }
1417 }
1418
1419 /*FUNCTION**********************************************************************
1420  *
1421  * Function Name : SIM_HAL_GetTpmChSrcMode
1422  * Description   : Get Timer/PWM x channel y input capture source select setting
1423  * This function will get Timer/PWM x channel y input capture source select
1424  * setting.
1425  *
1426  *END**************************************************************************/
1427 sim_tpm_ch_src_t SIM_HAL_GetTpmChSrcMode(uint32_t baseAddr,
1428                                          uint8_t instance,
1429                                          uint8_t channel)
1430 {
1431     sim_tpm_ch_src_t retValue = (sim_tpm_ch_src_t)0;
1432
1433     assert (instance < HW_TPM_INSTANCE_COUNT);
1434
1435     switch (instance)
1436     {
1437     case 1:
1438         switch (channel)
1439         {
1440         case 0:
1441             retValue = (sim_tpm_ch_src_t)BR_SIM_SOPT4_TPM1CH0SRC(baseAddr);
1442             break;
1443         default:
1444             break;
1445         }
1446         break;
1447     case 2:
1448         switch (channel)
1449         {
1450         case 0:
1451             retValue = (sim_tpm_ch_src_t)BR_SIM_SOPT4_TPM2CH0SRC(baseAddr);
1452             break;
1453         default:
1454             break;
1455         }
1456         break;
1457     default:
1458         break;
1459     }
1460
1461     return retValue;
1462 }
1463 #endif
1464
1465 /*******************************************************************************
1466  * EOF
1467  ******************************************************************************/
1468