git.leonardobizzoni.com Git - pioneer-stm32/blob

   1 /**\r
   2   ******************************************************************************\r
   3   * @file    stm32f7xx_hal_rcc_ex.c\r
   4   * @author  MCD Application Team\r
   5   * @brief   Extension RCC HAL module driver.\r
   6   *          This file provides firmware functions to manage the following\r
   7   *          functionalities RCC extension peripheral:\r
   8   *           + Extended Peripheral Control functions\r
   9   *\r
  10   ******************************************************************************\r
  11   * @attention\r
  12   *\r
  13   * <h2><center>&copy; Copyright (c) 2017 STMicroelectronics.\r
  14   * All rights reserved.</center></h2>\r
  15   *\r
  16   * This software component is licensed by ST under BSD 3-Clause license,\r
  17   * the "License"; You may not use this file except in compliance with the\r
  18   * License. You may obtain a copy of the License at:\r
  19   *                        opensource.org/licenses/BSD-3-Clause\r
  20   *\r
  21   ******************************************************************************\r
  22   */\r
  23 \r
  24 /* Includes ------------------------------------------------------------------*/\r
  25 #include "stm32f7xx_hal.h"\r
  26 \r
  27 /** @addtogroup STM32F7xx_HAL_Driver\r
  28   * @{\r
  29   */\r
  30 \r
  31 /** @defgroup RCCEx RCCEx\r
  32   * @brief RCCEx HAL module driver\r
  33   * @{\r
  34   */\r
  35 \r
  36 #ifdef HAL_RCC_MODULE_ENABLED\r
  37 \r
  38 /* Private typedef -----------------------------------------------------------*/\r
  39 /* Private define ------------------------------------------------------------*/\r
  40 /** @defgroup RCCEx_Private_Defines RCCEx Private Defines\r
  41   * @{\r
  42   */\r
  43 /**\r
  44   * @}\r
  45   */\r
  46 /* Private macro -------------------------------------------------------------*/\r
  47 /** @defgroup RCCEx_Private_Macros RCCEx Private Macros\r
  48  * @{\r
  49  */\r
  50 /**\r
  51   * @}\r
  52   */\r
  53 \r
  54 /** @defgroup RCCEx_Private_Macros RCCEx Private Macros\r
  55  * @{\r
  56  */\r
  57 \r
  58 /**\r
  59   * @}\r
  60   */\r
  61 \r
  62 \r
  63 /* Private variables ---------------------------------------------------------*/\r
  64 /* Private function prototypes -----------------------------------------------*/\r
  65 /* Private functions ---------------------------------------------------------*/\r
  66 \r
  67 /** @defgroup RCCEx_Exported_Functions RCCEx Exported Functions\r
  68   * @{\r
  69   */\r
  70 \r
  71 /** @defgroup RCCEx_Exported_Functions_Group1 Extended Peripheral Control functions\r
  72  *  @brief  Extended Peripheral Control functions\r
  73  *\r
  74 @verbatim\r
  75  ===============================================================================\r
  76                 ##### Extended Peripheral Control functions  #####\r
  77  ===============================================================================\r
  78     [..]\r
  79     This subsection provides a set of functions allowing to control the RCC Clocks\r
  80     frequencies.\r
  81     [..]\r
  82     (@) Important note: Care must be taken when HAL_RCCEx_PeriphCLKConfig() is used to\r
  83         select the RTC clock source; in this case the Backup domain will be reset in\r
  84         order to modify the RTC Clock source, as consequence RTC registers (including\r
  85         the backup registers) and RCC_BDCR register will be set to their reset values.\r
  86 \r
  87 @endverbatim\r
  88   * @{\r
  89   */\r
  90 #if defined (STM32F745xx) || defined (STM32F746xx) || defined (STM32F756xx) || defined (STM32F765xx) || \\r
  91     defined (STM32F767xx) || defined (STM32F769xx) || defined (STM32F777xx) || defined (STM32F779xx) || \\r
  92     defined (STM32F750xx)\r
  93 /**\r
  94   * @brief  Initializes the RCC extended peripherals clocks according to the specified\r
  95   *         parameters in the RCC_PeriphCLKInitTypeDef.\r
  96   * @param  PeriphClkInit pointer to an RCC_PeriphCLKInitTypeDef structure that\r
  97   *         contains the configuration information for the Extended Peripherals\r
  98   *         clocks(I2S, SAI, LTDC, RTC, TIM, UARTs, USARTs, LTPIM, SDMMC...).\r
  99   *\r
 100   * @note   Care must be taken when HAL_RCCEx_PeriphCLKConfig() is used to select\r
 101   *         the RTC clock source; in this case the Backup domain will be reset in\r
 102   *         order to modify the RTC Clock source, as consequence RTC registers (including\r
 103   *         the backup registers) are set to their reset values.\r
 104   *\r
 105   * @retval HAL status\r
 106   */\r
 107 HAL_StatusTypeDef HAL_RCCEx_PeriphCLKConfig(RCC_PeriphCLKInitTypeDef  *PeriphClkInit)\r
 108 {\r
 109   uint32_t tickstart = 0;\r
 110   uint32_t tmpreg0 = 0;\r
 111   uint32_t tmpreg1 = 0;\r
 112   uint32_t plli2sused = 0;\r
 113   uint32_t pllsaiused = 0;\r
 114 \r
 115   /* Check the parameters */\r
 116   assert_param(IS_RCC_PERIPHCLOCK(PeriphClkInit->PeriphClockSelection));\r
 117 \r
 118   /*----------------------------------- I2S configuration ----------------------------------*/\r
 119   if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_I2S) == (RCC_PERIPHCLK_I2S))\r
 120   {\r
 121     /* Check the parameters */\r
 122     assert_param(IS_RCC_I2SCLKSOURCE(PeriphClkInit->I2sClockSelection));\r
 123 \r
 124     /* Configure I2S Clock source */\r
 125     __HAL_RCC_I2S_CONFIG(PeriphClkInit->I2sClockSelection);\r
 126 \r
 127     /* Enable the PLLI2S when it's used as clock source for I2S */\r
 128     if(PeriphClkInit->I2sClockSelection == RCC_I2SCLKSOURCE_PLLI2S)\r
 129     {\r
 130       plli2sused = 1;\r
 131     }\r
 132   }\r
 133 \r
 134   /*------------------------------------ SAI1 configuration --------------------------------------*/\r
 135   if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_SAI1) == (RCC_PERIPHCLK_SAI1))\r
 136   {\r
 137     /* Check the parameters */\r
 138     assert_param(IS_RCC_SAI1CLKSOURCE(PeriphClkInit->Sai1ClockSelection));\r
 139 \r
 140     /* Configure SAI1 Clock source */\r
 141     __HAL_RCC_SAI1_CONFIG(PeriphClkInit->Sai1ClockSelection);\r
 142     /* Enable the PLLI2S when it's used as clock source for SAI */\r
 143     if(PeriphClkInit->Sai1ClockSelection == RCC_SAI1CLKSOURCE_PLLI2S)\r
 144     {\r
 145       plli2sused = 1;\r
 146     }\r
 147     /* Enable the PLLSAI when it's used as clock source for SAI */\r
 148     if(PeriphClkInit->Sai1ClockSelection == RCC_SAI1CLKSOURCE_PLLSAI)\r
 149     {\r
 150       pllsaiused = 1;\r
 151     }\r
 152   }\r
 153 \r
 154   /*------------------------------------ SAI2 configuration --------------------------------------*/\r
 155   if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_SAI2) == (RCC_PERIPHCLK_SAI2))\r
 156   {\r
 157     /* Check the parameters */\r
 158     assert_param(IS_RCC_SAI2CLKSOURCE(PeriphClkInit->Sai2ClockSelection));\r
 159 \r
 160     /* Configure SAI2 Clock source */\r
 161     __HAL_RCC_SAI2_CONFIG(PeriphClkInit->Sai2ClockSelection);\r
 162 \r
 163     /* Enable the PLLI2S when it's used as clock source for SAI */\r
 164     if(PeriphClkInit->Sai2ClockSelection == RCC_SAI2CLKSOURCE_PLLI2S)\r
 165     {\r
 166       plli2sused = 1;\r
 167     }\r
 168     /* Enable the PLLSAI when it's used as clock source for SAI */\r
 169     if(PeriphClkInit->Sai2ClockSelection == RCC_SAI2CLKSOURCE_PLLSAI)\r
 170     {\r
 171       pllsaiused = 1;\r
 172     }\r
 173   }\r
 174 \r
 175   /*-------------------------------------- SPDIF-RX Configuration -----------------------------------*/\r
 176   if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_SPDIFRX) == RCC_PERIPHCLK_SPDIFRX)\r
 177   {\r
 178       plli2sused = 1;\r
 179   }\r
 180 \r
 181   /*------------------------------------ RTC configuration --------------------------------------*/\r
 182   if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_RTC) == (RCC_PERIPHCLK_RTC))\r
 183   {\r
 184     /* Check for RTC Parameters used to output RTCCLK */\r
 185     assert_param(IS_RCC_RTCCLKSOURCE(PeriphClkInit->RTCClockSelection));\r
 186 \r
 187     /* Enable Power Clock*/\r
 188     __HAL_RCC_PWR_CLK_ENABLE();\r
 189 \r
 190     /* Enable write access to Backup domain */\r
 191     PWR->CR1 |= PWR_CR1_DBP;\r
 192 \r
 193     /* Get Start Tick*/\r
 194     tickstart = HAL_GetTick();\r
 195 \r
 196     /* Wait for Backup domain Write protection disable */\r
 197     while((PWR->CR1 & PWR_CR1_DBP) == RESET)\r
 198     {\r
 199       if((HAL_GetTick() - tickstart) > RCC_DBP_TIMEOUT_VALUE)\r
 200       {\r
 201         return HAL_TIMEOUT;\r
 202       }\r
 203     }\r
 204 \r
 205     /* Reset the Backup domain only if the RTC Clock source selection is modified */\r
 206     tmpreg0 = (RCC->BDCR & RCC_BDCR_RTCSEL);\r
 207 \r
 208     if((tmpreg0 != 0x00000000U) && (tmpreg0 != (PeriphClkInit->RTCClockSelection & RCC_BDCR_RTCSEL)))\r
 209     {\r
 210       /* Store the content of BDCR register before the reset of Backup Domain */\r
 211       tmpreg0 = (RCC->BDCR & ~(RCC_BDCR_RTCSEL));\r
 212 \r
 213       /* RTC Clock selection can be changed only if the Backup Domain is reset */\r
 214       __HAL_RCC_BACKUPRESET_FORCE();\r
 215       __HAL_RCC_BACKUPRESET_RELEASE();\r
 216 \r
 217       /* Restore the Content of BDCR register */\r
 218       RCC->BDCR = tmpreg0;\r
 219 \r
 220       /* Wait for LSE reactivation if LSE was enable prior to Backup Domain reset */\r
 221       if (HAL_IS_BIT_SET(RCC->BDCR, RCC_BDCR_LSEON))\r
 222       {\r
 223         /* Get Start Tick*/\r
 224         tickstart = HAL_GetTick();\r
 225 \r
 226         /* Wait till LSE is ready */\r
 227         while(__HAL_RCC_GET_FLAG(RCC_FLAG_LSERDY) == RESET)\r
 228         {\r
 229           if((HAL_GetTick() - tickstart ) > RCC_LSE_TIMEOUT_VALUE)\r
 230           {\r
 231             return HAL_TIMEOUT;\r
 232           }\r
 233         }\r
 234       }\r
 235     }\r
 236     __HAL_RCC_RTC_CONFIG(PeriphClkInit->RTCClockSelection);\r
 237   }\r
 238 \r
 239   /*------------------------------------ TIM configuration --------------------------------------*/\r
 240   if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_TIM) == (RCC_PERIPHCLK_TIM))\r
 241   {\r
 242     /* Check the parameters */\r
 243     assert_param(IS_RCC_TIMPRES(PeriphClkInit->TIMPresSelection));\r
 244 \r
 245     /* Configure Timer Prescaler */\r
 246     __HAL_RCC_TIMCLKPRESCALER(PeriphClkInit->TIMPresSelection);\r
 247   }\r
 248 \r
 249   /*-------------------------------------- I2C1 Configuration -----------------------------------*/\r
 250   if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_I2C1) == RCC_PERIPHCLK_I2C1)\r
 251   {\r
 252     /* Check the parameters */\r
 253     assert_param(IS_RCC_I2C1CLKSOURCE(PeriphClkInit->I2c1ClockSelection));\r
 254 \r
 255     /* Configure the I2C1 clock source */\r
 256     __HAL_RCC_I2C1_CONFIG(PeriphClkInit->I2c1ClockSelection);\r
 257   }\r
 258 \r
 259   /*-------------------------------------- I2C2 Configuration -----------------------------------*/\r
 260   if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_I2C2) == RCC_PERIPHCLK_I2C2)\r
 261   {\r
 262     /* Check the parameters */\r
 263     assert_param(IS_RCC_I2C2CLKSOURCE(PeriphClkInit->I2c2ClockSelection));\r
 264 \r
 265     /* Configure the I2C2 clock source */\r
 266     __HAL_RCC_I2C2_CONFIG(PeriphClkInit->I2c2ClockSelection);\r
 267   }\r
 268 \r
 269   /*-------------------------------------- I2C3 Configuration -----------------------------------*/\r
 270   if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_I2C3) == RCC_PERIPHCLK_I2C3)\r
 271   {\r
 272     /* Check the parameters */\r
 273     assert_param(IS_RCC_I2C3CLKSOURCE(PeriphClkInit->I2c3ClockSelection));\r
 274 \r
 275     /* Configure the I2C3 clock source */\r
 276     __HAL_RCC_I2C3_CONFIG(PeriphClkInit->I2c3ClockSelection);\r
 277   }\r
 278 \r
 279   /*-------------------------------------- I2C4 Configuration -----------------------------------*/\r
 280   if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_I2C4) == RCC_PERIPHCLK_I2C4)\r
 281   {\r
 282     /* Check the parameters */\r
 283     assert_param(IS_RCC_I2C4CLKSOURCE(PeriphClkInit->I2c4ClockSelection));\r
 284 \r
 285     /* Configure the I2C4 clock source */\r
 286     __HAL_RCC_I2C4_CONFIG(PeriphClkInit->I2c4ClockSelection);\r
 287   }\r
 288 \r
 289   /*-------------------------------------- USART1 Configuration -----------------------------------*/\r
 290   if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_USART1) == RCC_PERIPHCLK_USART1)\r
 291   {\r
 292     /* Check the parameters */\r
 293     assert_param(IS_RCC_USART1CLKSOURCE(PeriphClkInit->Usart1ClockSelection));\r
 294 \r
 295     /* Configure the USART1 clock source */\r
 296     __HAL_RCC_USART1_CONFIG(PeriphClkInit->Usart1ClockSelection);\r
 297   }\r
 298 \r
 299   /*-------------------------------------- USART2 Configuration -----------------------------------*/\r
 300   if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_USART2) == RCC_PERIPHCLK_USART2)\r
 301   {\r
 302     /* Check the parameters */\r
 303     assert_param(IS_RCC_USART2CLKSOURCE(PeriphClkInit->Usart2ClockSelection));\r
 304 \r
 305     /* Configure the USART2 clock source */\r
 306     __HAL_RCC_USART2_CONFIG(PeriphClkInit->Usart2ClockSelection);\r
 307   }\r
 308 \r
 309   /*-------------------------------------- USART3 Configuration -----------------------------------*/\r
 310   if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_USART3) == RCC_PERIPHCLK_USART3)\r
 311   {\r
 312     /* Check the parameters */\r
 313     assert_param(IS_RCC_USART3CLKSOURCE(PeriphClkInit->Usart3ClockSelection));\r
 314 \r
 315     /* Configure the USART3 clock source */\r
 316     __HAL_RCC_USART3_CONFIG(PeriphClkInit->Usart3ClockSelection);\r
 317   }\r
 318 \r
 319   /*-------------------------------------- UART4 Configuration -----------------------------------*/\r
 320   if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_UART4) == RCC_PERIPHCLK_UART4)\r
 321   {\r
 322     /* Check the parameters */\r
 323     assert_param(IS_RCC_UART4CLKSOURCE(PeriphClkInit->Uart4ClockSelection));\r
 324 \r
 325     /* Configure the UART4 clock source */\r
 326     __HAL_RCC_UART4_CONFIG(PeriphClkInit->Uart4ClockSelection);\r
 327   }\r
 328 \r
 329   /*-------------------------------------- UART5 Configuration -----------------------------------*/\r
 330   if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_UART5) == RCC_PERIPHCLK_UART5)\r
 331   {\r
 332     /* Check the parameters */\r
 333     assert_param(IS_RCC_UART5CLKSOURCE(PeriphClkInit->Uart5ClockSelection));\r
 334 \r
 335     /* Configure the UART5 clock source */\r
 336     __HAL_RCC_UART5_CONFIG(PeriphClkInit->Uart5ClockSelection);\r
 337   }\r
 338 \r
 339   /*-------------------------------------- USART6 Configuration -----------------------------------*/\r
 340   if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_USART6) == RCC_PERIPHCLK_USART6)\r
 341   {\r
 342     /* Check the parameters */\r
 343     assert_param(IS_RCC_USART6CLKSOURCE(PeriphClkInit->Usart6ClockSelection));\r
 344 \r
 345     /* Configure the USART6 clock source */\r
 346     __HAL_RCC_USART6_CONFIG(PeriphClkInit->Usart6ClockSelection);\r
 347   }\r
 348 \r
 349   /*-------------------------------------- UART7 Configuration -----------------------------------*/\r
 350   if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_UART7) == RCC_PERIPHCLK_UART7)\r
 351   {\r
 352     /* Check the parameters */\r
 353     assert_param(IS_RCC_UART7CLKSOURCE(PeriphClkInit->Uart7ClockSelection));\r
 354 \r
 355     /* Configure the UART7 clock source */\r
 356     __HAL_RCC_UART7_CONFIG(PeriphClkInit->Uart7ClockSelection);\r
 357   }\r
 358 \r
 359   /*-------------------------------------- UART8 Configuration -----------------------------------*/\r
 360   if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_UART8) == RCC_PERIPHCLK_UART8)\r
 361   {\r
 362     /* Check the parameters */\r
 363     assert_param(IS_RCC_UART8CLKSOURCE(PeriphClkInit->Uart8ClockSelection));\r
 364 \r
 365     /* Configure the UART8 clock source */\r
 366     __HAL_RCC_UART8_CONFIG(PeriphClkInit->Uart8ClockSelection);\r
 367   }\r
 368 \r
 369   /*--------------------------------------- CEC Configuration -----------------------------------*/\r
 370   if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_CEC) == RCC_PERIPHCLK_CEC)\r
 371   {\r
 372     /* Check the parameters */\r
 373     assert_param(IS_RCC_CECCLKSOURCE(PeriphClkInit->CecClockSelection));\r
 374 \r
 375     /* Configure the CEC clock source */\r
 376     __HAL_RCC_CEC_CONFIG(PeriphClkInit->CecClockSelection);\r
 377   }\r
 378 \r
 379   /*-------------------------------------- CK48 Configuration -----------------------------------*/\r
 380   if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_CLK48) == RCC_PERIPHCLK_CLK48)\r
 381   {\r
 382     /* Check the parameters */\r
 383     assert_param(IS_RCC_CLK48SOURCE(PeriphClkInit->Clk48ClockSelection));\r
 384 \r
 385     /* Configure the CLK48 source */\r
 386     __HAL_RCC_CLK48_CONFIG(PeriphClkInit->Clk48ClockSelection);\r
 387 \r
 388     /* Enable the PLLSAI when it's used as clock source for CK48 */\r
 389     if(PeriphClkInit->Clk48ClockSelection == RCC_CLK48SOURCE_PLLSAIP)\r
 390     {\r
 391       pllsaiused = 1;\r
 392     }\r
 393   }\r
 394 \r
 395   /*-------------------------------------- LTDC Configuration -----------------------------------*/\r
 396 #if defined(STM32F746xx) || defined(STM32F756xx) || defined (STM32F767xx) || defined (STM32F769xx) || defined (STM32F777xx) || defined (STM32F779xx) || defined (STM32F750xx)\r
 397   if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_LTDC) == RCC_PERIPHCLK_LTDC)\r
 398   {\r
 399     pllsaiused = 1;\r
 400   }\r
 401 #endif /* STM32F746xx || STM32F756xx || STM32F767xx || STM32F769xx || STM32F777xx || STM32F779xx || STM32F750xx */\r
 402 \r
 403   /*-------------------------------------- LPTIM1 Configuration -----------------------------------*/\r
 404   if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_LPTIM1) == RCC_PERIPHCLK_LPTIM1)\r
 405   {\r
 406     /* Check the parameters */\r
 407     assert_param(IS_RCC_LPTIM1CLK(PeriphClkInit->Lptim1ClockSelection));\r
 408 \r
 409     /* Configure the LTPIM1 clock source */\r
 410     __HAL_RCC_LPTIM1_CONFIG(PeriphClkInit->Lptim1ClockSelection);\r
 411    }\r
 412 \r
 413   /*------------------------------------- SDMMC1 Configuration ------------------------------------*/\r
 414   if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_SDMMC1) == RCC_PERIPHCLK_SDMMC1)\r
 415   {\r
 416     /* Check the parameters */\r
 417     assert_param(IS_RCC_SDMMC1CLKSOURCE(PeriphClkInit->Sdmmc1ClockSelection));\r
 418 \r
 419     /* Configure the SDMMC1 clock source */\r
 420     __HAL_RCC_SDMMC1_CONFIG(PeriphClkInit->Sdmmc1ClockSelection);\r
 421   }\r
 422 \r
 423 #if defined (STM32F765xx) || defined (STM32F767xx) || defined (STM32F769xx) || defined (STM32F777xx) || defined (STM32F779xx)\r
 424   /*------------------------------------- SDMMC2 Configuration ------------------------------------*/\r
 425   if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_SDMMC2) == RCC_PERIPHCLK_SDMMC2)\r
 426   {\r
 427     /* Check the parameters */\r
 428     assert_param(IS_RCC_SDMMC2CLKSOURCE(PeriphClkInit->Sdmmc2ClockSelection));\r
 429 \r
 430     /* Configure the SDMMC2 clock source */\r
 431     __HAL_RCC_SDMMC2_CONFIG(PeriphClkInit->Sdmmc2ClockSelection);\r
 432   }\r
 433 \r
 434   /*------------------------------------- DFSDM1 Configuration -------------------------------------*/\r
 435   if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_DFSDM1) == RCC_PERIPHCLK_DFSDM1)\r
 436   {\r
 437     /* Check the parameters */\r
 438     assert_param(IS_RCC_DFSDM1CLKSOURCE(PeriphClkInit->Dfsdm1ClockSelection));\r
 439 \r
 440     /* Configure the DFSDM1 interface clock source */\r
 441     __HAL_RCC_DFSDM1_CONFIG(PeriphClkInit->Dfsdm1ClockSelection);\r
 442   }\r
 443 \r
 444   /*------------------------------------- DFSDM AUDIO Configuration -------------------------------------*/\r
 445   if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_DFSDM1_AUDIO) == RCC_PERIPHCLK_DFSDM1_AUDIO)\r
 446   {\r
 447     /* Check the parameters */\r
 448     assert_param(IS_RCC_DFSDM1AUDIOCLKSOURCE(PeriphClkInit->Dfsdm1AudioClockSelection));\r
 449 \r
 450     /* Configure the DFSDM interface clock source */\r
 451     __HAL_RCC_DFSDM1AUDIO_CONFIG(PeriphClkInit->Dfsdm1AudioClockSelection);\r
 452   }\r
 453 #endif /* STM32F767xx || STM32F769xx || STM32F777xx || STM32F779xx */\r
 454 \r
 455   /*-------------------------------------- PLLI2S Configuration ---------------------------------*/\r
 456   /* PLLI2S is configured when a peripheral will use it as source clock : SAI1, SAI2, I2S or SPDIF-RX */\r
 457   if((plli2sused == 1) || (PeriphClkInit->PeriphClockSelection == RCC_PERIPHCLK_PLLI2S))\r
 458   {\r
 459     /* Disable the PLLI2S */\r
 460     __HAL_RCC_PLLI2S_DISABLE();\r
 461 \r
 462     /* Get Start Tick*/\r
 463     tickstart = HAL_GetTick();\r
 464 \r
 465     /* Wait till PLLI2S is disabled */\r
 466     while(__HAL_RCC_GET_FLAG(RCC_FLAG_PLLI2SRDY)  != RESET)\r
 467     {\r
 468       if((HAL_GetTick() - tickstart) > PLLI2S_TIMEOUT_VALUE)\r
 469       {\r
 470         /* return in case of Timeout detected */\r
 471         return HAL_TIMEOUT;\r
 472       }\r
 473     }\r
 474 \r
 475     /* check for common PLLI2S Parameters */\r
 476     assert_param(IS_RCC_PLLI2SN_VALUE(PeriphClkInit->PLLI2S.PLLI2SN));\r
 477 \r
 478     /*----------------- In Case of PLLI2S is selected as source clock for I2S -------------------*/\r
 479     if(((((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_I2S) == RCC_PERIPHCLK_I2S) && (PeriphClkInit->I2sClockSelection == RCC_I2SCLKSOURCE_PLLI2S)))\r
 480     {\r
 481       /* check for Parameters */\r
 482       assert_param(IS_RCC_PLLI2SR_VALUE(PeriphClkInit->PLLI2S.PLLI2SR));\r
 483 \r
 484       /* Read PLLI2SP and PLLI2SQ value from PLLI2SCFGR register (this value is not needed for I2S configuration) */\r
 485       tmpreg0 = ((RCC->PLLI2SCFGR & RCC_PLLI2SCFGR_PLLI2SP) >> RCC_PLLI2SCFGR_PLLI2SP_Pos);\r
 486       tmpreg1 = ((RCC->PLLI2SCFGR & RCC_PLLI2SCFGR_PLLI2SQ) >> RCC_PLLI2SCFGR_PLLI2SQ_Pos);\r
 487       /* Configure the PLLI2S division factors */\r
 488       /* PLLI2S_VCO = f(VCO clock) = f(PLLI2S clock input) x (PLLI2SN/PLLM) */\r
 489       /* I2SCLK = f(PLLI2S clock output) = f(VCO clock) / PLLI2SR */\r
 490       __HAL_RCC_PLLI2S_CONFIG(PeriphClkInit->PLLI2S.PLLI2SN , tmpreg0, tmpreg1, PeriphClkInit->PLLI2S.PLLI2SR);\r
 491     }\r
 492 \r
 493     /*----------------- In Case of PLLI2S is selected as source clock for SAI -------------------*/\r
 494     if(((((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_SAI1) == RCC_PERIPHCLK_SAI1) && (PeriphClkInit->Sai1ClockSelection == RCC_SAI1CLKSOURCE_PLLI2S)) ||\r
 495        ((((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_SAI2) == RCC_PERIPHCLK_SAI2) && (PeriphClkInit->Sai2ClockSelection == RCC_SAI2CLKSOURCE_PLLI2S)))\r
 496     {\r
 497       /* Check for PLLI2S Parameters */\r
 498       assert_param(IS_RCC_PLLI2SQ_VALUE(PeriphClkInit->PLLI2S.PLLI2SQ));\r
 499       /* Check for PLLI2S/DIVQ parameters */\r
 500       assert_param(IS_RCC_PLLI2S_DIVQ_VALUE(PeriphClkInit->PLLI2SDivQ));\r
 501 \r
 502       /* Read PLLI2SP and PLLI2SR values from PLLI2SCFGR register (this value is not needed for SAI configuration) */\r
 503       tmpreg0 = ((RCC->PLLI2SCFGR & RCC_PLLI2SCFGR_PLLI2SP) >> RCC_PLLI2SCFGR_PLLI2SP_Pos);\r
 504       tmpreg1 = ((RCC->PLLI2SCFGR & RCC_PLLI2SCFGR_PLLI2SR) >> RCC_PLLI2SCFGR_PLLI2SR_Pos);\r
 505       /* Configure the PLLI2S division factors */\r
 506       /* PLLI2S_VCO Input  = PLL_SOURCE/PLLM */\r
 507       /* PLLI2S_VCO Output = PLLI2S_VCO Input * PLLI2SN */\r
 508       /* SAI_CLK(first level) = PLLI2S_VCO Output/PLLI2SQ */\r
 509       __HAL_RCC_PLLI2S_CONFIG(PeriphClkInit->PLLI2S.PLLI2SN, tmpreg0, PeriphClkInit->PLLI2S.PLLI2SQ, tmpreg1);\r
 510 \r
 511       /* SAI_CLK_x = SAI_CLK(first level)/PLLI2SDIVQ */\r
 512       __HAL_RCC_PLLI2S_PLLSAICLKDIVQ_CONFIG(PeriphClkInit->PLLI2SDivQ);\r
 513     }\r
 514 \r
 515     /*----------------- In Case of PLLI2S is selected as source clock for SPDIF-RX -------------------*/\r
 516     if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_SPDIFRX) == RCC_PERIPHCLK_SPDIFRX)\r
 517     {\r
 518       /* check for Parameters */\r
 519       assert_param(IS_RCC_PLLI2SP_VALUE(PeriphClkInit->PLLI2S.PLLI2SP));\r
 520 \r
 521      /* Read PLLI2SR value from PLLI2SCFGR register (this value is not needed for SPDIF-RX configuration) */\r
 522       tmpreg0 = ((RCC->PLLI2SCFGR & RCC_PLLI2SCFGR_PLLI2SQ) >> RCC_PLLI2SCFGR_PLLI2SQ_Pos);\r
 523       tmpreg1 = ((RCC->PLLI2SCFGR & RCC_PLLI2SCFGR_PLLI2SR) >> RCC_PLLI2SCFGR_PLLI2SR_Pos);\r
 524       /* Configure the PLLI2S division factors */\r
 525       /* PLLI2S_VCO = f(VCO clock) = f(PLLI2S clock input) x (PLLI2SN/PLLM) */\r
 526       /* SPDIFCLK = f(PLLI2S clock output) = f(VCO clock) / PLLI2SP */\r
 527       __HAL_RCC_PLLI2S_CONFIG(PeriphClkInit->PLLI2S.PLLI2SN , PeriphClkInit->PLLI2S.PLLI2SP, tmpreg0, tmpreg1);\r
 528     }\r
 529 \r
 530     /*----------------- In Case of PLLI2S is just selected  -----------------*/\r
 531     if((PeriphClkInit->PeriphClockSelection & RCC_PERIPHCLK_PLLI2S) == RCC_PERIPHCLK_PLLI2S)\r
 532     {\r
 533       /* Check for Parameters */\r
 534       assert_param(IS_RCC_PLLI2SP_VALUE(PeriphClkInit->PLLI2S.PLLI2SP));\r
 535       assert_param(IS_RCC_PLLI2SR_VALUE(PeriphClkInit->PLLI2S.PLLI2SR));\r
 536       assert_param(IS_RCC_PLLI2SQ_VALUE(PeriphClkInit->PLLI2S.PLLI2SQ));\r
 537 \r
 538       /* Configure the PLLI2S division factors */\r
 539       /* PLLI2S_VCO = f(VCO clock) = f(PLLI2S clock input) x (PLLI2SN/PLLI2SM) */\r
 540       /* SPDIFRXCLK = f(PLLI2S clock output) = f(VCO clock) / PLLI2SP */\r
 541       __HAL_RCC_PLLI2S_CONFIG(PeriphClkInit->PLLI2S.PLLI2SN , PeriphClkInit->PLLI2S.PLLI2SP, PeriphClkInit->PLLI2S.PLLI2SQ, PeriphClkInit->PLLI2S.PLLI2SR);\r
 542     }\r
 543 \r
 544     /* Enable the PLLI2S */\r
 545     __HAL_RCC_PLLI2S_ENABLE();\r
 546 \r
 547     /* Get Start Tick*/\r
 548     tickstart = HAL_GetTick();\r
 549 \r
 550     /* Wait till PLLI2S is ready */\r
 551     while(__HAL_RCC_GET_FLAG(RCC_FLAG_PLLI2SRDY)  == RESET)\r
 552     {\r
 553       if((HAL_GetTick() - tickstart) > PLLI2S_TIMEOUT_VALUE)\r
 554       {\r
 555         /* return in case of Timeout detected */\r
 556         return HAL_TIMEOUT;\r
 557       }\r
 558     }\r
 559   }\r
 560 \r
 561   /*-------------------------------------- PLLSAI Configuration ---------------------------------*/\r
 562   /* PLLSAI is configured when a peripheral will use it as source clock : SAI1, SAI2, LTDC or CK48 */\r
 563   if(pllsaiused == 1)\r
 564   {\r
 565     /* Disable PLLSAI Clock */\r
 566     __HAL_RCC_PLLSAI_DISABLE();\r
 567 \r
 568     /* Get Start Tick*/\r
 569     tickstart = HAL_GetTick();\r
 570 \r
 571     /* Wait till PLLSAI is disabled */\r
 572     while(__HAL_RCC_PLLSAI_GET_FLAG() != RESET)\r
 573     {\r
 574       if((HAL_GetTick() - tickstart) > PLLSAI_TIMEOUT_VALUE)\r
 575       {\r
 576         /* return in case of Timeout detected */\r
 577         return HAL_TIMEOUT;\r
 578       }\r
 579     }\r
 580 \r
 581     /* Check the PLLSAI division factors */\r
 582     assert_param(IS_RCC_PLLSAIN_VALUE(PeriphClkInit->PLLSAI.PLLSAIN));\r
 583 \r
 584     /*----------------- In Case of PLLSAI is selected as source clock for SAI -------------------*/\r
 585     if(((((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_SAI1) == RCC_PERIPHCLK_SAI1) && (PeriphClkInit->Sai1ClockSelection == RCC_SAI1CLKSOURCE_PLLSAI)) ||\\r
 586        ((((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_SAI2) == RCC_PERIPHCLK_SAI2) && (PeriphClkInit->Sai2ClockSelection == RCC_SAI2CLKSOURCE_PLLSAI)))\r
 587     {\r
 588       /* check for PLLSAIQ Parameter */\r
 589       assert_param(IS_RCC_PLLSAIQ_VALUE(PeriphClkInit->PLLSAI.PLLSAIQ));\r
 590       /* check for PLLSAI/DIVQ Parameter */\r
 591       assert_param(IS_RCC_PLLSAI_DIVQ_VALUE(PeriphClkInit->PLLSAIDivQ));\r
 592 \r
 593       /* Read PLLSAIP value from PLLSAICFGR register (this value is not needed for SAI configuration) */\r
 594       tmpreg0 = ((RCC->PLLSAICFGR & RCC_PLLSAICFGR_PLLSAIP) >> RCC_PLLSAICFGR_PLLSAIP_Pos);\r
 595       tmpreg1 = ((RCC->PLLSAICFGR & RCC_PLLI2SCFGR_PLLI2SR) >> RCC_PLLSAICFGR_PLLSAIR_Pos);\r
 596       /* PLLSAI_VCO Input  = PLL_SOURCE/PLLM */\r
 597       /* PLLSAI_VCO Output = PLLSAI_VCO Input * PLLSAIN */\r
 598       /* SAI_CLK(first level) = PLLSAI_VCO Output/PLLSAIQ */\r
 599       __HAL_RCC_PLLSAI_CONFIG(PeriphClkInit->PLLSAI.PLLSAIN , tmpreg0, PeriphClkInit->PLLSAI.PLLSAIQ, tmpreg1);\r
 600 \r
 601       /* SAI_CLK_x = SAI_CLK(first level)/PLLSAIDIVQ */\r
 602       __HAL_RCC_PLLSAI_PLLSAICLKDIVQ_CONFIG(PeriphClkInit->PLLSAIDivQ);\r
 603     }\r
 604 \r
 605     /*----------------- In Case of PLLSAI is selected as source clock for CLK48 -------------------*/\r
 606     /* In Case of PLLI2S is selected as source clock for CK48 */\r
 607     if((((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_CLK48) == RCC_PERIPHCLK_CLK48) && (PeriphClkInit->Clk48ClockSelection == RCC_CLK48SOURCE_PLLSAIP))\r
 608     {\r
 609       /* check for Parameters */\r
 610       assert_param(IS_RCC_PLLSAIP_VALUE(PeriphClkInit->PLLSAI.PLLSAIP));\r
 611       /* Read PLLSAIQ and PLLSAIR value from PLLSAICFGR register (this value is not needed for CK48 configuration) */\r
 612       tmpreg0 = ((RCC->PLLSAICFGR & RCC_PLLSAICFGR_PLLSAIQ) >> RCC_PLLSAICFGR_PLLSAIQ_Pos);\r
 613       tmpreg1 = ((RCC->PLLSAICFGR & RCC_PLLSAICFGR_PLLSAIR) >> RCC_PLLSAICFGR_PLLSAIR_Pos);\r
 614 \r
 615       /* Configure the PLLSAI division factors */\r
 616       /* PLLSAI_VCO = f(VCO clock) = f(PLLSAI clock input) x (PLLI2SN/PLLM) */\r
 617       /* 48CLK = f(PLLSAI clock output) = f(VCO clock) / PLLSAIP */\r
 618       __HAL_RCC_PLLSAI_CONFIG(PeriphClkInit->PLLSAI.PLLSAIN , PeriphClkInit->PLLSAI.PLLSAIP, tmpreg0, tmpreg1);\r
 619     }\r
 620 \r
 621 #if defined(STM32F746xx) || defined(STM32F756xx) || defined (STM32F767xx) || defined (STM32F769xx) || defined (STM32F777xx) || defined (STM32F779xx) || defined (STM32F750xx)\r
 622     /*---------------------------- LTDC configuration -------------------------------*/\r
 623     if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_LTDC) == (RCC_PERIPHCLK_LTDC))\r
 624     {\r
 625       assert_param(IS_RCC_PLLSAIR_VALUE(PeriphClkInit->PLLSAI.PLLSAIR));\r
 626       assert_param(IS_RCC_PLLSAI_DIVR_VALUE(PeriphClkInit->PLLSAIDivR));\r
 627 \r
 628       /* Read PLLSAIP and PLLSAIQ value from PLLSAICFGR register (these value are not needed for LTDC configuration) */\r
 629       tmpreg0 = ((RCC->PLLSAICFGR & RCC_PLLSAICFGR_PLLSAIQ) >> RCC_PLLSAICFGR_PLLSAIQ_Pos);\r
 630       tmpreg1 = ((RCC->PLLSAICFGR & RCC_PLLSAICFGR_PLLSAIP) >> RCC_PLLSAICFGR_PLLSAIP_Pos);\r
 631 \r
 632       /* PLLSAI_VCO Input  = PLL_SOURCE/PLLM */\r
 633       /* PLLSAI_VCO Output = PLLSAI_VCO Input * PLLSAIN */\r
 634       /* LTDC_CLK(first level) = PLLSAI_VCO Output/PLLSAIR */\r
 635       __HAL_RCC_PLLSAI_CONFIG(PeriphClkInit->PLLSAI.PLLSAIN , tmpreg1, tmpreg0, PeriphClkInit->PLLSAI.PLLSAIR);\r
 636 \r
 637       /* LTDC_CLK = LTDC_CLK(first level)/PLLSAIDIVR */\r
 638       __HAL_RCC_PLLSAI_PLLSAICLKDIVR_CONFIG(PeriphClkInit->PLLSAIDivR);\r
 639     }\r
 640 #endif /* STM32F746xx || STM32F756xx || STM32F767xx || STM32F769xx || STM32F777xx || STM32F779xx || STM32F750xx  */\r
 641 \r
 642     /* Enable PLLSAI Clock */\r
 643     __HAL_RCC_PLLSAI_ENABLE();\r
 644 \r
 645     /* Get Start Tick*/\r
 646     tickstart = HAL_GetTick();\r
 647 \r
 648     /* Wait till PLLSAI is ready */\r
 649     while(__HAL_RCC_PLLSAI_GET_FLAG() == RESET)\r
 650     {\r
 651       if((HAL_GetTick() - tickstart) > PLLSAI_TIMEOUT_VALUE)\r
 652       {\r
 653         /* return in case of Timeout detected */\r
 654         return HAL_TIMEOUT;\r
 655       }\r
 656     }\r
 657   }\r
 658   return HAL_OK;\r
 659 }\r
 660 \r
 661 /**\r
 662   * @brief  Get the RCC_PeriphCLKInitTypeDef according to the internal\r
 663   *         RCC configuration registers.\r
 664   * @param  PeriphClkInit pointer to the configured RCC_PeriphCLKInitTypeDef structure\r
 665   * @retval None\r
 666   */\r
 667 void HAL_RCCEx_GetPeriphCLKConfig(RCC_PeriphCLKInitTypeDef  *PeriphClkInit)\r
 668 {\r
 669   uint32_t tempreg = 0;\r
 670 \r
 671   /* Set all possible values for the extended clock type parameter------------*/\r
 672 #if defined (STM32F765xx) || defined (STM32F767xx) || defined (STM32F769xx) || defined (STM32F777xx) || defined (STM32F779xx)\r
 673   PeriphClkInit->PeriphClockSelection = RCC_PERIPHCLK_I2S      | RCC_PERIPHCLK_LPTIM1   |\\r
 674                                         RCC_PERIPHCLK_SAI1     | RCC_PERIPHCLK_SAI2     |\\r
 675                                         RCC_PERIPHCLK_TIM      | RCC_PERIPHCLK_RTC      |\\r
 676                                         RCC_PERIPHCLK_CEC      | RCC_PERIPHCLK_I2C4     |\\r
 677                                         RCC_PERIPHCLK_I2C1     | RCC_PERIPHCLK_I2C2     |\\r
 678                                         RCC_PERIPHCLK_I2C3     | RCC_PERIPHCLK_USART1   |\\r
 679                                         RCC_PERIPHCLK_USART2   | RCC_PERIPHCLK_USART3   |\\r
 680                                         RCC_PERIPHCLK_UART4    | RCC_PERIPHCLK_UART5    |\\r
 681                                         RCC_PERIPHCLK_USART6   | RCC_PERIPHCLK_UART7    |\\r
 682                                         RCC_PERIPHCLK_UART8    | RCC_PERIPHCLK_SDMMC1   |\\r
 683                                         RCC_PERIPHCLK_CLK48    | RCC_PERIPHCLK_SDMMC2   |\\r
 684                                         RCC_PERIPHCLK_DFSDM1   | RCC_PERIPHCLK_DFSDM1_AUDIO;\r
 685 #else\r
 686   PeriphClkInit->PeriphClockSelection = RCC_PERIPHCLK_I2S      | RCC_PERIPHCLK_LPTIM1   |\\r
 687                                         RCC_PERIPHCLK_SAI1     | RCC_PERIPHCLK_SAI2     |\\r
 688                                         RCC_PERIPHCLK_TIM      | RCC_PERIPHCLK_RTC      |\\r
 689                                         RCC_PERIPHCLK_CEC      | RCC_PERIPHCLK_I2C4     |\\r
 690                                         RCC_PERIPHCLK_I2C1     | RCC_PERIPHCLK_I2C2     |\\r
 691                                         RCC_PERIPHCLK_I2C3     | RCC_PERIPHCLK_USART1   |\\r
 692                                         RCC_PERIPHCLK_USART2   | RCC_PERIPHCLK_USART3   |\\r
 693                                         RCC_PERIPHCLK_UART4    | RCC_PERIPHCLK_UART5    |\\r
 694                                         RCC_PERIPHCLK_USART6   | RCC_PERIPHCLK_UART7    |\\r
 695                                         RCC_PERIPHCLK_UART8    | RCC_PERIPHCLK_SDMMC1   |\\r
 696                                         RCC_PERIPHCLK_CLK48;\r
 697 #endif /* STM32F767xx || STM32F769xx || STM32F777xx || STM32F779xx */\r
 698 \r
 699   /* Get the PLLI2S Clock configuration -----------------------------------------------*/\r
 700   PeriphClkInit->PLLI2S.PLLI2SN = (uint32_t)((RCC->PLLI2SCFGR & RCC_PLLI2SCFGR_PLLI2SN) >> RCC_PLLI2SCFGR_PLLI2SN_Pos);\r
 701   PeriphClkInit->PLLI2S.PLLI2SP = (uint32_t)((RCC->PLLI2SCFGR & RCC_PLLI2SCFGR_PLLI2SP) >> RCC_PLLI2SCFGR_PLLI2SP_Pos);\r
 702   PeriphClkInit->PLLI2S.PLLI2SQ = (uint32_t)((RCC->PLLI2SCFGR & RCC_PLLI2SCFGR_PLLI2SQ) >> RCC_PLLI2SCFGR_PLLI2SQ_Pos);\r
 703   PeriphClkInit->PLLI2S.PLLI2SR = (uint32_t)((RCC->PLLI2SCFGR & RCC_PLLI2SCFGR_PLLI2SR) >> RCC_PLLI2SCFGR_PLLI2SR_Pos);\r
 704 \r
 705   /* Get the PLLSAI Clock configuration -----------------------------------------------*/\r
 706   PeriphClkInit->PLLSAI.PLLSAIN = (uint32_t)((RCC->PLLSAICFGR & RCC_PLLSAICFGR_PLLSAIN) >> RCC_PLLSAICFGR_PLLSAIN_Pos);\r
 707   PeriphClkInit->PLLSAI.PLLSAIP = (uint32_t)((RCC->PLLSAICFGR & RCC_PLLSAICFGR_PLLSAIP) >> RCC_PLLSAICFGR_PLLSAIP_Pos);\r
 708   PeriphClkInit->PLLSAI.PLLSAIQ = (uint32_t)((RCC->PLLSAICFGR & RCC_PLLSAICFGR_PLLSAIQ) >> RCC_PLLSAICFGR_PLLSAIQ_Pos);\r
 709   PeriphClkInit->PLLSAI.PLLSAIR = (uint32_t)((RCC->PLLSAICFGR & RCC_PLLSAICFGR_PLLSAIR) >> RCC_PLLSAICFGR_PLLSAIR_Pos);\r
 710 \r
 711   /* Get the PLLSAI/PLLI2S division factors -------------------------------------------*/\r
 712   PeriphClkInit->PLLI2SDivQ = (uint32_t)((RCC->DCKCFGR1 & RCC_DCKCFGR1_PLLI2SDIVQ) >> RCC_DCKCFGR1_PLLI2SDIVQ_Pos);\r
 713   PeriphClkInit->PLLSAIDivQ = (uint32_t)((RCC->DCKCFGR1 & RCC_DCKCFGR1_PLLSAIDIVQ) >> RCC_DCKCFGR1_PLLSAIDIVQ_Pos);\r
 714   PeriphClkInit->PLLSAIDivR = (uint32_t)((RCC->DCKCFGR1 & RCC_DCKCFGR1_PLLSAIDIVR) >> RCC_DCKCFGR1_PLLSAIDIVR_Pos);\r
 715 \r
 716   /* Get the SAI1 clock configuration ----------------------------------------------*/\r
 717   PeriphClkInit->Sai1ClockSelection = __HAL_RCC_GET_SAI1_SOURCE();\r
 718 \r
 719   /* Get the SAI2 clock configuration ----------------------------------------------*/\r
 720   PeriphClkInit->Sai2ClockSelection = __HAL_RCC_GET_SAI2_SOURCE();\r
 721 \r
 722   /* Get the I2S clock configuration ------------------------------------------*/\r
 723   PeriphClkInit->I2sClockSelection = __HAL_RCC_GET_I2SCLKSOURCE();\r
 724 \r
 725   /* Get the I2C1 clock configuration ------------------------------------------*/\r
 726   PeriphClkInit->I2c1ClockSelection = __HAL_RCC_GET_I2C1_SOURCE();\r
 727 \r
 728   /* Get the I2C2 clock configuration ------------------------------------------*/\r
 729   PeriphClkInit->I2c2ClockSelection = __HAL_RCC_GET_I2C2_SOURCE();\r
 730 \r
 731   /* Get the I2C3 clock configuration ------------------------------------------*/\r
 732   PeriphClkInit->I2c3ClockSelection = __HAL_RCC_GET_I2C3_SOURCE();\r
 733 \r
 734   /* Get the I2C4 clock configuration ------------------------------------------*/\r
 735   PeriphClkInit->I2c4ClockSelection = __HAL_RCC_GET_I2C4_SOURCE();\r
 736 \r
 737   /* Get the USART1 clock configuration ------------------------------------------*/\r
 738   PeriphClkInit->Usart1ClockSelection = __HAL_RCC_GET_USART1_SOURCE();\r
 739 \r
 740   /* Get the USART2 clock configuration ------------------------------------------*/\r
 741   PeriphClkInit->Usart2ClockSelection = __HAL_RCC_GET_USART2_SOURCE();\r
 742 \r
 743   /* Get the USART3 clock configuration ------------------------------------------*/\r
 744   PeriphClkInit->Usart3ClockSelection = __HAL_RCC_GET_USART3_SOURCE();\r
 745 \r
 746   /* Get the UART4 clock configuration ------------------------------------------*/\r
 747   PeriphClkInit->Uart4ClockSelection = __HAL_RCC_GET_UART4_SOURCE();\r
 748 \r
 749   /* Get the UART5 clock configuration ------------------------------------------*/\r
 750   PeriphClkInit->Uart5ClockSelection = __HAL_RCC_GET_UART5_SOURCE();\r
 751 \r
 752   /* Get the USART6 clock configuration ------------------------------------------*/\r
 753   PeriphClkInit->Usart6ClockSelection = __HAL_RCC_GET_USART6_SOURCE();\r
 754 \r
 755   /* Get the UART7 clock configuration ------------------------------------------*/\r
 756   PeriphClkInit->Uart7ClockSelection = __HAL_RCC_GET_UART7_SOURCE();\r
 757 \r
 758   /* Get the UART8 clock configuration ------------------------------------------*/\r
 759   PeriphClkInit->Uart8ClockSelection = __HAL_RCC_GET_UART8_SOURCE();\r
 760 \r
 761   /* Get the LPTIM1 clock configuration ------------------------------------------*/\r
 762   PeriphClkInit->Lptim1ClockSelection = __HAL_RCC_GET_LPTIM1_SOURCE();\r
 763 \r
 764   /* Get the CEC clock configuration -----------------------------------------------*/\r
 765   PeriphClkInit->CecClockSelection = __HAL_RCC_GET_CEC_SOURCE();\r
 766 \r
 767   /* Get the CK48 clock configuration -----------------------------------------------*/\r
 768   PeriphClkInit->Clk48ClockSelection = __HAL_RCC_GET_CLK48_SOURCE();\r
 769 \r
 770   /* Get the SDMMC1 clock configuration -----------------------------------------------*/\r
 771   PeriphClkInit->Sdmmc1ClockSelection = __HAL_RCC_GET_SDMMC1_SOURCE();\r
 772 \r
 773 #if defined (STM32F765xx) || defined (STM32F767xx) || defined (STM32F769xx) || defined (STM32F777xx) || defined (STM32F779xx)\r
 774   /* Get the SDMMC2 clock configuration -----------------------------------------------*/\r
 775   PeriphClkInit->Sdmmc2ClockSelection = __HAL_RCC_GET_SDMMC2_SOURCE();\r
 776 \r
 777   /* Get the DFSDM clock configuration -----------------------------------------------*/\r
 778   PeriphClkInit->Dfsdm1ClockSelection = __HAL_RCC_GET_DFSDM1_SOURCE();\r
 779 \r
 780   /* Get the DFSDM AUDIO clock configuration -----------------------------------------------*/\r
 781   PeriphClkInit->Dfsdm1AudioClockSelection = __HAL_RCC_GET_DFSDM1AUDIO_SOURCE();\r
 782 #endif /* STM32F767xx || STM32F769xx || STM32F777xx || STM32F779xx */\r
 783 \r
 784   /* Get the RTC Clock configuration -----------------------------------------------*/\r
 785   tempreg = (RCC->CFGR & RCC_CFGR_RTCPRE);\r
 786   PeriphClkInit->RTCClockSelection = (uint32_t)((tempreg) | (RCC->BDCR & RCC_BDCR_RTCSEL));\r
 787 \r
 788   /* Get the TIM Prescaler configuration --------------------------------------------*/\r
 789   if ((RCC->DCKCFGR1 & RCC_DCKCFGR1_TIMPRE) == RESET)\r
 790   {\r
 791     PeriphClkInit->TIMPresSelection = RCC_TIMPRES_DESACTIVATED;\r
 792   }\r
 793   else\r
 794   {\r
 795     PeriphClkInit->TIMPresSelection = RCC_TIMPRES_ACTIVATED;\r
 796   }\r
 797 }\r
 798 #endif /* STM32F745xx || STM32F746xx || STM32F756xx || STM32F765xx || STM32F767xx || STM32F769xx || STM32F777xx || STM32F779xx || STM32F750xx */\r
 799 \r
 800 #if defined (STM32F722xx) || defined (STM32F723xx) || defined (STM32F732xx) || defined (STM32F733xx) || defined (STM32F730xx)\r
 801 /**\r
 802   * @brief  Initializes the RCC extended peripherals clocks according to the specified\r
 803   *         parameters in the RCC_PeriphCLKInitTypeDef.\r
 804   * @param  PeriphClkInit pointer to an RCC_PeriphCLKInitTypeDef structure that\r
 805   *         contains the configuration information for the Extended Peripherals\r
 806   *         clocks(I2S, SAI, RTC, TIM, UARTs, USARTs, LTPIM, SDMMC...).\r
 807   *\r
 808   * @note   Care must be taken when HAL_RCCEx_PeriphCLKConfig() is used to select\r
 809   *         the RTC clock source; in this case the Backup domain will be reset in\r
 810   *         order to modify the RTC Clock source, as consequence RTC registers (including\r
 811   *         the backup registers) are set to their reset values.\r
 812   *\r
 813   * @retval HAL status\r
 814   */\r
 815 HAL_StatusTypeDef HAL_RCCEx_PeriphCLKConfig(RCC_PeriphCLKInitTypeDef  *PeriphClkInit)\r
 816 {\r
 817   uint32_t tickstart = 0;\r
 818   uint32_t tmpreg0 = 0;\r
 819   uint32_t plli2sused = 0;\r
 820   uint32_t pllsaiused = 0;\r
 821 \r
 822   /* Check the parameters */\r
 823   assert_param(IS_RCC_PERIPHCLOCK(PeriphClkInit->PeriphClockSelection));\r
 824 \r
 825   /*----------------------------------- I2S configuration ----------------------------------*/\r
 826   if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_I2S) == (RCC_PERIPHCLK_I2S))\r
 827   {\r
 828     /* Check the parameters */\r
 829     assert_param(IS_RCC_I2SCLKSOURCE(PeriphClkInit->I2sClockSelection));\r
 830 \r
 831     /* Configure I2S Clock source */\r
 832     __HAL_RCC_I2S_CONFIG(PeriphClkInit->I2sClockSelection);\r
 833 \r
 834     /* Enable the PLLI2S when it's used as clock source for I2S */\r
 835     if(PeriphClkInit->I2sClockSelection == RCC_I2SCLKSOURCE_PLLI2S)\r
 836     {\r
 837       plli2sused = 1;\r
 838     }\r
 839   }\r
 840 \r
 841   /*------------------------------------ SAI1 configuration --------------------------------------*/\r
 842   if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_SAI1) == (RCC_PERIPHCLK_SAI1))\r
 843   {\r
 844     /* Check the parameters */\r
 845     assert_param(IS_RCC_SAI1CLKSOURCE(PeriphClkInit->Sai1ClockSelection));\r
 846 \r
 847     /* Configure SAI1 Clock source */\r
 848     __HAL_RCC_SAI1_CONFIG(PeriphClkInit->Sai1ClockSelection);\r
 849     /* Enable the PLLI2S when it's used as clock source for SAI */\r
 850     if(PeriphClkInit->Sai1ClockSelection == RCC_SAI1CLKSOURCE_PLLI2S)\r
 851     {\r
 852       plli2sused = 1;\r
 853     }\r
 854     /* Enable the PLLSAI when it's used as clock source for SAI */\r
 855     if(PeriphClkInit->Sai1ClockSelection == RCC_SAI1CLKSOURCE_PLLSAI)\r
 856     {\r
 857       pllsaiused = 1;\r
 858     }\r
 859   }\r
 860 \r
 861   /*------------------------------------ SAI2 configuration --------------------------------------*/\r
 862   if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_SAI2) == (RCC_PERIPHCLK_SAI2))\r
 863   {\r
 864     /* Check the parameters */\r
 865     assert_param(IS_RCC_SAI2CLKSOURCE(PeriphClkInit->Sai2ClockSelection));\r
 866 \r
 867     /* Configure SAI2 Clock source */\r
 868     __HAL_RCC_SAI2_CONFIG(PeriphClkInit->Sai2ClockSelection);\r
 869 \r
 870     /* Enable the PLLI2S when it's used as clock source for SAI */\r
 871     if(PeriphClkInit->Sai2ClockSelection == RCC_SAI2CLKSOURCE_PLLI2S)\r
 872     {\r
 873       plli2sused = 1;\r
 874     }\r
 875     /* Enable the PLLSAI when it's used as clock source for SAI */\r
 876     if(PeriphClkInit->Sai2ClockSelection == RCC_SAI2CLKSOURCE_PLLSAI)\r
 877     {\r
 878       pllsaiused = 1;\r
 879     }\r
 880   }\r
 881 \r
 882   /*------------------------------------ RTC configuration --------------------------------------*/\r
 883   if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_RTC) == (RCC_PERIPHCLK_RTC))\r
 884   {\r
 885     /* Check for RTC Parameters used to output RTCCLK */\r
 886     assert_param(IS_RCC_RTCCLKSOURCE(PeriphClkInit->RTCClockSelection));\r
 887 \r
 888     /* Enable Power Clock*/\r
 889     __HAL_RCC_PWR_CLK_ENABLE();\r
 890 \r
 891     /* Enable write access to Backup domain */\r
 892     PWR->CR1 |= PWR_CR1_DBP;\r
 893 \r
 894     /* Get Start Tick*/\r
 895     tickstart = HAL_GetTick();\r
 896 \r
 897     /* Wait for Backup domain Write protection disable */\r
 898     while((PWR->CR1 & PWR_CR1_DBP) == RESET)\r
 899     {\r
 900       if((HAL_GetTick() - tickstart) > RCC_DBP_TIMEOUT_VALUE)\r
 901       {\r
 902         return HAL_TIMEOUT;\r
 903       }\r
 904     }\r
 905 \r
 906     /* Reset the Backup domain only if the RTC Clock source selection is modified */\r
 907     tmpreg0 = (RCC->BDCR & RCC_BDCR_RTCSEL);\r
 908 \r
 909     if((tmpreg0 != 0x00000000U) && (tmpreg0 != (PeriphClkInit->RTCClockSelection & RCC_BDCR_RTCSEL)))\r
 910     {\r
 911       /* Store the content of BDCR register before the reset of Backup Domain */\r
 912       tmpreg0 = (RCC->BDCR & ~(RCC_BDCR_RTCSEL));\r
 913 \r
 914       /* RTC Clock selection can be changed only if the Backup Domain is reset */\r
 915       __HAL_RCC_BACKUPRESET_FORCE();\r
 916       __HAL_RCC_BACKUPRESET_RELEASE();\r
 917 \r
 918       /* Restore the Content of BDCR register */\r
 919       RCC->BDCR = tmpreg0;\r
 920 \r
 921       /* Wait for LSE reactivation if LSE was enable prior to Backup Domain reset */\r
 922       if (HAL_IS_BIT_SET(RCC->BDCR, RCC_BDCR_LSEON))\r
 923       {\r
 924         /* Get Start Tick*/\r
 925         tickstart = HAL_GetTick();\r
 926 \r
 927         /* Wait till LSE is ready */\r
 928         while(__HAL_RCC_GET_FLAG(RCC_FLAG_LSERDY) == RESET)\r
 929         {\r
 930           if((HAL_GetTick() - tickstart ) > RCC_LSE_TIMEOUT_VALUE)\r
 931           {\r
 932             return HAL_TIMEOUT;\r
 933           }\r
 934         }\r
 935       }\r
 936     }\r
 937     __HAL_RCC_RTC_CONFIG(PeriphClkInit->RTCClockSelection);\r
 938   }\r
 939 \r
 940   /*------------------------------------ TIM configuration --------------------------------------*/\r
 941   if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_TIM) == (RCC_PERIPHCLK_TIM))\r
 942   {\r
 943     /* Check the parameters */\r
 944     assert_param(IS_RCC_TIMPRES(PeriphClkInit->TIMPresSelection));\r
 945 \r
 946     /* Configure Timer Prescaler */\r
 947     __HAL_RCC_TIMCLKPRESCALER(PeriphClkInit->TIMPresSelection);\r
 948   }\r
 949 \r
 950   /*-------------------------------------- I2C1 Configuration -----------------------------------*/\r
 951   if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_I2C1) == RCC_PERIPHCLK_I2C1)\r
 952   {\r
 953     /* Check the parameters */\r
 954     assert_param(IS_RCC_I2C1CLKSOURCE(PeriphClkInit->I2c1ClockSelection));\r
 955 \r
 956     /* Configure the I2C1 clock source */\r
 957     __HAL_RCC_I2C1_CONFIG(PeriphClkInit->I2c1ClockSelection);\r
 958   }\r
 959 \r
 960   /*-------------------------------------- I2C2 Configuration -----------------------------------*/\r
 961   if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_I2C2) == RCC_PERIPHCLK_I2C2)\r
 962   {\r
 963     /* Check the parameters */\r
 964     assert_param(IS_RCC_I2C2CLKSOURCE(PeriphClkInit->I2c2ClockSelection));\r
 965 \r
 966     /* Configure the I2C2 clock source */\r
 967     __HAL_RCC_I2C2_CONFIG(PeriphClkInit->I2c2ClockSelection);\r
 968   }\r
 969 \r
 970   /*-------------------------------------- I2C3 Configuration -----------------------------------*/\r
 971   if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_I2C3) == RCC_PERIPHCLK_I2C3)\r
 972   {\r
 973     /* Check the parameters */\r
 974     assert_param(IS_RCC_I2C3CLKSOURCE(PeriphClkInit->I2c3ClockSelection));\r
 975 \r
 976     /* Configure the I2C3 clock source */\r
 977     __HAL_RCC_I2C3_CONFIG(PeriphClkInit->I2c3ClockSelection);\r
 978   }\r
 979 \r
 980   /*-------------------------------------- USART1 Configuration -----------------------------------*/\r
 981   if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_USART1) == RCC_PERIPHCLK_USART1)\r
 982   {\r
 983     /* Check the parameters */\r
 984     assert_param(IS_RCC_USART1CLKSOURCE(PeriphClkInit->Usart1ClockSelection));\r
 985 \r
 986     /* Configure the USART1 clock source */\r
 987     __HAL_RCC_USART1_CONFIG(PeriphClkInit->Usart1ClockSelection);\r
 988   }\r
 989 \r
 990   /*-------------------------------------- USART2 Configuration -----------------------------------*/\r
 991   if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_USART2) == RCC_PERIPHCLK_USART2)\r
 992   {\r
 993     /* Check the parameters */\r
 994     assert_param(IS_RCC_USART2CLKSOURCE(PeriphClkInit->Usart2ClockSelection));\r
 995 \r
 996     /* Configure the USART2 clock source */\r
 997     __HAL_RCC_USART2_CONFIG(PeriphClkInit->Usart2ClockSelection);\r
 998   }\r
 999 \r
1000   /*-------------------------------------- USART3 Configuration -----------------------------------*/\r
1001   if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_USART3) == RCC_PERIPHCLK_USART3)\r
1002   {\r
1003     /* Check the parameters */\r
1004     assert_param(IS_RCC_USART3CLKSOURCE(PeriphClkInit->Usart3ClockSelection));\r
1005 \r
1006     /* Configure the USART3 clock source */\r
1007     __HAL_RCC_USART3_CONFIG(PeriphClkInit->Usart3ClockSelection);\r
1008   }\r
1009 \r
1010   /*-------------------------------------- UART4 Configuration -----------------------------------*/\r
1011   if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_UART4) == RCC_PERIPHCLK_UART4)\r
1012   {\r
1013     /* Check the parameters */\r
1014     assert_param(IS_RCC_UART4CLKSOURCE(PeriphClkInit->Uart4ClockSelection));\r
1015 \r
1016     /* Configure the UART4 clock source */\r
1017     __HAL_RCC_UART4_CONFIG(PeriphClkInit->Uart4ClockSelection);\r
1018   }\r
1019 \r
1020   /*-------------------------------------- UART5 Configuration -----------------------------------*/\r
1021   if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_UART5) == RCC_PERIPHCLK_UART5)\r
1022   {\r
1023     /* Check the parameters */\r
1024     assert_param(IS_RCC_UART5CLKSOURCE(PeriphClkInit->Uart5ClockSelection));\r
1025 \r
1026     /* Configure the UART5 clock source */\r
1027     __HAL_RCC_UART5_CONFIG(PeriphClkInit->Uart5ClockSelection);\r
1028   }\r
1029 \r
1030   /*-------------------------------------- USART6 Configuration -----------------------------------*/\r
1031   if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_USART6) == RCC_PERIPHCLK_USART6)\r
1032   {\r
1033     /* Check the parameters */\r
1034     assert_param(IS_RCC_USART6CLKSOURCE(PeriphClkInit->Usart6ClockSelection));\r
1035 \r
1036     /* Configure the USART6 clock source */\r
1037     __HAL_RCC_USART6_CONFIG(PeriphClkInit->Usart6ClockSelection);\r
1038   }\r
1039 \r
1040   /*-------------------------------------- UART7 Configuration -----------------------------------*/\r
1041   if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_UART7) == RCC_PERIPHCLK_UART7)\r
1042   {\r
1043     /* Check the parameters */\r
1044     assert_param(IS_RCC_UART7CLKSOURCE(PeriphClkInit->Uart7ClockSelection));\r
1045 \r
1046     /* Configure the UART7 clock source */\r
1047     __HAL_RCC_UART7_CONFIG(PeriphClkInit->Uart7ClockSelection);\r
1048   }\r
1049 \r
1050   /*-------------------------------------- UART8 Configuration -----------------------------------*/\r
1051   if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_UART8) == RCC_PERIPHCLK_UART8)\r
1052   {\r
1053     /* Check the parameters */\r
1054     assert_param(IS_RCC_UART8CLKSOURCE(PeriphClkInit->Uart8ClockSelection));\r
1055 \r
1056     /* Configure the UART8 clock source */\r
1057     __HAL_RCC_UART8_CONFIG(PeriphClkInit->Uart8ClockSelection);\r
1058   }\r
1059 \r
1060   /*-------------------------------------- CK48 Configuration -----------------------------------*/\r
1061   if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_CLK48) == RCC_PERIPHCLK_CLK48)\r
1062   {\r
1063     /* Check the parameters */\r
1064     assert_param(IS_RCC_CLK48SOURCE(PeriphClkInit->Clk48ClockSelection));\r
1065 \r
1066     /* Configure the CLK48 source */\r
1067     __HAL_RCC_CLK48_CONFIG(PeriphClkInit->Clk48ClockSelection);\r
1068 \r
1069     /* Enable the PLLSAI when it's used as clock source for CK48 */\r
1070     if(PeriphClkInit->Clk48ClockSelection == RCC_CLK48SOURCE_PLLSAIP)\r
1071     {\r
1072       pllsaiused = 1;\r
1073     }\r
1074   }\r
1075 \r
1076   /*-------------------------------------- LPTIM1 Configuration -----------------------------------*/\r
1077   if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_LPTIM1) == RCC_PERIPHCLK_LPTIM1)\r
1078   {\r
1079     /* Check the parameters */\r
1080     assert_param(IS_RCC_LPTIM1CLK(PeriphClkInit->Lptim1ClockSelection));\r
1081 \r
1082     /* Configure the LTPIM1 clock source */\r
1083     __HAL_RCC_LPTIM1_CONFIG(PeriphClkInit->Lptim1ClockSelection);\r
1084    }\r
1085 \r
1086   /*------------------------------------- SDMMC1 Configuration ------------------------------------*/\r
1087   if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_SDMMC1) == RCC_PERIPHCLK_SDMMC1)\r
1088   {\r
1089     /* Check the parameters */\r
1090     assert_param(IS_RCC_SDMMC1CLKSOURCE(PeriphClkInit->Sdmmc1ClockSelection));\r
1091 \r
1092     /* Configure the SDMMC1 clock source */\r
1093     __HAL_RCC_SDMMC1_CONFIG(PeriphClkInit->Sdmmc1ClockSelection);\r
1094   }\r
1095 \r
1096   /*------------------------------------- SDMMC2 Configuration ------------------------------------*/\r
1097   if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_SDMMC2) == RCC_PERIPHCLK_SDMMC2)\r
1098   {\r
1099     /* Check the parameters */\r
1100     assert_param(IS_RCC_SDMMC2CLKSOURCE(PeriphClkInit->Sdmmc2ClockSelection));\r
1101 \r
1102     /* Configure the SDMMC2 clock source */\r
1103     __HAL_RCC_SDMMC2_CONFIG(PeriphClkInit->Sdmmc2ClockSelection);\r
1104   }\r
1105 \r
1106   /*-------------------------------------- PLLI2S Configuration ---------------------------------*/\r
1107   /* PLLI2S is configured when a peripheral will use it as source clock : SAI1, SAI2 or I2S */\r
1108   if((plli2sused == 1) || (PeriphClkInit->PeriphClockSelection == RCC_PERIPHCLK_PLLI2S))\r
1109   {\r
1110     /* Disable the PLLI2S */\r
1111     __HAL_RCC_PLLI2S_DISABLE();\r
1112 \r
1113     /* Get Start Tick*/\r
1114     tickstart = HAL_GetTick();\r
1115 \r
1116     /* Wait till PLLI2S is disabled */\r
1117     while(__HAL_RCC_GET_FLAG(RCC_FLAG_PLLI2SRDY)  != RESET)\r
1118     {\r
1119       if((HAL_GetTick() - tickstart) > PLLI2S_TIMEOUT_VALUE)\r
1120       {\r
1121         /* return in case of Timeout detected */\r
1122         return HAL_TIMEOUT;\r
1123       }\r
1124     }\r
1125 \r
1126     /* check for common PLLI2S Parameters */\r
1127     assert_param(IS_RCC_PLLI2SN_VALUE(PeriphClkInit->PLLI2S.PLLI2SN));\r
1128 \r
1129     /*----------------- In Case of PLLI2S is selected as source clock for I2S -------------------*/\r
1130     if(((((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_I2S) == RCC_PERIPHCLK_I2S) && (PeriphClkInit->I2sClockSelection == RCC_I2SCLKSOURCE_PLLI2S)))\r
1131     {\r
1132       /* check for Parameters */\r
1133       assert_param(IS_RCC_PLLI2SR_VALUE(PeriphClkInit->PLLI2S.PLLI2SR));\r
1134 \r
1135       /* Read PLLI2SQ value from PLLI2SCFGR register (this value is not needed for I2S configuration) */\r
1136       tmpreg0 = ((RCC->PLLI2SCFGR & RCC_PLLI2SCFGR_PLLI2SQ) >> RCC_PLLI2SCFGR_PLLI2SQ_Pos);\r
1137       /* Configure the PLLI2S division factors */\r
1138       /* PLLI2S_VCO = f(VCO clock) = f(PLLI2S clock input) x (PLLI2SN/PLLM) */\r
1139       /* I2SCLK = f(PLLI2S clock output) = f(VCO clock) / PLLI2SR */\r
1140       __HAL_RCC_PLLI2S_CONFIG(PeriphClkInit->PLLI2S.PLLI2SN , tmpreg0, PeriphClkInit->PLLI2S.PLLI2SR);\r
1141     }\r
1142 \r
1143     /*----------------- In Case of PLLI2S is selected as source clock for SAI -------------------*/\r
1144     if(((((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_SAI1) == RCC_PERIPHCLK_SAI1) && (PeriphClkInit->Sai1ClockSelection == RCC_SAI1CLKSOURCE_PLLI2S)) ||\r
1145        ((((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_SAI2) == RCC_PERIPHCLK_SAI2) && (PeriphClkInit->Sai2ClockSelection == RCC_SAI2CLKSOURCE_PLLI2S)))\r
1146     {\r
1147       /* Check for PLLI2S Parameters */\r
1148       assert_param(IS_RCC_PLLI2SQ_VALUE(PeriphClkInit->PLLI2S.PLLI2SQ));\r
1149       /* Check for PLLI2S/DIVQ parameters */\r
1150       assert_param(IS_RCC_PLLI2S_DIVQ_VALUE(PeriphClkInit->PLLI2SDivQ));\r
1151 \r
1152       /* Read PLLI2SP and PLLI2SR values from PLLI2SCFGR register (this value is not needed for SAI configuration) */\r
1153       tmpreg0 = ((RCC->PLLI2SCFGR & RCC_PLLI2SCFGR_PLLI2SR) >> RCC_PLLI2SCFGR_PLLI2SR_Pos);\r
1154       /* Configure the PLLI2S division factors */\r
1155       /* PLLI2S_VCO Input  = PLL_SOURCE/PLLM */\r
1156       /* PLLI2S_VCO Output = PLLI2S_VCO Input * PLLI2SN */\r
1157       /* SAI_CLK(first level) = PLLI2S_VCO Output/PLLI2SQ */\r
1158       __HAL_RCC_PLLI2S_CONFIG(PeriphClkInit->PLLI2S.PLLI2SN, PeriphClkInit->PLLI2S.PLLI2SQ, tmpreg0);\r
1159 \r
1160       /* SAI_CLK_x = SAI_CLK(first level)/PLLI2SDIVQ */\r
1161       __HAL_RCC_PLLI2S_PLLSAICLKDIVQ_CONFIG(PeriphClkInit->PLLI2SDivQ);\r
1162     }\r
1163 \r
1164     /*----------------- In Case of PLLI2S is just selected  -----------------*/\r
1165     if((PeriphClkInit->PeriphClockSelection & RCC_PERIPHCLK_PLLI2S) == RCC_PERIPHCLK_PLLI2S)\r
1166     {\r
1167       /* Check for Parameters */\r
1168       assert_param(IS_RCC_PLLI2SR_VALUE(PeriphClkInit->PLLI2S.PLLI2SR));\r
1169       assert_param(IS_RCC_PLLI2SQ_VALUE(PeriphClkInit->PLLI2S.PLLI2SQ));\r
1170 \r
1171       /* Configure the PLLI2S division factors */\r
1172       /* PLLI2S_VCO = f(VCO clock) = f(PLLI2S clock input) x (PLLI2SN/PLLI2SM) */\r
1173       __HAL_RCC_PLLI2S_CONFIG(PeriphClkInit->PLLI2S.PLLI2SN , PeriphClkInit->PLLI2S.PLLI2SQ, PeriphClkInit->PLLI2S.PLLI2SR);\r
1174     }\r
1175 \r
1176     /* Enable the PLLI2S */\r
1177     __HAL_RCC_PLLI2S_ENABLE();\r
1178 \r
1179     /* Get Start Tick*/\r
1180     tickstart = HAL_GetTick();\r
1181 \r
1182     /* Wait till PLLI2S is ready */\r
1183     while(__HAL_RCC_GET_FLAG(RCC_FLAG_PLLI2SRDY)  == RESET)\r
1184     {\r
1185       if((HAL_GetTick() - tickstart) > PLLI2S_TIMEOUT_VALUE)\r
1186       {\r
1187         /* return in case of Timeout detected */\r
1188         return HAL_TIMEOUT;\r
1189       }\r
1190     }\r
1191   }\r
1192 \r
1193   /*-------------------------------------- PLLSAI Configuration ---------------------------------*/\r
1194   /* PLLSAI is configured when a peripheral will use it as source clock : SAI1, SAI2, LTDC or CK48 */\r
1195   if(pllsaiused == 1)\r
1196   {\r
1197     /* Disable PLLSAI Clock */\r
1198     __HAL_RCC_PLLSAI_DISABLE();\r
1199 \r
1200     /* Get Start Tick*/\r
1201     tickstart = HAL_GetTick();\r
1202 \r
1203     /* Wait till PLLSAI is disabled */\r
1204     while(__HAL_RCC_PLLSAI_GET_FLAG() != RESET)\r
1205     {\r
1206       if((HAL_GetTick() - tickstart) > PLLSAI_TIMEOUT_VALUE)\r
1207       {\r
1208         /* return in case of Timeout detected */\r
1209         return HAL_TIMEOUT;\r
1210       }\r
1211     }\r
1212 \r
1213     /* Check the PLLSAI division factors */\r
1214     assert_param(IS_RCC_PLLSAIN_VALUE(PeriphClkInit->PLLSAI.PLLSAIN));\r
1215 \r
1216     /*----------------- In Case of PLLSAI is selected as source clock for SAI -------------------*/\r
1217     if(((((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_SAI1) == RCC_PERIPHCLK_SAI1) && (PeriphClkInit->Sai1ClockSelection == RCC_SAI1CLKSOURCE_PLLSAI)) ||\\r
1218        ((((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_SAI2) == RCC_PERIPHCLK_SAI2) && (PeriphClkInit->Sai2ClockSelection == RCC_SAI2CLKSOURCE_PLLSAI)))\r
1219     {\r
1220       /* check for PLLSAIQ Parameter */\r
1221       assert_param(IS_RCC_PLLSAIQ_VALUE(PeriphClkInit->PLLSAI.PLLSAIQ));\r
1222       /* check for PLLSAI/DIVQ Parameter */\r
1223       assert_param(IS_RCC_PLLSAI_DIVQ_VALUE(PeriphClkInit->PLLSAIDivQ));\r
1224 \r
1225       /* Read PLLSAIP value from PLLSAICFGR register (this value is not needed for SAI configuration) */\r
1226       tmpreg0 = ((RCC->PLLSAICFGR & RCC_PLLSAICFGR_PLLSAIP) >> RCC_PLLSAICFGR_PLLSAIP_Pos);\r
1227       /* PLLSAI_VCO Input  = PLL_SOURCE/PLLM */\r
1228       /* PLLSAI_VCO Output = PLLSAI_VCO Input * PLLSAIN */\r
1229       /* SAI_CLK(first level) = PLLSAI_VCO Output/PLLSAIQ */\r
1230       __HAL_RCC_PLLSAI_CONFIG(PeriphClkInit->PLLSAI.PLLSAIN , tmpreg0, PeriphClkInit->PLLSAI.PLLSAIQ);\r
1231 \r
1232       /* SAI_CLK_x = SAI_CLK(first level)/PLLSAIDIVQ */\r
1233       __HAL_RCC_PLLSAI_PLLSAICLKDIVQ_CONFIG(PeriphClkInit->PLLSAIDivQ);\r
1234     }\r
1235 \r
1236     /*----------------- In Case of PLLSAI is selected as source clock for CLK48 -------------------*/\r
1237     /* In Case of PLLI2S is selected as source clock for CK48 */\r
1238     if((((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_CLK48) == RCC_PERIPHCLK_CLK48) && (PeriphClkInit->Clk48ClockSelection == RCC_CLK48SOURCE_PLLSAIP))\r
1239     {\r
1240       /* check for Parameters */\r
1241       assert_param(IS_RCC_PLLSAIP_VALUE(PeriphClkInit->PLLSAI.PLLSAIP));\r
1242       /* Read PLLSAIQ and PLLSAIR value from PLLSAICFGR register (this value is not needed for CK48 configuration) */\r
1243       tmpreg0 = ((RCC->PLLSAICFGR & RCC_PLLSAICFGR_PLLSAIQ) >> RCC_PLLSAICFGR_PLLSAIQ_Pos);\r
1244 \r
1245       /* Configure the PLLSAI division factors */\r
1246       /* PLLSAI_VCO = f(VCO clock) = f(PLLSAI clock input) x (PLLI2SN/PLLM) */\r
1247       /* 48CLK = f(PLLSAI clock output) = f(VCO clock) / PLLSAIP */\r
1248       __HAL_RCC_PLLSAI_CONFIG(PeriphClkInit->PLLSAI.PLLSAIN , PeriphClkInit->PLLSAI.PLLSAIP, tmpreg0);\r
1249     }\r
1250 \r
1251     /* Enable PLLSAI Clock */\r
1252     __HAL_RCC_PLLSAI_ENABLE();\r
1253 \r
1254     /* Get Start Tick*/\r
1255     tickstart = HAL_GetTick();\r
1256 \r
1257     /* Wait till PLLSAI is ready */\r
1258     while(__HAL_RCC_PLLSAI_GET_FLAG() == RESET)\r
1259     {\r
1260       if((HAL_GetTick() - tickstart) > PLLSAI_TIMEOUT_VALUE)\r
1261       {\r
1262         /* return in case of Timeout detected */\r
1263         return HAL_TIMEOUT;\r
1264       }\r
1265     }\r
1266   }\r
1267   return HAL_OK;\r
1268 }\r
1269 \r
1270 /**\r
1271   * @brief  Get the RCC_PeriphCLKInitTypeDef according to the internal\r
1272   *         RCC configuration registers.\r
1273   * @param  PeriphClkInit pointer to the configured RCC_PeriphCLKInitTypeDef structure\r
1274   * @retval None\r
1275   */\r
1276 void HAL_RCCEx_GetPeriphCLKConfig(RCC_PeriphCLKInitTypeDef  *PeriphClkInit)\r
1277 {\r
1278   uint32_t tempreg = 0;\r
1279 \r
1280   /* Set all possible values for the extended clock type parameter------------*/\r
1281   PeriphClkInit->PeriphClockSelection = RCC_PERIPHCLK_I2S      | RCC_PERIPHCLK_LPTIM1   |\\r
1282                                         RCC_PERIPHCLK_SAI1     | RCC_PERIPHCLK_SAI2     |\\r
1283                                         RCC_PERIPHCLK_TIM      | RCC_PERIPHCLK_RTC      |\\r
1284                                         RCC_PERIPHCLK_I2C1     | RCC_PERIPHCLK_I2C2     |\\r
1285                                         RCC_PERIPHCLK_I2C3     | RCC_PERIPHCLK_USART1   |\\r
1286                                         RCC_PERIPHCLK_USART2   | RCC_PERIPHCLK_USART3   |\\r
1287                                         RCC_PERIPHCLK_UART4    | RCC_PERIPHCLK_UART5    |\\r
1288                                         RCC_PERIPHCLK_USART6   | RCC_PERIPHCLK_UART7    |\\r
1289                                         RCC_PERIPHCLK_UART8    | RCC_PERIPHCLK_SDMMC1   |\\r
1290                                         RCC_PERIPHCLK_CLK48    | RCC_PERIPHCLK_SDMMC2;\r
1291 \r
1292   /* Get the PLLI2S Clock configuration -----------------------------------------------*/\r
1293   PeriphClkInit->PLLI2S.PLLI2SN = (uint32_t)((RCC->PLLI2SCFGR & RCC_PLLI2SCFGR_PLLI2SN) >> RCC_PLLI2SCFGR_PLLI2SN_Pos);\r
1294   PeriphClkInit->PLLI2S.PLLI2SQ = (uint32_t)((RCC->PLLI2SCFGR & RCC_PLLI2SCFGR_PLLI2SQ) >> RCC_PLLI2SCFGR_PLLI2SQ_Pos);\r
1295   PeriphClkInit->PLLI2S.PLLI2SR = (uint32_t)((RCC->PLLI2SCFGR & RCC_PLLI2SCFGR_PLLI2SR) >> RCC_PLLI2SCFGR_PLLI2SR_Pos);\r
1296 \r
1297   /* Get the PLLSAI Clock configuration -----------------------------------------------*/\r
1298   PeriphClkInit->PLLSAI.PLLSAIN = (uint32_t)((RCC->PLLSAICFGR & RCC_PLLSAICFGR_PLLSAIN) >> RCC_PLLSAICFGR_PLLSAIN_Pos);\r
1299   PeriphClkInit->PLLSAI.PLLSAIP = (uint32_t)((RCC->PLLSAICFGR & RCC_PLLSAICFGR_PLLSAIP) >> RCC_PLLSAICFGR_PLLSAIP_Pos);\r
1300   PeriphClkInit->PLLSAI.PLLSAIQ = (uint32_t)((RCC->PLLSAICFGR & RCC_PLLSAICFGR_PLLSAIQ) >> RCC_PLLSAICFGR_PLLSAIQ_Pos);\r
1301 \r
1302   /* Get the PLLSAI/PLLI2S division factors -------------------------------------------*/\r
1303   PeriphClkInit->PLLI2SDivQ = (uint32_t)((RCC->DCKCFGR1 & RCC_DCKCFGR1_PLLI2SDIVQ) >> RCC_DCKCFGR1_PLLI2SDIVQ_Pos);\r
1304   PeriphClkInit->PLLSAIDivQ = (uint32_t)((RCC->DCKCFGR1 & RCC_DCKCFGR1_PLLSAIDIVQ) >> RCC_DCKCFGR1_PLLSAIDIVQ_Pos);\r
1305 \r
1306   /* Get the SAI1 clock configuration ----------------------------------------------*/\r
1307   PeriphClkInit->Sai1ClockSelection = __HAL_RCC_GET_SAI1_SOURCE();\r
1308 \r
1309   /* Get the SAI2 clock configuration ----------------------------------------------*/\r
1310   PeriphClkInit->Sai2ClockSelection = __HAL_RCC_GET_SAI2_SOURCE();\r
1311 \r
1312   /* Get the I2S clock configuration ------------------------------------------*/\r
1313   PeriphClkInit->I2sClockSelection = __HAL_RCC_GET_I2SCLKSOURCE();\r
1314 \r
1315   /* Get the I2C1 clock configuration ------------------------------------------*/\r
1316   PeriphClkInit->I2c1ClockSelection = __HAL_RCC_GET_I2C1_SOURCE();\r
1317 \r
1318   /* Get the I2C2 clock configuration ------------------------------------------*/\r
1319   PeriphClkInit->I2c2ClockSelection = __HAL_RCC_GET_I2C2_SOURCE();\r
1320 \r
1321   /* Get the I2C3 clock configuration ------------------------------------------*/\r
1322   PeriphClkInit->I2c3ClockSelection = __HAL_RCC_GET_I2C3_SOURCE();\r
1323 \r
1324   /* Get the USART1 clock configuration ------------------------------------------*/\r
1325   PeriphClkInit->Usart1ClockSelection = __HAL_RCC_GET_USART1_SOURCE();\r
1326 \r
1327   /* Get the USART2 clock configuration ------------------------------------------*/\r
1328   PeriphClkInit->Usart2ClockSelection = __HAL_RCC_GET_USART2_SOURCE();\r
1329 \r
1330   /* Get the USART3 clock configuration ------------------------------------------*/\r
1331   PeriphClkInit->Usart3ClockSelection = __HAL_RCC_GET_USART3_SOURCE();\r
1332 \r
1333   /* Get the UART4 clock configuration ------------------------------------------*/\r
1334   PeriphClkInit->Uart4ClockSelection = __HAL_RCC_GET_UART4_SOURCE();\r
1335 \r
1336   /* Get the UART5 clock configuration ------------------------------------------*/\r
1337   PeriphClkInit->Uart5ClockSelection = __HAL_RCC_GET_UART5_SOURCE();\r
1338 \r
1339   /* Get the USART6 clock configuration ------------------------------------------*/\r
1340   PeriphClkInit->Usart6ClockSelection = __HAL_RCC_GET_USART6_SOURCE();\r
1341 \r
1342   /* Get the UART7 clock configuration ------------------------------------------*/\r
1343   PeriphClkInit->Uart7ClockSelection = __HAL_RCC_GET_UART7_SOURCE();\r
1344 \r
1345   /* Get the UART8 clock configuration ------------------------------------------*/\r
1346   PeriphClkInit->Uart8ClockSelection = __HAL_RCC_GET_UART8_SOURCE();\r
1347 \r
1348   /* Get the LPTIM1 clock configuration ------------------------------------------*/\r
1349   PeriphClkInit->Lptim1ClockSelection = __HAL_RCC_GET_LPTIM1_SOURCE();\r
1350 \r
1351   /* Get the CK48 clock configuration -----------------------------------------------*/\r
1352   PeriphClkInit->Clk48ClockSelection = __HAL_RCC_GET_CLK48_SOURCE();\r
1353 \r
1354   /* Get the SDMMC1 clock configuration -----------------------------------------------*/\r
1355   PeriphClkInit->Sdmmc1ClockSelection = __HAL_RCC_GET_SDMMC1_SOURCE();\r
1356 \r
1357   /* Get the SDMMC2 clock configuration -----------------------------------------------*/\r
1358   PeriphClkInit->Sdmmc2ClockSelection = __HAL_RCC_GET_SDMMC2_SOURCE();\r
1359 \r
1360   /* Get the RTC Clock configuration -----------------------------------------------*/\r
1361   tempreg = (RCC->CFGR & RCC_CFGR_RTCPRE);\r
1362   PeriphClkInit->RTCClockSelection = (uint32_t)((tempreg) | (RCC->BDCR & RCC_BDCR_RTCSEL));\r
1363 \r
1364   /* Get the TIM Prescaler configuration --------------------------------------------*/\r
1365   if ((RCC->DCKCFGR1 & RCC_DCKCFGR1_TIMPRE) == RESET)\r
1366   {\r
1367     PeriphClkInit->TIMPresSelection = RCC_TIMPRES_DESACTIVATED;\r
1368   }\r
1369   else\r
1370   {\r
1371     PeriphClkInit->TIMPresSelection = RCC_TIMPRES_ACTIVATED;\r
1372   }\r
1373 }\r
1374 #endif /* STM32F722xx || STM32F723xx || STM32F732xx || STM32F733xx || STM32F730xx */\r
1375 \r
1376 /**\r
1377   * @brief  Return the peripheral clock frequency for a given peripheral(SAI..)\r
1378   * @note   Return 0 if peripheral clock identifier not managed by this API\r
1379   * @param  PeriphClk Peripheral clock identifier\r
1380   *         This parameter can be one of the following values:\r
1381   *            @arg RCC_PERIPHCLK_SAI1: SAI1 peripheral clock\r
1382   *            @arg RCC_PERIPHCLK_SAI2: SAI2 peripheral clock\r
1383   * @retval Frequency in KHz\r
1384   */\r
1385 uint32_t HAL_RCCEx_GetPeriphCLKFreq(uint32_t PeriphClk)\r
1386 {\r
1387   uint32_t tmpreg = 0;\r
1388   /* This variable is used to store the SAI clock frequency (value in Hz) */\r
1389   uint32_t frequency = 0;\r
1390   /* This variable is used to store the VCO Input (value in Hz) */\r
1391   uint32_t vcoinput = 0;\r
1392   /* This variable is used to store the SAI clock source */\r
1393   uint32_t saiclocksource = 0;\r
1394 \r
1395   if (PeriphClk == RCC_PERIPHCLK_SAI1)\r
1396   {\r
1397     saiclocksource = RCC->DCKCFGR1;\r
1398     saiclocksource &= RCC_DCKCFGR1_SAI1SEL;\r
1399     switch (saiclocksource)\r
1400     {\r
1401     case 0: /* PLLSAI is the clock source for SAI1 */\r
1402       {\r
1403         /* Configure the PLLSAI division factor */\r
1404         /* PLLSAI_VCO Input  = PLL_SOURCE/PLLM */\r
1405         if((RCC->PLLCFGR & RCC_PLLCFGR_PLLSRC) == RCC_PLLSOURCE_HSI)\r
1406         {\r
1407           /* In Case the PLL Source is HSI (Internal Clock) */\r
1408           vcoinput = (HSI_VALUE / (uint32_t)(RCC->PLLCFGR & RCC_PLLCFGR_PLLM));\r
1409         }\r
1410         else\r
1411         {\r
1412           /* In Case the PLL Source is HSE (External Clock) */\r
1413           vcoinput = ((HSE_VALUE / (uint32_t)(RCC->PLLCFGR & RCC_PLLCFGR_PLLM)));\r
1414         }\r
1415         /* PLLSAI_VCO Output = PLLSAI_VCO Input * PLLSAIN */\r
1416         /* SAI_CLK(first level) = PLLSAI_VCO Output/PLLSAIQ */\r
1417         tmpreg = (RCC->PLLSAICFGR & RCC_PLLSAICFGR_PLLSAIQ) >> 24;\r
1418         frequency = (vcoinput * ((RCC->PLLSAICFGR & RCC_PLLSAICFGR_PLLSAIN) >> 6))/(tmpreg);\r
1419 \r
1420         /* SAI_CLK_x = SAI_CLK(first level)/PLLSAIDIVQ */\r
1421         tmpreg = (((RCC->DCKCFGR1 & RCC_DCKCFGR1_PLLSAIDIVQ) >> 8) + 1);\r
1422         frequency = frequency/(tmpreg);\r
1423         break;\r
1424       }\r
1425     case RCC_DCKCFGR1_SAI1SEL_0: /* PLLI2S is the clock source for SAI1 */\r
1426       {\r
1427         /* Configure the PLLI2S division factor */\r
1428         /* PLLI2S_VCO Input  = PLL_SOURCE/PLLM */\r
1429         if((RCC->PLLCFGR & RCC_PLLCFGR_PLLSRC) == RCC_PLLSOURCE_HSI)\r
1430         {\r
1431           /* In Case the PLL Source is HSI (Internal Clock) */\r
1432           vcoinput = (HSI_VALUE / (uint32_t)(RCC->PLLCFGR & RCC_PLLCFGR_PLLM));\r
1433         }\r
1434         else\r
1435         {\r
1436           /* In Case the PLL Source is HSE (External Clock) */\r
1437           vcoinput = ((HSE_VALUE / (uint32_t)(RCC->PLLCFGR & RCC_PLLCFGR_PLLM)));\r
1438         }\r
1439 \r
1440         /* PLLI2S_VCO Output = PLLI2S_VCO Input * PLLI2SN */\r
1441         /* SAI_CLK(first level) = PLLI2S_VCO Output/PLLI2SQ */\r
1442         tmpreg = (RCC->PLLI2SCFGR & RCC_PLLI2SCFGR_PLLI2SQ) >> 24;\r
1443         frequency = (vcoinput * ((RCC->PLLI2SCFGR & RCC_PLLI2SCFGR_PLLI2SN) >> 6))/(tmpreg);\r
1444 \r
1445         /* SAI_CLK_x = SAI_CLK(first level)/PLLI2SDIVQ */\r
1446         tmpreg = ((RCC->DCKCFGR1 & RCC_DCKCFGR1_PLLI2SDIVQ) + 1);\r
1447         frequency = frequency/(tmpreg);\r
1448         break;\r
1449       }\r
1450     case RCC_DCKCFGR1_SAI1SEL_1: /* External clock is the clock source for SAI1 */\r
1451       {\r
1452         frequency = EXTERNAL_CLOCK_VALUE;\r
1453         break;\r
1454       }\r
1455 #if defined (STM32F765xx) || defined (STM32F767xx) || defined (STM32F769xx) || defined (STM32F777xx) || defined (STM32F779xx)\r
1456     case RCC_DCKCFGR1_SAI1SEL: /* HSI or HSE is the clock source for SAI*/\r
1457       {\r
1458         if((RCC->PLLCFGR & RCC_PLLCFGR_PLLSRC) == RCC_PLLSOURCE_HSI)\r
1459         {\r
1460           /* In Case the main PLL Source is HSI */\r
1461           frequency = HSI_VALUE;\r
1462         }\r
1463         else\r
1464         {\r
1465           /* In Case the main PLL Source is HSE */\r
1466           frequency = HSE_VALUE;\r
1467         }\r
1468         break;\r
1469       }\r
1470 #endif /* STM32F767xx || STM32F769xx || STM32F777xx || STM32F779xx */\r
1471     default :\r
1472       {\r
1473         break;\r
1474       }\r
1475     }\r
1476   }\r
1477 \r
1478   if (PeriphClk == RCC_PERIPHCLK_SAI2)\r
1479   {\r
1480     saiclocksource = RCC->DCKCFGR1;\r
1481     saiclocksource &= RCC_DCKCFGR1_SAI2SEL;\r
1482     switch (saiclocksource)\r
1483     {\r
1484     case 0: /* PLLSAI is the clock source for SAI*/\r
1485       {\r
1486         /* Configure the PLLSAI division factor */\r
1487         /* PLLSAI_VCO Input  = PLL_SOURCE/PLLM */\r
1488         if((RCC->PLLCFGR & RCC_PLLCFGR_PLLSRC) == RCC_PLLSOURCE_HSI)\r
1489         {\r
1490           /* In Case the PLL Source is HSI (Internal Clock) */\r
1491           vcoinput = (HSI_VALUE / (uint32_t)(RCC->PLLCFGR & RCC_PLLCFGR_PLLM));\r
1492         }\r
1493         else\r
1494         {\r
1495           /* In Case the PLL Source is HSE (External Clock) */\r
1496           vcoinput = ((HSE_VALUE / (uint32_t)(RCC->PLLCFGR & RCC_PLLCFGR_PLLM)));\r
1497         }\r
1498         /* PLLSAI_VCO Output = PLLSAI_VCO Input * PLLSAIN */\r
1499         /* SAI_CLK(first level) = PLLSAI_VCO Output/PLLSAIQ */\r
1500         tmpreg = (RCC->PLLSAICFGR & RCC_PLLSAICFGR_PLLSAIQ) >> 24;\r
1501         frequency = (vcoinput * ((RCC->PLLSAICFGR & RCC_PLLSAICFGR_PLLSAIN) >> 6))/(tmpreg);\r
1502 \r
1503         /* SAI_CLK_x = SAI_CLK(first level)/PLLSAIDIVQ */\r
1504         tmpreg = (((RCC->DCKCFGR1 & RCC_DCKCFGR1_PLLSAIDIVQ) >> 8) + 1);\r
1505         frequency = frequency/(tmpreg);\r
1506         break;\r
1507       }\r
1508     case RCC_DCKCFGR1_SAI2SEL_0: /* PLLI2S is the clock source for SAI2 */\r
1509       {\r
1510         /* Configure the PLLI2S division factor */\r
1511         /* PLLI2S_VCO Input  = PLL_SOURCE/PLLM */\r
1512         if((RCC->PLLCFGR & RCC_PLLCFGR_PLLSRC) == RCC_PLLSOURCE_HSI)\r
1513         {\r
1514           /* In Case the PLL Source is HSI (Internal Clock) */\r
1515           vcoinput = (HSI_VALUE / (uint32_t)(RCC->PLLCFGR & RCC_PLLCFGR_PLLM));\r
1516         }\r
1517         else\r
1518         {\r
1519           /* In Case the PLL Source is HSE (External Clock) */\r
1520           vcoinput = ((HSE_VALUE / (uint32_t)(RCC->PLLCFGR & RCC_PLLCFGR_PLLM)));\r
1521         }\r
1522 \r
1523         /* PLLI2S_VCO Output = PLLI2S_VCO Input * PLLI2SN */\r
1524         /* SAI_CLK(first level) = PLLI2S_VCO Output/PLLI2SQ */\r
1525         tmpreg = (RCC->PLLI2SCFGR & RCC_PLLI2SCFGR_PLLI2SQ) >> 24;\r
1526         frequency = (vcoinput * ((RCC->PLLI2SCFGR & RCC_PLLI2SCFGR_PLLI2SN) >> 6))/(tmpreg);\r
1527 \r
1528         /* SAI_CLK_x = SAI_CLK(first level)/PLLI2SDIVQ */\r
1529         tmpreg = ((RCC->DCKCFGR1 & RCC_DCKCFGR1_PLLI2SDIVQ) + 1);\r
1530         frequency = frequency/(tmpreg);\r
1531         break;\r
1532       }\r
1533     case RCC_DCKCFGR1_SAI2SEL_1: /* External clock is the clock source for SAI2 */\r
1534       {\r
1535         frequency = EXTERNAL_CLOCK_VALUE;\r
1536         break;\r
1537       }\r
1538 #if defined (STM32F765xx) || defined (STM32F767xx) || defined (STM32F769xx) || defined (STM32F777xx) || defined (STM32F779xx)\r
1539     case RCC_DCKCFGR1_SAI2SEL: /* HSI or HSE is the clock source for SAI2 */\r
1540       {\r
1541         if((RCC->PLLCFGR & RCC_PLLCFGR_PLLSRC) == RCC_PLLSOURCE_HSI)\r
1542         {\r
1543           /* In Case the main PLL Source is HSI */\r
1544           frequency = HSI_VALUE;\r
1545         }\r
1546         else\r
1547         {\r
1548           /* In Case the main PLL Source is HSE */\r
1549           frequency = HSE_VALUE;\r
1550         }\r
1551         break;\r
1552       }\r
1553 #endif /* STM32F767xx || STM32F769xx || STM32F777xx || STM32F779xx */\r
1554     default :\r
1555       {\r
1556         break;\r
1557       }\r
1558     }\r
1559   }\r
1560 \r
1561   return frequency;\r
1562 }\r
1563 \r
1564 /**\r
1565   * @}\r
1566   */\r
1567 \r
1568 /** @defgroup RCCEx_Exported_Functions_Group2 Extended Clock management functions\r
1569  *  @brief  Extended Clock management functions\r
1570  *\r
1571 @verbatim\r
1572  ===============================================================================\r
1573                 ##### Extended clock management functions  #####\r
1574  ===============================================================================\r
1575     [..]\r
1576     This subsection provides a set of functions allowing to control the\r
1577     activation or deactivation of PLLI2S, PLLSAI.\r
1578 @endverbatim\r
1579   * @{\r
1580   */\r
1581 \r
1582 /**\r
1583   * @brief  Enable PLLI2S.\r
1584   * @param  PLLI2SInit  pointer to an RCC_PLLI2SInitTypeDef structure that\r
1585   *         contains the configuration information for the PLLI2S\r
1586   * @retval HAL status\r
1587   */\r
1588 HAL_StatusTypeDef HAL_RCCEx_EnablePLLI2S(RCC_PLLI2SInitTypeDef  *PLLI2SInit)\r
1589 {\r
1590   uint32_t tickstart;\r
1591 \r
1592   /* Check for parameters */\r
1593   assert_param(IS_RCC_PLLI2SN_VALUE(PLLI2SInit->PLLI2SN));\r
1594   assert_param(IS_RCC_PLLI2SR_VALUE(PLLI2SInit->PLLI2SR));\r
1595   assert_param(IS_RCC_PLLI2SQ_VALUE(PLLI2SInit->PLLI2SQ));\r
1596 #if defined(RCC_PLLI2SCFGR_PLLI2SP)\r
1597   assert_param(IS_RCC_PLLI2SP_VALUE(PLLI2SInit->PLLI2SP));\r
1598 #endif /* RCC_PLLI2SCFGR_PLLI2SP */\r
1599 \r
1600   /* Disable the PLLI2S */\r
1601   __HAL_RCC_PLLI2S_DISABLE();\r
1602 \r
1603   /* Wait till PLLI2S is disabled */\r
1604   tickstart = HAL_GetTick();\r
1605   while(__HAL_RCC_GET_FLAG(RCC_FLAG_PLLI2SRDY) != RESET)\r
1606   {\r
1607     if((HAL_GetTick() - tickstart ) > PLLI2S_TIMEOUT_VALUE)\r
1608     {\r
1609       /* return in case of Timeout detected */\r
1610       return HAL_TIMEOUT;\r
1611     }\r
1612   }\r
1613 \r
1614   /* Configure the PLLI2S division factors */\r
1615 #if defined (STM32F722xx) || defined (STM32F723xx) || defined (STM32F732xx) || defined (STM32F733xx) || defined (STM32F730xx)\r
1616   /* PLLI2S_VCO = f(VCO clock) = f(PLLI2S clock input) * PLLI2SN */\r
1617   /* I2SQCLK = PLLI2S_VCO / PLLI2SQ */\r
1618   /* I2SRCLK = PLLI2S_VCO / PLLI2SR */\r
1619   __HAL_RCC_PLLI2S_CONFIG(PLLI2SInit->PLLI2SN, PLLI2SInit->PLLI2SQ, PLLI2SInit->PLLI2SR);\r
1620 #else\r
1621   /* PLLI2S_VCO = f(VCO clock) = f(PLLI2S clock input) * PLLI2SN */\r
1622   /* I2SPCLK = PLLI2S_VCO / PLLI2SP */\r
1623   /* I2SQCLK = PLLI2S_VCO / PLLI2SQ */\r
1624   /* I2SRCLK = PLLI2S_VCO / PLLI2SR */\r
1625   __HAL_RCC_PLLI2S_CONFIG(PLLI2SInit->PLLI2SN, PLLI2SInit->PLLI2SP, PLLI2SInit->PLLI2SQ, PLLI2SInit->PLLI2SR);\r
1626 #endif /* STM32F722xx || STM32F723xx || STM32F732xx || STM32F733xx || STM32F730xx */\r
1627 \r
1628   /* Enable the PLLI2S */\r
1629   __HAL_RCC_PLLI2S_ENABLE();\r
1630 \r
1631   /* Wait till PLLI2S is ready */\r
1632   tickstart = HAL_GetTick();\r
1633   while(__HAL_RCC_GET_FLAG(RCC_FLAG_PLLI2SRDY) == RESET)\r
1634   {\r
1635     if((HAL_GetTick() - tickstart ) > PLLI2S_TIMEOUT_VALUE)\r
1636     {\r
1637       /* return in case of Timeout detected */\r
1638       return HAL_TIMEOUT;\r
1639     }\r
1640   }\r
1641 \r
1642  return HAL_OK;\r
1643 }\r
1644 \r
1645 /**\r
1646   * @brief  Disable PLLI2S.\r
1647   * @retval HAL status\r
1648   */\r
1649 HAL_StatusTypeDef HAL_RCCEx_DisablePLLI2S(void)\r
1650 {\r
1651   uint32_t tickstart;\r
1652 \r
1653   /* Disable the PLLI2S */\r
1654   __HAL_RCC_PLLI2S_DISABLE();\r
1655 \r
1656   /* Wait till PLLI2S is disabled */\r
1657   tickstart = HAL_GetTick();\r
1658   while(READ_BIT(RCC->CR, RCC_CR_PLLI2SRDY) != RESET)\r
1659   {\r
1660     if((HAL_GetTick() - tickstart) > PLLI2S_TIMEOUT_VALUE)\r
1661     {\r
1662       /* return in case of Timeout detected */\r
1663       return HAL_TIMEOUT;\r
1664     }\r
1665   }\r
1666 \r
1667   return HAL_OK;\r
1668 }\r
1669 \r
1670 /**\r
1671   * @brief  Enable PLLSAI.\r
1672   * @param  PLLSAIInit  pointer to an RCC_PLLSAIInitTypeDef structure that\r
1673   *         contains the configuration information for the PLLSAI\r
1674   * @retval HAL status\r
1675   */\r
1676 HAL_StatusTypeDef HAL_RCCEx_EnablePLLSAI(RCC_PLLSAIInitTypeDef  *PLLSAIInit)\r
1677 {\r
1678   uint32_t tickstart;\r
1679 \r
1680   /* Check for parameters */\r
1681   assert_param(IS_RCC_PLLSAIN_VALUE(PLLSAIInit->PLLSAIN));\r
1682   assert_param(IS_RCC_PLLSAIQ_VALUE(PLLSAIInit->PLLSAIQ));\r
1683   assert_param(IS_RCC_PLLSAIP_VALUE(PLLSAIInit->PLLSAIP));\r
1684 #if defined(RCC_PLLSAICFGR_PLLSAIR)\r
1685   assert_param(IS_RCC_PLLSAIR_VALUE(PLLSAIInit->PLLSAIR));\r
1686 #endif /* RCC_PLLSAICFGR_PLLSAIR */\r
1687 \r
1688   /* Disable the PLLSAI */\r
1689   __HAL_RCC_PLLSAI_DISABLE();\r
1690 \r
1691   /* Wait till PLLSAI is disabled */\r
1692   tickstart = HAL_GetTick();\r
1693   while(__HAL_RCC_PLLSAI_GET_FLAG() != RESET)\r
1694   {\r
1695     if((HAL_GetTick() - tickstart ) > PLLSAI_TIMEOUT_VALUE)\r
1696     {\r
1697       /* return in case of Timeout detected */\r
1698       return HAL_TIMEOUT;\r
1699     }\r
1700   }\r
1701 \r
1702   /* Configure the PLLSAI division factors */\r
1703 #if defined (STM32F722xx) || defined (STM32F723xx) || defined (STM32F732xx) || defined (STM32F733xx) || defined (STM32F730xx)\r
1704   /* PLLSAI_VCO = f(VCO clock) = f(PLLSAI clock input) * PLLSAIN */\r
1705   /* SAIPCLK = PLLSAI_VCO / PLLSAIP */\r
1706   /* SAIQCLK = PLLSAI_VCO / PLLSAIQ */\r
1707   __HAL_RCC_PLLSAI_CONFIG(PLLSAIInit->PLLSAIN, PLLSAIInit->PLLSAIP, PLLSAIInit->PLLSAIQ);\r
1708 #else\r
1709   /* PLLSAI_VCO = f(VCO clock) = f(PLLSAI clock input) * PLLSAIN */\r
1710   /* SAIPCLK = PLLSAI_VCO / PLLSAIP */\r
1711   /* SAIQCLK = PLLSAI_VCO / PLLSAIQ */\r
1712   /* SAIRCLK = PLLSAI_VCO / PLLSAIR */\r
1713   __HAL_RCC_PLLSAI_CONFIG(PLLSAIInit->PLLSAIN, PLLSAIInit->PLLSAIP, \\r
1714                           PLLSAIInit->PLLSAIQ, PLLSAIInit->PLLSAIR);\r
1715 #endif /* STM32F722xx || STM32F723xx || STM32F732xx || STM32F733xx || STM32F730xx */\r
1716 \r
1717   /* Enable the PLLSAI */\r
1718   __HAL_RCC_PLLSAI_ENABLE();\r
1719 \r
1720   /* Wait till PLLSAI is ready */\r
1721   tickstart = HAL_GetTick();\r
1722   while(__HAL_RCC_PLLSAI_GET_FLAG() == RESET)\r
1723   {\r
1724     if((HAL_GetTick() - tickstart ) > PLLSAI_TIMEOUT_VALUE)\r
1725     {\r
1726       /* return in case of Timeout detected */\r
1727       return HAL_TIMEOUT;\r
1728     }\r
1729   }\r
1730 \r
1731  return HAL_OK;\r
1732 }\r
1733 \r
1734 /**\r
1735   * @brief  Disable PLLSAI.\r
1736   * @retval HAL status\r
1737   */\r
1738 HAL_StatusTypeDef HAL_RCCEx_DisablePLLSAI(void)\r
1739 {\r
1740   uint32_t tickstart;\r
1741 \r
1742   /* Disable the PLLSAI */\r
1743   __HAL_RCC_PLLSAI_DISABLE();\r
1744 \r
1745   /* Wait till PLLSAI is disabled */\r
1746   tickstart = HAL_GetTick();\r
1747   while(__HAL_RCC_PLLSAI_GET_FLAG() != RESET)\r
1748   {\r
1749     if((HAL_GetTick() - tickstart) > PLLSAI_TIMEOUT_VALUE)\r
1750     {\r
1751       /* return in case of Timeout detected */\r
1752       return HAL_TIMEOUT;\r
1753     }\r
1754   }\r
1755 \r
1756   return HAL_OK;\r
1757 }\r
1758 \r
1759 /**\r
1760   * @}\r
1761   */\r
1762 \r
1763 /**\r
1764   * @}\r
1765   */\r
1766 \r
1767 #endif /* HAL_RCC_MODULE_ENABLED */\r
1768 /**\r
1769   * @}\r
1770   */\r
1771 \r
1772 /**\r
1773   * @}\r
1774   */\r
1775 \r
1776 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/\r