git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/CORTEX_M0+_LPC51U68_LPCXpresso/drivers/fsl_clock.h

   1 /*\r
   2  * Copyright (c) 2016, Freescale Semiconductor, Inc.\r
   3  * Copyright 2016 - 2019 , NXP\r
   4  * All rights reserved.\r
   5  *\r
   6  *\r
   7  * SPDX-License-Identifier: BSD-3-Clause\r
   8  */\r
   9 \r
  10 #ifndef _FSL_CLOCK_H_\r
  11 #define _FSL_CLOCK_H_\r
  12 \r
  13 #include "fsl_common.h"\r
  14 \r
  15 /*! @addtogroup clock */\r
  16 /*! @{ */\r
  17 \r
  18 /*! @file */\r
  19 \r
  20 /*******************************************************************************\r
  21  * Definitions\r
  22  *****************************************************************************/\r
  23 \r
  24 /*! @name Driver version */\r
  25 /*@{*/\r
  26 /*! @brief CLOCK driver version 2.2.0. */\r
  27 #define FSL_CLOCK_DRIVER_VERSION (MAKE_VERSION(2, 2, 0))\r
  28 /*@}*/\r
  29 \r
  30 /* Definition for delay API in clock driver, users can redefine it to the real application. */\r
  31 #ifndef SDK_DEVICE_MAXIMUM_CPU_CLOCK_FREQUENCY\r
  32 #define SDK_DEVICE_MAXIMUM_CPU_CLOCK_FREQUENCY (96000000UL)\r
  33 #endif\r
  34 \r
  35 /*!\r
  36  * @brief User-defined the size of cache for CLOCK_PllGetConfig() function.\r
  37  *\r
  38  * Once define this MACRO to be non-zero value, CLOCK_PllGetConfig() function\r
  39  * would cache the recent calulation and accelerate the execution to get the\r
  40  * right settings.\r
  41  */\r
  42 #ifndef CLOCK_USR_CFG_PLL_CONFIG_CACHE_COUNT\r
  43 #define CLOCK_USR_CFG_PLL_CONFIG_CACHE_COUNT 2U\r
  44 #endif\r
  45 \r
  46 /*! @brief Clock ip name array for FLEXCOMM. */\r
  47 #define FLEXCOMM_CLOCKS                                                                                             \\r
  48     {                                                                                                               \\r
  49         kCLOCK_FlexComm0, kCLOCK_FlexComm1, kCLOCK_FlexComm2, kCLOCK_FlexComm3, kCLOCK_FlexComm4, kCLOCK_FlexComm5, \\r
  50             kCLOCK_FlexComm6, kCLOCK_FlexComm7                                                                      \\r
  51     }\r
  52 /*! @brief Clock ip name array for LPUART. */\r
  53 #define LPUART_CLOCKS                                                                                         \\r
  54     {                                                                                                         \\r
  55         kCLOCK_MinUart0, kCLOCK_MinUart1, kCLOCK_MinUart2, kCLOCK_MinUart3, kCLOCK_MinUart4, kCLOCK_MinUart5, \\r
  56             kCLOCK_MinUart6, kCLOCK_MinUart7                                                                  \\r
  57     }\r
  58 \r
  59 /*! @brief Clock ip name array for BI2C. */\r
  60 #define BI2C_CLOCKS                                                                                                    \\r
  61     {                                                                                                                  \\r
  62         kCLOCK_BI2c0, kCLOCK_BI2c1, kCLOCK_BI2c2, kCLOCK_BI2c3, kCLOCK_BI2c4, kCLOCK_BI2c5, kCLOCK_BI2c6, kCLOCK_BI2c7 \\r
  63     }\r
  64 /*! @brief Clock ip name array for LSPI. */\r
  65 #define LPSI_CLOCKS                                                                                                    \\r
  66     {                                                                                                                  \\r
  67         kCLOCK_LSpi0, kCLOCK_LSpi1, kCLOCK_LSpi2, kCLOCK_LSpi3, kCLOCK_LSpi4, kCLOCK_LSpi5, kCLOCK_LSpi6, kCLOCK_LSpi7 \\r
  68     }\r
  69 /*! @brief Clock ip name array for FLEXI2S. */\r
  70 #define FLEXI2S_CLOCKS                                                                                        \\r
  71     {                                                                                                         \\r
  72         kCLOCK_FlexI2s0, kCLOCK_FlexI2s1, kCLOCK_FlexI2s2, kCLOCK_FlexI2s3, kCLOCK_FlexI2s4, kCLOCK_FlexI2s5, \\r
  73             kCLOCK_FlexI2s6, kCLOCK_FlexI2s7                                                                  \\r
  74     }\r
  75 /*! @brief Clock ip name array for UTICK. */\r
  76 #define UTICK_CLOCKS \\r
  77     {                \\r
  78         kCLOCK_Utick \\r
  79     }\r
  80 /*! @brief Clock ip name array for DMA. */\r
  81 #define DMA_CLOCKS \\r
  82     {              \\r
  83         kCLOCK_Dma \\r
  84     }\r
  85 /*! @brief Clock ip name array for CT32B. */\r
  86 #define CTIMER_CLOCKS                                  \\r
  87     {                                                  \\r
  88         kCLOCK_Ctimer0, kCLOCK_Ctimer1, kCLOCK_Ctimer3 \\r
  89     }\r
  90 \r
  91 /*! @brief Clock ip name array for GPIO. */\r
  92 #define GPIO_CLOCKS                \\r
  93     {                              \\r
  94         kCLOCK_Gpio0, kCLOCK_Gpio1 \\r
  95     }\r
  96 /*! @brief Clock ip name array for ADC. */\r
  97 #define ADC_CLOCKS  \\r
  98     {               \\r
  99         kCLOCK_Adc0 \\r
 100     }\r
 101 /*! @brief Clock ip name array for MRT. */\r
 102 #define MRT_CLOCKS \\r
 103     {              \\r
 104         kCLOCK_Mrt \\r
 105     }\r
 106 /*! @brief Clock ip name array for MRT. */\r
 107 #define SCT_CLOCKS  \\r
 108     {               \\r
 109         kCLOCK_Sct0 \\r
 110     }\r
 111 /*! @brief Clock ip name array for RTC. */\r
 112 #define RTC_CLOCKS \\r
 113     {              \\r
 114         kCLOCK_Rtc \\r
 115     }\r
 116 /*! @brief Clock ip name array for WWDT. */\r
 117 #define WWDT_CLOCKS \\r
 118     {               \\r
 119         kCLOCK_Wwdt \\r
 120     }\r
 121 /*! @brief Clock ip name array for CRC. */\r
 122 #define CRC_CLOCKS \\r
 123     {              \\r
 124         kCLOCK_Crc \\r
 125     }\r
 126 /*! @brief Clock ip name array for USBD. */\r
 127 #define USBD_CLOCKS  \\r
 128     {                \\r
 129         kCLOCK_Usbd0 \\r
 130     }\r
 131 \r
 132 /*! @brief Clock ip name array for GINT. GINT0 & GINT1 share same slot */\r
 133 #define GINT_CLOCKS              \\r
 134     {                            \\r
 135         kCLOCK_Gint, kCLOCK_Gint \\r
 136     }\r
 137 \r
 138 /*! @brief Clock gate name used for CLOCK_EnableClock/CLOCK_DisableClock. */\r
 139 /*------------------------------------------------------------------------------\r
 140  clock_ip_name_t definition:\r
 141 ------------------------------------------------------------------------------*/\r
 142 \r
 143 #define CLK_GATE_REG_OFFSET_SHIFT 8U\r
 144 #define CLK_GATE_REG_OFFSET_MASK 0xFFFFFF00U\r
 145 #define CLK_GATE_BIT_SHIFT_SHIFT 0U\r
 146 #define CLK_GATE_BIT_SHIFT_MASK 0x000000FFU\r
 147 \r
 148 #define CLK_GATE_DEFINE(reg_offset, bit_shift)                                  \\r
 149     ((((reg_offset) << CLK_GATE_REG_OFFSET_SHIFT) & CLK_GATE_REG_OFFSET_MASK) | \\r
 150      (((bit_shift) << CLK_GATE_BIT_SHIFT_SHIFT) & CLK_GATE_BIT_SHIFT_MASK))\r
 151 \r
 152 #define CLK_GATE_ABSTRACT_REG_OFFSET(x) (((uint32_t)(x)&CLK_GATE_REG_OFFSET_MASK) >> CLK_GATE_REG_OFFSET_SHIFT)\r
 153 #define CLK_GATE_ABSTRACT_BITS_SHIFT(x) (((uint32_t)(x)&CLK_GATE_BIT_SHIFT_MASK) >> CLK_GATE_BIT_SHIFT_SHIFT)\r
 154 \r
 155 #define AHB_CLK_CTRL0 0\r
 156 #define AHB_CLK_CTRL1 1\r
 157 #define ASYNC_CLK_CTRL0 2\r
 158 \r
 159 /*! @brief Clock gate name used for CLOCK_EnableClock/CLOCK_DisableClock. */\r
 160 typedef enum _clock_ip_name\r
 161 {\r
 162     kCLOCK_IpInvalid = 0U,\r
 163     kCLOCK_Rom       = CLK_GATE_DEFINE(AHB_CLK_CTRL0, 1),\r
 164     kCLOCK_Flash     = CLK_GATE_DEFINE(AHB_CLK_CTRL0, 7),\r
 165     kCLOCK_Fmc       = CLK_GATE_DEFINE(AHB_CLK_CTRL0, 8),\r
 166     kCLOCK_InputMux  = CLK_GATE_DEFINE(AHB_CLK_CTRL0, 11),\r
 167     kCLOCK_Iocon     = CLK_GATE_DEFINE(AHB_CLK_CTRL0, 13),\r
 168     kCLOCK_Gpio0     = CLK_GATE_DEFINE(AHB_CLK_CTRL0, 14),\r
 169     kCLOCK_Gpio1     = CLK_GATE_DEFINE(AHB_CLK_CTRL0, 15),\r
 170     kCLOCK_Pint      = CLK_GATE_DEFINE(AHB_CLK_CTRL0, 18),\r
 171     kCLOCK_Gint  = CLK_GATE_DEFINE(AHB_CLK_CTRL0, 19), /* GPIO_GLOBALINT0 and GPIO_GLOBALINT1 share the same slot  */\r
 172     kCLOCK_Dma   = CLK_GATE_DEFINE(AHB_CLK_CTRL0, 20),\r
 173     kCLOCK_Crc   = CLK_GATE_DEFINE(AHB_CLK_CTRL0, 21),\r
 174     kCLOCK_Wwdt  = CLK_GATE_DEFINE(AHB_CLK_CTRL0, 22),\r
 175     kCLOCK_Rtc   = CLK_GATE_DEFINE(AHB_CLK_CTRL0, 23),\r
 176     kCLOCK_Adc0  = CLK_GATE_DEFINE(AHB_CLK_CTRL0, 27),\r
 177     kCLOCK_Mrt   = CLK_GATE_DEFINE(AHB_CLK_CTRL1, 0),\r
 178     kCLOCK_Sct0  = CLK_GATE_DEFINE(AHB_CLK_CTRL1, 2),\r
 179     kCLOCK_Utick = CLK_GATE_DEFINE(AHB_CLK_CTRL1, 10),\r
 180     kCLOCK_FlexComm0 = CLK_GATE_DEFINE(AHB_CLK_CTRL1, 11),\r
 181     kCLOCK_FlexComm1 = CLK_GATE_DEFINE(AHB_CLK_CTRL1, 12),\r
 182     kCLOCK_FlexComm2 = CLK_GATE_DEFINE(AHB_CLK_CTRL1, 13),\r
 183     kCLOCK_FlexComm3 = CLK_GATE_DEFINE(AHB_CLK_CTRL1, 14),\r
 184     kCLOCK_FlexComm4 = CLK_GATE_DEFINE(AHB_CLK_CTRL1, 15),\r
 185     kCLOCK_FlexComm5 = CLK_GATE_DEFINE(AHB_CLK_CTRL1, 16),\r
 186     kCLOCK_FlexComm6 = CLK_GATE_DEFINE(AHB_CLK_CTRL1, 17),\r
 187     kCLOCK_FlexComm7 = CLK_GATE_DEFINE(AHB_CLK_CTRL1, 18),\r
 188     kCLOCK_MinUart0  = CLK_GATE_DEFINE(AHB_CLK_CTRL1, 11),\r
 189     kCLOCK_MinUart1  = CLK_GATE_DEFINE(AHB_CLK_CTRL1, 12),\r
 190     kCLOCK_MinUart2  = CLK_GATE_DEFINE(AHB_CLK_CTRL1, 13),\r
 191     kCLOCK_MinUart3  = CLK_GATE_DEFINE(AHB_CLK_CTRL1, 14),\r
 192     kCLOCK_MinUart4  = CLK_GATE_DEFINE(AHB_CLK_CTRL1, 15),\r
 193     kCLOCK_MinUart5  = CLK_GATE_DEFINE(AHB_CLK_CTRL1, 16),\r
 194     kCLOCK_MinUart6  = CLK_GATE_DEFINE(AHB_CLK_CTRL1, 17),\r
 195     kCLOCK_MinUart7  = CLK_GATE_DEFINE(AHB_CLK_CTRL1, 18),\r
 196     kCLOCK_LSpi0     = CLK_GATE_DEFINE(AHB_CLK_CTRL1, 11),\r
 197     kCLOCK_LSpi1     = CLK_GATE_DEFINE(AHB_CLK_CTRL1, 12),\r
 198     kCLOCK_LSpi2     = CLK_GATE_DEFINE(AHB_CLK_CTRL1, 13),\r
 199     kCLOCK_LSpi3     = CLK_GATE_DEFINE(AHB_CLK_CTRL1, 14),\r
 200     kCLOCK_LSpi4     = CLK_GATE_DEFINE(AHB_CLK_CTRL1, 15),\r
 201     kCLOCK_LSpi5     = CLK_GATE_DEFINE(AHB_CLK_CTRL1, 16),\r
 202     kCLOCK_LSpi6     = CLK_GATE_DEFINE(AHB_CLK_CTRL1, 17),\r
 203     kCLOCK_LSpi7     = CLK_GATE_DEFINE(AHB_CLK_CTRL1, 18),\r
 204     kCLOCK_BI2c0     = CLK_GATE_DEFINE(AHB_CLK_CTRL1, 11),\r
 205     kCLOCK_BI2c1     = CLK_GATE_DEFINE(AHB_CLK_CTRL1, 12),\r
 206     kCLOCK_BI2c2     = CLK_GATE_DEFINE(AHB_CLK_CTRL1, 13),\r
 207     kCLOCK_BI2c3     = CLK_GATE_DEFINE(AHB_CLK_CTRL1, 14),\r
 208     kCLOCK_BI2c4     = CLK_GATE_DEFINE(AHB_CLK_CTRL1, 15),\r
 209     kCLOCK_BI2c5     = CLK_GATE_DEFINE(AHB_CLK_CTRL1, 16),\r
 210     kCLOCK_BI2c6     = CLK_GATE_DEFINE(AHB_CLK_CTRL1, 17),\r
 211     kCLOCK_BI2c7     = CLK_GATE_DEFINE(AHB_CLK_CTRL1, 18),\r
 212     kCLOCK_FlexI2s0  = CLK_GATE_DEFINE(AHB_CLK_CTRL1, 11),\r
 213     kCLOCK_FlexI2s1  = CLK_GATE_DEFINE(AHB_CLK_CTRL1, 12),\r
 214     kCLOCK_FlexI2s2  = CLK_GATE_DEFINE(AHB_CLK_CTRL1, 13),\r
 215     kCLOCK_FlexI2s3  = CLK_GATE_DEFINE(AHB_CLK_CTRL1, 14),\r
 216     kCLOCK_FlexI2s4  = CLK_GATE_DEFINE(AHB_CLK_CTRL1, 15),\r
 217     kCLOCK_FlexI2s5  = CLK_GATE_DEFINE(AHB_CLK_CTRL1, 16),\r
 218     kCLOCK_FlexI2s6  = CLK_GATE_DEFINE(AHB_CLK_CTRL1, 17),\r
 219     kCLOCK_FlexI2s7  = CLK_GATE_DEFINE(AHB_CLK_CTRL1, 18),\r
 220     kCLOCK_Ct32b2    = CLK_GATE_DEFINE(AHB_CLK_CTRL1, 22),\r
 221     kCLOCK_Usbd0     = CLK_GATE_DEFINE(AHB_CLK_CTRL1, 25),\r
 222     kCLOCK_Ctimer0   = CLK_GATE_DEFINE(AHB_CLK_CTRL1, 26),\r
 223     kCLOCK_Ctimer1   = CLK_GATE_DEFINE(AHB_CLK_CTRL1, 27),\r
 224 \r
 225     kCLOCK_Ctimer3 = CLK_GATE_DEFINE(ASYNC_CLK_CTRL0, 13),\r
 226 } clock_ip_name_t;\r
 227 \r
 228 /*! @brief Clock name used to get clock frequency. */\r
 229 typedef enum _clock_name\r
 230 {\r
 231     kCLOCK_CoreSysClk,  /*!< Core/system clock  (aka MAIN_CLK)                       */\r
 232     kCLOCK_BusClk,      /*!< Bus clock (AHB clock)                                   */\r
 233     kCLOCK_FroHf,       /*!< FRO48/96                                                */\r
 234     kCLOCK_Fro12M,      /*!< FRO12M                                                  */\r
 235     kCLOCK_ExtClk,      /*!< External Clock                                          */\r
 236     kCLOCK_PllOut,      /*!< PLL Output                                              */\r
 237     kCLOCK_UsbClk,      /*!< USB input                                               */\r
 238     kCLOCK_WdtOsc,      /*!< Watchdog Oscillator                                     */\r
 239     kCLOCK_Frg,         /*!< Frg Clock                                               */\r
 240     kCLOCK_AsyncApbClk, /*!< Async APB clock                                                                                                                                                        */\r
 241     kCLOCK_FlexI2S,     /*!< FlexI2S clock                                           */\r
 242     kCLOCK_Flexcomm0,   /*!< Flexcomm0Clock                                          */\r
 243     kCLOCK_Flexcomm1,   /*!< Flexcomm1Clock                                          */\r
 244     kCLOCK_Flexcomm2,   /*!< Flexcomm2Clock                                          */\r
 245     kCLOCK_Flexcomm3,   /*!< Flexcomm3Clock                                          */\r
 246     kCLOCK_Flexcomm4,   /*!< Flexcomm4Clock                                          */\r
 247     kCLOCK_Flexcomm5,   /*!< Flexcomm5Clock                                          */\r
 248     kCLOCK_Flexcomm6,   /*!< Flexcomm6Clock                                          */\r
 249     kCLOCK_Flexcomm7,   /*!< Flexcomm7Clock                                          */\r
 250 } clock_name_t;\r
 251 \r
 252 /**\r
 253  * Clock source selections for the asynchronous APB clock\r
 254  */\r
 255 typedef enum _async_clock_src\r
 256 {\r
 257     kCLOCK_AsyncMainClk = 0, /*!< Main System clock */\r
 258     kCLOCK_AsyncFro12Mhz,    /*!< 12MHz FRO */\r
 259 } async_clock_src_t;\r
 260 \r
 261 /*! @brief Clock Mux Switches\r
 262  *  The encoding is as follows each connection identified is 32bits wide while 24bits are valuable\r
 263  *  starting from LSB upwards\r
 264  *\r
 265  *  [4 bits for choice, 0 means invalid choice] [8 bits mux ID]*\r
 266  *\r
 267  */\r
 268 \r
 269 #define CLK_ATTACH_ID(mux, sel, pos) (((mux << 0U) | ((sel + 1) & 0xFU) << 8U) << (pos * 12U))\r
 270 #define MUX_A(mux, sel) CLK_ATTACH_ID(mux, sel, 0U)\r
 271 #define MUX_B(mux, sel, selector) (CLK_ATTACH_ID(mux, sel, 1U) | (selector << 24U))\r
 272 \r
 273 #define GET_ID_ITEM(connection) ((connection)&0xFFFU)\r
 274 #define GET_ID_NEXT_ITEM(connection) ((connection) >> 12U)\r
 275 #define GET_ID_ITEM_MUX(connection) ((connection)&0xFFU)\r
 276 #define GET_ID_ITEM_SEL(connection) ((((connection)&0xF00U) >> 8U) - 1U)\r
 277 #define GET_ID_SELECTOR(connection) ((connection)&0xF000000U)\r
 278 \r
 279 #define CM_MAINCLKSELA 0\r
 280 #define CM_MAINCLKSELB 1\r
 281 #define CM_CLKOUTCLKSELA 2\r
 282 #define CM_CLKOUTCLKSELB 3\r
 283 #define CM_SYSPLLCLKSEL 4\r
 284 #define CM_USBPLLCLKSEL 5\r
 285 #define CM_AUDPLLCLKSEL 6\r
 286 #define CM_SCTPLLCLKSEL 7\r
 287 #define CM_ADCASYNCCLKSEL 9\r
 288 #define CM_USBCLKSEL 10\r
 289 #define CM_USB1CLKSEL 11\r
 290 #define CM_FXCOMCLKSEL0 12\r
 291 #define CM_FXCOMCLKSEL1 13\r
 292 #define CM_FXCOMCLKSEL2 14\r
 293 #define CM_FXCOMCLKSEL3 15\r
 294 #define CM_FXCOMCLKSEL4 16\r
 295 #define CM_FXCOMCLKSEL5 17\r
 296 #define CM_FXCOMCLKSEL6 18\r
 297 #define CM_FXCOMCLKSEL7 19\r
 298 #define CM_FXCOMCLKSEL8 20\r
 299 #define CM_FXCOMCLKSEL9 21\r
 300 #define CM_FXCOMCLKSEL10 22\r
 301 #define CM_FXCOMCLKSEL11 23\r
 302 #define CM_FXI2S0MCLKCLKSEL 24\r
 303 #define CM_FXI2S1MCLKCLKSEL 25\r
 304 #define CM_FRGCLKSEL 26\r
 305 \r
 306 #define CM_ASYNCAPB 28\r
 307 \r
 308 typedef enum _clock_attach_id\r
 309 {\r
 310 \r
 311     kFRO12M_to_MAIN_CLK  = MUX_A(CM_MAINCLKSELA, 0) | MUX_B(CM_MAINCLKSELB, 0, 0),\r
 312     kEXT_CLK_to_MAIN_CLK = MUX_A(CM_MAINCLKSELA, 1) | MUX_B(CM_MAINCLKSELB, 0, 0),\r
 313     kWDT_OSC_to_MAIN_CLK = MUX_A(CM_MAINCLKSELA, 2) | MUX_B(CM_MAINCLKSELB, 0, 0),\r
 314     kFRO_HF_to_MAIN_CLK  = MUX_A(CM_MAINCLKSELA, 3) | MUX_B(CM_MAINCLKSELB, 0, 0),\r
 315     kSYS_PLL_to_MAIN_CLK = MUX_A(CM_MAINCLKSELA, 0) | MUX_B(CM_MAINCLKSELB, 2, 0),\r
 316     kOSC32K_to_MAIN_CLK  = MUX_A(CM_MAINCLKSELA, 0) | MUX_B(CM_MAINCLKSELB, 3, 0),\r
 317 \r
 318     kFRO12M_to_SYS_PLL  = MUX_A(CM_SYSPLLCLKSEL, 0),\r
 319     kEXT_CLK_to_SYS_PLL = MUX_A(CM_SYSPLLCLKSEL, 1),\r
 320     kWDT_OSC_to_SYS_PLL = MUX_A(CM_SYSPLLCLKSEL, 2),\r
 321     kOSC32K_to_SYS_PLL  = MUX_A(CM_SYSPLLCLKSEL, 3),\r
 322     kNONE_to_SYS_PLL    = MUX_A(CM_SYSPLLCLKSEL, 7),\r
 323 \r
 324     kMAIN_CLK_to_ASYNC_APB = MUX_A(CM_ASYNCAPB, 0),\r
 325     kFRO12M_to_ASYNC_APB   = MUX_A(CM_ASYNCAPB, 1),\r
 326 \r
 327     kMAIN_CLK_to_ADC_CLK = MUX_A(CM_ADCASYNCCLKSEL, 0),\r
 328     kSYS_PLL_to_ADC_CLK  = MUX_A(CM_ADCASYNCCLKSEL, 1),\r
 329     kFRO_HF_to_ADC_CLK   = MUX_A(CM_ADCASYNCCLKSEL, 2),\r
 330     kNONE_to_ADC_CLK     = MUX_A(CM_ADCASYNCCLKSEL, 7),\r
 331 \r
 332     kFRO12M_to_FLEXCOMM0  = MUX_A(CM_FXCOMCLKSEL0, 0),\r
 333     kFRO_HF_to_FLEXCOMM0  = MUX_A(CM_FXCOMCLKSEL0, 1),\r
 334     kSYS_PLL_to_FLEXCOMM0 = MUX_A(CM_FXCOMCLKSEL0, 2),\r
 335     kMCLK_to_FLEXCOMM0    = MUX_A(CM_FXCOMCLKSEL0, 3),\r
 336     kFRG_to_FLEXCOMM0     = MUX_A(CM_FXCOMCLKSEL0, 4),\r
 337     kNONE_to_FLEXCOMM0    = MUX_A(CM_FXCOMCLKSEL0, 7),\r
 338 \r
 339     kFRO12M_to_FLEXCOMM1  = MUX_A(CM_FXCOMCLKSEL1, 0),\r
 340     kFRO_HF_to_FLEXCOMM1  = MUX_A(CM_FXCOMCLKSEL1, 1),\r
 341     kSYS_PLL_to_FLEXCOMM1 = MUX_A(CM_FXCOMCLKSEL1, 2),\r
 342     kMCLK_to_FLEXCOMM1    = MUX_A(CM_FXCOMCLKSEL1, 3),\r
 343     kFRG_to_FLEXCOMM1     = MUX_A(CM_FXCOMCLKSEL1, 4),\r
 344     kNONE_to_FLEXCOMM1    = MUX_A(CM_FXCOMCLKSEL1, 7),\r
 345 \r
 346     kFRO12M_to_FLEXCOMM2  = MUX_A(CM_FXCOMCLKSEL2, 0),\r
 347     kFRO_HF_to_FLEXCOMM2  = MUX_A(CM_FXCOMCLKSEL2, 1),\r
 348     kSYS_PLL_to_FLEXCOMM2 = MUX_A(CM_FXCOMCLKSEL2, 2),\r
 349     kMCLK_to_FLEXCOMM2    = MUX_A(CM_FXCOMCLKSEL2, 3),\r
 350     kFRG_to_FLEXCOMM2     = MUX_A(CM_FXCOMCLKSEL2, 4),\r
 351     kNONE_to_FLEXCOMM2    = MUX_A(CM_FXCOMCLKSEL2, 7),\r
 352 \r
 353     kFRO12M_to_FLEXCOMM3  = MUX_A(CM_FXCOMCLKSEL3, 0),\r
 354     kFRO_HF_to_FLEXCOMM3  = MUX_A(CM_FXCOMCLKSEL3, 1),\r
 355     kSYS_PLL_to_FLEXCOMM3 = MUX_A(CM_FXCOMCLKSEL3, 2),\r
 356     kMCLK_to_FLEXCOMM3    = MUX_A(CM_FXCOMCLKSEL3, 3),\r
 357     kFRG_to_FLEXCOMM3     = MUX_A(CM_FXCOMCLKSEL3, 4),\r
 358     kNONE_to_FLEXCOMM3    = MUX_A(CM_FXCOMCLKSEL3, 7),\r
 359 \r
 360     kFRO12M_to_FLEXCOMM4  = MUX_A(CM_FXCOMCLKSEL4, 0),\r
 361     kFRO_HF_to_FLEXCOMM4  = MUX_A(CM_FXCOMCLKSEL4, 1),\r
 362     kSYS_PLL_to_FLEXCOMM4 = MUX_A(CM_FXCOMCLKSEL4, 2),\r
 363     kMCLK_to_FLEXCOMM4    = MUX_A(CM_FXCOMCLKSEL4, 3),\r
 364     kFRG_to_FLEXCOMM4     = MUX_A(CM_FXCOMCLKSEL4, 4),\r
 365     kNONE_to_FLEXCOMM4    = MUX_A(CM_FXCOMCLKSEL4, 7),\r
 366 \r
 367     kFRO12M_to_FLEXCOMM5  = MUX_A(CM_FXCOMCLKSEL5, 0),\r
 368     kFRO_HF_to_FLEXCOMM5  = MUX_A(CM_FXCOMCLKSEL5, 1),\r
 369     kSYS_PLL_to_FLEXCOMM5 = MUX_A(CM_FXCOMCLKSEL5, 2),\r
 370     kMCLK_to_FLEXCOMM5    = MUX_A(CM_FXCOMCLKSEL5, 3),\r
 371     kFRG_to_FLEXCOMM5     = MUX_A(CM_FXCOMCLKSEL5, 4),\r
 372     kNONE_to_FLEXCOMM5    = MUX_A(CM_FXCOMCLKSEL5, 7),\r
 373 \r
 374     kFRO12M_to_FLEXCOMM6  = MUX_A(CM_FXCOMCLKSEL6, 0),\r
 375     kFRO_HF_to_FLEXCOMM6  = MUX_A(CM_FXCOMCLKSEL6, 1),\r
 376     kSYS_PLL_to_FLEXCOMM6 = MUX_A(CM_FXCOMCLKSEL6, 2),\r
 377     kMCLK_to_FLEXCOMM6    = MUX_A(CM_FXCOMCLKSEL6, 3),\r
 378     kFRG_to_FLEXCOMM6     = MUX_A(CM_FXCOMCLKSEL6, 4),\r
 379     kNONE_to_FLEXCOMM6    = MUX_A(CM_FXCOMCLKSEL6, 7),\r
 380 \r
 381     kFRO12M_to_FLEXCOMM7  = MUX_A(CM_FXCOMCLKSEL7, 0),\r
 382     kFRO_HF_to_FLEXCOMM7  = MUX_A(CM_FXCOMCLKSEL7, 1),\r
 383     kSYS_PLL_to_FLEXCOMM7 = MUX_A(CM_FXCOMCLKSEL7, 2),\r
 384     kMCLK_to_FLEXCOMM7    = MUX_A(CM_FXCOMCLKSEL7, 3),\r
 385     kFRG_to_FLEXCOMM7     = MUX_A(CM_FXCOMCLKSEL7, 4),\r
 386     kNONE_to_FLEXCOMM7    = MUX_A(CM_FXCOMCLKSEL7, 7),\r
 387 \r
 388     kMAIN_CLK_to_FRG = MUX_A(CM_FRGCLKSEL, 0),\r
 389     kSYS_PLL_to_FRG  = MUX_A(CM_FRGCLKSEL, 1),\r
 390     kFRO12M_to_FRG   = MUX_A(CM_FRGCLKSEL, 2),\r
 391     kFRO_HF_to_FRG   = MUX_A(CM_FRGCLKSEL, 3),\r
 392     kNONE_to_FRG     = MUX_A(CM_FRGCLKSEL, 7),\r
 393 \r
 394     kFRO_HF_to_MCLK   = MUX_A(CM_FXI2S0MCLKCLKSEL, 0),\r
 395     kSYS_PLL_to_MCLK  = MUX_A(CM_FXI2S0MCLKCLKSEL, 1),\r
 396     kMAIN_CLK_to_MCLK = MUX_A(CM_FXI2S0MCLKCLKSEL, 2),\r
 397     kNONE_to_MCLK     = MUX_A(CM_FXI2S0MCLKCLKSEL, 7),\r
 398 \r
 399     kFRO_HF_to_USB_CLK   = MUX_A(CM_USBCLKSEL, 0),\r
 400     kSYS_PLL_to_USB_CLK  = MUX_A(CM_USBCLKSEL, 1),\r
 401     kMAIN_CLK_to_USB_CLK = MUX_A(CM_USBCLKSEL, 2),\r
 402     kNONE_to_USB_CLK     = MUX_A(CM_USBCLKSEL, 7),\r
 403 \r
 404     kMAIN_CLK_to_CLKOUT = MUX_A(CM_CLKOUTCLKSELA, 0),\r
 405     kEXT_CLK_to_CLKOUT  = MUX_A(CM_CLKOUTCLKSELA, 1),\r
 406     kWDT_OSC_to_CLKOUT  = MUX_A(CM_CLKOUTCLKSELA, 2),\r
 407     kFRO_HF_to_CLKOUT   = MUX_A(CM_CLKOUTCLKSELA, 3),\r
 408     kSYS_PLL_to_CLKOUT  = MUX_A(CM_CLKOUTCLKSELA, 4),\r
 409     kFRO12M_to_CLKOUT   = MUX_A(CM_CLKOUTCLKSELA, 5),\r
 410     kOSC32K_to_CLKOUT   = MUX_A(CM_CLKOUTCLKSELA, 6),\r
 411     kNONE_to_CLKOUT     = MUX_A(CM_CLKOUTCLKSELA, 7),\r
 412     kNONE_to_NONE       = (int)0x80000000U,\r
 413 } clock_attach_id_t;\r
 414 \r
 415 /*  Clock dividers */\r
 416 typedef enum _clock_div_name\r
 417 {\r
 418     kCLOCK_DivSystickClk  = 0,\r
 419     kCLOCK_DivTraceClk    = 1,\r
 420     kCLOCK_DivAhbClk      = 32,\r
 421     kCLOCK_DivClkOut      = 33,\r
 422     kCLOCK_DivAdcAsyncClk = 37,\r
 423     kCLOCK_DivUsbClk      = 38,\r
 424     kCLOCK_DivFrg         = 40,\r
 425     kCLOCK_DivFxI2s0MClk  = 43\r
 426 } clock_div_name_t;\r
 427 \r
 428 /*******************************************************************************\r
 429  * API\r
 430  ******************************************************************************/\r
 431 \r
 432 #if defined(__cplusplus)\r
 433 extern "C" {\r
 434 #endif /* __cplusplus */\r
 435 \r
 436 static inline void CLOCK_EnableClock(clock_ip_name_t clk)\r
 437 {\r
 438     uint32_t index = CLK_GATE_ABSTRACT_REG_OFFSET(clk);\r
 439     if (index < 2)\r
 440     {\r
 441         SYSCON->AHBCLKCTRLSET[index] = (1U << CLK_GATE_ABSTRACT_BITS_SHIFT(clk));\r
 442     }\r
 443     else\r
 444     {\r
 445         ASYNC_SYSCON->ASYNCAPBCLKCTRLSET = (1U << CLK_GATE_ABSTRACT_BITS_SHIFT(clk));\r
 446     }\r
 447 }\r
 448 \r
 449 static inline void CLOCK_DisableClock(clock_ip_name_t clk)\r
 450 {\r
 451     uint32_t index = CLK_GATE_ABSTRACT_REG_OFFSET(clk);\r
 452     if (index < 2)\r
 453     {\r
 454         SYSCON->AHBCLKCTRLCLR[index] = (1U << CLK_GATE_ABSTRACT_BITS_SHIFT(clk));\r
 455     }\r
 456     else\r
 457     {\r
 458         ASYNC_SYSCON->ASYNCAPBCLKCTRLCLR = (1U << CLK_GATE_ABSTRACT_BITS_SHIFT(clk));\r
 459     }\r
 460 }\r
 461 /**\r
 462  * @brief FLASH Access time definitions\r
 463  */\r
 464 typedef enum _clock_flashtim\r
 465 {\r
 466     kCLOCK_Flash1Cycle = 0, /*!< Flash accesses use 1 CPU clock */\r
 467     kCLOCK_Flash2Cycle,     /*!< Flash accesses use 2 CPU clocks */\r
 468     kCLOCK_Flash3Cycle,     /*!< Flash accesses use 3 CPU clocks */\r
 469     kCLOCK_Flash4Cycle,     /*!< Flash accesses use 4 CPU clocks */\r
 470     kCLOCK_Flash5Cycle,     /*!< Flash accesses use 5 CPU clocks */\r
 471     kCLOCK_Flash6Cycle,     /*!< Flash accesses use 6 CPU clocks */\r
 472 } clock_flashtim_t;\r
 473 \r
 474 /**\r
 475  * @brief       Set FLASH memory access time in clocks\r
 476  * @param       clks    : Clock cycles for FLASH access\r
 477  * @return      Nothing\r
 478  */\r
 479 static inline void CLOCK_SetFLASHAccessCycles(clock_flashtim_t clks)\r
 480 {\r
 481     uint32_t tmp;\r
 482 \r
 483     tmp = SYSCON->FLASHCFG & ~(SYSCON_FLASHCFG_FLASHTIM_MASK);\r
 484 \r
 485     /* Don't alter lower bits */\r
 486     SYSCON->FLASHCFG = tmp | ((uint32_t)clks << SYSCON_FLASHCFG_FLASHTIM_SHIFT);\r
 487 }\r
 488 \r
 489 /**\r
 490  * @brief       Initialize the Core clock to given frequency (12, 48 or 96 MHz).\r
 491  * Turns on FRO and uses default CCO, if freq is 12000000, then high speed output is off, else high speed output is\r
 492  * enabled.\r
 493  * @param       iFreq   : Desired frequency (must be one of CLK_FRO_12MHZ or CLK_FRO_48MHZ or CLK_FRO_96MHZ)\r
 494  * @return      returns success or fail status.\r
 495  */\r
 496 status_t CLOCK_SetupFROClocking(uint32_t iFreq);\r
 497 /**\r
 498  * @brief       Configure the clock selection muxes.\r
 499  * @param       connection      : Clock to be configured.\r
 500  * @return      Nothing\r
 501  */\r
 502 void CLOCK_AttachClk(clock_attach_id_t connection);\r
 503 /**\r
 504  * @brief   Get the actual clock attach id.\r
 505  * This fuction uses the offset in input attach id, then it reads the actual source value in\r
 506  * the register and combine the offset to obtain an actual attach id.\r
 507  * @param   attachId  : Clock attach id to get.\r
 508  * @return  Clock source value.\r
 509  */\r
 510 clock_attach_id_t CLOCK_GetClockAttachId(clock_attach_id_t attachId);\r
 511 /**\r
 512  * @brief       Setup peripheral clock dividers.\r
 513  * @param       div_name        : Clock divider name\r
 514  * @param divided_by_value: Value to be divided\r
 515  * @param reset :  Whether to reset the divider counter.\r
 516  * @return      Nothing\r
 517  */\r
 518 void CLOCK_SetClkDiv(clock_div_name_t div_name, uint32_t divided_by_value, bool reset);\r
 519 /**\r
 520  * @brief       Set the flash wait states for the input freuqency.\r
 521  * @param       iFreq   : Input frequency\r
 522  * @return      Nothing\r
 523  */\r
 524 void CLOCK_SetFLASHAccessCyclesForFreq(uint32_t iFreq);\r
 525 /*! @brief      Return Frequency of selected clock\r
 526  *  @return     Frequency of selected clock\r
 527  */\r
 528 uint32_t CLOCK_GetFreq(clock_name_t clockName);\r
 529 \r
 530 /*! @brief      Return Input frequency for the Fractional baud rate generator\r
 531  *  @return     Input Frequency for FRG\r
 532  */\r
 533 uint32_t CLOCK_GetFRGInputClock(void);\r
 534 \r
 535 /*! @brief      Set output of the Fractional baud rate generator\r
 536  * @param       freq    : Desired output frequency\r
 537  * @return      Error Code 0 - fail 1 - success\r
 538  */\r
 539 uint32_t CLOCK_SetFRGClock(uint32_t freq);\r
 540 \r
 541 /*! @brief      Return Frequency of FRO 12MHz\r
 542  *  @return     Frequency of FRO 12MHz\r
 543  */\r
 544 uint32_t CLOCK_GetFro12MFreq(void);\r
 545 /*! @brief      Return Frequency of External Clock\r
 546  *  @return     Frequency of External Clock. If no external clock is used returns 0.\r
 547  */\r
 548 uint32_t CLOCK_GetExtClkFreq(void);\r
 549 /*! @brief      Return Frequency of Watchdog Oscillator\r
 550  *  @return     Frequency of Watchdog Oscillator\r
 551  */\r
 552 uint32_t CLOCK_GetWdtOscFreq(void);\r
 553 /*! @brief      Return Frequency of High-Freq output of FRO\r
 554  *  @return     Frequency of High-Freq output of FRO\r
 555  */\r
 556 uint32_t CLOCK_GetFroHfFreq(void);\r
 557 /*! @brief      Return Frequency of PLL\r
 558  *  @return     Frequency of PLL\r
 559  */\r
 560 uint32_t CLOCK_GetPllOutFreq(void);\r
 561 /*! @brief      Return Frequency of 32kHz osc\r
 562  *  @return     Frequency of 32kHz osc\r
 563  */\r
 564 uint32_t CLOCK_GetOsc32KFreq(void);\r
 565 /*! @brief      Return Frequency of Core System\r
 566  *  @return     Frequency of Core System\r
 567  */\r
 568 uint32_t CLOCK_GetCoreSysClkFreq(void);\r
 569 /*! @brief      Return Frequency of I2S MCLK Clock\r
 570  *  @return     Frequency of I2S MCLK Clock\r
 571  */\r
 572 uint32_t CLOCK_GetI2SMClkFreq(void);\r
 573 /*! @brief      Return Frequency of Flexcomm functional Clock\r
 574  *  @return     Frequency of Flexcomm functional Clock\r
 575  */\r
 576 uint32_t CLOCK_GetFlexCommClkFreq(uint32_t id);\r
 577 /*! @brief      Return Frequency of Adc Clock\r
 578  *  @return     Frequency of Adc Clock.\r
 579  */\r
 580 uint32_t CLOCK_GetAdcClkFreq(void);\r
 581 /*! @brief      Return Asynchronous APB Clock source\r
 582  *  @return     Asynchronous APB CLock source\r
 583  */\r
 584 __STATIC_INLINE async_clock_src_t CLOCK_GetAsyncApbClkSrc(void)\r
 585 {\r
 586     return (async_clock_src_t)(ASYNC_SYSCON->ASYNCAPBCLKSELA & 0x3);\r
 587 }\r
 588 /*! @brief      Return Frequency of Asynchronous APB Clock\r
 589  *  @return     Frequency of Asynchronous APB Clock Clock\r
 590  */\r
 591 uint32_t CLOCK_GetAsyncApbClkFreq(void);\r
 592 /*! @brief      Return System PLL input clock rate\r
 593  *  @return     System PLL input clock rate\r
 594  */\r
 595 uint32_t CLOCK_GetSystemPLLInClockRate(void);\r
 596 \r
 597 /*! @brief      Return System PLL output clock rate\r
 598  *  @param      recompute       : Forces a PLL rate recomputation if true\r
 599  *  @return     System PLL output clock rate\r
 600  *  @note       The PLL rate is cached in the driver in a variable as\r
 601  *  the rate computation function can take some time to perform. It\r
 602  *  is recommended to use 'false' with the 'recompute' parameter.\r
 603  */\r
 604 uint32_t CLOCK_GetSystemPLLOutClockRate(bool recompute);\r
 605 \r
 606 /*! @brief      Enables and disables PLL bypass mode\r
 607  *  @brief      bypass  : true to bypass PLL (PLL output = PLL input, false to disable bypass\r
 608  *  @return     System PLL output clock rate\r
 609  */\r
 610 __STATIC_INLINE void CLOCK_SetBypassPLL(bool bypass)\r
 611 {\r
 612     if (bypass)\r
 613     {\r
 614         SYSCON->SYSPLLCTRL |= (1UL << SYSCON_SYSPLLCTRL_BYPASS_SHIFT);\r
 615     }\r
 616     else\r
 617     {\r
 618         SYSCON->SYSPLLCTRL &= ~(1UL << SYSCON_SYSPLLCTRL_BYPASS_SHIFT);\r
 619     }\r
 620 }\r
 621 \r
 622 /*! @brief      Check if PLL is locked or not\r
 623  *  @return     true if the PLL is locked, false if not locked\r
 624  */\r
 625 __STATIC_INLINE bool CLOCK_IsSystemPLLLocked(void)\r
 626 {\r
 627     return (bool)((SYSCON->SYSPLLSTAT & SYSCON_SYSPLLSTAT_LOCK_MASK) != 0);\r
 628 }\r
 629 \r
 630 /*! @brief Store the current PLL rate\r
 631  *  @param      rate: Current rate of the PLL\r
 632  *  @return     Nothing\r
 633  **/\r
 634 void CLOCK_SetStoredPLLClockRate(uint32_t rate);\r
 635 \r
 636 /*! @brief PLL configuration structure flags for 'flags' field\r
 637  * These flags control how the PLL configuration function sets up the PLL setup structure.<br>\r
 638  *\r
 639  * When the PLL_CONFIGFLAG_USEINRATE flag is selected, the 'InputRate' field in the\r
 640  * configuration structure must be assigned with the expected PLL frequency. If the\r
 641  * PLL_CONFIGFLAG_USEINRATE is not used, 'InputRate' is ignored in the configuration\r
 642  * function and the driver will determine the PLL rate from the currently selected\r
 643  * PLL source. This flag might be used to configure the PLL input clock more accurately\r
 644  * when using the WDT oscillator or a more dyanmic CLKIN source.<br>\r
 645  *\r
 646  * When the PLL_CONFIGFLAG_FORCENOFRACT flag is selected, the PLL hardware for the\r
 647  * automatic bandwidth selection, Spread Spectrum (SS) support, and fractional M-divider\r
 648  * are not used.<br>\r
 649  */\r
 650 #define PLL_CONFIGFLAG_USEINRATE (1 << 0) /*!< Flag to use InputRate in PLL configuration structure for setup */\r
 651 #define PLL_CONFIGFLAG_FORCENOFRACT                                                                                    \\r
 652     (1                                                                                                                 \\r
 653      << 2) /*!< Force non-fractional output mode, PLL output will not use the fractional, automatic bandwidth, or SS \ \\r
 654                \ \ \                                                                                                   \\r
 655                  \ \ \ \ \                                                                                             \\r
 656                     \ \ \ \ \ \ \                                                                                      \\r
 657                       \ \ \ \ \ \ \ \ \                                                                                \\r
 658                         \ \ \ \ \ \ \ \ \ \ \                                                                          \\r
 659                           hardware */\r
 660 \r
 661 /*! @brief PLL Spread Spectrum (SS) Programmable modulation frequency\r
 662  * See (MF) field in the SYSPLLSSCTRL1 register in the UM.\r
 663  */\r
 664 typedef enum _ss_progmodfm\r
 665 {\r
 666     kSS_MF_512 = (0 << 20), /*!< Nss = 512 (fm ? 3.9 - 7.8 kHz) */\r
 667     kSS_MF_384 = (1 << 20), /*!< Nss ?= 384 (fm ? 5.2 - 10.4 kHz) */\r
 668     kSS_MF_256 = (2 << 20), /*!< Nss = 256 (fm ? 7.8 - 15.6 kHz) */\r
 669     kSS_MF_128 = (3 << 20), /*!< Nss = 128 (fm ? 15.6 - 31.3 kHz) */\r
 670     kSS_MF_64  = (4 << 20), /*!< Nss = 64 (fm ? 32.3 - 64.5 kHz) */\r
 671     kSS_MF_32  = (5 << 20), /*!< Nss = 32 (fm ? 62.5- 125 kHz) */\r
 672     kSS_MF_24  = (6 << 20), /*!< Nss ?= 24 (fm ? 83.3- 166.6 kHz) */\r
 673     kSS_MF_16  = (7 << 20)  /*!< Nss = 16 (fm ? 125- 250 kHz) */\r
 674 } ss_progmodfm_t;\r
 675 \r
 676 /*! @brief PLL Spread Spectrum (SS) Programmable frequency modulation depth\r
 677  * See (MR) field in the SYSPLLSSCTRL1 register in the UM.\r
 678  */\r
 679 typedef enum _ss_progmoddp\r
 680 {\r
 681     kSS_MR_K0   = (0 << 23), /*!< k = 0 (no spread spectrum) */\r
 682     kSS_MR_K1   = (1 << 23), /*!< k = 1 */\r
 683     kSS_MR_K1_5 = (2 << 23), /*!< k = 1.5 */\r
 684     kSS_MR_K2   = (3 << 23), /*!< k = 2 */\r
 685     kSS_MR_K3   = (4 << 23), /*!< k = 3 */\r
 686     kSS_MR_K4   = (5 << 23), /*!< k = 4 */\r
 687     kSS_MR_K6   = (6 << 23), /*!< k = 6 */\r
 688     kSS_MR_K8   = (7 << 23)  /*!< k = 8 */\r
 689 } ss_progmoddp_t;\r
 690 \r
 691 /*! @brief PLL Spread Spectrum (SS) Modulation waveform control\r
 692  * See (MC) field in the SYSPLLSSCTRL1 register in the UM.<br>\r
 693  * Compensation for low pass filtering of the PLL to get a triangular\r
 694  * modulation at the output of the PLL, giving a flat frequency spectrum.\r
 695  */\r
 696 typedef enum _ss_modwvctrl\r
 697 {\r
 698     kSS_MC_NOC  = (0 << 26), /*!< no compensation */\r
 699     kSS_MC_RECC = (2 << 26), /*!< recommended setting */\r
 700     kSS_MC_MAXC = (3 << 26), /*!< max. compensation */\r
 701 } ss_modwvctrl_t;\r
 702 \r
 703 /*! @brief PLL configuration structure\r
 704  *\r
 705  * This structure can be used to configure the settings for a PLL\r
 706  * setup structure. Fill in the desired configuration for the PLL\r
 707  * and call the PLL setup function to fill in a PLL setup structure.\r
 708  */\r
 709 typedef struct _pll_config\r
 710 {\r
 711     uint32_t desiredRate; /*!< Desired PLL rate in Hz */\r
 712     uint32_t inputRate;   /*!< PLL input clock in Hz, only used if PLL_CONFIGFLAG_USEINRATE flag is set */\r
 713     uint32_t flags;       /*!< PLL configuration flags, Or'ed value of PLL_CONFIGFLAG_* definitions */\r
 714     ss_progmodfm_t ss_mf; /*!< SS Programmable modulation frequency, only applicable when not using\r
 715                              PLL_CONFIGFLAG_FORCENOFRACT flag */\r
 716     ss_progmoddp_t ss_mr; /*!< SS Programmable frequency modulation depth, only applicable when not using\r
 717                              PLL_CONFIGFLAG_FORCENOFRACT flag */\r
 718     ss_modwvctrl_t\r
 719         ss_mc; /*!< SS Modulation waveform control, only applicable when not using PLL_CONFIGFLAG_FORCENOFRACT flag */\r
 720     bool mfDither; /*!< false for fixed modulation frequency or true for dithering, only applicable when not using\r
 721                       PLL_CONFIGFLAG_FORCENOFRACT flag */\r
 722 \r
 723 } pll_config_t;\r
 724 \r
 725 /*! @brief PLL setup structure flags for 'flags' field\r
 726  * These flags control how the PLL setup function sets up the PLL\r
 727  */\r
 728 #define PLL_SETUPFLAG_POWERUP (1 << 0)         /*!< Setup will power on the PLL after setup */\r
 729 #define PLL_SETUPFLAG_WAITLOCK (1 << 1)        /*!< Setup will wait for PLL lock, implies the PLL will be pwoered on */\r
 730 #define PLL_SETUPFLAG_ADGVOLT (1 << 2)         /*!< Optimize system voltage for the new PLL rate */\r
 731 #define PLL_SETUPFLAG_USEFEEDBACKDIV2 (1 << 3) /*!< Use feedback divider by 2 in divider path */\r
 732 \r
 733 /*! @brief PLL setup structure\r
 734  * This structure can be used to pre-build a PLL setup configuration\r
 735  * at run-time and quickly set the PLL to the configuration. It can be\r
 736  * populated with the PLL setup function. If powering up or waiting\r
 737  * for PLL lock, the PLL input clock source should be configured prior\r
 738  * to PLL setup.\r
 739  */\r
 740 typedef struct _pll_setup\r
 741 {\r
 742     uint32_t syspllctrl;      /*!< PLL control register SYSPLLCTRL */\r
 743     uint32_t syspllndec;      /*!< PLL NDEC register SYSPLLNDEC */\r
 744     uint32_t syspllpdec;      /*!< PLL PDEC register SYSPLLPDEC */\r
 745     uint32_t syspllssctrl[2]; /*!< PLL SSCTL registers SYSPLLSSCTRL */\r
 746     uint32_t pllRate;         /*!< Acutal PLL rate */\r
 747     uint32_t flags;           /*!< PLL setup flags, Or'ed value of PLL_SETUPFLAG_* definitions */\r
 748 } pll_setup_t;\r
 749 \r
 750 /*! @brief PLL status definitions\r
 751  */\r
 752 typedef enum _pll_error\r
 753 {\r
 754     kStatus_PLL_Success         = MAKE_STATUS(kStatusGroup_Generic, 0), /*!< PLL operation was successful */\r
 755     kStatus_PLL_OutputTooLow    = MAKE_STATUS(kStatusGroup_Generic, 1), /*!< PLL output rate request was too low */\r
 756     kStatus_PLL_OutputTooHigh   = MAKE_STATUS(kStatusGroup_Generic, 2), /*!< PLL output rate request was too high */\r
 757     kStatus_PLL_InputTooLow     = MAKE_STATUS(kStatusGroup_Generic, 3), /*!< PLL input rate is too low */\r
 758     kStatus_PLL_InputTooHigh    = MAKE_STATUS(kStatusGroup_Generic, 4), /*!< PLL input rate is too high */\r
 759     kStatus_PLL_OutsideIntLimit = MAKE_STATUS(kStatusGroup_Generic, 5)  /*!< Requested output rate isn't possible */\r
 760 } pll_error_t;\r
 761 \r
 762 /*! @brief USB clock source definition. */\r
 763 typedef enum _clock_usb_src\r
 764 {\r
 765     kCLOCK_UsbSrcFro       = (uint32_t)kCLOCK_FroHf,      /*!< Use FRO 96 or 48 MHz. */\r
 766     kCLOCK_UsbSrcSystemPll = (uint32_t)kCLOCK_PllOut,     /*!< Use System PLL output. */\r
 767     kCLOCK_UsbSrcMainClock = (uint32_t)kCLOCK_CoreSysClk, /*!< Use Main clock.    */\r
 768     kCLOCK_UsbSrcNone      = SYSCON_USBCLKSEL_SEL(\r
 769         7) /*!< Use None, this may be selected in order to reduce power when no output is needed. */\r
 770 } clock_usb_src_t;\r
 771 \r
 772 /*! @brief      Return System PLL output clock rate from setup structure\r
 773  *  @param      pSetup  : Pointer to a PLL setup structure\r
 774  *  @return     System PLL output clock rate calculated from the setup structure\r
 775  */\r
 776 uint32_t CLOCK_GetSystemPLLOutFromSetup(pll_setup_t *pSetup);\r
 777 \r
 778 /*! @brief      Set PLL output based on the passed PLL setup data\r
 779  *  @param      pControl        : Pointer to populated PLL control structure to generate setup with\r
 780  *  @param      pSetup          : Pointer to PLL setup structure to be filled\r
 781  *  @return     PLL_ERROR_SUCCESS on success, or PLL setup error code\r
 782  *  @note       Actual frequency for setup may vary from the desired frequency based on the\r
 783  *  accuracy of input clocks, rounding, non-fractional PLL mode, etc.\r
 784  */\r
 785 pll_error_t CLOCK_SetupPLLData(pll_config_t *pControl, pll_setup_t *pSetup);\r
 786 \r
 787 /*! @brief      Set PLL output from PLL setup structure (precise frequency)\r
 788  * @param       pSetup  : Pointer to populated PLL setup structure\r
 789  * @param flagcfg : Flag configuration for PLL config structure\r
 790  * @return      PLL_ERROR_SUCCESS on success, or PLL setup error code\r
 791  * @note        This function will power off the PLL, setup the PLL with the\r
 792  * new setup data, and then optionally powerup the PLL, wait for PLL lock,\r
 793  * and adjust system voltages to the new PLL rate. The function will not\r
 794  * alter any source clocks (ie, main systen clock) that may use the PLL,\r
 795  * so these should be setup prior to and after exiting the function.\r
 796  */\r
 797 pll_error_t CLOCK_SetupSystemPLLPrec(pll_setup_t *pSetup, uint32_t flagcfg);\r
 798 \r
 799 /**\r
 800  * @brief       Set PLL output from PLL setup structure (precise frequency)\r
 801  * @param       pSetup  : Pointer to populated PLL setup structure\r
 802  * @return      kStatus_PLL_Success on success, or PLL setup error code\r
 803  * @note        This function will power off the PLL, setup the PLL with the\r
 804  * new setup data, and then optionally powerup the PLL, wait for PLL lock,\r
 805  * and adjust system voltages to the new PLL rate. The function will not\r
 806  * alter any source clocks (ie, main systen clock) that may use the PLL,\r
 807  * so these should be setup prior to and after exiting the function.\r
 808  */\r
 809 pll_error_t CLOCK_SetPLLFreq(const pll_setup_t *pSetup);\r
 810 \r
 811 /*! @brief      Set PLL output based on the multiplier and input frequency\r
 812  * @param       multiply_by     : multiplier\r
 813  * @param       input_freq      : Clock input frequency of the PLL\r
 814  * @return      Nothing\r
 815  * @note        Unlike the Chip_Clock_SetupSystemPLLPrec() function, this\r
 816  * function does not disable or enable PLL power, wait for PLL lock,\r
 817  * or adjust system voltages. These must be done in the application.\r
 818  * The function will not alter any source clocks (ie, main systen clock)\r
 819  * that may use the PLL, so these should be setup prior to and after\r
 820  * exiting the function.\r
 821  */\r
 822 void CLOCK_SetupSystemPLLMult(uint32_t multiply_by, uint32_t input_freq);\r
 823 \r
 824 /*! @brief Disable USB FS clock.\r
 825  *\r
 826  * Disable USB FS clock.\r
 827  */\r
 828 static inline void CLOCK_DisableUsbfs0Clock(void)\r
 829 {\r
 830     CLOCK_DisableClock(kCLOCK_Usbd0);\r
 831 }\r
 832 bool CLOCK_EnableUsbfs0Clock(clock_usb_src_t src, uint32_t freq);\r
 833 \r
 834 /*!\r
 835  * @brief Use DWT to delay at least for some time.\r
 836  *  Please note that, this API will calculate the microsecond period with the maximum devices\r
 837  *  supported CPU frequency, so this API will only delay for at least the given microseconds, if precise\r
 838  *  delay count was needed, please implement a new timer count to achieve this function.\r
 839  *\r
 840  * @param delay_us  Delay time in unit of microsecond.\r
 841  */\r
 842 void SDK_DelayAtLeastUs(uint32_t delay_us);\r
 843 \r
 844 #if defined(__cplusplus)\r
 845 }\r
 846 #endif /* __cplusplus */\r
 847 \r
 848 /*! @} */\r
 849 \r
 850 #endif /* _FSL_CLOCK_H_ */\r