tool/mbed/mbed-sdk/libraries/mbed/targets/hal/TARGET_Freescale/TARGET_KPSDK_MCUS/TARGET_MCU_K64F/MK64F12/fsl_clock_K64F12.h

   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 #if !defined(__FSL_CLOCK_K64F12_H__)
  32 #define __FSL_CLOCK_K64F12__H__
  33
  34 /*! @addtogroup clock_manager*/
  35 /*! @{*/
  36
  37 /*! @file*/
  38
  39 /*******************************************************************************
  40  * Definitions
  41  ******************************************************************************/
  42
  43
  44 /*******************************************************************************
  45  * API
  46  ******************************************************************************/
  47
  48 #if defined(__cplusplus)
  49 extern "C" {
  50 #endif /* __cplusplus*/
  51
  52 /*!
  53  * @brief Gets the clock frequency for DMA module.
  54  *
  55  * This function gets the clock frequence for DMA moudle.
  56  * @param instance module device instance
  57  * @return freq    clock frequence for this module
  58  */
  59 uint32_t    CLOCK_SYS_GetDmaFreq(uint32_t instance);
  60
  61 /*!
  62  * @brief Gets the clock frequency for DMAMUX module.
  63  *
  64  * This function gets the clock frequence for DMAMUX moudle.
  65  * @param instance module device instance
  66  * @return freq    clock frequence for this module
  67  */
  68 uint32_t    CLOCK_SYS_GetDmamuxFreq(uint32_t instance);
  69
  70 /*!
  71  * @brief Gets the clock frequency for PORT module.
  72  *
  73  * This function gets the clock frequence for PORT moudle.
  74  * @param instance module device instance
  75  * @return freq    clock frequence for this module
  76  */
  77 uint32_t    CLOCK_SYS_GetPortFreq(uint32_t instance);
  78
  79 /*!
  80  * @brief Gets the clock frequency for MPU module.
  81  *
  82  * This function gets the clock frequence for MPU moudle.
  83  * @param instance module device instance
  84  * @return freq    clock frequence for this module
  85  */
  86 uint32_t    CLOCK_SYS_GetMpuFreq(uint32_t instance);
  87
  88 /*!
  89  * @brief Gets the clock frequency for EWM module.
  90  *
  91  * This function gets the clock frequence for EWM moudle.
  92  * @param instance module device instance
  93  * @return freq    clock frequence for this module
  94  */
  95 uint32_t    CLOCK_SYS_GetEwmFreq(uint32_t instance);
  96
  97 /*!
  98  * @brief Gets the clock frequency for FLEXBUS module.
  99  *
 100  * This function gets the clock frequence for FLEXBUS moudle.
 101  * @param instance module device instance
 102  * @return freq    clock frequence for this module
 103  */
 104 uint32_t    CLOCK_SYS_GetFlexbusFreq(uint32_t instance);
 105
 106 /*!
 107  * @brief Gets the clock frequency for FTF module. (Flash Memory)
 108  *
 109  * This function gets the clock frequence for FTF module. (Flash Memory)
 110  * @param instance module device instance
 111  * @return freq    clock frequence for this module
 112  */
 113 uint32_t    CLOCK_SYS_GetFtfFreq(uint32_t instance);
 114
 115 /*!
 116  * @brief Gets the clock frequency for CRC module.
 117  *
 118  * This function gets the clock frequence for CRC module.
 119  * @param instance module device instance
 120  * @return freq    clock frequence for this module
 121  */
 122 uint32_t    CLOCK_SYS_GetCrcFreq(uint32_t instance);
 123
 124 /*!
 125  * @brief Gets the clock frequency for RNGA module.
 126  *
 127  * This function gets the clock frequence for RNGA module.
 128  * @param instance module device instance
 129  * @return freq    clock frequence for this module
 130  */
 131 uint32_t    CLOCK_SYS_GetRngaFreq(uint32_t instance);
 132
 133 /*!
 134  * @brief Gets the clock frequency for ADC module.
 135  *
 136  * This function gets the clock frequence for ADC module.
 137  * @param instance module device instance
 138  * @return freq    clock frequence for this module
 139  */
 140 uint32_t    CLOCK_SYS_GetAdcFreq(uint32_t instance);
 141
 142 /*!
 143  * @brief Gets the clock frequency for CMP module.
 144  *
 145  * This function gets the clock frequence for CMP module.
 146  * @param instance module device instance
 147  * @return freq    clock frequence for this module
 148  */
 149 uint32_t    CLOCK_SYS_GetCmpFreq(uint32_t instance);
 150
 151 /*!
 152  * @brief Gets the clock frequency for VREF module.
 153  *
 154  * This function gets the clock frequence for VREF module.
 155  * @param instance module device instance
 156  * @return freq    clock frequence for this module
 157  */
 158 uint32_t    CLOCK_SYS_GetVrefFreq(uint32_t instance);
 159
 160 /*!
 161  * @brief Gets the clock frequency for PDB module.
 162  *
 163  * This function gets the clock frequence for PDB module.
 164  * @param instance module device instance
 165  * @return freq    clock frequence for this module
 166  */
 167 uint32_t    CLOCK_SYS_GetPdbFreq(uint32_t instance);
 168
 169 /*!
 170  * @brief Gets the clock frequency for FTM module. (FlexTimer)
 171  *
 172  * This function gets the clock frequence for FTM module.
 173  * @param instance module device instance
 174  * @return freq    clock frequence for this module
 175  */
 176 uint32_t    CLOCK_SYS_GetFtmFreq(uint32_t instance);
 177
 178 /*!
 179  * @brief Gets the clock frequency for PIT module.
 180  *
 181  * This function gets the clock frequence for PIT module.
 182  * @param instance module device instance
 183  * @return freq    clock frequence for this module
 184  */
 185 uint32_t    CLOCK_SYS_GetPitFreq(uint32_t instance);
 186
 187 /*!
 188  * @brief Gets the clock frequency for CMT module.
 189  *
 190  * This function gets the clock frequence for CMT module.
 191  * @param instance module device instance
 192  * @return freq    clock frequence for this module
 193  */
 194 uint32_t    CLOCK_SYS_GetCmtFreq(uint32_t instance);
 195
 196 /*!
 197  * @brief Gets the clock frequency for ENET module RMII clock.
 198  *
 199  * This function gets the clock frequence for ENET module RMII clock..
 200  * @param instance module device instance
 201  * @return freq    clock frequence for this module
 202  */
 203 uint32_t    CLOCK_SYS_GetEnetRmiiFreq(uint32_t instance);
 204
 205 /*!
 206  * @brief Gets the clock frequency for ENET module TIME clock.
 207  *
 208  * This function gets the clock frequence for ENET module TIME clock..
 209  * @param instance module device instance
 210  * @return freq    clock frequence for this module
 211  */
 212 uint32_t    CLOCK_SYS_GetEnetTimeStampFreq(uint32_t instance);
 213
 214 /*!
 215  * @brief Gets the clock frequency for USB FS OTG module
 216  *
 217  * This function gets the clock frequence for USB FS OTG module.
 218  * @param instance module device instance
 219  * @return freq    clock frequence for this module
 220  */
 221 uint32_t    CLOCK_SYS_GetUsbFreq(uint32_t instance);
 222
 223 /*!
 224  * @brief Gets the clock frequency for USB DCD module
 225  *
 226  * This function gets the clock frequence for USB DCD module.
 227  * @param instance module device instance
 228  * @return freq    clock frequence for this module
 229  */
 230 uint32_t    CLOCK_SYS_GetUsbdcdFreq(uint32_t instance);
 231
 232 /*!
 233  * @brief Gets the clock frequency for SPI module
 234  *
 235  * This function gets the clock frequence for SPI module.
 236  * @param instance module device instance
 237  * @return freq    clock frequence for this module
 238  */
 239 uint32_t    CLOCK_SYS_GetSpiFreq(uint32_t instance);
 240
 241 /*!
 242  * @brief Gets the clock frequency for I2C module
 243  *
 244  * This function gets the clock frequence for I2C module.
 245  * @param instance module device instance
 246  * @return freq    clock frequence for this module
 247  */
 248 uint32_t    CLOCK_SYS_GetI2cFreq(uint32_t instance);
 249
 250 /*!
 251  * @brief Gets the clock frequency for UART module
 252  *
 253  * This function gets the clock frequence for UART module.
 254  * @param instance module device instance
 255  * @return freq    clock frequence for this module
 256  */
 257 uint32_t    CLOCK_SYS_GetUartFreq(uint32_t instance);
 258
 259 /*!
 260  * @brief Gets the clock frequency for SDHC module.
 261  *
 262  * This function gets the clock frequence for SDHC moudle.
 263  * @param instance module device instance
 264  * @return freq    clock frequence for this module
 265  */
 266 uint32_t    CLOCK_SYS_GetSdhcFreq(uint32_t instance);
 267
 268 /*!
 269  * @brief Gets the clock frequency for I2S module.
 270  *
 271  * This function gets the clock frequence for I2S module.
 272  * @param instance module device instance
 273  * @return freq    clock frequence for this module
 274  */
 275 uint32_t    CLOCK_SYS_GetSaiFreq(uint32_t instance);
 276
 277 /*!
 278  * @brief Gets the clock frequency for GPIO module
 279  *
 280  * This function gets the clock frequence for GPIO module.
 281  * @param instance module device instance
 282  * @return freq    clock frequence for this module
 283  */
 284 uint32_t    CLOCK_SYS_GetGpioFreq(uint32_t instance);
 285
 286 /*!
 287  * @brief Enable the clock for DMA module.
 288  *
 289  * This function enables the clock for DMA moudle.
 290  * @param instance module device instance
 291  */
 292 static inline void CLOCK_SYS_EnableDmaClock(uint32_t instance)
 293 {
 294     SIM_HAL_EnableDmaClock(g_simBaseAddr[0], instance);
 295 }
 296
 297 /*!
 298  * @brief Disable the clock for DMA module.
 299  *
 300  * This function disables the clock for DMA moudle.
 301  * @param instance module device instance
 302  */
 303 static inline void CLOCK_SYS_DisableDmaClock(uint32_t instance)
 304 {
 305     SIM_HAL_DisableDmaClock(g_simBaseAddr[0], instance);
 306 }
 307
 308 /*!
 309  * @brief Get the the clock gate state for DMA module.
 310  *
 311  * This function will get the clock gate state for DMA moudle.
 312  * @param instance module device instance
 313  * @return state true - ungated(Enabled), false - gated (Disabled)
 314  */
 315 static inline bool CLOCK_SYS_GetDmaGateCmd(uint32_t instance)
 316 {
 317     return SIM_HAL_GetDmaGateCmd(g_simBaseAddr[0], instance);
 318 }
 319
 320 /*!
 321  * @brief Enable the clock for DMAMUX module.
 322  *
 323  * This function enables the clock for DMAMUX moudle.
 324  * @param instance module device instance
 325  */
 326 static inline void CLOCK_SYS_EnableDmamuxClock(uint32_t instance)
 327 {
 328     SIM_HAL_EnableDmamuxClock(g_simBaseAddr[0], instance);
 329 }
 330
 331 /*!
 332  * @brief Disable the clock for DMAMUX module.
 333  *
 334  * This function disables the clock for DMAMUX moudle.
 335  * @param instance module device instance
 336  */
 337 static inline void CLOCK_SYS_DisableDmamuxClock(uint32_t instance)
 338 {
 339     SIM_HAL_DisableDmamuxClock(g_simBaseAddr[0], instance);
 340 }
 341
 342 /*!
 343  * @brief Get the the clock gate state for DMAMUX module.
 344  *
 345  * This function will get the clock gate state for DMAMUX moudle.
 346  * @param instance module device instance
 347  * @return state true - ungated(Enabled), false - gated (Disabled)
 348  */
 349 static inline bool CLOCK_SYS_GetDmamuxGateCmd(uint32_t instance)
 350 {
 351     return SIM_HAL_GetDmamuxGateCmd(g_simBaseAddr[0], instance);
 352 }
 353
 354 /*!
 355  * @brief Enable the clock for PORT module.
 356  *
 357  * This function enables the clock for PORT moudle.
 358  * @param instance module device instance
 359  */
 360 static inline void CLOCK_SYS_EnablePortClock(uint32_t instance)
 361 {
 362     SIM_HAL_EnablePortClock(g_simBaseAddr[0], instance);
 363 }
 364
 365 /*!
 366  * @brief Disable the clock for PORT module.
 367  *
 368  * This function disables the clock for PORT moudle.
 369  * @param instance module device instance
 370  */
 371 static inline void CLOCK_SYS_DisablePortClock(uint32_t instance)
 372 {
 373     SIM_HAL_DisablePortClock(g_simBaseAddr[0], instance);
 374 }
 375
 376 /*!
 377  * @brief Get the the clock gate state for PORT module.
 378  *
 379  * This function will get the clock gate state for PORT moudle.
 380  * @param instance module device instance
 381  * @return state true - ungated(Enabled), false - gated (Disabled)
 382  */
 383 static inline bool CLOCK_SYS_GetPortGateCmd(uint32_t instance)
 384 {
 385     return SIM_HAL_GetPortGateCmd(g_simBaseAddr[0], instance);
 386 }
 387
 388 /*!
 389  * @brief Enable the clock for MPU module.
 390  *
 391  * This function enables the clock for MPU moudle.
 392  * @param instance module device instance
 393  */
 394 static inline void CLOCK_SYS_EnableMpuClock(uint32_t instance)
 395 {
 396     SIM_HAL_EnableMpuClock(g_simBaseAddr[0], instance);
 397 }
 398
 399 /*!
 400  * @brief Disable the clock for MPU module.
 401  *
 402  * This function disables the clock for MPU moudle.
 403  * @param instance module device instance
 404  */
 405 static inline void CLOCK_SYS_DisableMpuClock(uint32_t instance)
 406 {
 407     SIM_HAL_DisableMpuClock(g_simBaseAddr[0], instance);
 408 }
 409
 410 /*!
 411  * @brief Get the the clock gate state for MPU module.
 412  *
 413  * This function will get the clock gate state for MPU moudle.
 414  * @param instance module device instance
 415  * @return state true - ungated(Enabled), false - gated (Disabled)
 416  */
 417 static inline bool CLOCK_SYS_GetMpuGateCmd(uint32_t instance)
 418 {
 419     return SIM_HAL_GetMpuGateCmd(g_simBaseAddr[0], instance);
 420 }
 421
 422 /*!
 423  * @brief Enable the clock for EWM module.
 424  *
 425  * This function enables the clock for EWM moudle.
 426  * @param instance module device instance
 427  */
 428 static inline void CLOCK_SYS_EnableEwmClock(uint32_t instance)
 429 {
 430     SIM_HAL_EnableEwmClock(g_simBaseAddr[0], instance);
 431 }
 432
 433 /*!
 434  * @brief Disable the clock for EWM module.
 435  *
 436  * This function disables the clock for EWM moudle.
 437  * @param instance module device instance
 438  */
 439 static inline void CLOCK_SYS_DisableEwmClock(uint32_t instance)
 440 {
 441     SIM_HAL_DisableEwmClock(g_simBaseAddr[0], instance);
 442 }
 443
 444 /*!
 445  * @brief Get the the clock gate state for EWM module.
 446  *
 447  * This function will get the clock gate state for EWM moudle.
 448  * @param instance module device instance
 449  * @return state true - ungated(Enabled), false - gated (Disabled)
 450  */
 451 static inline bool CLOCK_SYS_GetEwmGateCmd(uint32_t instance)
 452 {
 453     return SIM_HAL_GetEwmGateCmd(g_simBaseAddr[0], instance);
 454 }
 455
 456 /*!
 457  * @brief Enable the clock for FLEXBUS module.
 458  *
 459  * This function enables the clock for FLEXBUS moudle.
 460  * @param instance module device instance
 461  */
 462 static inline void CLOCK_SYS_EnableFlexbusClock(uint32_t instance)
 463 {
 464     SIM_HAL_EnableFlexbusClock(g_simBaseAddr[0], instance);
 465 }
 466
 467 /*!
 468  * @brief Disable the clock for FLEXBUS module.
 469  *
 470  * This function disables the clock for FLEXBUS moudle.
 471  * @param instance module device instance
 472  */
 473 static inline void CLOCK_SYS_DisableFlexbusClock(uint32_t instance)
 474 {
 475     SIM_HAL_DisableFlexbusClock(g_simBaseAddr[0], instance);
 476 }
 477
 478 /*!
 479  * @brief Get the the clock gate state for FLEXBUS module.
 480  *
 481  * This function will get the clock gate state for FLEXBUS moudle.
 482  * @param instance module device instance
 483  * @return state true - ungated(Enabled), false - gated (Disabled)
 484  */
 485 static inline bool CLOCK_SYS_GetFlexbusGateCmd(uint32_t instance)
 486 {
 487     return SIM_HAL_GetFlexbusGateCmd(g_simBaseAddr[0], instance);
 488 }
 489
 490 /*!
 491  * @brief Enable the clock for FTF module.
 492  *
 493  * This function enables the clock for FTF moudle.
 494  * @param instance module device instance
 495  */
 496 static inline void CLOCK_SYS_EnableFtfClock(uint32_t instance)
 497 {
 498     SIM_HAL_EnableFtfClock(g_simBaseAddr[0], instance);
 499 }
 500
 501 /*!
 502  * @brief Disable the clock for FTF module.
 503  *
 504  * This function disables the clock for FTF moudle.
 505  * @param instance module device instance
 506  */
 507 static inline void CLOCK_SYS_DisableFtfClock(uint32_t instance)
 508 {
 509     SIM_HAL_DisableFtfClock(g_simBaseAddr[0], instance);
 510 }
 511
 512 /*!
 513  * @brief Get the the clock gate state for FTF module.
 514  *
 515  * This function will get the clock gate state for FTF moudle.
 516  * @param instance module device instance
 517  * @return state true - ungated(Enabled), false - gated (Disabled)
 518  */
 519 static inline bool CLOCK_SYS_GetFtfGateCmd(uint32_t instance)
 520 {
 521     return SIM_HAL_GetFtfGateCmd(g_simBaseAddr[0], instance);
 522 }
 523
 524 /*!
 525  * @brief Enable the clock for CRC module.
 526  *
 527  * This function enables the clock for CRC moudle.
 528  * @param instance module device instance
 529  */
 530 static inline void CLOCK_SYS_EnableCrcClock(uint32_t instance)
 531 {
 532     SIM_HAL_EnableCrcClock(g_simBaseAddr[0], instance);
 533 }
 534
 535 /*!
 536  * @brief Disable the clock for CRC module.
 537  *
 538  * This function disables the clock for CRC moudle.
 539  * @param instance module device instance
 540  */
 541 static inline void CLOCK_SYS_DisableCrcClock(uint32_t instance)
 542 {
 543     SIM_HAL_DisableCrcClock(g_simBaseAddr[0], instance);
 544 }
 545
 546 /*!
 547  * @brief Get the the clock gate state for CRC module.
 548  *
 549  * This function will get the clock gate state for CRC moudle.
 550  * @param instance module device instance
 551  * @return state true - ungated(Enabled), false - gated (Disabled)
 552  */
 553 static inline bool CLOCK_SYS_GetCrcGateCmd(uint32_t instance)
 554 {
 555     return SIM_HAL_GetCrcGateCmd(g_simBaseAddr[0], instance);
 556 }
 557
 558 /*!
 559  * @brief Enable the clock for RNGA module.
 560  *
 561  * This function enables the clock for RNGA moudle.
 562  * @param instance module device instance
 563  */
 564 static inline void CLOCK_SYS_EnableRngaClock(uint32_t instance)
 565 {
 566     SIM_HAL_EnableRngaClock(g_simBaseAddr[0], instance);
 567 }
 568
 569 /*!
 570  * @brief Disable the clock for RNGA module.
 571  *
 572  * This function disables the clock for RNGA moudle.
 573  * @param instance module device instance
 574  */
 575 static inline void CLOCK_SYS_DisableRngaClock(uint32_t instance)
 576 {
 577     SIM_HAL_DisableRngaClock(g_simBaseAddr[0], instance);
 578 }
 579
 580 /*!
 581  * @brief Get the the clock gate state for RNGA module.
 582  *
 583  * This function will get the clock gate state for RNGA moudle.
 584  * @param instance module device instance
 585  * @return state true - ungated(Enabled), false - gated (Disabled)
 586  */
 587 static inline bool CLOCK_SYS_GetRngaGateCmd(uint32_t instance)
 588 {
 589     return SIM_HAL_GetRngaGateCmd(g_simBaseAddr[0], instance);
 590 }
 591
 592 /*!
 593  * @brief Enable the clock for ADC module.
 594  *
 595  * This function enables the clock for ADC moudle.
 596  * @param instance module device instance
 597  */
 598 static inline void CLOCK_SYS_EnableAdcClock(uint32_t instance)
 599 {
 600     SIM_HAL_EnableAdcClock(g_simBaseAddr[0], instance);
 601 }
 602
 603 /*!
 604  * @brief Disable the clock for ADC module.
 605  *
 606  * This function disables the clock for ADC moudle.
 607  * @param instance module device instance
 608  */
 609 static inline void CLOCK_SYS_DisableAdcClock(uint32_t instance)
 610 {
 611     SIM_HAL_DisableAdcClock(g_simBaseAddr[0], instance);
 612 }
 613
 614 /*!
 615  * @brief Get the the clock gate state for ADC module.
 616  *
 617  * This function will get the clock gate state for ADC moudle.
 618  * @param instance module device instance
 619  * @return state true - ungated(Enabled), false - gated (Disabled)
 620  */
 621 static inline bool CLOCK_SYS_GetAdcGateCmd(uint32_t instance)
 622 {
 623     return SIM_HAL_GetAdcGateCmd(g_simBaseAddr[0], instance);
 624 }
 625
 626 /*!
 627  * @brief Enable the clock for CMP module.
 628  *
 629  * This function enables the clock for CMP moudle.
 630  * @param instance module device instance
 631  */
 632 static inline void CLOCK_SYS_EnableCmpClock(uint32_t instance)
 633 {
 634     SIM_HAL_EnableCmpClock(g_simBaseAddr[0], instance);
 635 }
 636
 637 /*!
 638  * @brief Disable the clock for CMP module.
 639  *
 640  * This function disables the clock for CMP moudle.
 641  * @param instance module device instance
 642  */
 643 static inline void CLOCK_SYS_DisableCmpClock(uint32_t instance)
 644 {
 645     SIM_HAL_DisableCmpClock(g_simBaseAddr[0], instance);
 646 }
 647
 648 /*!
 649  * @brief Get the the clock gate state for CMP module.
 650  *
 651  * This function will get the clock gate state for CMP moudle.
 652  * @param instance module device instance
 653  * @return state true - ungated(Enabled), false - gated (Disabled)
 654  */
 655 static inline bool CLOCK_SYS_GetCmpGateCmd(uint32_t instance)
 656 {
 657     return SIM_HAL_GetCmpGateCmd(g_simBaseAddr[0], instance);
 658 }
 659
 660 /*!
 661  * @brief Enable the clock for DAC module.
 662  *
 663  * This function enables the clock for DAC moudle.
 664  * @param instance module device instance
 665  */
 666 static inline void CLOCK_SYS_EnableDacClock(uint32_t instance)
 667 {
 668     SIM_HAL_EnableDacClock(g_simBaseAddr[0], instance);
 669 }
 670
 671 /*!
 672  * @brief Disable the clock for DAC module.
 673  *
 674  * This function disables the clock for DAC moudle.
 675  * @param instance module device instance
 676  */
 677 static inline void CLOCK_SYS_DisableDacClock(uint32_t instance)
 678 {
 679     SIM_HAL_DisableDacClock(g_simBaseAddr[0], instance);
 680 }
 681
 682 /*!
 683  * @brief Get the the clock gate state for DAC module.
 684  *
 685  * This function will get the clock gate state for DAC moudle.
 686  * @param instance module device instance
 687  * @return state true - ungated(Enabled), false - gated (Disabled)
 688  */
 689 static inline bool CLOCK_SYS_GetDacGateCmd(uint32_t instance)
 690 {
 691     return SIM_HAL_GetDacGateCmd(g_simBaseAddr[0], instance);
 692 }
 693
 694 /*!
 695  * @brief Enable the clock for VREF module.
 696  *
 697  * This function enables the clock for VREF moudle.
 698  * @param instance module device instance
 699  */
 700 static inline void CLOCK_SYS_EnableVrefClock(uint32_t instance)
 701 {
 702     SIM_HAL_EnableVrefClock(g_simBaseAddr[0], instance);
 703 }
 704
 705 /*!
 706  * @brief Disable the clock for VREF module.
 707  *
 708  * This function disables the clock for VREF moudle.
 709  * @param instance module device instance
 710  */
 711 static inline void CLOCK_SYS_DisableVrefClock(uint32_t instance)
 712 {
 713     SIM_HAL_DisableVrefClock(g_simBaseAddr[0], instance);
 714 }
 715
 716 /*!
 717  * @brief Get the the clock gate state for VREF module.
 718  *
 719  * This function will get the clock gate state for VREF moudle.
 720  * @param instance module device instance
 721  * @return state true - ungated(Enabled), false - gated (Disabled)
 722  */
 723 static inline bool CLOCK_SYS_GetVrefGateCmd(uint32_t instance)
 724 {
 725     return SIM_HAL_GetVrefGateCmd(g_simBaseAddr[0], instance);
 726 }
 727
 728 /*!
 729  * @brief Enable the clock for SAI module.
 730  *
 731  * This function enables the clock for SAI moudle.
 732  * @param instance module device instance
 733  */
 734 static inline void CLOCK_SYS_EnableSaiClock(uint32_t instance)
 735 {
 736     SIM_HAL_EnableSaiClock(g_simBaseAddr[0], instance);
 737 }
 738
 739 /*!
 740  * @brief Disable the clock for SAI module.
 741  *
 742  * This function disables the clock for SAI moudle.
 743  * @param instance module device instance
 744  */
 745 static inline void CLOCK_SYS_DisableSaiClock(uint32_t instance)
 746 {
 747     SIM_HAL_DisableSaiClock(g_simBaseAddr[0], instance);
 748 }
 749
 750 /*!
 751  * @brief Get the the clock gate state for SAI module.
 752  *
 753  * This function will get the clock gate state for SAI moudle.
 754  * @param instance module device instance
 755  * @return state true - ungated(Enabled), false - gated (Disabled)
 756  */
 757 static inline bool CLOCK_SYS_GetSaiGateCmd(uint32_t instance)
 758 {
 759     return SIM_HAL_GetSaiGateCmd(g_simBaseAddr[0], instance);
 760 }
 761
 762 /*!
 763  * @brief Enable the clock for PDB module.
 764  *
 765  * This function enables the clock for PDB moudle.
 766  * @param instance module device instance
 767  */
 768 static inline void CLOCK_SYS_EnablePdbClock(uint32_t instance)
 769 {
 770     SIM_HAL_EnablePdbClock(g_simBaseAddr[0], instance);
 771 }
 772
 773 /*!
 774  * @brief Disable the clock for PDB module.
 775  *
 776  * This function disables the clock for PDB moudle.
 777  * @param instance module device instance
 778  */
 779 static inline void CLOCK_SYS_DisablePdbClock(uint32_t instance)
 780 {
 781     SIM_HAL_DisablePdbClock(g_simBaseAddr[0], instance);
 782 }
 783
 784 /*!
 785  * @brief Get the the clock gate state for PDB module.
 786  *
 787  * This function will get the clock gate state for PDB moudle.
 788  * @param instance module device instance
 789  * @return state true - ungated(Enabled), false - gated (Disabled)
 790  */
 791 static inline bool CLOCK_SYS_GetPdbGateCmd(uint32_t instance)
 792 {
 793     return SIM_HAL_GetPdbGateCmd(g_simBaseAddr[0], instance);
 794 }
 795
 796 /*!
 797  * @brief Enable the clock for FTM module.
 798  *
 799  * This function enables the clock for FTM moudle.
 800  * @param instance module device instance
 801  */
 802 static inline void CLOCK_SYS_EnableFtmClock(uint32_t instance)
 803 {
 804     SIM_HAL_EnableFtmClock(g_simBaseAddr[0], instance);
 805 }
 806
 807 /*!
 808  * @brief Disable the clock for FTM module.
 809  *
 810  * This function disables the clock for FTM moudle.
 811  * @param instance module device instance
 812  */
 813 static inline void CLOCK_SYS_DisableFtmClock(uint32_t instance)
 814 {
 815     SIM_HAL_DisableFtmClock(g_simBaseAddr[0], instance);
 816 }
 817
 818 /*!
 819  * @brief Get the the clock gate state for FTM module.
 820  *
 821  * This function will get the clock gate state for FTM moudle.
 822  * @param instance module device instance
 823  * @return state true - ungated(Enabled), false - gated (Disabled)
 824  */
 825 static inline bool CLOCK_SYS_GetFtmGateCmd(uint32_t instance)
 826 {
 827     return SIM_HAL_GetFtmGateCmd(g_simBaseAddr[0], instance);
 828 }
 829
 830 /*!
 831  * @brief Enable the clock for PIT module.
 832  *
 833  * This function enables the clock for PIT moudle.
 834  * @param instance module device instance
 835  */
 836 static inline void CLOCK_SYS_EnablePitClock(uint32_t instance)
 837 {
 838     SIM_HAL_EnablePitClock(g_simBaseAddr[0], instance);
 839 }
 840
 841 /*!
 842  * @brief Disable the clock for PIT module.
 843  *
 844  * This function disables the clock for PIT moudle.
 845  * @param instance module device instance
 846  */
 847 static inline void CLOCK_SYS_DisablePitClock(uint32_t instance)
 848 {
 849     SIM_HAL_DisablePitClock(g_simBaseAddr[0], instance);
 850 }
 851
 852 /*!
 853  * @brief Get the the clock gate state for PIT module.
 854  *
 855  * This function will get the clock gate state for PIT moudle.
 856  * @param instance module device instance
 857  * @return state true - ungated(Enabled), false - gated (Disabled)
 858  */
 859 static inline bool CLOCK_SYS_GetPitGateCmd(uint32_t instance)
 860 {
 861     return SIM_HAL_GetPitGateCmd(g_simBaseAddr[0], instance);
 862 }
 863
 864 /*!
 865  * @brief Enable the clock for LPTIMER module.
 866  *
 867  * This function enables the clock for LPTIMER moudle.
 868  * @param instance module device instance
 869  */
 870 static inline void CLOCK_SYS_EnableLptimerClock(uint32_t instance)
 871 {
 872     SIM_HAL_EnableLptimerClock(g_simBaseAddr[0], instance);
 873 }
 874
 875 /*!
 876  * @brief Disable the clock for LPTIMER module.
 877  *
 878  * This function disables the clock for LPTIMER moudle.
 879  * @param instance module device instance
 880  */
 881 static inline void CLOCK_SYS_DisableLptimerClock(uint32_t instance)
 882 {
 883     SIM_HAL_DisableLptimerClock(g_simBaseAddr[0], instance);
 884 }
 885
 886 /*!
 887  * @brief Get the the clock gate state for LPTIMER module.
 888  *
 889  * This function will get the clock gate state for LPTIMER moudle.
 890  * @param instance module device instance
 891  * @return state true - ungated(Enabled), false - gated (Disabled)
 892  */
 893 static inline bool CLOCK_SYS_GetLptimerGateCmd(uint32_t instance)
 894 {
 895     return SIM_HAL_GetLptimerGateCmd(g_simBaseAddr[0], instance);
 896 }
 897
 898 /*!
 899  * @brief Enable the clock for CMT module.
 900  *
 901  * This function enables the clock for CMT moudle.
 902  * @param instance module device instance
 903  */
 904 static inline void CLOCK_SYS_EnableCmtClock(uint32_t instance)
 905 {
 906     SIM_HAL_EnableCmtClock(g_simBaseAddr[0], instance);
 907 }
 908
 909 /*!
 910  * @brief Disable the clock for CMT module.
 911  *
 912  * This function disables the clock for CMT moudle.
 913  * @param instance module device instance
 914  */
 915 static inline void CLOCK_SYS_DisableCmtClock(uint32_t instance)
 916 {
 917     SIM_HAL_DisableCmtClock(g_simBaseAddr[0], instance);
 918 }
 919
 920 /*!
 921  * @brief Get the the clock gate state for CMT module.
 922  *
 923  * This function will get the clock gate state for CMT moudle.
 924  * @param instance module device instance
 925  * @return state true - ungated(Enabled), false - gated (Disabled)
 926  */
 927 static inline bool CLOCK_SYS_GetCmtGateCmd(uint32_t instance)
 928 {
 929     return SIM_HAL_GetCmtGateCmd(g_simBaseAddr[0], instance);
 930 }
 931
 932 /*!
 933  * @brief Enable the clock for RTC module.
 934  *
 935  * This function enables the clock for RTC moudle.
 936  * @param instance module device instance
 937  */
 938 static inline void CLOCK_SYS_EnableRtcClock(uint32_t instance)
 939 {
 940     SIM_HAL_EnableRtcClock(g_simBaseAddr[0], instance);
 941 }
 942
 943 /*!
 944  * @brief Disable the clock for RTC module.
 945  *
 946  * This function disables the clock for RTC moudle.
 947  * @param instance module device instance
 948  */
 949 static inline void CLOCK_SYS_DisableRtcClock(uint32_t instance)
 950 {
 951     SIM_HAL_DisableRtcClock(g_simBaseAddr[0], instance);
 952 }
 953
 954 /*!
 955  * @brief Get the the clock gate state for RTC module.
 956  *
 957  * This function will get the clock gate state for RTC moudle.
 958  * @param instance module device instance
 959  * @return state true - ungated(Enabled), false - gated (Disabled)
 960  */
 961 static inline bool CLOCK_SYS_GetRtcGateCmd(uint32_t instance)
 962 {
 963     return SIM_HAL_GetRtcGateCmd(g_simBaseAddr[0], instance);
 964 }
 965
 966 /*!
 967  * @brief Enable the clock for ENET module.
 968  *
 969  * This function enables the clock for ENET moudle.
 970  * @param instance module device instance
 971  */
 972 static inline void CLOCK_SYS_EnableEnetClock(uint32_t instance)
 973 {
 974     SIM_HAL_EnableEnetClock(g_simBaseAddr[0], instance);
 975 }
 976
 977 /*!
 978  * @brief Disable the clock for ENET module.
 979  *
 980  * This function disables the clock for ENET moudle.
 981  * @param instance module device instance
 982  */
 983 static inline void CLOCK_SYS_DisableEnetClock(uint32_t instance)
 984 {
 985     SIM_HAL_DisableEnetClock(g_simBaseAddr[0], instance);
 986 }
 987
 988 /*!
 989  * @brief Get the the clock gate state for ENET module.
 990  *
 991  * This function will get the clock gate state for ENET moudle.
 992  * @param instance module device instance
 993  * @return state true - ungated(Enabled), false - gated (Disabled)
 994  */
 995 static inline bool CLOCK_SYS_GetEnetGateCmd(uint32_t instance)
 996 {
 997     return SIM_HAL_GetEnetGateCmd(g_simBaseAddr[0], instance);
 998 }
 999
1000 /*!
1001  * @brief Enable the clock for USBFS module.
1002  *
1003  * This function enables the clock for USBFS moudle.
1004  * @param instance module device instance
1005  */
1006 static inline void CLOCK_SYS_EnableUsbClock(uint32_t instance)
1007 {
1008     SIM_HAL_EnableUsbClock(g_simBaseAddr[0], instance);
1009 }
1010
1011 /*!
1012  * @brief Disable the clock for USBFS module.
1013  *
1014  * This function disables the clock for USBFS moudle.
1015  * @param instance module device instance
1016  */
1017 static inline void CLOCK_SYS_DisableUsbClock(uint32_t instance)
1018 {
1019     SIM_HAL_DisableUsbClock(g_simBaseAddr[0], instance);
1020 }
1021
1022 /*!
1023  * @brief Get the the clock gate state for USB module.
1024  *
1025  * This function will get the clock gate state for USB moudle.
1026  * @param instance module device instance
1027  * @return state true - ungated(Enabled), false - gated (Disabled)
1028  */
1029 static inline bool CLOCK_SYS_GetUsbGateCmd(uint32_t instance)
1030 {
1031     return SIM_HAL_GetUsbGateCmd(g_simBaseAddr[0], instance);
1032 }
1033
1034 /*!
1035  * @brief Enable the clock for USBDCD module.
1036  *
1037  * This function enables the clock for USBDCD moudle.
1038  * @param instance module device instance
1039  */
1040 static inline void CLOCK_SYS_EnableUsbdcdClock(uint32_t instance)
1041 {
1042     SIM_HAL_EnableUsbdcdClock(g_simBaseAddr[0], instance);
1043 }
1044
1045 /*!
1046  * @brief Disable the clock for USBDCD module.
1047  *
1048  * This function disables the clock for USBDCD moudle.
1049  * @param instance module device instance
1050  */
1051 static inline void CLOCK_SYS_DisableUsbdcdClock(uint32_t instance)
1052 {
1053     SIM_HAL_DisableUsbdcdClock(g_simBaseAddr[0], instance);
1054 }
1055
1056 /*!
1057  * @brief Get the the clock gate state for USBDCD module.
1058  *
1059  * This function will get the clock gate state for USBDCD moudle.
1060  * @param instance module device instance
1061  * @return state true - ungated(Enabled), false - gated (Disabled)
1062  */
1063 static inline bool CLOCK_SYS_GetUsbdcdGateCmd(uint32_t instance)
1064 {
1065     return SIM_HAL_GetUsbdcdGateCmd(g_simBaseAddr[0], instance);
1066 }
1067
1068 /*!
1069  * @brief Enable the clock for FLEXCAN module.
1070  *
1071  * This function enables the clock for FLEXCAN moudle.
1072  * @param instance module device instance
1073  */
1074 static inline void CLOCK_SYS_EnableFlexcanClock(uint32_t instance)
1075 {
1076     SIM_HAL_EnableFlexcanClock(g_simBaseAddr[0], instance);
1077 }
1078
1079 /*!
1080  * @brief Disable the clock for FLEXCAN module.
1081  *
1082  * This function disables the clock for FLEXCAN moudle.
1083  * @param instance module device instance
1084  */
1085 static inline void CLOCK_SYS_DisableFlexcanClock(uint32_t instance)
1086 {
1087     SIM_HAL_DisableFlexcanClock(g_simBaseAddr[0], instance);
1088 }
1089
1090 /*!
1091  * @brief Get the the clock gate state for FLEXCAN module.
1092  *
1093  * This function will get the clock gate state for FLEXCAN moudle.
1094  * @param instance module device instance
1095  * @return state true - ungated(Enabled), false - gated (Disabled)
1096  */
1097 static inline bool CLOCK_SYS_GetFlexcanGateCmd(uint32_t instance)
1098 {
1099     return SIM_HAL_GetFlexcanGateCmd(g_simBaseAddr[0], instance);
1100 }
1101
1102 /*!
1103  * @brief Enable the clock for SPI module.
1104  *
1105  * This function enables the clock for SPI moudle.
1106  * @param instance module device instance
1107  */
1108 static inline void CLOCK_SYS_EnableSpiClock(uint32_t instance)
1109 {
1110     SIM_HAL_EnableSpiClock(g_simBaseAddr[0], instance);
1111 }
1112
1113 /*!
1114  * @brief Disable the clock for SPI module.
1115  *
1116  * This function disables the clock for SPI moudle.
1117  * @param instance module device instance
1118  */
1119 static inline void CLOCK_SYS_DisableSpiClock(uint32_t instance)
1120 {
1121     SIM_HAL_DisableSpiClock(g_simBaseAddr[0], instance);
1122 }
1123
1124 /*!
1125  * @brief Get the the clock gate state for SPI module.
1126  *
1127  * This function will get the clock gate state for SPI moudle.
1128  * @param instance module device instance
1129  * @return state true - ungated(Enabled), false - gated (Disabled)
1130  */
1131 static inline bool CLOCK_SYS_GetSpiGateCmd(uint32_t instance)
1132 {
1133     return SIM_HAL_GetSpiGateCmd(g_simBaseAddr[0], instance);
1134 }
1135
1136 /*!
1137  * @brief Enable the clock for I2C module.
1138  *
1139  * This function enables the clock for I2C moudle.
1140  * @param instance module device instance
1141  */
1142 static inline void CLOCK_SYS_EnableI2cClock(uint32_t instance)
1143 {
1144     SIM_HAL_EnableI2cClock(g_simBaseAddr[0], instance);
1145 }
1146
1147 /*!
1148  * @brief Disable the clock for I2C module.
1149  *
1150  * This function disables the clock for I2C moudle.
1151  * @param instance module device instance
1152  */
1153 static inline void CLOCK_SYS_DisableI2cClock(uint32_t instance)
1154 {
1155     SIM_HAL_DisableI2cClock(g_simBaseAddr[0], instance);
1156 }
1157
1158 /*!
1159  * @brief Get the the clock gate state for I2C module.
1160  *
1161  * This function will get the clock gate state for I2C moudle.
1162  * @param instance module device instance
1163  * @return state true - ungated(Enabled), false - gated (Disabled)
1164  */
1165 static inline bool CLOCK_SYS_GetI2cGateCmd(uint32_t instance)
1166 {
1167     return SIM_HAL_GetI2cGateCmd(g_simBaseAddr[0], instance);
1168 }
1169
1170 /*!
1171  * @brief Enable the clock for UART module.
1172  *
1173  * This function enables the clock for UART moudle.
1174  * @param instance module device instance
1175  */
1176 static inline void CLOCK_SYS_EnableUartClock(uint32_t instance)
1177 {
1178     SIM_HAL_EnableUartClock(g_simBaseAddr[0], instance);
1179 }
1180
1181 /*!
1182  * @brief Disable the clock for UART module.
1183  *
1184  * This function disables the clock for UART moudle.
1185  * @param instance module device instance
1186  */
1187 static inline void CLOCK_SYS_DisableUartClock(uint32_t instance)
1188 {
1189     SIM_HAL_DisableUartClock(g_simBaseAddr[0], instance);
1190 }
1191
1192 /*!
1193  * @brief Get the the clock gate state for UART module.
1194  *
1195  * This function will get the clock gate state for UART moudle.
1196  * @param instance module device instance
1197  * @return state true - ungated(Enabled), false - gated (Disabled)
1198  */
1199 static inline bool CLOCK_SYS_GetUartGateCmd(uint32_t instance)
1200 {
1201     return SIM_HAL_GetUartGateCmd(g_simBaseAddr[0], instance);
1202 }
1203
1204 /*!
1205  * @brief Enable the clock for SDHC module.
1206  *
1207  * This function enables the clock for SDHC moudle.
1208  * @param instance module device instance
1209  */
1210 static inline void CLOCK_SYS_EnableSdhcClock(uint32_t instance)
1211 {
1212     SIM_HAL_EnableSdhcClock(g_simBaseAddr[0], instance);
1213 }
1214
1215 /*!
1216  * @brief Disable the clock for SDHC module.
1217  *
1218  * This function disables the clock for SDHC moudle.
1219  * @param instance module device instance
1220  */
1221 static inline void CLOCK_SYS_DisableSdhcClock(uint32_t instance)
1222 {
1223     SIM_HAL_DisableSdhcClock(g_simBaseAddr[0], instance);
1224 }
1225
1226 /*!
1227  * @brief Get the the clock gate state for SDHC module.
1228  *
1229  * This function will get the clock gate state for SDHC moudle.
1230  * @param instance module device instance
1231  * @return state true - ungated(Enabled), false - gated (Disabled)
1232  */
1233 static inline bool CLOCK_SYS_GetSdhcGateCmd(uint32_t instance)
1234 {
1235     return SIM_HAL_GetSdhcGateCmd(g_simBaseAddr[0], instance);
1236 }
1237
1238 #if defined(__cplusplus)
1239 }
1240 #endif /* __cplusplus*/
1241
1242 /*! @}*/
1243
1244 #endif /* __FSL_CLOCK_K64F12_H__ */
1245 /*******************************************************************************
1246  * EOF
1247  ******************************************************************************/
1248