mbed-dev | Mbed

Users » ptpaterson » Code » mbed-dev

Paul Paterson / mbed-dev

Fork of mbed-dev by mbed official

targets/TARGET_STM/TARGET_STM32L4/device/stm32l4xx_hal_rcc_ex.c@149:156823d33999, 2016-10-28 (annotated)

Committer:: <>
Date:: Fri Oct 28 11:17:30 2016 +0100
Revision:: 149:156823d33999
Parent:: targets/cmsis/TARGET_STM/TARGET_STM32L4/stm32l4xx_hal_rcc_ex.c@144:ef7eb2e8f9f7

This updates the lib to the mbed lib v128

NOTE: This release includes a restructuring of the file and directory locations and thus some

include paths in your code may need updating accordingly.

Who changed what in which revision?

User	Revision	Line number	New contents of line
<>	144:ef7eb2e8f9f7	1	/**
<>	144:ef7eb2e8f9f7	2	******************************************************************************
<>	144:ef7eb2e8f9f7	3	* @file stm32l4xx_hal_rcc_ex.c
<>	144:ef7eb2e8f9f7	4	* @author MCD Application Team
<>	144:ef7eb2e8f9f7	5	* @version V1.5.1
<>	144:ef7eb2e8f9f7	6	* @date 31-May-2016
<>	144:ef7eb2e8f9f7	7	* @brief Extended RCC HAL module driver.
<>	144:ef7eb2e8f9f7	8	* This file provides firmware functions to manage the following
<>	144:ef7eb2e8f9f7	9	* functionalities RCC extended peripheral:
<>	144:ef7eb2e8f9f7	10	* + Extended Peripheral Control functions
<>	144:ef7eb2e8f9f7	11	* + Extended Clock management functions
<>	144:ef7eb2e8f9f7	12	* + Extended Clock Recovery System Control functions
<>	144:ef7eb2e8f9f7	13	*
<>	144:ef7eb2e8f9f7	14	******************************************************************************
<>	144:ef7eb2e8f9f7	15	* @attention
<>	144:ef7eb2e8f9f7	16	*
<>	144:ef7eb2e8f9f7	17	* <h2><center>© COPYRIGHT(c) 2016 STMicroelectronics</center></h2>
<>	144:ef7eb2e8f9f7	18	*
<>	144:ef7eb2e8f9f7	19	* Redistribution and use in source and binary forms, with or without modification,
<>	144:ef7eb2e8f9f7	20	* are permitted provided that the following conditions are met:
<>	144:ef7eb2e8f9f7	21	* 1. Redistributions of source code must retain the above copyright notice,
<>	144:ef7eb2e8f9f7	22	* this list of conditions and the following disclaimer.
<>	144:ef7eb2e8f9f7	23	* 2. Redistributions in binary form must reproduce the above copyright notice,
<>	144:ef7eb2e8f9f7	24	* this list of conditions and the following disclaimer in the documentation
<>	144:ef7eb2e8f9f7	25	* and/or other materials provided with the distribution.
<>	144:ef7eb2e8f9f7	26	* 3. Neither the name of STMicroelectronics nor the names of its contributors
<>	144:ef7eb2e8f9f7	27	* may be used to endorse or promote products derived from this software
<>	144:ef7eb2e8f9f7	28	* without specific prior written permission.
<>	144:ef7eb2e8f9f7	29	*
<>	144:ef7eb2e8f9f7	30	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
<>	144:ef7eb2e8f9f7	31	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
<>	144:ef7eb2e8f9f7	32	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
<>	144:ef7eb2e8f9f7	33	* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
<>	144:ef7eb2e8f9f7	34	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
<>	144:ef7eb2e8f9f7	35	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
<>	144:ef7eb2e8f9f7	36	* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
<>	144:ef7eb2e8f9f7	37	* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
<>	144:ef7eb2e8f9f7	38	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
<>	144:ef7eb2e8f9f7	39	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
<>	144:ef7eb2e8f9f7	40	*
<>	144:ef7eb2e8f9f7	41	******************************************************************************
<>	144:ef7eb2e8f9f7	42	*/
<>	144:ef7eb2e8f9f7	43
<>	144:ef7eb2e8f9f7	44	/* Includes ------------------------------------------------------------------*/
<>	144:ef7eb2e8f9f7	45	#include "stm32l4xx_hal.h"
<>	144:ef7eb2e8f9f7	46
<>	144:ef7eb2e8f9f7	47	/** @addtogroup STM32L4xx_HAL_Driver
<>	144:ef7eb2e8f9f7	48	* @{
<>	144:ef7eb2e8f9f7	49	*/
<>	144:ef7eb2e8f9f7	50
<>	144:ef7eb2e8f9f7	51	/** @defgroup RCCEx RCCEx
<>	144:ef7eb2e8f9f7	52	* @brief RCC Extended HAL module driver
<>	144:ef7eb2e8f9f7	53	* @{
<>	144:ef7eb2e8f9f7	54	*/
<>	144:ef7eb2e8f9f7	55
<>	144:ef7eb2e8f9f7	56	#ifdef HAL_RCC_MODULE_ENABLED
<>	144:ef7eb2e8f9f7	57
<>	144:ef7eb2e8f9f7	58	/* Private typedef -----------------------------------------------------------*/
<>	144:ef7eb2e8f9f7	59	/* Private defines -----------------------------------------------------------*/
<>	144:ef7eb2e8f9f7	60	/** @defgroup RCCEx_Private_Constants RCCEx Private Constants
<>	144:ef7eb2e8f9f7	61	* @{
<>	144:ef7eb2e8f9f7	62	*/
<>	144:ef7eb2e8f9f7	63	#define PLLSAI1_TIMEOUT_VALUE ((uint32_t)2U) /* 2 ms (minimum Tick + 1) */
<>	144:ef7eb2e8f9f7	64	#define PLLSAI2_TIMEOUT_VALUE ((uint32_t)2U) /* 2 ms (minimum Tick + 1) */
<>	144:ef7eb2e8f9f7	65	#define PLL_TIMEOUT_VALUE ((uint32_t)2U) /* 2 ms (minimum Tick + 1) */
<>	144:ef7eb2e8f9f7	66
<>	144:ef7eb2e8f9f7	67	#define DIVIDER_P_UPDATE 0U
<>	144:ef7eb2e8f9f7	68	#define DIVIDER_Q_UPDATE 1U
<>	144:ef7eb2e8f9f7	69	#define DIVIDER_R_UPDATE 2U
<>	144:ef7eb2e8f9f7	70
<>	144:ef7eb2e8f9f7	71	#define __LSCO_CLK_ENABLE() __HAL_RCC_GPIOA_CLK_ENABLE()
<>	144:ef7eb2e8f9f7	72	#define LSCO_GPIO_PORT GPIOA
<>	144:ef7eb2e8f9f7	73	#define LSCO_PIN GPIO_PIN_2
<>	144:ef7eb2e8f9f7	74	/**
<>	144:ef7eb2e8f9f7	75	* @}
<>	144:ef7eb2e8f9f7	76	*/
<>	144:ef7eb2e8f9f7	77
<>	144:ef7eb2e8f9f7	78	/* Private macros ------------------------------------------------------------*/
<>	144:ef7eb2e8f9f7	79	/* Private variables ---------------------------------------------------------*/
<>	144:ef7eb2e8f9f7	80	/* Private function prototypes -----------------------------------------------*/
<>	144:ef7eb2e8f9f7	81	/** @defgroup RCCEx_Private_Functions RCCEx Private Functions
<>	144:ef7eb2e8f9f7	82	* @{
<>	144:ef7eb2e8f9f7	83	*/
<>	144:ef7eb2e8f9f7	84	static HAL_StatusTypeDef RCCEx_PLLSAI1_Config(RCC_PLLSAI1InitTypeDef *PllSai1, uint32_t Divider);
<>	144:ef7eb2e8f9f7	85
<>	144:ef7eb2e8f9f7	86	#if defined(RCC_PLLSAI2_SUPPORT)
<>	144:ef7eb2e8f9f7	87
<>	144:ef7eb2e8f9f7	88	static HAL_StatusTypeDef RCCEx_PLLSAI2_Config(RCC_PLLSAI2InitTypeDef *PllSai2, uint32_t Divider);
<>	144:ef7eb2e8f9f7	89
<>	144:ef7eb2e8f9f7	90	#endif /* RCC_PLLSAI2_SUPPORT */
<>	144:ef7eb2e8f9f7	91
<>	144:ef7eb2e8f9f7	92	/**
<>	144:ef7eb2e8f9f7	93	* @}
<>	144:ef7eb2e8f9f7	94	*/
<>	144:ef7eb2e8f9f7	95
<>	144:ef7eb2e8f9f7	96	/* Exported functions --------------------------------------------------------*/
<>	144:ef7eb2e8f9f7	97
<>	144:ef7eb2e8f9f7	98	/** @defgroup RCCEx_Exported_Functions RCCEx Exported Functions
<>	144:ef7eb2e8f9f7	99	* @{
<>	144:ef7eb2e8f9f7	100	*/
<>	144:ef7eb2e8f9f7	101
<>	144:ef7eb2e8f9f7	102	/** @defgroup RCCEx_Exported_Functions_Group1 Extended Peripheral Control functions
<>	144:ef7eb2e8f9f7	103	* @brief Extended Peripheral Control functions
<>	144:ef7eb2e8f9f7	104	*
<>	144:ef7eb2e8f9f7	105	@verbatim
<>	144:ef7eb2e8f9f7	106	===============================================================================
<>	144:ef7eb2e8f9f7	107	##### Extended Peripheral Control functions #####
<>	144:ef7eb2e8f9f7	108	===============================================================================
<>	144:ef7eb2e8f9f7	109	[..]
<>	144:ef7eb2e8f9f7	110	This subsection provides a set of functions allowing to control the RCC Clocks
<>	144:ef7eb2e8f9f7	111	frequencies.
<>	144:ef7eb2e8f9f7	112	[..]
<>	144:ef7eb2e8f9f7	113	(@) Important note: Care must be taken when HAL_RCCEx_PeriphCLKConfig() is used to
<>	144:ef7eb2e8f9f7	114	select the RTC clock source; in this case the Backup domain will be reset in
<>	144:ef7eb2e8f9f7	115	order to modify the RTC Clock source, as consequence RTC registers (including
<>	144:ef7eb2e8f9f7	116	the backup registers) are set to their reset values.
<>	144:ef7eb2e8f9f7	117
<>	144:ef7eb2e8f9f7	118	@endverbatim
<>	144:ef7eb2e8f9f7	119	* @{
<>	144:ef7eb2e8f9f7	120	*/
<>	144:ef7eb2e8f9f7	121	/**
<>	144:ef7eb2e8f9f7	122	* @brief Initialize the RCC extended peripherals clocks according to the specified
<>	144:ef7eb2e8f9f7	123	* parameters in the RCC_PeriphCLKInitTypeDef.
<>	144:ef7eb2e8f9f7	124	* @param PeriphClkInit pointer to an RCC_PeriphCLKInitTypeDef structure that
<>	144:ef7eb2e8f9f7	125	* contains a field PeriphClockSelection which can be a combination of the following values:
<>	144:ef7eb2e8f9f7	126	* @arg @ref RCC_PERIPHCLK_RTC RTC peripheral clock
<>	144:ef7eb2e8f9f7	127	* @arg @ref RCC_PERIPHCLK_ADC ADC peripheral clock
<>	144:ef7eb2e8f9f7	128	@if STM32L486xx
<>	144:ef7eb2e8f9f7	129	* @arg @ref RCC_PERIPHCLK_DFSDM1 DFSDM1 peripheral clock (only for devices with DFSDM1)
<>	144:ef7eb2e8f9f7	130	@endif
<>	144:ef7eb2e8f9f7	131	* @arg @ref RCC_PERIPHCLK_I2C1 I2C1 peripheral clock
<>	144:ef7eb2e8f9f7	132	* @arg @ref RCC_PERIPHCLK_I2C2 I2C2 peripheral clock
<>	144:ef7eb2e8f9f7	133	* @arg @ref RCC_PERIPHCLK_I2C3 I2C3 peripheral clock
<>	144:ef7eb2e8f9f7	134	* @arg @ref RCC_PERIPHCLK_LPTIM1 LPTIM1 peripheral clock
<>	144:ef7eb2e8f9f7	135	* @arg @ref RCC_PERIPHCLK_LPTIM2 LPTIM2 peripheral clock
<>	144:ef7eb2e8f9f7	136	* @arg @ref RCC_PERIPHCLK_LPUART1 LPUART1 peripheral clock
<>	144:ef7eb2e8f9f7	137	* @arg @ref RCC_PERIPHCLK_RNG RNG peripheral clock
<>	144:ef7eb2e8f9f7	138	* @arg @ref RCC_PERIPHCLK_SAI1 SAI1 peripheral clock
<>	144:ef7eb2e8f9f7	139	@if STM32L486xx
<>	144:ef7eb2e8f9f7	140	* @arg @ref RCC_PERIPHCLK_SAI2 SAI2 peripheral clock (only for devices with SAI2)
<>	144:ef7eb2e8f9f7	141	@endif
<>	144:ef7eb2e8f9f7	142	* @arg @ref RCC_PERIPHCLK_SDMMC1 SDMMC1 peripheral clock
<>	144:ef7eb2e8f9f7	143	@if STM32L443xx
<>	144:ef7eb2e8f9f7	144	* @arg @ref RCC_PERIPHCLK_SWPMI1 SWPMI1 peripheral clock (only for devices with SWPMI1)
<>	144:ef7eb2e8f9f7	145	@endif
<>	144:ef7eb2e8f9f7	146	@if STM32L486xx
<>	144:ef7eb2e8f9f7	147	* @arg @ref RCC_PERIPHCLK_SWPMI1 SWPMI1 peripheral clock (only for devices with SWPMI1)
<>	144:ef7eb2e8f9f7	148	@endif
<>	144:ef7eb2e8f9f7	149	* @arg @ref RCC_PERIPHCLK_USART1 USART1 peripheral clock
<>	144:ef7eb2e8f9f7	150	* @arg @ref RCC_PERIPHCLK_USART2 USART1 peripheral clock
<>	144:ef7eb2e8f9f7	151	* @arg @ref RCC_PERIPHCLK_USART3 USART1 peripheral clock
<>	144:ef7eb2e8f9f7	152	@if STM32L486xx
<>	144:ef7eb2e8f9f7	153	* @arg @ref RCC_PERIPHCLK_UART4 USART1 peripheral clock (only for devices with UART4)
<>	144:ef7eb2e8f9f7	154	* @arg @ref RCC_PERIPHCLK_UART5 USART1 peripheral clock (only for devices with UART5)
<>	144:ef7eb2e8f9f7	155	* @arg @ref RCC_PERIPHCLK_USB USB peripheral clock (only for devices with USB)
<>	144:ef7eb2e8f9f7	156	@endif
<>	144:ef7eb2e8f9f7	157	*
<>	144:ef7eb2e8f9f7	158	* @note Care must be taken when HAL_RCCEx_PeriphCLKConfig() is used to select
<>	144:ef7eb2e8f9f7	159	* the RTC clock source: in this case the access to Backup domain is enabled.
<>	144:ef7eb2e8f9f7	160	*
<>	144:ef7eb2e8f9f7	161	* @retval HAL status
<>	144:ef7eb2e8f9f7	162	*/
<>	144:ef7eb2e8f9f7	163	HAL_StatusTypeDef HAL_RCCEx_PeriphCLKConfig(RCC_PeriphCLKInitTypeDef *PeriphClkInit)
<>	144:ef7eb2e8f9f7	164	{
<>	144:ef7eb2e8f9f7	165	uint32_t tmpregister = 0;
<>	144:ef7eb2e8f9f7	166	uint32_t tickstart = 0U;
<>	144:ef7eb2e8f9f7	167	HAL_StatusTypeDef ret = HAL_OK; /* Intermediate status */
<>	144:ef7eb2e8f9f7	168	HAL_StatusTypeDef status = HAL_OK; /* Final status */
<>	144:ef7eb2e8f9f7	169
<>	144:ef7eb2e8f9f7	170	/* Check the parameters */
<>	144:ef7eb2e8f9f7	171	assert_param(IS_RCC_PERIPHCLOCK(PeriphClkInit->PeriphClockSelection));
<>	144:ef7eb2e8f9f7	172
<>	144:ef7eb2e8f9f7	173	/-------------------------- SAI1 clock source configuration ---------------------/
<>	144:ef7eb2e8f9f7	174	if((((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_SAI1) == RCC_PERIPHCLK_SAI1))
<>	144:ef7eb2e8f9f7	175	{
<>	144:ef7eb2e8f9f7	176	/* Check the parameters */
<>	144:ef7eb2e8f9f7	177	assert_param(IS_RCC_SAI1CLK(PeriphClkInit->Sai1ClockSelection));
<>	144:ef7eb2e8f9f7	178
<>	144:ef7eb2e8f9f7	179	switch(PeriphClkInit->Sai1ClockSelection)
<>	144:ef7eb2e8f9f7	180	{
<>	144:ef7eb2e8f9f7	181	case RCC_SAI1CLKSOURCE_PLL: /* PLL is used as clock source for SAI1*/
<>	144:ef7eb2e8f9f7	182	/* Enable SAI Clock output generated form System PLL . */
<>	144:ef7eb2e8f9f7	183	#if defined(RCC_PLLSAI2_SUPPORT)
<>	144:ef7eb2e8f9f7	184	__HAL_RCC_PLLCLKOUT_ENABLE(RCC_PLL_SAI3CLK);
<>	144:ef7eb2e8f9f7	185	#else
<>	144:ef7eb2e8f9f7	186	__HAL_RCC_PLLCLKOUT_ENABLE(RCC_PLL_SAI2CLK);
<>	144:ef7eb2e8f9f7	187	#endif /* RCC_PLLSAI2_SUPPORT */
<>	144:ef7eb2e8f9f7	188	/* SAI1 clock source config set later after clock selection check */
<>	144:ef7eb2e8f9f7	189	break;
<>	144:ef7eb2e8f9f7	190
<>	144:ef7eb2e8f9f7	191	case RCC_SAI1CLKSOURCE_PLLSAI1: /* PLLSAI1 is used as clock source for SAI1*/
<>	144:ef7eb2e8f9f7	192	/* PLLSAI1 input clock, parameters M, N & P configuration and clock output (PLLSAI1ClockOut) */
<>	144:ef7eb2e8f9f7	193	ret = RCCEx_PLLSAI1_Config(&(PeriphClkInit->PLLSAI1), DIVIDER_P_UPDATE);
<>	144:ef7eb2e8f9f7	194	/* SAI1 clock source config set later after clock selection check */
<>	144:ef7eb2e8f9f7	195	break;
<>	144:ef7eb2e8f9f7	196
<>	144:ef7eb2e8f9f7	197	#if defined(RCC_PLLSAI2_SUPPORT)
<>	144:ef7eb2e8f9f7	198
<>	144:ef7eb2e8f9f7	199	case RCC_SAI1CLKSOURCE_PLLSAI2: /* PLLSAI2 is used as clock source for SAI1*/
<>	144:ef7eb2e8f9f7	200	/* PLLSAI2 input clock, parameters M, N & P configuration clock output (PLLSAI2ClockOut) */
<>	144:ef7eb2e8f9f7	201	ret = RCCEx_PLLSAI2_Config(&(PeriphClkInit->PLLSAI2), DIVIDER_P_UPDATE);
<>	144:ef7eb2e8f9f7	202	/* SAI1 clock source config set later after clock selection check */
<>	144:ef7eb2e8f9f7	203	break;
<>	144:ef7eb2e8f9f7	204
<>	144:ef7eb2e8f9f7	205	#endif /* RCC_PLLSAI2_SUPPORT */
<>	144:ef7eb2e8f9f7	206
<>	144:ef7eb2e8f9f7	207	case RCC_SAI1CLKSOURCE_PIN: /* External clock is used as source of SAI1 clock*/
<>	144:ef7eb2e8f9f7	208	/* SAI1 clock source config set later after clock selection check */
<>	144:ef7eb2e8f9f7	209	break;
<>	144:ef7eb2e8f9f7	210
<>	144:ef7eb2e8f9f7	211	default:
<>	144:ef7eb2e8f9f7	212	ret = HAL_ERROR;
<>	144:ef7eb2e8f9f7	213	break;
<>	144:ef7eb2e8f9f7	214	}
<>	144:ef7eb2e8f9f7	215
<>	144:ef7eb2e8f9f7	216	if(ret == HAL_OK)
<>	144:ef7eb2e8f9f7	217	{
<>	144:ef7eb2e8f9f7	218	/* Set the source of SAI1 clock*/
<>	144:ef7eb2e8f9f7	219	__HAL_RCC_SAI1_CONFIG(PeriphClkInit->Sai1ClockSelection);
<>	144:ef7eb2e8f9f7	220	}
<>	144:ef7eb2e8f9f7	221	else
<>	144:ef7eb2e8f9f7	222	{
<>	144:ef7eb2e8f9f7	223	/* set overall return value */
<>	144:ef7eb2e8f9f7	224	status = ret;
<>	144:ef7eb2e8f9f7	225	}
<>	144:ef7eb2e8f9f7	226	}
<>	144:ef7eb2e8f9f7	227
<>	144:ef7eb2e8f9f7	228	#if defined(SAI2)
<>	144:ef7eb2e8f9f7	229
<>	144:ef7eb2e8f9f7	230	/-------------------------- SAI2 clock source configuration ---------------------/
<>	144:ef7eb2e8f9f7	231	if((((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_SAI2) == RCC_PERIPHCLK_SAI2))
<>	144:ef7eb2e8f9f7	232	{
<>	144:ef7eb2e8f9f7	233	/* Check the parameters */
<>	144:ef7eb2e8f9f7	234	assert_param(IS_RCC_SAI2CLK(PeriphClkInit->Sai2ClockSelection));
<>	144:ef7eb2e8f9f7	235
<>	144:ef7eb2e8f9f7	236	switch(PeriphClkInit->Sai2ClockSelection)
<>	144:ef7eb2e8f9f7	237	{
<>	144:ef7eb2e8f9f7	238	case RCC_SAI2CLKSOURCE_PLL: /* PLL is used as clock source for SAI2*/
<>	144:ef7eb2e8f9f7	239	/* Enable SAI Clock output generated form System PLL . */
<>	144:ef7eb2e8f9f7	240	__HAL_RCC_PLLCLKOUT_ENABLE(RCC_PLL_SAI3CLK);
<>	144:ef7eb2e8f9f7	241	/* SAI2 clock source config set later after clock selection check */
<>	144:ef7eb2e8f9f7	242	break;
<>	144:ef7eb2e8f9f7	243
<>	144:ef7eb2e8f9f7	244	case RCC_SAI2CLKSOURCE_PLLSAI1: /* PLLSAI1 is used as clock source for SAI2*/
<>	144:ef7eb2e8f9f7	245	/* PLLSAI1 input clock, parameters M, N & P configuration and clock output (PLLSAI1ClockOut) */
<>	144:ef7eb2e8f9f7	246	ret = RCCEx_PLLSAI1_Config(&(PeriphClkInit->PLLSAI1), DIVIDER_P_UPDATE);
<>	144:ef7eb2e8f9f7	247	/* SAI2 clock source config set later after clock selection check */
<>	144:ef7eb2e8f9f7	248	break;
<>	144:ef7eb2e8f9f7	249
<>	144:ef7eb2e8f9f7	250	case RCC_SAI2CLKSOURCE_PLLSAI2: /* PLLSAI2 is used as clock source for SAI2*/
<>	144:ef7eb2e8f9f7	251	/* PLLSAI2 input clock, parameters M, N & P configuration and clock output (PLLSAI2ClockOut) */
<>	144:ef7eb2e8f9f7	252	ret = RCCEx_PLLSAI2_Config(&(PeriphClkInit->PLLSAI2), DIVIDER_P_UPDATE);
<>	144:ef7eb2e8f9f7	253	/* SAI2 clock source config set later after clock selection check */
<>	144:ef7eb2e8f9f7	254	break;
<>	144:ef7eb2e8f9f7	255
<>	144:ef7eb2e8f9f7	256	case RCC_SAI2CLKSOURCE_PIN: /* External clock is used as source of SAI2 clock*/
<>	144:ef7eb2e8f9f7	257	/* SAI2 clock source config set later after clock selection check */
<>	144:ef7eb2e8f9f7	258	break;
<>	144:ef7eb2e8f9f7	259
<>	144:ef7eb2e8f9f7	260	default:
<>	144:ef7eb2e8f9f7	261	ret = HAL_ERROR;
<>	144:ef7eb2e8f9f7	262	break;
<>	144:ef7eb2e8f9f7	263	}
<>	144:ef7eb2e8f9f7	264
<>	144:ef7eb2e8f9f7	265	if(ret == HAL_OK)
<>	144:ef7eb2e8f9f7	266	{
<>	144:ef7eb2e8f9f7	267	/* Set the source of SAI2 clock*/
<>	144:ef7eb2e8f9f7	268	__HAL_RCC_SAI2_CONFIG(PeriphClkInit->Sai2ClockSelection);
<>	144:ef7eb2e8f9f7	269	}
<>	144:ef7eb2e8f9f7	270	else
<>	144:ef7eb2e8f9f7	271	{
<>	144:ef7eb2e8f9f7	272	/* set overall return value */
<>	144:ef7eb2e8f9f7	273	status = ret;
<>	144:ef7eb2e8f9f7	274	}
<>	144:ef7eb2e8f9f7	275	}
<>	144:ef7eb2e8f9f7	276	#endif /* SAI2 */
<>	144:ef7eb2e8f9f7	277
<>	144:ef7eb2e8f9f7	278	/-------------------------- RTC clock source configuration ----------------------/
<>	144:ef7eb2e8f9f7	279	if((PeriphClkInit->PeriphClockSelection & RCC_PERIPHCLK_RTC) == RCC_PERIPHCLK_RTC)
<>	144:ef7eb2e8f9f7	280	{
<>	144:ef7eb2e8f9f7	281	FlagStatus pwrclkchanged = RESET;
<>	144:ef7eb2e8f9f7	282
<>	144:ef7eb2e8f9f7	283	/* Check for RTC Parameters used to output RTCCLK */
<>	144:ef7eb2e8f9f7	284	assert_param(IS_RCC_RTCCLKSOURCE(PeriphClkInit->RTCClockSelection));
<>	144:ef7eb2e8f9f7	285
<>	144:ef7eb2e8f9f7	286	/* Enable Power Clock */
<>	144:ef7eb2e8f9f7	287	if(__HAL_RCC_PWR_IS_CLK_DISABLED())
<>	144:ef7eb2e8f9f7	288	{
<>	144:ef7eb2e8f9f7	289	__HAL_RCC_PWR_CLK_ENABLE();
<>	144:ef7eb2e8f9f7	290	pwrclkchanged = SET;
<>	144:ef7eb2e8f9f7	291	}
<>	144:ef7eb2e8f9f7	292
<>	144:ef7eb2e8f9f7	293	/* Enable write access to Backup domain */
<>	144:ef7eb2e8f9f7	294	SET_BIT(PWR->CR1, PWR_CR1_DBP);
<>	144:ef7eb2e8f9f7	295
<>	144:ef7eb2e8f9f7	296	/* Wait for Backup domain Write protection disable */
<>	144:ef7eb2e8f9f7	297	tickstart = HAL_GetTick();
<>	144:ef7eb2e8f9f7	298
<>	144:ef7eb2e8f9f7	299	while((PWR->CR1 & PWR_CR1_DBP) == RESET)
<>	144:ef7eb2e8f9f7	300	{
<>	144:ef7eb2e8f9f7	301	if((HAL_GetTick() - tickstart) > RCC_DBP_TIMEOUT_VALUE)
<>	144:ef7eb2e8f9f7	302	{
<>	144:ef7eb2e8f9f7	303	ret = HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	304	break;
<>	144:ef7eb2e8f9f7	305	}
<>	144:ef7eb2e8f9f7	306	}
<>	144:ef7eb2e8f9f7	307
<>	144:ef7eb2e8f9f7	308	if(ret == HAL_OK)
<>	144:ef7eb2e8f9f7	309	{
<>	144:ef7eb2e8f9f7	310	/* Reset the Backup domain only if the RTC Clock source selection is modified from default */
<>	144:ef7eb2e8f9f7	311	tmpregister = READ_BIT(RCC->BDCR, RCC_BDCR_RTCSEL);
<>	144:ef7eb2e8f9f7	312
<>	144:ef7eb2e8f9f7	313	if((tmpregister != RCC_RTCCLKSOURCE_NO_CLK) && (tmpregister != PeriphClkInit->RTCClockSelection))
<>	144:ef7eb2e8f9f7	314	{
<>	144:ef7eb2e8f9f7	315	/* Store the content of BDCR register before the reset of Backup Domain */
<>	144:ef7eb2e8f9f7	316	tmpregister = READ_BIT(RCC->BDCR, ~(RCC_BDCR_RTCSEL));
<>	144:ef7eb2e8f9f7	317	/* RTC Clock selection can be changed only if the Backup Domain is reset */
<>	144:ef7eb2e8f9f7	318	__HAL_RCC_BACKUPRESET_FORCE();
<>	144:ef7eb2e8f9f7	319	__HAL_RCC_BACKUPRESET_RELEASE();
<>	144:ef7eb2e8f9f7	320	/* Restore the Content of BDCR register */
<>	144:ef7eb2e8f9f7	321	RCC->BDCR = tmpregister;
<>	144:ef7eb2e8f9f7	322	}
<>	144:ef7eb2e8f9f7	323
<>	144:ef7eb2e8f9f7	324	/* Wait for LSE reactivation if LSE was enable prior to Backup Domain reset */
<>	144:ef7eb2e8f9f7	325	if (HAL_IS_BIT_SET(tmpregister, RCC_BDCR_LSEON))
<>	144:ef7eb2e8f9f7	326	{
<>	144:ef7eb2e8f9f7	327	/* Get Start Tick*/
<>	144:ef7eb2e8f9f7	328	tickstart = HAL_GetTick();
<>	144:ef7eb2e8f9f7	329
<>	144:ef7eb2e8f9f7	330	/* Wait till LSE is ready */
<>	144:ef7eb2e8f9f7	331	while(READ_BIT(RCC->BDCR, RCC_BDCR_LSERDY) == RESET)
<>	144:ef7eb2e8f9f7	332	{
<>	144:ef7eb2e8f9f7	333	if((HAL_GetTick() - tickstart) > RCC_LSE_TIMEOUT_VALUE)
<>	144:ef7eb2e8f9f7	334	{
<>	144:ef7eb2e8f9f7	335	ret = HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	336	break;
<>	144:ef7eb2e8f9f7	337	}
<>	144:ef7eb2e8f9f7	338	}
<>	144:ef7eb2e8f9f7	339	}
<>	144:ef7eb2e8f9f7	340
<>	144:ef7eb2e8f9f7	341	if(ret == HAL_OK)
<>	144:ef7eb2e8f9f7	342	{
<>	144:ef7eb2e8f9f7	343	/* Apply new RTC clock source selection */
<>	144:ef7eb2e8f9f7	344	__HAL_RCC_RTC_CONFIG(PeriphClkInit->RTCClockSelection);
<>	144:ef7eb2e8f9f7	345	}
<>	144:ef7eb2e8f9f7	346	else
<>	144:ef7eb2e8f9f7	347	{
<>	144:ef7eb2e8f9f7	348	/* set overall return value */
<>	144:ef7eb2e8f9f7	349	status = ret;
<>	144:ef7eb2e8f9f7	350	}
<>	144:ef7eb2e8f9f7	351	}
<>	144:ef7eb2e8f9f7	352	else
<>	144:ef7eb2e8f9f7	353	{
<>	144:ef7eb2e8f9f7	354	/* set overall return value */
<>	144:ef7eb2e8f9f7	355	status = ret;
<>	144:ef7eb2e8f9f7	356	}
<>	144:ef7eb2e8f9f7	357
<>	144:ef7eb2e8f9f7	358	/* Restore clock configuration if changed */
<>	144:ef7eb2e8f9f7	359	if(pwrclkchanged == SET)
<>	144:ef7eb2e8f9f7	360	{
<>	144:ef7eb2e8f9f7	361	__HAL_RCC_PWR_CLK_DISABLE();
<>	144:ef7eb2e8f9f7	362	}
<>	144:ef7eb2e8f9f7	363	}
<>	144:ef7eb2e8f9f7	364
<>	144:ef7eb2e8f9f7	365	/-------------------------- USART1 clock source configuration -------------------/
<>	144:ef7eb2e8f9f7	366	if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_USART1) == RCC_PERIPHCLK_USART1)
<>	144:ef7eb2e8f9f7	367	{
<>	144:ef7eb2e8f9f7	368	/* Check the parameters */
<>	144:ef7eb2e8f9f7	369	assert_param(IS_RCC_USART1CLKSOURCE(PeriphClkInit->Usart1ClockSelection));
<>	144:ef7eb2e8f9f7	370
<>	144:ef7eb2e8f9f7	371	/* Configure the USART1 clock source */
<>	144:ef7eb2e8f9f7	372	__HAL_RCC_USART1_CONFIG(PeriphClkInit->Usart1ClockSelection);
<>	144:ef7eb2e8f9f7	373	}
<>	144:ef7eb2e8f9f7	374
<>	144:ef7eb2e8f9f7	375	/-------------------------- USART2 clock source configuration -------------------/
<>	144:ef7eb2e8f9f7	376	if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_USART2) == RCC_PERIPHCLK_USART2)
<>	144:ef7eb2e8f9f7	377	{
<>	144:ef7eb2e8f9f7	378	/* Check the parameters */
<>	144:ef7eb2e8f9f7	379	assert_param(IS_RCC_USART2CLKSOURCE(PeriphClkInit->Usart2ClockSelection));
<>	144:ef7eb2e8f9f7	380
<>	144:ef7eb2e8f9f7	381	/* Configure the USART2 clock source */
<>	144:ef7eb2e8f9f7	382	__HAL_RCC_USART2_CONFIG(PeriphClkInit->Usart2ClockSelection);
<>	144:ef7eb2e8f9f7	383	}
<>	144:ef7eb2e8f9f7	384
<>	144:ef7eb2e8f9f7	385	#if defined(USART3)
<>	144:ef7eb2e8f9f7	386
<>	144:ef7eb2e8f9f7	387	/-------------------------- USART3 clock source configuration -------------------/
<>	144:ef7eb2e8f9f7	388	if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_USART3) == RCC_PERIPHCLK_USART3)
<>	144:ef7eb2e8f9f7	389	{
<>	144:ef7eb2e8f9f7	390	/* Check the parameters */
<>	144:ef7eb2e8f9f7	391	assert_param(IS_RCC_USART3CLKSOURCE(PeriphClkInit->Usart3ClockSelection));
<>	144:ef7eb2e8f9f7	392
<>	144:ef7eb2e8f9f7	393	/* Configure the USART3 clock source */
<>	144:ef7eb2e8f9f7	394	__HAL_RCC_USART3_CONFIG(PeriphClkInit->Usart3ClockSelection);
<>	144:ef7eb2e8f9f7	395	}
<>	144:ef7eb2e8f9f7	396
<>	144:ef7eb2e8f9f7	397	#endif /* USART3 */
<>	144:ef7eb2e8f9f7	398
<>	144:ef7eb2e8f9f7	399	#if defined(UART4)
<>	144:ef7eb2e8f9f7	400
<>	144:ef7eb2e8f9f7	401	/-------------------------- UART4 clock source configuration --------------------/
<>	144:ef7eb2e8f9f7	402	if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_UART4) == RCC_PERIPHCLK_UART4)
<>	144:ef7eb2e8f9f7	403	{
<>	144:ef7eb2e8f9f7	404	/* Check the parameters */
<>	144:ef7eb2e8f9f7	405	assert_param(IS_RCC_UART4CLKSOURCE(PeriphClkInit->Uart4ClockSelection));
<>	144:ef7eb2e8f9f7	406
<>	144:ef7eb2e8f9f7	407	/* Configure the UART4 clock source */
<>	144:ef7eb2e8f9f7	408	__HAL_RCC_UART4_CONFIG(PeriphClkInit->Uart4ClockSelection);
<>	144:ef7eb2e8f9f7	409	}
<>	144:ef7eb2e8f9f7	410
<>	144:ef7eb2e8f9f7	411	#endif /* UART4 */
<>	144:ef7eb2e8f9f7	412
<>	144:ef7eb2e8f9f7	413	#if defined(UART5)
<>	144:ef7eb2e8f9f7	414
<>	144:ef7eb2e8f9f7	415	/-------------------------- UART5 clock source configuration --------------------/
<>	144:ef7eb2e8f9f7	416	if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_UART5) == RCC_PERIPHCLK_UART5)
<>	144:ef7eb2e8f9f7	417	{
<>	144:ef7eb2e8f9f7	418	/* Check the parameters */
<>	144:ef7eb2e8f9f7	419	assert_param(IS_RCC_UART5CLKSOURCE(PeriphClkInit->Uart5ClockSelection));
<>	144:ef7eb2e8f9f7	420
<>	144:ef7eb2e8f9f7	421	/* Configure the UART5 clock source */
<>	144:ef7eb2e8f9f7	422	__HAL_RCC_UART5_CONFIG(PeriphClkInit->Uart5ClockSelection);
<>	144:ef7eb2e8f9f7	423	}
<>	144:ef7eb2e8f9f7	424
<>	144:ef7eb2e8f9f7	425	#endif /* UART5 */
<>	144:ef7eb2e8f9f7	426
<>	144:ef7eb2e8f9f7	427	/-------------------------- LPUART1 clock source configuration ------------------/
<>	144:ef7eb2e8f9f7	428	if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_LPUART1) == RCC_PERIPHCLK_LPUART1)
<>	144:ef7eb2e8f9f7	429	{
<>	144:ef7eb2e8f9f7	430	/* Check the parameters */
<>	144:ef7eb2e8f9f7	431	assert_param(IS_RCC_LPUART1CLKSOURCE(PeriphClkInit->Lpuart1ClockSelection));
<>	144:ef7eb2e8f9f7	432
<>	144:ef7eb2e8f9f7	433	/* Configure the LPUAR1 clock source */
<>	144:ef7eb2e8f9f7	434	__HAL_RCC_LPUART1_CONFIG(PeriphClkInit->Lpuart1ClockSelection);
<>	144:ef7eb2e8f9f7	435	}
<>	144:ef7eb2e8f9f7	436
<>	144:ef7eb2e8f9f7	437	/-------------------------- LPTIM1 clock source configuration -------------------/
<>	144:ef7eb2e8f9f7	438	if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_LPTIM1) == (RCC_PERIPHCLK_LPTIM1))
<>	144:ef7eb2e8f9f7	439	{
<>	144:ef7eb2e8f9f7	440	assert_param(IS_RCC_LPTIM1CLK(PeriphClkInit->Lptim1ClockSelection));
<>	144:ef7eb2e8f9f7	441	__HAL_RCC_LPTIM1_CONFIG(PeriphClkInit->Lptim1ClockSelection);
<>	144:ef7eb2e8f9f7	442	}
<>	144:ef7eb2e8f9f7	443
<>	144:ef7eb2e8f9f7	444	/-------------------------- LPTIM2 clock source configuration -------------------/
<>	144:ef7eb2e8f9f7	445	if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_LPTIM2) == (RCC_PERIPHCLK_LPTIM2))
<>	144:ef7eb2e8f9f7	446	{
<>	144:ef7eb2e8f9f7	447	assert_param(IS_RCC_LPTIM2CLK(PeriphClkInit->Lptim2ClockSelection));
<>	144:ef7eb2e8f9f7	448	__HAL_RCC_LPTIM2_CONFIG(PeriphClkInit->Lptim2ClockSelection);
<>	144:ef7eb2e8f9f7	449	}
<>	144:ef7eb2e8f9f7	450
<>	144:ef7eb2e8f9f7	451	/-------------------------- I2C1 clock source configuration ---------------------/
<>	144:ef7eb2e8f9f7	452	if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_I2C1) == RCC_PERIPHCLK_I2C1)
<>	144:ef7eb2e8f9f7	453	{
<>	144:ef7eb2e8f9f7	454	/* Check the parameters */
<>	144:ef7eb2e8f9f7	455	assert_param(IS_RCC_I2C1CLKSOURCE(PeriphClkInit->I2c1ClockSelection));
<>	144:ef7eb2e8f9f7	456
<>	144:ef7eb2e8f9f7	457	/* Configure the I2C1 clock source */
<>	144:ef7eb2e8f9f7	458	__HAL_RCC_I2C1_CONFIG(PeriphClkInit->I2c1ClockSelection);
<>	144:ef7eb2e8f9f7	459	}
<>	144:ef7eb2e8f9f7	460
<>	144:ef7eb2e8f9f7	461	#if defined(I2C2)
<>	144:ef7eb2e8f9f7	462
<>	144:ef7eb2e8f9f7	463	/-------------------------- I2C2 clock source configuration ---------------------/
<>	144:ef7eb2e8f9f7	464	if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_I2C2) == RCC_PERIPHCLK_I2C2)
<>	144:ef7eb2e8f9f7	465	{
<>	144:ef7eb2e8f9f7	466	/* Check the parameters */
<>	144:ef7eb2e8f9f7	467	assert_param(IS_RCC_I2C2CLKSOURCE(PeriphClkInit->I2c2ClockSelection));
<>	144:ef7eb2e8f9f7	468
<>	144:ef7eb2e8f9f7	469	/* Configure the I2C2 clock source */
<>	144:ef7eb2e8f9f7	470	__HAL_RCC_I2C2_CONFIG(PeriphClkInit->I2c2ClockSelection);
<>	144:ef7eb2e8f9f7	471	}
<>	144:ef7eb2e8f9f7	472
<>	144:ef7eb2e8f9f7	473	#endif /* I2C2 */
<>	144:ef7eb2e8f9f7	474
<>	144:ef7eb2e8f9f7	475	/-------------------------- I2C3 clock source configuration ---------------------/
<>	144:ef7eb2e8f9f7	476	if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_I2C3) == RCC_PERIPHCLK_I2C3)
<>	144:ef7eb2e8f9f7	477	{
<>	144:ef7eb2e8f9f7	478	/* Check the parameters */
<>	144:ef7eb2e8f9f7	479	assert_param(IS_RCC_I2C3CLKSOURCE(PeriphClkInit->I2c3ClockSelection));
<>	144:ef7eb2e8f9f7	480
<>	144:ef7eb2e8f9f7	481	/* Configure the I2C3 clock source */
<>	144:ef7eb2e8f9f7	482	__HAL_RCC_I2C3_CONFIG(PeriphClkInit->I2c3ClockSelection);
<>	144:ef7eb2e8f9f7	483	}
<>	144:ef7eb2e8f9f7	484
<>	144:ef7eb2e8f9f7	485	#if defined(USB_OTG_FS) \|\| defined(USB)
<>	144:ef7eb2e8f9f7	486
<>	144:ef7eb2e8f9f7	487	/-------------------------- USB clock source configuration ----------------------/
<>	144:ef7eb2e8f9f7	488	if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_USB) == (RCC_PERIPHCLK_USB))
<>	144:ef7eb2e8f9f7	489	{
<>	144:ef7eb2e8f9f7	490	assert_param(IS_RCC_USBCLKSOURCE(PeriphClkInit->UsbClockSelection));
<>	144:ef7eb2e8f9f7	491	__HAL_RCC_USB_CONFIG(PeriphClkInit->UsbClockSelection);
<>	144:ef7eb2e8f9f7	492
<>	144:ef7eb2e8f9f7	493	if(PeriphClkInit->UsbClockSelection == RCC_USBCLKSOURCE_PLL)
<>	144:ef7eb2e8f9f7	494	{
<>	144:ef7eb2e8f9f7	495	/* Enable PLL48M1CLK output */
<>	144:ef7eb2e8f9f7	496	__HAL_RCC_PLLCLKOUT_ENABLE(RCC_PLL_48M1CLK);
<>	144:ef7eb2e8f9f7	497	}
<>	144:ef7eb2e8f9f7	498	else if(PeriphClkInit->UsbClockSelection == RCC_USBCLKSOURCE_PLLSAI1)
<>	144:ef7eb2e8f9f7	499	{
<>	144:ef7eb2e8f9f7	500	/* PLLSAI1 input clock, parameters M, N & Q configuration and clock output (PLLSAI1ClockOut) */
<>	144:ef7eb2e8f9f7	501	ret = RCCEx_PLLSAI1_Config(&(PeriphClkInit->PLLSAI1), DIVIDER_Q_UPDATE);
<>	144:ef7eb2e8f9f7	502
<>	144:ef7eb2e8f9f7	503	if(ret != HAL_OK)
<>	144:ef7eb2e8f9f7	504	{
<>	144:ef7eb2e8f9f7	505	/* set overall return value */
<>	144:ef7eb2e8f9f7	506	status = ret;
<>	144:ef7eb2e8f9f7	507	}
<>	144:ef7eb2e8f9f7	508	}
<>	144:ef7eb2e8f9f7	509	}
<>	144:ef7eb2e8f9f7	510
<>	144:ef7eb2e8f9f7	511	#endif /* USB_OTG_FS \|\| USB */
<>	144:ef7eb2e8f9f7	512
<>	144:ef7eb2e8f9f7	513	#if defined(SDMMC1)
<>	144:ef7eb2e8f9f7	514
<>	144:ef7eb2e8f9f7	515	/-------------------------- SDMMC1 clock source configuration -------------------/
<>	144:ef7eb2e8f9f7	516	if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_SDMMC1) == (RCC_PERIPHCLK_SDMMC1))
<>	144:ef7eb2e8f9f7	517	{
<>	144:ef7eb2e8f9f7	518	assert_param(IS_RCC_SDMMC1CLKSOURCE(PeriphClkInit->Sdmmc1ClockSelection));
<>	144:ef7eb2e8f9f7	519	__HAL_RCC_SDMMC1_CONFIG(PeriphClkInit->Sdmmc1ClockSelection);
<>	144:ef7eb2e8f9f7	520
<>	144:ef7eb2e8f9f7	521	if(PeriphClkInit->Sdmmc1ClockSelection == RCC_SDMMC1CLKSOURCE_PLL)
<>	144:ef7eb2e8f9f7	522	{
<>	144:ef7eb2e8f9f7	523	/* Enable PLL48M1CLK output */
<>	144:ef7eb2e8f9f7	524	__HAL_RCC_PLLCLKOUT_ENABLE(RCC_PLL_48M1CLK);
<>	144:ef7eb2e8f9f7	525	}
<>	144:ef7eb2e8f9f7	526	else if(PeriphClkInit->Sdmmc1ClockSelection == RCC_SDMMC1CLKSOURCE_PLLSAI1)
<>	144:ef7eb2e8f9f7	527	{
<>	144:ef7eb2e8f9f7	528	/* PLLSAI1 input clock, parameters M, N & Q configuration and clock output (PLLSAI1ClockOut) */
<>	144:ef7eb2e8f9f7	529	ret = RCCEx_PLLSAI1_Config(&(PeriphClkInit->PLLSAI1), DIVIDER_Q_UPDATE);
<>	144:ef7eb2e8f9f7	530
<>	144:ef7eb2e8f9f7	531	if(ret != HAL_OK)
<>	144:ef7eb2e8f9f7	532	{
<>	144:ef7eb2e8f9f7	533	/* set overall return value */
<>	144:ef7eb2e8f9f7	534	status = ret;
<>	144:ef7eb2e8f9f7	535	}
<>	144:ef7eb2e8f9f7	536	}
<>	144:ef7eb2e8f9f7	537	}
<>	144:ef7eb2e8f9f7	538
<>	144:ef7eb2e8f9f7	539	#endif /* SDMMC1 */
<>	144:ef7eb2e8f9f7	540
<>	144:ef7eb2e8f9f7	541	/-------------------------- RNG clock source configuration ----------------------/
<>	144:ef7eb2e8f9f7	542	if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_RNG) == (RCC_PERIPHCLK_RNG))
<>	144:ef7eb2e8f9f7	543	{
<>	144:ef7eb2e8f9f7	544	assert_param(IS_RCC_RNGCLKSOURCE(PeriphClkInit->RngClockSelection));
<>	144:ef7eb2e8f9f7	545	__HAL_RCC_RNG_CONFIG(PeriphClkInit->RngClockSelection);
<>	144:ef7eb2e8f9f7	546
<>	144:ef7eb2e8f9f7	547	if(PeriphClkInit->RngClockSelection == RCC_RNGCLKSOURCE_PLL)
<>	144:ef7eb2e8f9f7	548	{
<>	144:ef7eb2e8f9f7	549	/* Enable PLL48M1CLK output */
<>	144:ef7eb2e8f9f7	550	__HAL_RCC_PLLCLKOUT_ENABLE(RCC_PLL_48M1CLK);
<>	144:ef7eb2e8f9f7	551	}
<>	144:ef7eb2e8f9f7	552	else if(PeriphClkInit->RngClockSelection == RCC_RNGCLKSOURCE_PLLSAI1)
<>	144:ef7eb2e8f9f7	553	{
<>	144:ef7eb2e8f9f7	554	/* PLLSAI1 input clock, parameters M, N & Q configuration and clock output (PLLSAI1ClockOut) */
<>	144:ef7eb2e8f9f7	555	ret = RCCEx_PLLSAI1_Config(&(PeriphClkInit->PLLSAI1), DIVIDER_Q_UPDATE);
<>	144:ef7eb2e8f9f7	556
<>	144:ef7eb2e8f9f7	557	if(ret != HAL_OK)
<>	144:ef7eb2e8f9f7	558	{
<>	144:ef7eb2e8f9f7	559	/* set overall return value */
<>	144:ef7eb2e8f9f7	560	status = ret;
<>	144:ef7eb2e8f9f7	561	}
<>	144:ef7eb2e8f9f7	562	}
<>	144:ef7eb2e8f9f7	563	}
<>	144:ef7eb2e8f9f7	564
<>	144:ef7eb2e8f9f7	565	/-------------------------- ADC clock source configuration ----------------------/
<>	144:ef7eb2e8f9f7	566	if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_ADC) == RCC_PERIPHCLK_ADC)
<>	144:ef7eb2e8f9f7	567	{
<>	144:ef7eb2e8f9f7	568	/* Check the parameters */
<>	144:ef7eb2e8f9f7	569	assert_param(IS_RCC_ADCCLKSOURCE(PeriphClkInit->AdcClockSelection));
<>	144:ef7eb2e8f9f7	570
<>	144:ef7eb2e8f9f7	571	/* Configure the ADC interface clock source */
<>	144:ef7eb2e8f9f7	572	__HAL_RCC_ADC_CONFIG(PeriphClkInit->AdcClockSelection);
<>	144:ef7eb2e8f9f7	573
<>	144:ef7eb2e8f9f7	574	if(PeriphClkInit->AdcClockSelection == RCC_ADCCLKSOURCE_PLLSAI1)
<>	144:ef7eb2e8f9f7	575	{
<>	144:ef7eb2e8f9f7	576	/* PLLSAI1 input clock, parameters M, N & R configuration and clock output (PLLSAI1ClockOut) */
<>	144:ef7eb2e8f9f7	577	ret = RCCEx_PLLSAI1_Config(&(PeriphClkInit->PLLSAI1), DIVIDER_R_UPDATE);
<>	144:ef7eb2e8f9f7	578
<>	144:ef7eb2e8f9f7	579	if(ret != HAL_OK)
<>	144:ef7eb2e8f9f7	580	{
<>	144:ef7eb2e8f9f7	581	/* set overall return value */
<>	144:ef7eb2e8f9f7	582	status = ret;
<>	144:ef7eb2e8f9f7	583	}
<>	144:ef7eb2e8f9f7	584	}
<>	144:ef7eb2e8f9f7	585
<>	144:ef7eb2e8f9f7	586	#if defined(STM32L471xx) \|\| defined(STM32L475xx) \|\| defined(STM32L476xx) \|\| defined(STM32L485xx) \|\| defined(STM32L486xx)
<>	144:ef7eb2e8f9f7	587
<>	144:ef7eb2e8f9f7	588	else if(PeriphClkInit->AdcClockSelection == RCC_ADCCLKSOURCE_PLLSAI2)
<>	144:ef7eb2e8f9f7	589	{
<>	144:ef7eb2e8f9f7	590	/* PLLSAI2 input clock, parameters M, N & R configuration and clock output (PLLSAI2ClockOut) */
<>	144:ef7eb2e8f9f7	591	ret = RCCEx_PLLSAI2_Config(&(PeriphClkInit->PLLSAI2), DIVIDER_R_UPDATE);
<>	144:ef7eb2e8f9f7	592
<>	144:ef7eb2e8f9f7	593	if(ret != HAL_OK)
<>	144:ef7eb2e8f9f7	594	{
<>	144:ef7eb2e8f9f7	595	/* set overall return value */
<>	144:ef7eb2e8f9f7	596	status = ret;
<>	144:ef7eb2e8f9f7	597	}
<>	144:ef7eb2e8f9f7	598	}
<>	144:ef7eb2e8f9f7	599
<>	144:ef7eb2e8f9f7	600	#endif /* STM32L471xx \|\| STM32L475xx \|\| STM32L476xx \|\| STM32L485xx \|\| STM32L486xx */
<>	144:ef7eb2e8f9f7	601
<>	144:ef7eb2e8f9f7	602	}
<>	144:ef7eb2e8f9f7	603
<>	144:ef7eb2e8f9f7	604	#if defined(SWPMI1)
<>	144:ef7eb2e8f9f7	605
<>	144:ef7eb2e8f9f7	606	/-------------------------- SWPMI1 clock source configuration -------------------/
<>	144:ef7eb2e8f9f7	607	if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_SWPMI1) == RCC_PERIPHCLK_SWPMI1)
<>	144:ef7eb2e8f9f7	608	{
<>	144:ef7eb2e8f9f7	609	/* Check the parameters */
<>	144:ef7eb2e8f9f7	610	assert_param(IS_RCC_SWPMI1CLKSOURCE(PeriphClkInit->Swpmi1ClockSelection));
<>	144:ef7eb2e8f9f7	611
<>	144:ef7eb2e8f9f7	612	/* Configure the SWPMI1 clock source */
<>	144:ef7eb2e8f9f7	613	__HAL_RCC_SWPMI1_CONFIG(PeriphClkInit->Swpmi1ClockSelection);
<>	144:ef7eb2e8f9f7	614	}
<>	144:ef7eb2e8f9f7	615
<>	144:ef7eb2e8f9f7	616	#endif /* SWPMI1 */
<>	144:ef7eb2e8f9f7	617
<>	144:ef7eb2e8f9f7	618	#if defined(DFSDM1_Filter0)
<>	144:ef7eb2e8f9f7	619
<>	144:ef7eb2e8f9f7	620	/-------------------------- DFSDM1 clock source configuration -------------------/
<>	144:ef7eb2e8f9f7	621	if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_DFSDM1) == RCC_PERIPHCLK_DFSDM1)
<>	144:ef7eb2e8f9f7	622	{
<>	144:ef7eb2e8f9f7	623	/* Check the parameters */
<>	144:ef7eb2e8f9f7	624	assert_param(IS_RCC_DFSDM1CLKSOURCE(PeriphClkInit->Dfsdm1ClockSelection));
<>	144:ef7eb2e8f9f7	625
<>	144:ef7eb2e8f9f7	626	/* Configure the DFSDM1 interface clock source */
<>	144:ef7eb2e8f9f7	627	__HAL_RCC_DFSDM1_CONFIG(PeriphClkInit->Dfsdm1ClockSelection);
<>	144:ef7eb2e8f9f7	628	}
<>	144:ef7eb2e8f9f7	629
<>	144:ef7eb2e8f9f7	630	#endif /* DFSDM1_Filter0 */
<>	144:ef7eb2e8f9f7	631
<>	144:ef7eb2e8f9f7	632	return status;
<>	144:ef7eb2e8f9f7	633	}
<>	144:ef7eb2e8f9f7	634
<>	144:ef7eb2e8f9f7	635	/**
<>	144:ef7eb2e8f9f7	636	* @brief Get the RCC_ClkInitStruct according to the internal RCC configuration registers.
<>	144:ef7eb2e8f9f7	637	* @param PeriphClkInit pointer to an RCC_PeriphCLKInitTypeDef structure that
<>	144:ef7eb2e8f9f7	638	* returns the configuration information for the Extended Peripherals
<>	144:ef7eb2e8f9f7	639	* clocks(SAI1, SAI2, LPTIM1, LPTIM2, I2C1, I2C2, I2C3, LPUART,
<>	144:ef7eb2e8f9f7	640	* USART1, USART2, USART3, UART4, UART5, RTC, ADCx, DFSDMx, SWPMI1, USB, SDMMC1 and RNG).
<>	144:ef7eb2e8f9f7	641	* @retval None
<>	144:ef7eb2e8f9f7	642	*/
<>	144:ef7eb2e8f9f7	643	void HAL_RCCEx_GetPeriphCLKConfig(RCC_PeriphCLKInitTypeDef *PeriphClkInit)
<>	144:ef7eb2e8f9f7	644	{
<>	144:ef7eb2e8f9f7	645	/* Set all possible values for the extended clock type parameter------------*/
<>	144:ef7eb2e8f9f7	646
<>	144:ef7eb2e8f9f7	647	#if defined(STM32L431xx)
<>	144:ef7eb2e8f9f7	648
<>	144:ef7eb2e8f9f7	649	PeriphClkInit->PeriphClockSelection = RCC_PERIPHCLK_USART1 \| RCC_PERIPHCLK_USART2 \| RCC_PERIPHCLK_USART3 \| \
<>	144:ef7eb2e8f9f7	650	RCC_PERIPHCLK_LPUART1 \| RCC_PERIPHCLK_I2C1 \| RCC_PERIPHCLK_I2C2 \| RCC_PERIPHCLK_I2C3 \| \
<>	144:ef7eb2e8f9f7	651	RCC_PERIPHCLK_LPTIM1 \| RCC_PERIPHCLK_LPTIM2 \| RCC_PERIPHCLK_SAI1 \| \
<>	144:ef7eb2e8f9f7	652	RCC_PERIPHCLK_SDMMC1 \| RCC_PERIPHCLK_RNG \| RCC_PERIPHCLK_ADC \| RCC_PERIPHCLK_SWPMI1 \| \
<>	144:ef7eb2e8f9f7	653	RCC_PERIPHCLK_RTC ;
<>	144:ef7eb2e8f9f7	654
<>	144:ef7eb2e8f9f7	655	#elif defined(STM32L432xx) \|\| defined(STM32L442xx)
<>	144:ef7eb2e8f9f7	656
<>	144:ef7eb2e8f9f7	657	PeriphClkInit->PeriphClockSelection = RCC_PERIPHCLK_USART1 \| RCC_PERIPHCLK_USART2 \| \
<>	144:ef7eb2e8f9f7	658	RCC_PERIPHCLK_LPUART1 \| RCC_PERIPHCLK_I2C1 \| RCC_PERIPHCLK_I2C3 \| \
<>	144:ef7eb2e8f9f7	659	RCC_PERIPHCLK_LPTIM1 \| RCC_PERIPHCLK_LPTIM2 \| RCC_PERIPHCLK_SAI1 \| RCC_PERIPHCLK_USB \| \
<>	144:ef7eb2e8f9f7	660	RCC_PERIPHCLK_RNG \| RCC_PERIPHCLK_ADC \| RCC_PERIPHCLK_SWPMI1 \| \
<>	144:ef7eb2e8f9f7	661	RCC_PERIPHCLK_RTC ;
<>	144:ef7eb2e8f9f7	662
<>	144:ef7eb2e8f9f7	663	#elif defined(STM32L433xx) \|\| defined(STM32L443xx)
<>	144:ef7eb2e8f9f7	664
<>	144:ef7eb2e8f9f7	665	PeriphClkInit->PeriphClockSelection = RCC_PERIPHCLK_USART1 \| RCC_PERIPHCLK_USART2 \| RCC_PERIPHCLK_USART3 \| \
<>	144:ef7eb2e8f9f7	666	RCC_PERIPHCLK_LPUART1 \| RCC_PERIPHCLK_I2C1 \| RCC_PERIPHCLK_I2C2 \| RCC_PERIPHCLK_I2C3 \| \
<>	144:ef7eb2e8f9f7	667	RCC_PERIPHCLK_LPTIM1 \| RCC_PERIPHCLK_LPTIM2 \| RCC_PERIPHCLK_SAI1 \| RCC_PERIPHCLK_USB \| \
<>	144:ef7eb2e8f9f7	668	RCC_PERIPHCLK_SDMMC1 \| RCC_PERIPHCLK_RNG \| RCC_PERIPHCLK_ADC \| RCC_PERIPHCLK_SWPMI1 \| \
<>	144:ef7eb2e8f9f7	669	RCC_PERIPHCLK_RTC ;
<>	144:ef7eb2e8f9f7	670	#elif defined(STM32L471xx)
<>	144:ef7eb2e8f9f7	671
<>	144:ef7eb2e8f9f7	672	PeriphClkInit->PeriphClockSelection = RCC_PERIPHCLK_USART1 \| RCC_PERIPHCLK_USART2 \| RCC_PERIPHCLK_USART3 \| RCC_PERIPHCLK_UART4 \| RCC_PERIPHCLK_UART5 \| \
<>	144:ef7eb2e8f9f7	673	RCC_PERIPHCLK_LPUART1 \| RCC_PERIPHCLK_I2C1 \| RCC_PERIPHCLK_I2C2 \| RCC_PERIPHCLK_I2C3 \| \
<>	144:ef7eb2e8f9f7	674	RCC_PERIPHCLK_LPTIM1 \| RCC_PERIPHCLK_LPTIM2 \| RCC_PERIPHCLK_SAI1 \| RCC_PERIPHCLK_SAI2 \| \
<>	144:ef7eb2e8f9f7	675	RCC_PERIPHCLK_SDMMC1 \| RCC_PERIPHCLK_RNG \| RCC_PERIPHCLK_ADC \| RCC_PERIPHCLK_SWPMI1 \| RCC_PERIPHCLK_DFSDM1 \| \
<>	144:ef7eb2e8f9f7	676	RCC_PERIPHCLK_RTC ;
<>	144:ef7eb2e8f9f7	677
<>	144:ef7eb2e8f9f7	678	#elif defined(STM32L475xx) \|\| defined(STM32L476xx) \|\| defined(STM32L485xx) \|\| defined(STM32L486xx)
<>	144:ef7eb2e8f9f7	679
<>	144:ef7eb2e8f9f7	680	PeriphClkInit->PeriphClockSelection = RCC_PERIPHCLK_USART1 \| RCC_PERIPHCLK_USART2 \| RCC_PERIPHCLK_USART3 \| RCC_PERIPHCLK_UART4 \| RCC_PERIPHCLK_UART5 \| \
<>	144:ef7eb2e8f9f7	681	RCC_PERIPHCLK_LPUART1 \| RCC_PERIPHCLK_I2C1 \| RCC_PERIPHCLK_I2C2 \| RCC_PERIPHCLK_I2C3 \| \
<>	144:ef7eb2e8f9f7	682	RCC_PERIPHCLK_LPTIM1 \| RCC_PERIPHCLK_LPTIM2 \| RCC_PERIPHCLK_SAI1 \| RCC_PERIPHCLK_SAI2 \| RCC_PERIPHCLK_USB \| \
<>	144:ef7eb2e8f9f7	683	RCC_PERIPHCLK_SDMMC1 \| RCC_PERIPHCLK_RNG \| RCC_PERIPHCLK_ADC \| RCC_PERIPHCLK_SWPMI1 \| RCC_PERIPHCLK_DFSDM1 \| \
<>	144:ef7eb2e8f9f7	684	RCC_PERIPHCLK_RTC ;
<>	144:ef7eb2e8f9f7	685
<>	144:ef7eb2e8f9f7	686	#endif /* STM32L431xx */
<>	144:ef7eb2e8f9f7	687
<>	144:ef7eb2e8f9f7	688	/* Get the PLLSAI1 Clock configuration -----------------------------------------------*/
<>	144:ef7eb2e8f9f7	689
<>	144:ef7eb2e8f9f7	690	PeriphClkInit->PLLSAI1.PLLSAI1Source = (uint32_t)((RCC->PLLCFGR & RCC_PLLCFGR_PLLSRC) >> POSITION_VAL(RCC_PLLCFGR_PLLSRC));
<>	144:ef7eb2e8f9f7	691	PeriphClkInit->PLLSAI1.PLLSAI1M = (uint32_t)((RCC->PLLCFGR & RCC_PLLCFGR_PLLM) >> POSITION_VAL(RCC_PLLCFGR_PLLM)) + 1U;
<>	144:ef7eb2e8f9f7	692	PeriphClkInit->PLLSAI1.PLLSAI1N = (uint32_t)((RCC->PLLSAI1CFGR & RCC_PLLSAI1CFGR_PLLSAI1N) >> POSITION_VAL(RCC_PLLSAI1CFGR_PLLSAI1N));
<>	144:ef7eb2e8f9f7	693	PeriphClkInit->PLLSAI1.PLLSAI1P = (uint32_t)(((RCC->PLLSAI1CFGR & RCC_PLLSAI1CFGR_PLLSAI1P) >> POSITION_VAL(RCC_PLLSAI1CFGR_PLLSAI1P)) << 4U) + 7U;
<>	144:ef7eb2e8f9f7	694	PeriphClkInit->PLLSAI1.PLLSAI1Q = (uint32_t)(((RCC->PLLSAI1CFGR & RCC_PLLSAI1CFGR_PLLSAI1Q) >> POSITION_VAL(RCC_PLLSAI1CFGR_PLLSAI1Q))+1U) * 2U;
<>	144:ef7eb2e8f9f7	695	PeriphClkInit->PLLSAI1.PLLSAI1R = (uint32_t)(((RCC->PLLSAI1CFGR & RCC_PLLSAI1CFGR_PLLSAI1R) >> POSITION_VAL(RCC_PLLSAI1CFGR_PLLSAI1R))+1U) * 2U;
<>	144:ef7eb2e8f9f7	696
<>	144:ef7eb2e8f9f7	697	#if defined(RCC_PLLSAI2_SUPPORT)
<>	144:ef7eb2e8f9f7	698
<>	144:ef7eb2e8f9f7	699	/* Get the PLLSAI2 Clock configuration -----------------------------------------------*/
<>	144:ef7eb2e8f9f7	700
<>	144:ef7eb2e8f9f7	701	PeriphClkInit->PLLSAI2.PLLSAI2Source = PeriphClkInit->PLLSAI1.PLLSAI1Source;
<>	144:ef7eb2e8f9f7	702	PeriphClkInit->PLLSAI2.PLLSAI2M = PeriphClkInit->PLLSAI1.PLLSAI1M;
<>	144:ef7eb2e8f9f7	703	PeriphClkInit->PLLSAI2.PLLSAI2N = (uint32_t)((RCC->PLLSAI2CFGR & RCC_PLLSAI2CFGR_PLLSAI2N) >> POSITION_VAL(RCC_PLLSAI2CFGR_PLLSAI2N));
<>	144:ef7eb2e8f9f7	704	PeriphClkInit->PLLSAI2.PLLSAI2P = (uint32_t)(((RCC->PLLSAI2CFGR & RCC_PLLSAI2CFGR_PLLSAI2P) >> POSITION_VAL(RCC_PLLSAI2CFGR_PLLSAI2P)) << 4U) + 7U;
<>	144:ef7eb2e8f9f7	705	PeriphClkInit->PLLSAI2.PLLSAI2R = (uint32_t)(((RCC->PLLSAI2CFGR & RCC_PLLSAI2CFGR_PLLSAI2R)>> POSITION_VAL(RCC_PLLSAI2CFGR_PLLSAI2R))+1U) * 2U;
<>	144:ef7eb2e8f9f7	706
<>	144:ef7eb2e8f9f7	707	#endif /* RCC_PLLSAI2_SUPPORT */
<>	144:ef7eb2e8f9f7	708
<>	144:ef7eb2e8f9f7	709	/* Get the USART1 clock source ---------------------------------------------*/
<>	144:ef7eb2e8f9f7	710	PeriphClkInit->Usart1ClockSelection = __HAL_RCC_GET_USART1_SOURCE();
<>	144:ef7eb2e8f9f7	711	/* Get the USART2 clock source ---------------------------------------------*/
<>	144:ef7eb2e8f9f7	712	PeriphClkInit->Usart2ClockSelection = __HAL_RCC_GET_USART2_SOURCE();
<>	144:ef7eb2e8f9f7	713
<>	144:ef7eb2e8f9f7	714	#if defined(USART3)
<>	144:ef7eb2e8f9f7	715	/* Get the USART3 clock source ---------------------------------------------*/
<>	144:ef7eb2e8f9f7	716	PeriphClkInit->Usart3ClockSelection = __HAL_RCC_GET_USART3_SOURCE();
<>	144:ef7eb2e8f9f7	717	#endif /* USART3 */
<>	144:ef7eb2e8f9f7	718
<>	144:ef7eb2e8f9f7	719	#if defined(UART4)
<>	144:ef7eb2e8f9f7	720	/* Get the UART4 clock source ----------------------------------------------*/
<>	144:ef7eb2e8f9f7	721	PeriphClkInit->Uart4ClockSelection = __HAL_RCC_GET_UART4_SOURCE();
<>	144:ef7eb2e8f9f7	722	#endif /* UART4 */
<>	144:ef7eb2e8f9f7	723
<>	144:ef7eb2e8f9f7	724	#if defined(UART5)
<>	144:ef7eb2e8f9f7	725	/* Get the UART5 clock source ----------------------------------------------*/
<>	144:ef7eb2e8f9f7	726	PeriphClkInit->Uart5ClockSelection = __HAL_RCC_GET_UART5_SOURCE();
<>	144:ef7eb2e8f9f7	727	#endif /* UART5 */
<>	144:ef7eb2e8f9f7	728
<>	144:ef7eb2e8f9f7	729	/* Get the LPUART1 clock source --------------------------------------------*/
<>	144:ef7eb2e8f9f7	730	PeriphClkInit->Lpuart1ClockSelection = __HAL_RCC_GET_LPUART1_SOURCE();
<>	144:ef7eb2e8f9f7	731
<>	144:ef7eb2e8f9f7	732	/* Get the I2C1 clock source -----------------------------------------------*/
<>	144:ef7eb2e8f9f7	733	PeriphClkInit->I2c1ClockSelection = __HAL_RCC_GET_I2C1_SOURCE();
<>	144:ef7eb2e8f9f7	734
<>	144:ef7eb2e8f9f7	735	#if defined(I2C2)
<>	144:ef7eb2e8f9f7	736	/* Get the I2C2 clock source ----------------------------------------------*/
<>	144:ef7eb2e8f9f7	737	PeriphClkInit->I2c2ClockSelection = __HAL_RCC_GET_I2C2_SOURCE();
<>	144:ef7eb2e8f9f7	738	#endif /* I2C2 */
<>	144:ef7eb2e8f9f7	739
<>	144:ef7eb2e8f9f7	740	/* Get the I2C3 clock source -----------------------------------------------*/
<>	144:ef7eb2e8f9f7	741	PeriphClkInit->I2c3ClockSelection = __HAL_RCC_GET_I2C3_SOURCE();
<>	144:ef7eb2e8f9f7	742
<>	144:ef7eb2e8f9f7	743	/* Get the LPTIM1 clock source ---------------------------------------------*/
<>	144:ef7eb2e8f9f7	744	PeriphClkInit->Lptim1ClockSelection = __HAL_RCC_GET_LPTIM1_SOURCE();
<>	144:ef7eb2e8f9f7	745
<>	144:ef7eb2e8f9f7	746	/* Get the LPTIM2 clock source ---------------------------------------------*/
<>	144:ef7eb2e8f9f7	747	PeriphClkInit->Lptim2ClockSelection = __HAL_RCC_GET_LPTIM2_SOURCE();
<>	144:ef7eb2e8f9f7	748
<>	144:ef7eb2e8f9f7	749	/* Get the SAI1 clock source -----------------------------------------------*/
<>	144:ef7eb2e8f9f7	750	PeriphClkInit->Sai1ClockSelection = __HAL_RCC_GET_SAI1_SOURCE();
<>	144:ef7eb2e8f9f7	751
<>	144:ef7eb2e8f9f7	752	#if defined(SAI2)
<>	144:ef7eb2e8f9f7	753	/* Get the SAI2 clock source -----------------------------------------------*/
<>	144:ef7eb2e8f9f7	754	PeriphClkInit->Sai2ClockSelection = __HAL_RCC_GET_SAI2_SOURCE();
<>	144:ef7eb2e8f9f7	755	#endif /* SAI2 */
<>	144:ef7eb2e8f9f7	756
<>	144:ef7eb2e8f9f7	757	/* Get the RTC clock source ------------------------------------------------*/
<>	144:ef7eb2e8f9f7	758	PeriphClkInit->RTCClockSelection = __HAL_RCC_GET_RTC_SOURCE();
<>	144:ef7eb2e8f9f7	759
<>	144:ef7eb2e8f9f7	760	#if defined(USB_OTG_FS) \|\| defined(USB)
<>	144:ef7eb2e8f9f7	761	/* Get the USB clock source ------------------------------------------------*/
<>	144:ef7eb2e8f9f7	762	PeriphClkInit->UsbClockSelection = __HAL_RCC_GET_USB_SOURCE();
<>	144:ef7eb2e8f9f7	763	#endif /* USB_OTG_FS \|\| USB */
<>	144:ef7eb2e8f9f7	764
<>	144:ef7eb2e8f9f7	765	#if defined(SDMMC1)
<>	144:ef7eb2e8f9f7	766	/* Get the SDMMC1 clock source ---------------------------------------------*/
<>	144:ef7eb2e8f9f7	767	PeriphClkInit->Sdmmc1ClockSelection = __HAL_RCC_GET_SDMMC1_SOURCE();
<>	144:ef7eb2e8f9f7	768	#endif /* SDMMC1 */
<>	144:ef7eb2e8f9f7	769
<>	144:ef7eb2e8f9f7	770	/* Get the RNG clock source ------------------------------------------------*/
<>	144:ef7eb2e8f9f7	771	PeriphClkInit->RngClockSelection = __HAL_RCC_GET_RNG_SOURCE();
<>	144:ef7eb2e8f9f7	772
<>	144:ef7eb2e8f9f7	773	/* Get the ADC clock source ------------------------------------------------*/
<>	144:ef7eb2e8f9f7	774	PeriphClkInit->AdcClockSelection = __HAL_RCC_GET_ADC_SOURCE();
<>	144:ef7eb2e8f9f7	775
<>	144:ef7eb2e8f9f7	776	#if defined(SWPMI1)
<>	144:ef7eb2e8f9f7	777	/* Get the SWPMI1 clock source ---------------------------------------------*/
<>	144:ef7eb2e8f9f7	778	PeriphClkInit->Swpmi1ClockSelection = __HAL_RCC_GET_SWPMI1_SOURCE();
<>	144:ef7eb2e8f9f7	779	#endif /* SWPMI1 */
<>	144:ef7eb2e8f9f7	780
<>	144:ef7eb2e8f9f7	781	#if defined(DFSDM1_Filter0)
<>	144:ef7eb2e8f9f7	782	/* Get the DFSDM1 clock source ---------------------------------------------*/
<>	144:ef7eb2e8f9f7	783	PeriphClkInit->Dfsdm1ClockSelection = __HAL_RCC_GET_DFSDM1_SOURCE();
<>	144:ef7eb2e8f9f7	784	#endif /* DFSDM1_Filter0 */
<>	144:ef7eb2e8f9f7	785	}
<>	144:ef7eb2e8f9f7	786
<>	144:ef7eb2e8f9f7	787	/**
<>	144:ef7eb2e8f9f7	788	* @brief Return the peripheral clock frequency for peripherals with clock source from PLLSAIs
<>	144:ef7eb2e8f9f7	789	* @note Return 0 if peripheral clock identifier not managed by this API
<>	144:ef7eb2e8f9f7	790	* @param PeriphClk Peripheral clock identifier
<>	144:ef7eb2e8f9f7	791	* This parameter can be one of the following values:
<>	144:ef7eb2e8f9f7	792	* @arg @ref RCC_PERIPHCLK_RTC RTC peripheral clock
<>	144:ef7eb2e8f9f7	793	* @arg @ref RCC_PERIPHCLK_ADC ADC peripheral clock
<>	144:ef7eb2e8f9f7	794	@if STM32L486xx
<>	144:ef7eb2e8f9f7	795	* @arg @ref RCC_PERIPHCLK_DFSDM1 DFSDM1 peripheral clock (only for devices with DFSDM)
<>	144:ef7eb2e8f9f7	796	@endif
<>	144:ef7eb2e8f9f7	797	* @arg @ref RCC_PERIPHCLK_I2C1 I2C1 peripheral clock
<>	144:ef7eb2e8f9f7	798	* @arg @ref RCC_PERIPHCLK_I2C2 I2C2 peripheral clock
<>	144:ef7eb2e8f9f7	799	* @arg @ref RCC_PERIPHCLK_I2C3 I2C3 peripheral clock
<>	144:ef7eb2e8f9f7	800	* @arg @ref RCC_PERIPHCLK_LPTIM1 LPTIM1 peripheral clock
<>	144:ef7eb2e8f9f7	801	* @arg @ref RCC_PERIPHCLK_LPTIM2 LPTIM2 peripheral clock
<>	144:ef7eb2e8f9f7	802	* @arg @ref RCC_PERIPHCLK_LPUART1 LPUART1 peripheral clock
<>	144:ef7eb2e8f9f7	803	* @arg @ref RCC_PERIPHCLK_RNG RNG peripheral clock
<>	144:ef7eb2e8f9f7	804	* @arg @ref RCC_PERIPHCLK_SAI1 SAI1 peripheral clock
<>	144:ef7eb2e8f9f7	805	@if STM32L486xx
<>	144:ef7eb2e8f9f7	806	* @arg @ref RCC_PERIPHCLK_SAI2 SAI2 peripheral clock (only for devices with SAI2)
<>	144:ef7eb2e8f9f7	807	@endif
<>	144:ef7eb2e8f9f7	808	* @arg @ref RCC_PERIPHCLK_SDMMC1 SDMMC1 peripheral clock
<>	144:ef7eb2e8f9f7	809	* @arg @ref RCC_PERIPHCLK_SWPMI1 SWPMI1 peripheral clock
<>	144:ef7eb2e8f9f7	810	* @arg @ref RCC_PERIPHCLK_USART1 USART1 peripheral clock
<>	144:ef7eb2e8f9f7	811	* @arg @ref RCC_PERIPHCLK_USART2 USART1 peripheral clock
<>	144:ef7eb2e8f9f7	812	* @arg @ref RCC_PERIPHCLK_USART3 USART1 peripheral clock
<>	144:ef7eb2e8f9f7	813	@if STM32L486xx
<>	144:ef7eb2e8f9f7	814	* @arg @ref RCC_PERIPHCLK_UART4 UART4 peripheral clock (only for devices with UART4)
<>	144:ef7eb2e8f9f7	815	* @arg @ref RCC_PERIPHCLK_UART5 UART5 peripheral clock (only for devices with UART5)
<>	144:ef7eb2e8f9f7	816	* @arg @ref RCC_PERIPHCLK_USB USB peripheral clock (only for devices with USB)
<>	144:ef7eb2e8f9f7	817	@endif
<>	144:ef7eb2e8f9f7	818	* @retval Frequency in Hz
<>	144:ef7eb2e8f9f7	819	*/
<>	144:ef7eb2e8f9f7	820	uint32_t HAL_RCCEx_GetPeriphCLKFreq(uint32_t PeriphClk)
<>	144:ef7eb2e8f9f7	821	{
<>	144:ef7eb2e8f9f7	822	uint32_t frequency = 0U;
<>	144:ef7eb2e8f9f7	823	uint32_t srcclk = 0U;
<>	144:ef7eb2e8f9f7	824	uint32_t pllvco = 0U, plln = 0U, pllp = 0U;
<>	144:ef7eb2e8f9f7	825
<>	144:ef7eb2e8f9f7	826	/* Check the parameters */
<>	144:ef7eb2e8f9f7	827	assert_param(IS_RCC_PERIPHCLOCK(PeriphClk));
<>	144:ef7eb2e8f9f7	828
<>	144:ef7eb2e8f9f7	829	if(PeriphClk == RCC_PERIPHCLK_RTC)
<>	144:ef7eb2e8f9f7	830	{
<>	144:ef7eb2e8f9f7	831	/* Get the current RTC source */
<>	144:ef7eb2e8f9f7	832	srcclk = __HAL_RCC_GET_RTC_SOURCE();
<>	144:ef7eb2e8f9f7	833
<>	144:ef7eb2e8f9f7	834	/* Check if LSE is ready and if RTC clock selection is LSE */
<>	144:ef7eb2e8f9f7	835	if ((srcclk == RCC_RTCCLKSOURCE_LSE) && (HAL_IS_BIT_SET(RCC->BDCR, RCC_BDCR_LSERDY)))
<>	144:ef7eb2e8f9f7	836	{
<>	144:ef7eb2e8f9f7	837	frequency = LSE_VALUE;
<>	144:ef7eb2e8f9f7	838	}
<>	144:ef7eb2e8f9f7	839	/* Check if LSI is ready and if RTC clock selection is LSI */
<>	144:ef7eb2e8f9f7	840	else if ((srcclk == RCC_RTCCLKSOURCE_LSI) && (HAL_IS_BIT_SET(RCC->CSR, RCC_CSR_LSIRDY)))
<>	144:ef7eb2e8f9f7	841	{
<>	144:ef7eb2e8f9f7	842	frequency = LSI_VALUE;
<>	144:ef7eb2e8f9f7	843	}
<>	144:ef7eb2e8f9f7	844	/* Check if HSE is ready and if RTC clock selection is HSI_DIV32*/
<>	144:ef7eb2e8f9f7	845	else if ((srcclk == RCC_RTCCLKSOURCE_HSE_DIV32) && (HAL_IS_BIT_SET(RCC->CR, RCC_CR_HSERDY)))
<>	144:ef7eb2e8f9f7	846	{
<>	144:ef7eb2e8f9f7	847	frequency = HSE_VALUE / 32;
<>	144:ef7eb2e8f9f7	848	}
<>	144:ef7eb2e8f9f7	849	/* Clock not enabled for RTC*/
<>	144:ef7eb2e8f9f7	850	else
<>	144:ef7eb2e8f9f7	851	{
<>	144:ef7eb2e8f9f7	852	frequency = 0U;
<>	144:ef7eb2e8f9f7	853	}
<>	144:ef7eb2e8f9f7	854	}
<>	144:ef7eb2e8f9f7	855	else
<>	144:ef7eb2e8f9f7	856	{
<>	144:ef7eb2e8f9f7	857	/* Other external peripheral clock source than RTC */
<>	144:ef7eb2e8f9f7	858
<>	144:ef7eb2e8f9f7	859	/* Compute PLL clock input */
<>	144:ef7eb2e8f9f7	860	if(__HAL_RCC_GET_PLL_OSCSOURCE() == RCC_PLLSOURCE_MSI) /* MSI ? */
<>	144:ef7eb2e8f9f7	861	{
<>	144:ef7eb2e8f9f7	862	if(HAL_IS_BIT_SET(RCC->CR, RCC_CR_MSIRDY))
<>	144:ef7eb2e8f9f7	863	{
<>	144:ef7eb2e8f9f7	864	pllvco = (1U << ((__HAL_RCC_GET_MSI_RANGE() >> 4U) - 4U)) * 1000000U;
<>	144:ef7eb2e8f9f7	865	}
<>	144:ef7eb2e8f9f7	866	else
<>	144:ef7eb2e8f9f7	867	{
<>	144:ef7eb2e8f9f7	868	pllvco = 0U;
<>	144:ef7eb2e8f9f7	869	}
<>	144:ef7eb2e8f9f7	870	}
<>	144:ef7eb2e8f9f7	871	else if(__HAL_RCC_GET_PLL_OSCSOURCE() == RCC_PLLSOURCE_HSI) /* HSI ? */
<>	144:ef7eb2e8f9f7	872	{
<>	144:ef7eb2e8f9f7	873	if(HAL_IS_BIT_SET(RCC->CR, RCC_CR_HSIRDY))
<>	144:ef7eb2e8f9f7	874	{
<>	144:ef7eb2e8f9f7	875	pllvco = HSI_VALUE;
<>	144:ef7eb2e8f9f7	876	}
<>	144:ef7eb2e8f9f7	877	else
<>	144:ef7eb2e8f9f7	878	{
<>	144:ef7eb2e8f9f7	879	pllvco = 0U;
<>	144:ef7eb2e8f9f7	880	}
<>	144:ef7eb2e8f9f7	881	}
<>	144:ef7eb2e8f9f7	882	else if(__HAL_RCC_GET_PLL_OSCSOURCE() == RCC_PLLSOURCE_HSE) /* HSE ? */
<>	144:ef7eb2e8f9f7	883	{
<>	144:ef7eb2e8f9f7	884	if(HAL_IS_BIT_SET(RCC->CR, RCC_CR_HSERDY))
<>	144:ef7eb2e8f9f7	885	{
<>	144:ef7eb2e8f9f7	886	pllvco = HSE_VALUE;
<>	144:ef7eb2e8f9f7	887	}
<>	144:ef7eb2e8f9f7	888	else
<>	144:ef7eb2e8f9f7	889	{
<>	144:ef7eb2e8f9f7	890	pllvco = 0U;
<>	144:ef7eb2e8f9f7	891	}
<>	144:ef7eb2e8f9f7	892	}
<>	144:ef7eb2e8f9f7	893	else /* No source */
<>	144:ef7eb2e8f9f7	894	{
<>	144:ef7eb2e8f9f7	895	pllvco = 0U;
<>	144:ef7eb2e8f9f7	896	}
<>	144:ef7eb2e8f9f7	897
<>	144:ef7eb2e8f9f7	898	/* f(PLL Source) / PLLM */
<>	144:ef7eb2e8f9f7	899	pllvco = (pllvco / ((READ_BIT(RCC->PLLCFGR, RCC_PLLCFGR_PLLM) >> POSITION_VAL(RCC_PLLCFGR_PLLM)) + 1U));
<>	144:ef7eb2e8f9f7	900
<>	144:ef7eb2e8f9f7	901	switch(PeriphClk)
<>	144:ef7eb2e8f9f7	902	{
<>	144:ef7eb2e8f9f7	903	#if defined(SAI2)
<>	144:ef7eb2e8f9f7	904
<>	144:ef7eb2e8f9f7	905	case RCC_PERIPHCLK_SAI1:
<>	144:ef7eb2e8f9f7	906	case RCC_PERIPHCLK_SAI2:
<>	144:ef7eb2e8f9f7	907
<>	144:ef7eb2e8f9f7	908	if(PeriphClk == RCC_PERIPHCLK_SAI1)
<>	144:ef7eb2e8f9f7	909	{
<>	144:ef7eb2e8f9f7	910	srcclk = __HAL_RCC_GET_SAI1_SOURCE();
<>	144:ef7eb2e8f9f7	911
<>	144:ef7eb2e8f9f7	912	if(srcclk == RCC_SAI1CLKSOURCE_PIN)
<>	144:ef7eb2e8f9f7	913	{
<>	144:ef7eb2e8f9f7	914	frequency = EXTERNAL_SAI1_CLOCK_VALUE;
<>	144:ef7eb2e8f9f7	915	}
<>	144:ef7eb2e8f9f7	916	/* Else, PLL clock output to check below */
<>	144:ef7eb2e8f9f7	917	}
<>	144:ef7eb2e8f9f7	918	else /* RCC_PERIPHCLK_SAI2 */
<>	144:ef7eb2e8f9f7	919	{
<>	144:ef7eb2e8f9f7	920	srcclk = __HAL_RCC_GET_SAI2_SOURCE();
<>	144:ef7eb2e8f9f7	921
<>	144:ef7eb2e8f9f7	922	if(srcclk == RCC_SAI2CLKSOURCE_PIN)
<>	144:ef7eb2e8f9f7	923	{
<>	144:ef7eb2e8f9f7	924	frequency = EXTERNAL_SAI2_CLOCK_VALUE;
<>	144:ef7eb2e8f9f7	925	}
<>	144:ef7eb2e8f9f7	926	/* Else, PLL clock output to check below */
<>	144:ef7eb2e8f9f7	927	}
<>	144:ef7eb2e8f9f7	928
<>	144:ef7eb2e8f9f7	929	#else
<>	144:ef7eb2e8f9f7	930
<>	144:ef7eb2e8f9f7	931	case RCC_PERIPHCLK_SAI1:
<>	144:ef7eb2e8f9f7	932
<>	144:ef7eb2e8f9f7	933	if(PeriphClk == RCC_PERIPHCLK_SAI1)
<>	144:ef7eb2e8f9f7	934	{
<>	144:ef7eb2e8f9f7	935	srcclk = READ_BIT(RCC->CCIPR, RCC_CCIPR_SAI1SEL);
<>	144:ef7eb2e8f9f7	936
<>	144:ef7eb2e8f9f7	937	if(srcclk == RCC_SAI1CLKSOURCE_PIN)
<>	144:ef7eb2e8f9f7	938	{
<>	144:ef7eb2e8f9f7	939	frequency = EXTERNAL_SAI1_CLOCK_VALUE;
<>	144:ef7eb2e8f9f7	940	}
<>	144:ef7eb2e8f9f7	941	/* Else, PLL clock output to check below */
<>	144:ef7eb2e8f9f7	942	}
<>	144:ef7eb2e8f9f7	943
<>	144:ef7eb2e8f9f7	944	#endif /* SAI2 */
<>	144:ef7eb2e8f9f7	945
<>	144:ef7eb2e8f9f7	946	if(frequency == 0U)
<>	144:ef7eb2e8f9f7	947	{
<>	144:ef7eb2e8f9f7	948	#if defined(SAI2)
<>	144:ef7eb2e8f9f7	949	if((srcclk == RCC_SAI1CLKSOURCE_PLL) \|\| (srcclk == RCC_SAI2CLKSOURCE_PLL))
<>	144:ef7eb2e8f9f7	950	{
<>	144:ef7eb2e8f9f7	951	if(__HAL_RCC_GET_PLLCLKOUT_CONFIG(RCC_PLL_SAI3CLK) != RESET)
<>	144:ef7eb2e8f9f7	952	{
<>	144:ef7eb2e8f9f7	953	/* f(PLLSAI3CLK) = f(VCO input) * PLLN / PLLP */
<>	144:ef7eb2e8f9f7	954	plln = READ_BIT(RCC->PLLCFGR, RCC_PLLCFGR_PLLN) >> POSITION_VAL(RCC_PLLCFGR_PLLN);
<>	144:ef7eb2e8f9f7	955	#if defined(RCC_PLLP_DIV_2_31_SUPPORT)
<>	144:ef7eb2e8f9f7	956	pllp = READ_BIT(RCC->PLLCFGR, RCC_PLLCFGR_PLLPDIV) >> POSITION_VAL(RCC_PLLCFGR_PLLPDIV);
<>	144:ef7eb2e8f9f7	957	#endif
<>	144:ef7eb2e8f9f7	958	if(pllp == 0U)
<>	144:ef7eb2e8f9f7	959	{
<>	144:ef7eb2e8f9f7	960	if(READ_BIT(RCC->PLLCFGR, RCC_PLLCFGR_PLLP) != RESET)
<>	144:ef7eb2e8f9f7	961	{
<>	144:ef7eb2e8f9f7	962	pllp = 17U;
<>	144:ef7eb2e8f9f7	963	}
<>	144:ef7eb2e8f9f7	964	else
<>	144:ef7eb2e8f9f7	965	{
<>	144:ef7eb2e8f9f7	966	pllp = 7U;
<>	144:ef7eb2e8f9f7	967	}
<>	144:ef7eb2e8f9f7	968	}
<>	144:ef7eb2e8f9f7	969	frequency = (pllvco * plln) / pllp;
<>	144:ef7eb2e8f9f7	970	}
<>	144:ef7eb2e8f9f7	971	}
<>	144:ef7eb2e8f9f7	972	else if(srcclk == 0U) /* RCC_SAI1CLKSOURCE_PLLSAI1 \|\| RCC_SAI2CLKSOURCE_PLLSAI1 */
<>	144:ef7eb2e8f9f7	973	{
<>	144:ef7eb2e8f9f7	974	if(__HAL_RCC_GET_PLLSAI1CLKOUT_CONFIG(RCC_PLLSAI1_SAI1CLK) != RESET)
<>	144:ef7eb2e8f9f7	975	{
<>	144:ef7eb2e8f9f7	976	/* f(PLLSAI1CLK) = f(VCOSAI1 input) * PLLSAI1N / PLLSAI1P */
<>	144:ef7eb2e8f9f7	977	plln = READ_BIT(RCC->PLLSAI1CFGR, RCC_PLLSAI1CFGR_PLLSAI1N) >> POSITION_VAL(RCC_PLLSAI1CFGR_PLLSAI1N);
<>	144:ef7eb2e8f9f7	978	#if defined(RCC_PLLSAI1P_DIV_2_31_SUPPORT)
<>	144:ef7eb2e8f9f7	979	pllp = READ_BIT(RCC->PLLSAI1CFGR, RCC_PLLSAI1CFGR_PLLSAI1PDIV) >> POSITION_VAL(RCC_PLLSAI1CFGR_PLLSAI1PDIV);
<>	144:ef7eb2e8f9f7	980	#endif
<>	144:ef7eb2e8f9f7	981	if(pllp == 0U)
<>	144:ef7eb2e8f9f7	982	{
<>	144:ef7eb2e8f9f7	983	if(READ_BIT(RCC->PLLSAI1CFGR, RCC_PLLSAI1CFGR_PLLSAI1P) != RESET)
<>	144:ef7eb2e8f9f7	984	{
<>	144:ef7eb2e8f9f7	985	pllp = 17U;
<>	144:ef7eb2e8f9f7	986	}
<>	144:ef7eb2e8f9f7	987	else
<>	144:ef7eb2e8f9f7	988	{
<>	144:ef7eb2e8f9f7	989	pllp = 7U;
<>	144:ef7eb2e8f9f7	990	}
<>	144:ef7eb2e8f9f7	991	}
<>	144:ef7eb2e8f9f7	992	frequency = (pllvco * plln) / pllp;
<>	144:ef7eb2e8f9f7	993	}
<>	144:ef7eb2e8f9f7	994	}
<>	144:ef7eb2e8f9f7	995	#else
<>	144:ef7eb2e8f9f7	996	if(srcclk == RCC_SAI1CLKSOURCE_PLL)
<>	144:ef7eb2e8f9f7	997	{
<>	144:ef7eb2e8f9f7	998	if(__HAL_RCC_GET_PLLCLKOUT_CONFIG(RCC_PLL_SAI2CLK) != RESET)
<>	144:ef7eb2e8f9f7	999	{
<>	144:ef7eb2e8f9f7	1000	/* f(PLLSAI2CLK) = f(VCO input) * PLLN / PLLP */
<>	144:ef7eb2e8f9f7	1001	plln = READ_BIT(RCC->PLLCFGR, RCC_PLLCFGR_PLLN) >> POSITION_VAL(RCC_PLLCFGR_PLLN);
<>	144:ef7eb2e8f9f7	1002	#if defined(RCC_PLLP_DIV_2_31_SUPPORT)
<>	144:ef7eb2e8f9f7	1003	pllp = READ_BIT(RCC->PLLCFGR, RCC_PLLCFGR_PLLPDIV) >> POSITION_VAL(RCC_PLLCFGR_PLLPDIV);
<>	144:ef7eb2e8f9f7	1004	#endif
<>	144:ef7eb2e8f9f7	1005	if(pllp == 0U)
<>	144:ef7eb2e8f9f7	1006	{
<>	144:ef7eb2e8f9f7	1007	if(READ_BIT(RCC->PLLCFGR, RCC_PLLCFGR_PLLP) != RESET)
<>	144:ef7eb2e8f9f7	1008	{
<>	144:ef7eb2e8f9f7	1009	pllp = 17U;
<>	144:ef7eb2e8f9f7	1010	}
<>	144:ef7eb2e8f9f7	1011	else
<>	144:ef7eb2e8f9f7	1012	{
<>	144:ef7eb2e8f9f7	1013	pllp = 7U;
<>	144:ef7eb2e8f9f7	1014	}
<>	144:ef7eb2e8f9f7	1015	}
<>	144:ef7eb2e8f9f7	1016
<>	144:ef7eb2e8f9f7	1017	frequency = (pllvco * plln) / pllp;
<>	144:ef7eb2e8f9f7	1018	}
<>	144:ef7eb2e8f9f7	1019	else if(HAL_IS_BIT_SET(RCC->CR, RCC_CR_HSIRDY))
<>	144:ef7eb2e8f9f7	1020	{
<>	144:ef7eb2e8f9f7	1021	/* HSI automatically selected as clock source if PLLs not enabled */
<>	144:ef7eb2e8f9f7	1022	frequency = HSI_VALUE;
<>	144:ef7eb2e8f9f7	1023	}
<>	144:ef7eb2e8f9f7	1024	else
<>	144:ef7eb2e8f9f7	1025	{
<>	144:ef7eb2e8f9f7	1026	/* No clock source */
<>	144:ef7eb2e8f9f7	1027	frequency = 0U;
<>	144:ef7eb2e8f9f7	1028	}
<>	144:ef7eb2e8f9f7	1029	}
<>	144:ef7eb2e8f9f7	1030	else if(srcclk == RCC_SAI1CLKSOURCE_PLLSAI1)
<>	144:ef7eb2e8f9f7	1031	{
<>	144:ef7eb2e8f9f7	1032	if(__HAL_RCC_GET_PLLSAI1CLKOUT_CONFIG(RCC_PLLSAI1_SAI1CLK) != RESET)
<>	144:ef7eb2e8f9f7	1033	{
<>	144:ef7eb2e8f9f7	1034	/* f(PLLSAI1CLK) = f(VCOSAI1 input) * PLLSAI1N / PLLSAI1P */
<>	144:ef7eb2e8f9f7	1035	plln = READ_BIT(RCC->PLLSAI1CFGR, RCC_PLLSAI1CFGR_PLLSAI1N) >> POSITION_VAL(RCC_PLLSAI1CFGR_PLLSAI1N);
<>	144:ef7eb2e8f9f7	1036	#if defined(RCC_PLLSAI1P_DIV_2_31_SUPPORT)
<>	144:ef7eb2e8f9f7	1037	pllp = READ_BIT(RCC->PLLSAI1CFGR, RCC_PLLSAI1CFGR_PLLSAI1PDIV) >> POSITION_VAL(RCC_PLLSAI1CFGR_PLLSAI1PDIV);
<>	144:ef7eb2e8f9f7	1038	#endif
<>	144:ef7eb2e8f9f7	1039	if(pllp == 0U)
<>	144:ef7eb2e8f9f7	1040	{
<>	144:ef7eb2e8f9f7	1041	if(READ_BIT(RCC->PLLSAI1CFGR, RCC_PLLSAI1CFGR_PLLSAI1P) != RESET)
<>	144:ef7eb2e8f9f7	1042	{
<>	144:ef7eb2e8f9f7	1043	pllp = 17U;
<>	144:ef7eb2e8f9f7	1044	}
<>	144:ef7eb2e8f9f7	1045	else
<>	144:ef7eb2e8f9f7	1046	{
<>	144:ef7eb2e8f9f7	1047	pllp = 7U;
<>	144:ef7eb2e8f9f7	1048	}
<>	144:ef7eb2e8f9f7	1049	}
<>	144:ef7eb2e8f9f7	1050
<>	144:ef7eb2e8f9f7	1051	frequency = (pllvco * plln) / pllp;
<>	144:ef7eb2e8f9f7	1052	}
<>	144:ef7eb2e8f9f7	1053	else if(HAL_IS_BIT_SET(RCC->CR, RCC_CR_HSIRDY))
<>	144:ef7eb2e8f9f7	1054	{
<>	144:ef7eb2e8f9f7	1055	/* HSI automatically selected as clock source if PLLs not enabled */
<>	144:ef7eb2e8f9f7	1056	frequency = HSI_VALUE;
<>	144:ef7eb2e8f9f7	1057	}
<>	144:ef7eb2e8f9f7	1058	else
<>	144:ef7eb2e8f9f7	1059	{
<>	144:ef7eb2e8f9f7	1060	/* No clock source */
<>	144:ef7eb2e8f9f7	1061	frequency = 0U;
<>	144:ef7eb2e8f9f7	1062	}
<>	144:ef7eb2e8f9f7	1063	}
<>	144:ef7eb2e8f9f7	1064	#endif /* SAI2 */
<>	144:ef7eb2e8f9f7	1065
<>	144:ef7eb2e8f9f7	1066	#if defined(RCC_PLLSAI2_SUPPORT)
<>	144:ef7eb2e8f9f7	1067
<>	144:ef7eb2e8f9f7	1068	else if((srcclk == RCC_SAI1CLKSOURCE_PLLSAI2) \|\| (srcclk == RCC_SAI2CLKSOURCE_PLLSAI2))
<>	144:ef7eb2e8f9f7	1069	{
<>	144:ef7eb2e8f9f7	1070	if(__HAL_RCC_GET_PLLSAI2CLKOUT_CONFIG(RCC_PLLSAI2_SAI2CLK) != RESET)
<>	144:ef7eb2e8f9f7	1071	{
<>	144:ef7eb2e8f9f7	1072	/* f(PLLSAI2CLK) = f(VCOSAI2 input) * PLLSAI2N / PLLSAI2P */
<>	144:ef7eb2e8f9f7	1073	plln = READ_BIT(RCC->PLLSAI2CFGR, RCC_PLLSAI2CFGR_PLLSAI2N) >> POSITION_VAL(RCC_PLLSAI2CFGR_PLLSAI2N);
<>	144:ef7eb2e8f9f7	1074	#if defined(RCC_PLLSAI2P_DIV_2_31_SUPPORT)
<>	144:ef7eb2e8f9f7	1075	pllp = READ_BIT(RCC->PLLSAI2CFGR, RCC_PLLSAI2CFGR_PLLSAI2PDIV) >> POSITION_VAL(RCC_PLLSAI2CFGR_PLLSAI2PDIV);
<>	144:ef7eb2e8f9f7	1076	#endif
<>	144:ef7eb2e8f9f7	1077	if(pllp == 0U)
<>	144:ef7eb2e8f9f7	1078	{
<>	144:ef7eb2e8f9f7	1079	if(READ_BIT(RCC->PLLSAI2CFGR, RCC_PLLSAI2CFGR_PLLSAI2P) != RESET)
<>	144:ef7eb2e8f9f7	1080	{
<>	144:ef7eb2e8f9f7	1081	pllp = 17U;
<>	144:ef7eb2e8f9f7	1082	}
<>	144:ef7eb2e8f9f7	1083	else
<>	144:ef7eb2e8f9f7	1084	{
<>	144:ef7eb2e8f9f7	1085	pllp = 7U;
<>	144:ef7eb2e8f9f7	1086	}
<>	144:ef7eb2e8f9f7	1087	}
<>	144:ef7eb2e8f9f7	1088	frequency = (pllvco * plln) / pllp;
<>	144:ef7eb2e8f9f7	1089	}
<>	144:ef7eb2e8f9f7	1090	}
<>	144:ef7eb2e8f9f7	1091
<>	144:ef7eb2e8f9f7	1092	#endif /* RCC_PLLSAI2_SUPPORT */
<>	144:ef7eb2e8f9f7	1093
<>	144:ef7eb2e8f9f7	1094	else
<>	144:ef7eb2e8f9f7	1095	{
<>	144:ef7eb2e8f9f7	1096	/* No clock source */
<>	144:ef7eb2e8f9f7	1097	frequency = 0U;
<>	144:ef7eb2e8f9f7	1098	}
<>	144:ef7eb2e8f9f7	1099	}
<>	144:ef7eb2e8f9f7	1100	break;
<>	144:ef7eb2e8f9f7	1101
<>	144:ef7eb2e8f9f7	1102	#if defined(USB_OTG_FS) \|\| defined(USB)
<>	144:ef7eb2e8f9f7	1103
<>	144:ef7eb2e8f9f7	1104	case RCC_PERIPHCLK_USB:
<>	144:ef7eb2e8f9f7	1105
<>	144:ef7eb2e8f9f7	1106	#endif /* USB_OTG_FS \|\| USB */
<>	144:ef7eb2e8f9f7	1107
<>	144:ef7eb2e8f9f7	1108	case RCC_PERIPHCLK_RNG:
<>	144:ef7eb2e8f9f7	1109
<>	144:ef7eb2e8f9f7	1110	#if defined(SDMMC1)
<>	144:ef7eb2e8f9f7	1111
<>	144:ef7eb2e8f9f7	1112	case RCC_PERIPHCLK_SDMMC1:
<>	144:ef7eb2e8f9f7	1113
<>	144:ef7eb2e8f9f7	1114	#endif /* SDMMC1 */
<>	144:ef7eb2e8f9f7	1115
<>	144:ef7eb2e8f9f7	1116	srcclk = READ_BIT(RCC->CCIPR, RCC_CCIPR_CLK48SEL);
<>	144:ef7eb2e8f9f7	1117
<>	144:ef7eb2e8f9f7	1118	if(srcclk == RCC_CCIPR_CLK48SEL) /* MSI ? */
<>	144:ef7eb2e8f9f7	1119	{
<>	144:ef7eb2e8f9f7	1120	if(HAL_IS_BIT_SET(RCC->CR, RCC_CR_MSIRDY))
<>	144:ef7eb2e8f9f7	1121	{
<>	144:ef7eb2e8f9f7	1122	frequency = (1U << ((__HAL_RCC_GET_MSI_RANGE() >> 4U) - 4U)) * 1000000U;
<>	144:ef7eb2e8f9f7	1123	}
<>	144:ef7eb2e8f9f7	1124	else
<>	144:ef7eb2e8f9f7	1125	{
<>	144:ef7eb2e8f9f7	1126	frequency = 0U;
<>	144:ef7eb2e8f9f7	1127	}
<>	144:ef7eb2e8f9f7	1128	}
<>	144:ef7eb2e8f9f7	1129	else if(srcclk == RCC_CCIPR_CLK48SEL_1) /* PLL ? */
<>	144:ef7eb2e8f9f7	1130	{
<>	144:ef7eb2e8f9f7	1131	if(HAL_IS_BIT_SET(RCC->CR, RCC_CR_PLLRDY) && HAL_IS_BIT_SET(RCC->PLLCFGR, RCC_PLLCFGR_PLLQEN))
<>	144:ef7eb2e8f9f7	1132	{
<>	144:ef7eb2e8f9f7	1133	/* f(PLL48M1CLK) = f(VCO input) * PLLN / PLLQ */
<>	144:ef7eb2e8f9f7	1134	plln = READ_BIT(RCC->PLLCFGR, RCC_PLLCFGR_PLLN) >> POSITION_VAL(RCC_PLLCFGR_PLLN);
<>	144:ef7eb2e8f9f7	1135	frequency = (pllvco * plln) / (((READ_BIT(RCC->PLLCFGR, RCC_PLLCFGR_PLLQ) >> POSITION_VAL(RCC_PLLCFGR_PLLQ)) + 1U) << 1U);
<>	144:ef7eb2e8f9f7	1136	}
<>	144:ef7eb2e8f9f7	1137	else
<>	144:ef7eb2e8f9f7	1138	{
<>	144:ef7eb2e8f9f7	1139	frequency = 0U;
<>	144:ef7eb2e8f9f7	1140	}
<>	144:ef7eb2e8f9f7	1141	}
<>	144:ef7eb2e8f9f7	1142	else if(srcclk == RCC_CCIPR_CLK48SEL_0) /* PLLSAI1 ? */
<>	144:ef7eb2e8f9f7	1143	{
<>	144:ef7eb2e8f9f7	1144	if(HAL_IS_BIT_SET(RCC->CR, RCC_CR_PLLSAI1RDY) && HAL_IS_BIT_SET(RCC->PLLSAI1CFGR, RCC_PLLSAI1CFGR_PLLSAI1QEN))
<>	144:ef7eb2e8f9f7	1145	{
<>	144:ef7eb2e8f9f7	1146	/* f(PLL48M2CLK) = f(VCOSAI1 input) * PLLSAI1N / PLLSAI1Q */
<>	144:ef7eb2e8f9f7	1147	plln = READ_BIT(RCC->PLLSAI1CFGR, RCC_PLLSAI1CFGR_PLLSAI1N) >> POSITION_VAL(RCC_PLLSAI1CFGR_PLLSAI1N);
<>	144:ef7eb2e8f9f7	1148	frequency = (pllvco * plln) / (((READ_BIT(RCC->PLLSAI1CFGR, RCC_PLLSAI1CFGR_PLLSAI1Q) >> POSITION_VAL(RCC_PLLSAI1CFGR_PLLSAI1Q)) + 1U) << 1U);
<>	144:ef7eb2e8f9f7	1149	}
<>	144:ef7eb2e8f9f7	1150	else
<>	144:ef7eb2e8f9f7	1151	{
<>	144:ef7eb2e8f9f7	1152	frequency = 0U;
<>	144:ef7eb2e8f9f7	1153	}
<>	144:ef7eb2e8f9f7	1154	}
<>	144:ef7eb2e8f9f7	1155	#if defined(RCC_HSI48_SUPPORT)
<>	144:ef7eb2e8f9f7	1156	else if((srcclk == 0U) && (HAL_IS_BIT_SET(RCC->CRRCR, RCC_CRRCR_HSI48RDY))) /* HSI48 ? */
<>	144:ef7eb2e8f9f7	1157	{
<>	144:ef7eb2e8f9f7	1158	frequency = HSI48_VALUE;
<>	144:ef7eb2e8f9f7	1159	}
<>	144:ef7eb2e8f9f7	1160	else /* No clock source */
<>	144:ef7eb2e8f9f7	1161	{
<>	144:ef7eb2e8f9f7	1162	frequency = 0U;
<>	144:ef7eb2e8f9f7	1163	}
<>	144:ef7eb2e8f9f7	1164	#else
<>	144:ef7eb2e8f9f7	1165	else /* No clock source */
<>	144:ef7eb2e8f9f7	1166	{
<>	144:ef7eb2e8f9f7	1167	frequency = 0U;
<>	144:ef7eb2e8f9f7	1168	}
<>	144:ef7eb2e8f9f7	1169	#endif /* RCC_HSI48_SUPPORT */
<>	144:ef7eb2e8f9f7	1170	break;
<>	144:ef7eb2e8f9f7	1171
<>	144:ef7eb2e8f9f7	1172	case RCC_PERIPHCLK_USART1:
<>	144:ef7eb2e8f9f7	1173	/* Get the current USART1 source */
<>	144:ef7eb2e8f9f7	1174	srcclk = __HAL_RCC_GET_USART1_SOURCE();
<>	144:ef7eb2e8f9f7	1175
<>	144:ef7eb2e8f9f7	1176	if(srcclk == RCC_USART1CLKSOURCE_PCLK2)
<>	144:ef7eb2e8f9f7	1177	{
<>	144:ef7eb2e8f9f7	1178	frequency = HAL_RCC_GetPCLK2Freq();
<>	144:ef7eb2e8f9f7	1179	}
<>	144:ef7eb2e8f9f7	1180	else if(srcclk == RCC_USART1CLKSOURCE_SYSCLK)
<>	144:ef7eb2e8f9f7	1181	{
<>	144:ef7eb2e8f9f7	1182	frequency = HAL_RCC_GetSysClockFreq();
<>	144:ef7eb2e8f9f7	1183	}
<>	144:ef7eb2e8f9f7	1184	else if((srcclk == RCC_USART1CLKSOURCE_HSI) && (HAL_IS_BIT_SET(RCC->CR, RCC_CR_HSIRDY)))
<>	144:ef7eb2e8f9f7	1185	{
<>	144:ef7eb2e8f9f7	1186	frequency = HSI_VALUE;
<>	144:ef7eb2e8f9f7	1187	}
<>	144:ef7eb2e8f9f7	1188	else if((srcclk == RCC_USART1CLKSOURCE_LSE) && (HAL_IS_BIT_SET(RCC->BDCR, RCC_BDCR_LSERDY)))
<>	144:ef7eb2e8f9f7	1189	{
<>	144:ef7eb2e8f9f7	1190	frequency = LSE_VALUE;
<>	144:ef7eb2e8f9f7	1191	}
<>	144:ef7eb2e8f9f7	1192	/* Clock not enabled for USART1 */
<>	144:ef7eb2e8f9f7	1193	else
<>	144:ef7eb2e8f9f7	1194	{
<>	144:ef7eb2e8f9f7	1195	frequency = 0U;
<>	144:ef7eb2e8f9f7	1196	}
<>	144:ef7eb2e8f9f7	1197	break;
<>	144:ef7eb2e8f9f7	1198
<>	144:ef7eb2e8f9f7	1199	case RCC_PERIPHCLK_USART2:
<>	144:ef7eb2e8f9f7	1200	/* Get the current USART2 source */
<>	144:ef7eb2e8f9f7	1201	srcclk = __HAL_RCC_GET_USART2_SOURCE();
<>	144:ef7eb2e8f9f7	1202
<>	144:ef7eb2e8f9f7	1203	if(srcclk == RCC_USART2CLKSOURCE_PCLK1)
<>	144:ef7eb2e8f9f7	1204	{
<>	144:ef7eb2e8f9f7	1205	frequency = HAL_RCC_GetPCLK1Freq();
<>	144:ef7eb2e8f9f7	1206	}
<>	144:ef7eb2e8f9f7	1207	else if(srcclk == RCC_USART2CLKSOURCE_SYSCLK)
<>	144:ef7eb2e8f9f7	1208	{
<>	144:ef7eb2e8f9f7	1209	frequency = HAL_RCC_GetSysClockFreq();
<>	144:ef7eb2e8f9f7	1210	}
<>	144:ef7eb2e8f9f7	1211	else if((srcclk == RCC_USART2CLKSOURCE_HSI) && (HAL_IS_BIT_SET(RCC->CR, RCC_CR_HSIRDY)))
<>	144:ef7eb2e8f9f7	1212	{
<>	144:ef7eb2e8f9f7	1213	frequency = HSI_VALUE;
<>	144:ef7eb2e8f9f7	1214	}
<>	144:ef7eb2e8f9f7	1215	else if((srcclk == RCC_USART2CLKSOURCE_LSE) && (HAL_IS_BIT_SET(RCC->BDCR, RCC_BDCR_LSERDY)))
<>	144:ef7eb2e8f9f7	1216	{
<>	144:ef7eb2e8f9f7	1217	frequency = LSE_VALUE;
<>	144:ef7eb2e8f9f7	1218	}
<>	144:ef7eb2e8f9f7	1219	/* Clock not enabled for USART2 */
<>	144:ef7eb2e8f9f7	1220	else
<>	144:ef7eb2e8f9f7	1221	{
<>	144:ef7eb2e8f9f7	1222	frequency = 0U;
<>	144:ef7eb2e8f9f7	1223	}
<>	144:ef7eb2e8f9f7	1224	break;
<>	144:ef7eb2e8f9f7	1225
<>	144:ef7eb2e8f9f7	1226	#if defined(USART3)
<>	144:ef7eb2e8f9f7	1227
<>	144:ef7eb2e8f9f7	1228	case RCC_PERIPHCLK_USART3:
<>	144:ef7eb2e8f9f7	1229	/* Get the current USART3 source */
<>	144:ef7eb2e8f9f7	1230	srcclk = __HAL_RCC_GET_USART3_SOURCE();
<>	144:ef7eb2e8f9f7	1231
<>	144:ef7eb2e8f9f7	1232	if(srcclk == RCC_USART3CLKSOURCE_PCLK1)
<>	144:ef7eb2e8f9f7	1233	{
<>	144:ef7eb2e8f9f7	1234	frequency = HAL_RCC_GetPCLK1Freq();
<>	144:ef7eb2e8f9f7	1235	}
<>	144:ef7eb2e8f9f7	1236	else if(srcclk == RCC_USART3CLKSOURCE_SYSCLK)
<>	144:ef7eb2e8f9f7	1237	{
<>	144:ef7eb2e8f9f7	1238	frequency = HAL_RCC_GetSysClockFreq();
<>	144:ef7eb2e8f9f7	1239	}
<>	144:ef7eb2e8f9f7	1240	else if((srcclk == RCC_USART3CLKSOURCE_HSI) && (HAL_IS_BIT_SET(RCC->CR, RCC_CR_HSIRDY)))
<>	144:ef7eb2e8f9f7	1241	{
<>	144:ef7eb2e8f9f7	1242	frequency = HSI_VALUE;
<>	144:ef7eb2e8f9f7	1243	}
<>	144:ef7eb2e8f9f7	1244	else if((srcclk == RCC_USART3CLKSOURCE_LSE) && (HAL_IS_BIT_SET(RCC->BDCR, RCC_BDCR_LSERDY)))
<>	144:ef7eb2e8f9f7	1245	{
<>	144:ef7eb2e8f9f7	1246	frequency = LSE_VALUE;
<>	144:ef7eb2e8f9f7	1247	}
<>	144:ef7eb2e8f9f7	1248	/* Clock not enabled for USART3 */
<>	144:ef7eb2e8f9f7	1249	else
<>	144:ef7eb2e8f9f7	1250	{
<>	144:ef7eb2e8f9f7	1251	frequency = 0U;
<>	144:ef7eb2e8f9f7	1252	}
<>	144:ef7eb2e8f9f7	1253	break;
<>	144:ef7eb2e8f9f7	1254
<>	144:ef7eb2e8f9f7	1255	#endif /* USART3 */
<>	144:ef7eb2e8f9f7	1256
<>	144:ef7eb2e8f9f7	1257	#if defined(UART4)
<>	144:ef7eb2e8f9f7	1258
<>	144:ef7eb2e8f9f7	1259	case RCC_PERIPHCLK_UART4:
<>	144:ef7eb2e8f9f7	1260	/* Get the current UART4 source */
<>	144:ef7eb2e8f9f7	1261	srcclk = __HAL_RCC_GET_UART4_SOURCE();
<>	144:ef7eb2e8f9f7	1262
<>	144:ef7eb2e8f9f7	1263	if(srcclk == RCC_UART4CLKSOURCE_PCLK1)
<>	144:ef7eb2e8f9f7	1264	{
<>	144:ef7eb2e8f9f7	1265	frequency = HAL_RCC_GetPCLK1Freq();
<>	144:ef7eb2e8f9f7	1266	}
<>	144:ef7eb2e8f9f7	1267	else if(srcclk == RCC_UART4CLKSOURCE_SYSCLK)
<>	144:ef7eb2e8f9f7	1268	{
<>	144:ef7eb2e8f9f7	1269	frequency = HAL_RCC_GetSysClockFreq();
<>	144:ef7eb2e8f9f7	1270	}
<>	144:ef7eb2e8f9f7	1271	else if((srcclk == RCC_UART4CLKSOURCE_HSI) && (HAL_IS_BIT_SET(RCC->CR, RCC_CR_HSIRDY)))
<>	144:ef7eb2e8f9f7	1272	{
<>	144:ef7eb2e8f9f7	1273	frequency = HSI_VALUE;
<>	144:ef7eb2e8f9f7	1274	}
<>	144:ef7eb2e8f9f7	1275	else if((srcclk == RCC_UART4CLKSOURCE_LSE) && (HAL_IS_BIT_SET(RCC->BDCR, RCC_BDCR_LSERDY)))
<>	144:ef7eb2e8f9f7	1276	{
<>	144:ef7eb2e8f9f7	1277	frequency = LSE_VALUE;
<>	144:ef7eb2e8f9f7	1278	}
<>	144:ef7eb2e8f9f7	1279	/* Clock not enabled for UART4 */
<>	144:ef7eb2e8f9f7	1280	else
<>	144:ef7eb2e8f9f7	1281	{
<>	144:ef7eb2e8f9f7	1282	frequency = 0U;
<>	144:ef7eb2e8f9f7	1283	}
<>	144:ef7eb2e8f9f7	1284	break;
<>	144:ef7eb2e8f9f7	1285
<>	144:ef7eb2e8f9f7	1286	#endif /* UART4 */
<>	144:ef7eb2e8f9f7	1287
<>	144:ef7eb2e8f9f7	1288	#if defined(UART5)
<>	144:ef7eb2e8f9f7	1289
<>	144:ef7eb2e8f9f7	1290	case RCC_PERIPHCLK_UART5:
<>	144:ef7eb2e8f9f7	1291	/* Get the current UART5 source */
<>	144:ef7eb2e8f9f7	1292	srcclk = __HAL_RCC_GET_UART5_SOURCE();
<>	144:ef7eb2e8f9f7	1293
<>	144:ef7eb2e8f9f7	1294	if(srcclk == RCC_UART5CLKSOURCE_PCLK1)
<>	144:ef7eb2e8f9f7	1295	{
<>	144:ef7eb2e8f9f7	1296	frequency = HAL_RCC_GetPCLK1Freq();
<>	144:ef7eb2e8f9f7	1297	}
<>	144:ef7eb2e8f9f7	1298	else if(srcclk == RCC_UART5CLKSOURCE_SYSCLK)
<>	144:ef7eb2e8f9f7	1299	{
<>	144:ef7eb2e8f9f7	1300	frequency = HAL_RCC_GetSysClockFreq();
<>	144:ef7eb2e8f9f7	1301	}
<>	144:ef7eb2e8f9f7	1302	else if((srcclk == RCC_UART5CLKSOURCE_HSI) && (HAL_IS_BIT_SET(RCC->CR, RCC_CR_HSIRDY)))
<>	144:ef7eb2e8f9f7	1303	{
<>	144:ef7eb2e8f9f7	1304	frequency = HSI_VALUE;
<>	144:ef7eb2e8f9f7	1305	}
<>	144:ef7eb2e8f9f7	1306	else if((srcclk == RCC_UART5CLKSOURCE_LSE) && (HAL_IS_BIT_SET(RCC->BDCR, RCC_BDCR_LSERDY)))
<>	144:ef7eb2e8f9f7	1307	{
<>	144:ef7eb2e8f9f7	1308	frequency = LSE_VALUE;
<>	144:ef7eb2e8f9f7	1309	}
<>	144:ef7eb2e8f9f7	1310	/* Clock not enabled for UART5 */
<>	144:ef7eb2e8f9f7	1311	else
<>	144:ef7eb2e8f9f7	1312	{
<>	144:ef7eb2e8f9f7	1313	frequency = 0U;
<>	144:ef7eb2e8f9f7	1314	}
<>	144:ef7eb2e8f9f7	1315	break;
<>	144:ef7eb2e8f9f7	1316
<>	144:ef7eb2e8f9f7	1317	#endif /* UART5 */
<>	144:ef7eb2e8f9f7	1318
<>	144:ef7eb2e8f9f7	1319	case RCC_PERIPHCLK_LPUART1:
<>	144:ef7eb2e8f9f7	1320	/* Get the current LPUART1 source */
<>	144:ef7eb2e8f9f7	1321	srcclk = __HAL_RCC_GET_LPUART1_SOURCE();
<>	144:ef7eb2e8f9f7	1322
<>	144:ef7eb2e8f9f7	1323	if(srcclk == RCC_LPUART1CLKSOURCE_PCLK1)
<>	144:ef7eb2e8f9f7	1324	{
<>	144:ef7eb2e8f9f7	1325	frequency = HAL_RCC_GetPCLK1Freq();
<>	144:ef7eb2e8f9f7	1326	}
<>	144:ef7eb2e8f9f7	1327	else if(srcclk == RCC_LPUART1CLKSOURCE_SYSCLK)
<>	144:ef7eb2e8f9f7	1328	{
<>	144:ef7eb2e8f9f7	1329	frequency = HAL_RCC_GetSysClockFreq();
<>	144:ef7eb2e8f9f7	1330	}
<>	144:ef7eb2e8f9f7	1331	else if((srcclk == RCC_LPUART1CLKSOURCE_HSI) && (HAL_IS_BIT_SET(RCC->CR, RCC_CR_HSIRDY)))
<>	144:ef7eb2e8f9f7	1332	{
<>	144:ef7eb2e8f9f7	1333	frequency = HSI_VALUE;
<>	144:ef7eb2e8f9f7	1334	}
<>	144:ef7eb2e8f9f7	1335	else if((srcclk == RCC_LPUART1CLKSOURCE_LSE) && (HAL_IS_BIT_SET(RCC->BDCR, RCC_BDCR_LSERDY)))
<>	144:ef7eb2e8f9f7	1336	{
<>	144:ef7eb2e8f9f7	1337	frequency = LSE_VALUE;
<>	144:ef7eb2e8f9f7	1338	}
<>	144:ef7eb2e8f9f7	1339	/* Clock not enabled for LPUART1 */
<>	144:ef7eb2e8f9f7	1340	else
<>	144:ef7eb2e8f9f7	1341	{
<>	144:ef7eb2e8f9f7	1342	frequency = 0U;
<>	144:ef7eb2e8f9f7	1343	}
<>	144:ef7eb2e8f9f7	1344	break;
<>	144:ef7eb2e8f9f7	1345
<>	144:ef7eb2e8f9f7	1346	case RCC_PERIPHCLK_ADC:
<>	144:ef7eb2e8f9f7	1347
<>	144:ef7eb2e8f9f7	1348	srcclk = __HAL_RCC_GET_ADC_SOURCE();
<>	144:ef7eb2e8f9f7	1349
<>	144:ef7eb2e8f9f7	1350	if(srcclk == RCC_ADCCLKSOURCE_SYSCLK)
<>	144:ef7eb2e8f9f7	1351	{
<>	144:ef7eb2e8f9f7	1352	frequency = HAL_RCC_GetSysClockFreq();
<>	144:ef7eb2e8f9f7	1353	}
<>	144:ef7eb2e8f9f7	1354	else if(srcclk == RCC_ADCCLKSOURCE_PLLSAI1)
<>	144:ef7eb2e8f9f7	1355	{
<>	144:ef7eb2e8f9f7	1356	if(__HAL_RCC_GET_PLLSAI1CLKOUT_CONFIG(RCC_PLLSAI1_ADC1CLK) != RESET)
<>	144:ef7eb2e8f9f7	1357	{
<>	144:ef7eb2e8f9f7	1358	/* f(PLLADC1CLK) = f(VCOSAI1 input) * PLLSAI1N / PLLSAI1R */
<>	144:ef7eb2e8f9f7	1359	plln = READ_BIT(RCC->PLLSAI1CFGR, RCC_PLLSAI1CFGR_PLLSAI1N) >> POSITION_VAL(RCC_PLLSAI1CFGR_PLLSAI1N);
<>	144:ef7eb2e8f9f7	1360	frequency = (pllvco * plln) / (((READ_BIT(RCC->PLLSAI1CFGR, RCC_PLLSAI1CFGR_PLLSAI1R) >> POSITION_VAL(RCC_PLLSAI1CFGR_PLLSAI1R)) + 1U) << 1U);
<>	144:ef7eb2e8f9f7	1361	}
<>	144:ef7eb2e8f9f7	1362	}
<>	144:ef7eb2e8f9f7	1363	#if defined(STM32L471xx) \|\| defined(STM32L475xx) \|\| defined(STM32L476xx) \|\| defined(STM32L485xx) \|\| defined(STM32L486xx)
<>	144:ef7eb2e8f9f7	1364	else if(srcclk == RCC_ADCCLKSOURCE_PLLSAI2)
<>	144:ef7eb2e8f9f7	1365	{
<>	144:ef7eb2e8f9f7	1366	if(__HAL_RCC_GET_PLLSAI2CLKOUT_CONFIG(RCC_PLLSAI2_ADC2CLK) != RESET)
<>	144:ef7eb2e8f9f7	1367	{
<>	144:ef7eb2e8f9f7	1368	/* f(PLLADC2CLK) = f(VCOSAI2 input) * PLLSAI2N / PLLSAI2R */
<>	144:ef7eb2e8f9f7	1369	plln = READ_BIT(RCC->PLLSAI2CFGR, RCC_PLLSAI2CFGR_PLLSAI2N) >> POSITION_VAL(RCC_PLLSAI2CFGR_PLLSAI2N);
<>	144:ef7eb2e8f9f7	1370	frequency = (pllvco * plln) / (((READ_BIT(RCC->PLLSAI2CFGR, RCC_PLLSAI2CFGR_PLLSAI2R) >> POSITION_VAL(RCC_PLLSAI2CFGR_PLLSAI2R)) + 1U) << 1U);
<>	144:ef7eb2e8f9f7	1371	}
<>	144:ef7eb2e8f9f7	1372	}
<>	144:ef7eb2e8f9f7	1373	#endif /* STM32L471xx \|\| STM32L475xx \|\| STM32L476xx \|\| STM32L485xx \|\| STM32L486xx */
<>	144:ef7eb2e8f9f7	1374	/* Clock not enabled for ADC */
<>	144:ef7eb2e8f9f7	1375	else
<>	144:ef7eb2e8f9f7	1376	{
<>	144:ef7eb2e8f9f7	1377	frequency = 0U;
<>	144:ef7eb2e8f9f7	1378	}
<>	144:ef7eb2e8f9f7	1379	break;
<>	144:ef7eb2e8f9f7	1380
<>	144:ef7eb2e8f9f7	1381	#if defined(DFSDM1_Filter0)
<>	144:ef7eb2e8f9f7	1382
<>	144:ef7eb2e8f9f7	1383	case RCC_PERIPHCLK_DFSDM1:
<>	144:ef7eb2e8f9f7	1384	/* Get the current DFSDM1 source */
<>	144:ef7eb2e8f9f7	1385	srcclk = __HAL_RCC_GET_DFSDM1_SOURCE();
<>	144:ef7eb2e8f9f7	1386
<>	144:ef7eb2e8f9f7	1387	if(srcclk == RCC_DFSDM1CLKSOURCE_PCLK)
<>	144:ef7eb2e8f9f7	1388	{
<>	144:ef7eb2e8f9f7	1389	frequency = HAL_RCC_GetPCLK1Freq();
<>	144:ef7eb2e8f9f7	1390	}
<>	144:ef7eb2e8f9f7	1391	else
<>	144:ef7eb2e8f9f7	1392	{
<>	144:ef7eb2e8f9f7	1393	frequency = HAL_RCC_GetSysClockFreq();
<>	144:ef7eb2e8f9f7	1394	}
<>	144:ef7eb2e8f9f7	1395	break;
<>	144:ef7eb2e8f9f7	1396
<>	144:ef7eb2e8f9f7	1397	#endif /* DFSDM1_Filter0 */
<>	144:ef7eb2e8f9f7	1398
<>	144:ef7eb2e8f9f7	1399	case RCC_PERIPHCLK_I2C1:
<>	144:ef7eb2e8f9f7	1400	/* Get the current I2C1 source */
<>	144:ef7eb2e8f9f7	1401	srcclk = __HAL_RCC_GET_I2C1_SOURCE();
<>	144:ef7eb2e8f9f7	1402
<>	144:ef7eb2e8f9f7	1403	if(srcclk == RCC_I2C1CLKSOURCE_PCLK1)
<>	144:ef7eb2e8f9f7	1404	{
<>	144:ef7eb2e8f9f7	1405	frequency = HAL_RCC_GetPCLK1Freq();
<>	144:ef7eb2e8f9f7	1406	}
<>	144:ef7eb2e8f9f7	1407	else if(srcclk == RCC_I2C1CLKSOURCE_SYSCLK)
<>	144:ef7eb2e8f9f7	1408	{
<>	144:ef7eb2e8f9f7	1409	frequency = HAL_RCC_GetSysClockFreq();
<>	144:ef7eb2e8f9f7	1410	}
<>	144:ef7eb2e8f9f7	1411	else if((srcclk == RCC_I2C1CLKSOURCE_HSI) && (HAL_IS_BIT_SET(RCC->CR, RCC_CR_HSIRDY)))
<>	144:ef7eb2e8f9f7	1412	{
<>	144:ef7eb2e8f9f7	1413	frequency = HSI_VALUE;
<>	144:ef7eb2e8f9f7	1414	}
<>	144:ef7eb2e8f9f7	1415	/* Clock not enabled for I2C1 */
<>	144:ef7eb2e8f9f7	1416	else
<>	144:ef7eb2e8f9f7	1417	{
<>	144:ef7eb2e8f9f7	1418	frequency = 0U;
<>	144:ef7eb2e8f9f7	1419	}
<>	144:ef7eb2e8f9f7	1420	break;
<>	144:ef7eb2e8f9f7	1421
<>	144:ef7eb2e8f9f7	1422	#if defined(I2C2)
<>	144:ef7eb2e8f9f7	1423
<>	144:ef7eb2e8f9f7	1424	case RCC_PERIPHCLK_I2C2:
<>	144:ef7eb2e8f9f7	1425	/* Get the current I2C2 source */
<>	144:ef7eb2e8f9f7	1426	srcclk = __HAL_RCC_GET_I2C2_SOURCE();
<>	144:ef7eb2e8f9f7	1427
<>	144:ef7eb2e8f9f7	1428	if(srcclk == RCC_I2C2CLKSOURCE_PCLK1)
<>	144:ef7eb2e8f9f7	1429	{
<>	144:ef7eb2e8f9f7	1430	frequency = HAL_RCC_GetPCLK1Freq();
<>	144:ef7eb2e8f9f7	1431	}
<>	144:ef7eb2e8f9f7	1432	else if(srcclk == RCC_I2C2CLKSOURCE_SYSCLK)
<>	144:ef7eb2e8f9f7	1433	{
<>	144:ef7eb2e8f9f7	1434	frequency = HAL_RCC_GetSysClockFreq();
<>	144:ef7eb2e8f9f7	1435	}
<>	144:ef7eb2e8f9f7	1436	else if((srcclk == RCC_I2C2CLKSOURCE_HSI) && (HAL_IS_BIT_SET(RCC->CR, RCC_CR_HSIRDY)))
<>	144:ef7eb2e8f9f7	1437	{
<>	144:ef7eb2e8f9f7	1438	frequency = HSI_VALUE;
<>	144:ef7eb2e8f9f7	1439	}
<>	144:ef7eb2e8f9f7	1440	/* Clock not enabled for I2C2 */
<>	144:ef7eb2e8f9f7	1441	else
<>	144:ef7eb2e8f9f7	1442	{
<>	144:ef7eb2e8f9f7	1443	frequency = 0U;
<>	144:ef7eb2e8f9f7	1444	}
<>	144:ef7eb2e8f9f7	1445	break;
<>	144:ef7eb2e8f9f7	1446
<>	144:ef7eb2e8f9f7	1447	#endif /* I2C2 */
<>	144:ef7eb2e8f9f7	1448
<>	144:ef7eb2e8f9f7	1449	case RCC_PERIPHCLK_I2C3:
<>	144:ef7eb2e8f9f7	1450	/* Get the current I2C3 source */
<>	144:ef7eb2e8f9f7	1451	srcclk = __HAL_RCC_GET_I2C3_SOURCE();
<>	144:ef7eb2e8f9f7	1452
<>	144:ef7eb2e8f9f7	1453	if(srcclk == RCC_I2C3CLKSOURCE_PCLK1)
<>	144:ef7eb2e8f9f7	1454	{
<>	144:ef7eb2e8f9f7	1455	frequency = HAL_RCC_GetPCLK1Freq();
<>	144:ef7eb2e8f9f7	1456	}
<>	144:ef7eb2e8f9f7	1457	else if(srcclk == RCC_I2C3CLKSOURCE_SYSCLK)
<>	144:ef7eb2e8f9f7	1458	{
<>	144:ef7eb2e8f9f7	1459	frequency = HAL_RCC_GetSysClockFreq();
<>	144:ef7eb2e8f9f7	1460	}
<>	144:ef7eb2e8f9f7	1461	else if((srcclk == RCC_I2C3CLKSOURCE_HSI) && (HAL_IS_BIT_SET(RCC->CR, RCC_CR_HSIRDY)))
<>	144:ef7eb2e8f9f7	1462	{
<>	144:ef7eb2e8f9f7	1463	frequency = HSI_VALUE;
<>	144:ef7eb2e8f9f7	1464	}
<>	144:ef7eb2e8f9f7	1465	/* Clock not enabled for I2C3 */
<>	144:ef7eb2e8f9f7	1466	else
<>	144:ef7eb2e8f9f7	1467	{
<>	144:ef7eb2e8f9f7	1468	frequency = 0U;
<>	144:ef7eb2e8f9f7	1469	}
<>	144:ef7eb2e8f9f7	1470	break;
<>	144:ef7eb2e8f9f7	1471
<>	144:ef7eb2e8f9f7	1472	case RCC_PERIPHCLK_LPTIM1:
<>	144:ef7eb2e8f9f7	1473	/* Get the current LPTIM1 source */
<>	144:ef7eb2e8f9f7	1474	srcclk = __HAL_RCC_GET_LPTIM1_SOURCE();
<>	144:ef7eb2e8f9f7	1475
<>	144:ef7eb2e8f9f7	1476	if(srcclk == RCC_LPTIM1CLKSOURCE_PCLK)
<>	144:ef7eb2e8f9f7	1477	{
<>	144:ef7eb2e8f9f7	1478	frequency = HAL_RCC_GetPCLK1Freq();
<>	144:ef7eb2e8f9f7	1479	}
<>	144:ef7eb2e8f9f7	1480	else if((srcclk == RCC_LPTIM1CLKSOURCE_LSI) && (HAL_IS_BIT_SET(RCC->CSR, RCC_CSR_LSIRDY)))
<>	144:ef7eb2e8f9f7	1481	{
<>	144:ef7eb2e8f9f7	1482	frequency = LSI_VALUE;
<>	144:ef7eb2e8f9f7	1483	}
<>	144:ef7eb2e8f9f7	1484	else if((srcclk == RCC_LPTIM1CLKSOURCE_HSI) && (HAL_IS_BIT_SET(RCC->CR, RCC_CR_HSIRDY)))
<>	144:ef7eb2e8f9f7	1485	{
<>	144:ef7eb2e8f9f7	1486	frequency = HSI_VALUE;
<>	144:ef7eb2e8f9f7	1487	}
<>	144:ef7eb2e8f9f7	1488	else if ((srcclk == RCC_LPTIM1CLKSOURCE_LSE) && (HAL_IS_BIT_SET(RCC->BDCR, RCC_BDCR_LSERDY)))
<>	144:ef7eb2e8f9f7	1489	{
<>	144:ef7eb2e8f9f7	1490	frequency = LSE_VALUE;
<>	144:ef7eb2e8f9f7	1491	}
<>	144:ef7eb2e8f9f7	1492	/* Clock not enabled for LPTIM1 */
<>	144:ef7eb2e8f9f7	1493	else
<>	144:ef7eb2e8f9f7	1494	{
<>	144:ef7eb2e8f9f7	1495	frequency = 0U;
<>	144:ef7eb2e8f9f7	1496	}
<>	144:ef7eb2e8f9f7	1497	break;
<>	144:ef7eb2e8f9f7	1498
<>	144:ef7eb2e8f9f7	1499	case RCC_PERIPHCLK_LPTIM2:
<>	144:ef7eb2e8f9f7	1500	/* Get the current LPTIM2 source */
<>	144:ef7eb2e8f9f7	1501	srcclk = __HAL_RCC_GET_LPTIM2_SOURCE();
<>	144:ef7eb2e8f9f7	1502
<>	144:ef7eb2e8f9f7	1503	if(srcclk == RCC_LPTIM2CLKSOURCE_PCLK)
<>	144:ef7eb2e8f9f7	1504	{
<>	144:ef7eb2e8f9f7	1505	frequency = HAL_RCC_GetPCLK1Freq();
<>	144:ef7eb2e8f9f7	1506	}
<>	144:ef7eb2e8f9f7	1507	else if((srcclk == RCC_LPTIM2CLKSOURCE_LSI) && (HAL_IS_BIT_SET(RCC->CSR, RCC_CSR_LSIRDY)))
<>	144:ef7eb2e8f9f7	1508	{
<>	144:ef7eb2e8f9f7	1509	frequency = LSI_VALUE;
<>	144:ef7eb2e8f9f7	1510	}
<>	144:ef7eb2e8f9f7	1511	else if((srcclk == RCC_LPTIM2CLKSOURCE_HSI) && (HAL_IS_BIT_SET(RCC->CR, RCC_CR_HSIRDY)))
<>	144:ef7eb2e8f9f7	1512	{
<>	144:ef7eb2e8f9f7	1513	frequency = HSI_VALUE;
<>	144:ef7eb2e8f9f7	1514	}
<>	144:ef7eb2e8f9f7	1515	else if ((srcclk == RCC_LPTIM2CLKSOURCE_LSE) && (HAL_IS_BIT_SET(RCC->BDCR, RCC_BDCR_LSERDY)))
<>	144:ef7eb2e8f9f7	1516	{
<>	144:ef7eb2e8f9f7	1517	frequency = LSE_VALUE;
<>	144:ef7eb2e8f9f7	1518	}
<>	144:ef7eb2e8f9f7	1519	/* Clock not enabled for LPTIM2 */
<>	144:ef7eb2e8f9f7	1520	else
<>	144:ef7eb2e8f9f7	1521	{
<>	144:ef7eb2e8f9f7	1522	frequency = 0U;
<>	144:ef7eb2e8f9f7	1523	}
<>	144:ef7eb2e8f9f7	1524	break;
<>	144:ef7eb2e8f9f7	1525
<>	144:ef7eb2e8f9f7	1526	#if defined(SWPMI1)
<>	144:ef7eb2e8f9f7	1527
<>	144:ef7eb2e8f9f7	1528	case RCC_PERIPHCLK_SWPMI1:
<>	144:ef7eb2e8f9f7	1529	/* Get the current SWPMI1 source */
<>	144:ef7eb2e8f9f7	1530	srcclk = __HAL_RCC_GET_SWPMI1_SOURCE();
<>	144:ef7eb2e8f9f7	1531
<>	144:ef7eb2e8f9f7	1532	if(srcclk == RCC_SWPMI1CLKSOURCE_PCLK)
<>	144:ef7eb2e8f9f7	1533	{
<>	144:ef7eb2e8f9f7	1534	frequency = HAL_RCC_GetPCLK1Freq();
<>	144:ef7eb2e8f9f7	1535	}
<>	144:ef7eb2e8f9f7	1536	else if((srcclk == RCC_SWPMI1CLKSOURCE_HSI) && (HAL_IS_BIT_SET(RCC->CR, RCC_CR_HSIRDY)))
<>	144:ef7eb2e8f9f7	1537	{
<>	144:ef7eb2e8f9f7	1538	frequency = HSI_VALUE;
<>	144:ef7eb2e8f9f7	1539	}
<>	144:ef7eb2e8f9f7	1540	/* Clock not enabled for SWPMI1 */
<>	144:ef7eb2e8f9f7	1541	else
<>	144:ef7eb2e8f9f7	1542	{
<>	144:ef7eb2e8f9f7	1543	frequency = 0U;
<>	144:ef7eb2e8f9f7	1544	}
<>	144:ef7eb2e8f9f7	1545	break;
<>	144:ef7eb2e8f9f7	1546
<>	144:ef7eb2e8f9f7	1547	#endif /* SWPMI1 */
<>	144:ef7eb2e8f9f7	1548
<>	144:ef7eb2e8f9f7	1549	default:
<>	144:ef7eb2e8f9f7	1550	break;
<>	144:ef7eb2e8f9f7	1551	}
<>	144:ef7eb2e8f9f7	1552	}
<>	144:ef7eb2e8f9f7	1553
<>	144:ef7eb2e8f9f7	1554	return(frequency);
<>	144:ef7eb2e8f9f7	1555	}
<>	144:ef7eb2e8f9f7	1556
<>	144:ef7eb2e8f9f7	1557	/**
<>	144:ef7eb2e8f9f7	1558	* @}
<>	144:ef7eb2e8f9f7	1559	*/
<>	144:ef7eb2e8f9f7	1560
<>	144:ef7eb2e8f9f7	1561	/** @defgroup RCCEx_Exported_Functions_Group2 Extended Clock management functions
<>	144:ef7eb2e8f9f7	1562	* @brief Extended Clock management functions
<>	144:ef7eb2e8f9f7	1563	*
<>	144:ef7eb2e8f9f7	1564	@verbatim
<>	144:ef7eb2e8f9f7	1565	===============================================================================
<>	144:ef7eb2e8f9f7	1566	##### Extended clock management functions #####
<>	144:ef7eb2e8f9f7	1567	===============================================================================
<>	144:ef7eb2e8f9f7	1568	[..]
<>	144:ef7eb2e8f9f7	1569	This subsection provides a set of functions allowing to control the
<>	144:ef7eb2e8f9f7	1570	activation or deactivation of MSI PLL-mode, PLLSAI1, PLLSAI2, LSE CSS,
<>	144:ef7eb2e8f9f7	1571	Low speed clock output and clock after wake-up from STOP mode.
<>	144:ef7eb2e8f9f7	1572	@endverbatim
<>	144:ef7eb2e8f9f7	1573	* @{
<>	144:ef7eb2e8f9f7	1574	*/
<>	144:ef7eb2e8f9f7	1575
<>	144:ef7eb2e8f9f7	1576	/**
<>	144:ef7eb2e8f9f7	1577	* @brief Enable PLLSAI1.
<>	144:ef7eb2e8f9f7	1578	* @param PLLSAI1Init pointer to an RCC_PLLSAI1InitTypeDef structure that
<>	144:ef7eb2e8f9f7	1579	* contains the configuration information for the PLLSAI1
<>	144:ef7eb2e8f9f7	1580	* @retval HAL status
<>	144:ef7eb2e8f9f7	1581	*/
<>	144:ef7eb2e8f9f7	1582	HAL_StatusTypeDef HAL_RCCEx_EnablePLLSAI1(RCC_PLLSAI1InitTypeDef *PLLSAI1Init)
<>	144:ef7eb2e8f9f7	1583	{
<>	144:ef7eb2e8f9f7	1584	uint32_t tickstart = 0U;
<>	144:ef7eb2e8f9f7	1585	HAL_StatusTypeDef status = HAL_OK;
<>	144:ef7eb2e8f9f7	1586
<>	144:ef7eb2e8f9f7	1587	/* check for PLLSAI1 Parameters used to output PLLSAI1CLK */
<>	144:ef7eb2e8f9f7	1588	assert_param(IS_RCC_PLLSAI1SOURCE(PLLSAI1Init->PLLSAI1Source));
<>	144:ef7eb2e8f9f7	1589	assert_param(IS_RCC_PLLSAI1M_VALUE(PLLSAI1Init->PLLSAI1M));
<>	144:ef7eb2e8f9f7	1590	assert_param(IS_RCC_PLLSAI1N_VALUE(PLLSAI1Init->PLLSAI1N));
<>	144:ef7eb2e8f9f7	1591	assert_param(IS_RCC_PLLSAI1P_VALUE(PLLSAI1Init->PLLSAI1P));
<>	144:ef7eb2e8f9f7	1592	assert_param(IS_RCC_PLLSAI1Q_VALUE(PLLSAI1Init->PLLSAI1Q));
<>	144:ef7eb2e8f9f7	1593	assert_param(IS_RCC_PLLSAI1R_VALUE(PLLSAI1Init->PLLSAI1R));
<>	144:ef7eb2e8f9f7	1594	assert_param(IS_RCC_PLLSAI1CLOCKOUT_VALUE(PLLSAI1Init->PLLSAI1ClockOut));
<>	144:ef7eb2e8f9f7	1595
<>	144:ef7eb2e8f9f7	1596	/* Disable the PLLSAI1 */
<>	144:ef7eb2e8f9f7	1597	__HAL_RCC_PLLSAI1_DISABLE();
<>	144:ef7eb2e8f9f7	1598
<>	144:ef7eb2e8f9f7	1599	/* Get Start Tick*/
<>	144:ef7eb2e8f9f7	1600	tickstart = HAL_GetTick();
<>	144:ef7eb2e8f9f7	1601
<>	144:ef7eb2e8f9f7	1602	/* Wait till PLLSAI1 is ready to be updated */
<>	144:ef7eb2e8f9f7	1603	while(READ_BIT(RCC->CR, RCC_CR_PLLSAI1RDY) != RESET)
<>	144:ef7eb2e8f9f7	1604	{
<>	144:ef7eb2e8f9f7	1605	if((HAL_GetTick() - tickstart) > PLLSAI1_TIMEOUT_VALUE)
<>	144:ef7eb2e8f9f7	1606	{
<>	144:ef7eb2e8f9f7	1607	status = HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	1608	break;
<>	144:ef7eb2e8f9f7	1609	}
<>	144:ef7eb2e8f9f7	1610	}
<>	144:ef7eb2e8f9f7	1611
<>	144:ef7eb2e8f9f7	1612	if(status == HAL_OK)
<>	144:ef7eb2e8f9f7	1613	{
<>	144:ef7eb2e8f9f7	1614	/* Configure the PLLSAI1 Multiplication factor N */
<>	144:ef7eb2e8f9f7	1615	/* Configure the PLLSAI1 Division factors P, Q and R */
<>	144:ef7eb2e8f9f7	1616	__HAL_RCC_PLLSAI1_CONFIG(PLLSAI1Init->PLLSAI1N, PLLSAI1Init->PLLSAI1P, PLLSAI1Init->PLLSAI1Q, PLLSAI1Init->PLLSAI1R);
<>	144:ef7eb2e8f9f7	1617	/* Configure the PLLSAI1 Clock output(s) */
<>	144:ef7eb2e8f9f7	1618	__HAL_RCC_PLLSAI1CLKOUT_ENABLE(PLLSAI1Init->PLLSAI1ClockOut);
<>	144:ef7eb2e8f9f7	1619
<>	144:ef7eb2e8f9f7	1620	/* Enable the PLLSAI1 again by setting PLLSAI1ON to 1*/
<>	144:ef7eb2e8f9f7	1621	__HAL_RCC_PLLSAI1_ENABLE();
<>	144:ef7eb2e8f9f7	1622
<>	144:ef7eb2e8f9f7	1623	/* Get Start Tick*/
<>	144:ef7eb2e8f9f7	1624	tickstart = HAL_GetTick();
<>	144:ef7eb2e8f9f7	1625
<>	144:ef7eb2e8f9f7	1626	/* Wait till PLLSAI1 is ready */
<>	144:ef7eb2e8f9f7	1627	while(READ_BIT(RCC->CR, RCC_CR_PLLSAI1RDY) == RESET)
<>	144:ef7eb2e8f9f7	1628	{
<>	144:ef7eb2e8f9f7	1629	if((HAL_GetTick() - tickstart) > PLLSAI1_TIMEOUT_VALUE)
<>	144:ef7eb2e8f9f7	1630	{
<>	144:ef7eb2e8f9f7	1631	status = HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	1632	break;
<>	144:ef7eb2e8f9f7	1633	}
<>	144:ef7eb2e8f9f7	1634	}
<>	144:ef7eb2e8f9f7	1635	}
<>	144:ef7eb2e8f9f7	1636
<>	144:ef7eb2e8f9f7	1637	return status;
<>	144:ef7eb2e8f9f7	1638	}
<>	144:ef7eb2e8f9f7	1639
<>	144:ef7eb2e8f9f7	1640	/**
<>	144:ef7eb2e8f9f7	1641	* @brief Disable PLLSAI1.
<>	144:ef7eb2e8f9f7	1642	* @retval HAL status
<>	144:ef7eb2e8f9f7	1643	*/
<>	144:ef7eb2e8f9f7	1644	HAL_StatusTypeDef HAL_RCCEx_DisablePLLSAI1(void)
<>	144:ef7eb2e8f9f7	1645	{
<>	144:ef7eb2e8f9f7	1646	uint32_t tickstart = 0U;
<>	144:ef7eb2e8f9f7	1647	HAL_StatusTypeDef status = HAL_OK;
<>	144:ef7eb2e8f9f7	1648
<>	144:ef7eb2e8f9f7	1649	/* Disable the PLLSAI1 */
<>	144:ef7eb2e8f9f7	1650	__HAL_RCC_PLLSAI1_DISABLE();
<>	144:ef7eb2e8f9f7	1651
<>	144:ef7eb2e8f9f7	1652	/* Get Start Tick*/
<>	144:ef7eb2e8f9f7	1653	tickstart = HAL_GetTick();
<>	144:ef7eb2e8f9f7	1654
<>	144:ef7eb2e8f9f7	1655	/* Wait till PLLSAI1 is ready */
<>	144:ef7eb2e8f9f7	1656	while(READ_BIT(RCC->CR, RCC_CR_PLLSAI1RDY) != RESET)
<>	144:ef7eb2e8f9f7	1657	{
<>	144:ef7eb2e8f9f7	1658	if((HAL_GetTick() - tickstart) > PLLSAI1_TIMEOUT_VALUE)
<>	144:ef7eb2e8f9f7	1659	{
<>	144:ef7eb2e8f9f7	1660	status = HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	1661	break;
<>	144:ef7eb2e8f9f7	1662	}
<>	144:ef7eb2e8f9f7	1663	}
<>	144:ef7eb2e8f9f7	1664
<>	144:ef7eb2e8f9f7	1665	/* Disable the PLLSAI1 Clock outputs */
<>	144:ef7eb2e8f9f7	1666	__HAL_RCC_PLLSAI1CLKOUT_DISABLE(RCC_PLLSAI1CFGR_PLLSAI1PEN\|RCC_PLLSAI1CFGR_PLLSAI1QEN\|RCC_PLLSAI1CFGR_PLLSAI1REN);
<>	144:ef7eb2e8f9f7	1667
<>	144:ef7eb2e8f9f7	1668	/* Reset PLL source to save power if no PLLs on */
<>	144:ef7eb2e8f9f7	1669	if((READ_BIT(RCC->CR, RCC_CR_PLLRDY) == RESET)
<>	144:ef7eb2e8f9f7	1670	#if defined(RCC_PLLSAI2_SUPPORT)
<>	144:ef7eb2e8f9f7	1671	&&
<>	144:ef7eb2e8f9f7	1672	(READ_BIT(RCC->CR, RCC_CR_PLLSAI2RDY) == RESET)
<>	144:ef7eb2e8f9f7	1673	#endif /* RCC_PLLSAI2_SUPPORT */
<>	144:ef7eb2e8f9f7	1674	)
<>	144:ef7eb2e8f9f7	1675	{
<>	144:ef7eb2e8f9f7	1676	MODIFY_REG(RCC->PLLCFGR, RCC_PLLCFGR_PLLSRC, RCC_PLLSOURCE_NONE);
<>	144:ef7eb2e8f9f7	1677	}
<>	144:ef7eb2e8f9f7	1678
<>	144:ef7eb2e8f9f7	1679	return status;
<>	144:ef7eb2e8f9f7	1680	}
<>	144:ef7eb2e8f9f7	1681
<>	144:ef7eb2e8f9f7	1682	#if defined(RCC_PLLSAI2_SUPPORT)
<>	144:ef7eb2e8f9f7	1683
<>	144:ef7eb2e8f9f7	1684	/**
<>	144:ef7eb2e8f9f7	1685	* @brief Enable PLLSAI2.
<>	144:ef7eb2e8f9f7	1686	* @param PLLSAI2Init pointer to an RCC_PLLSAI2InitTypeDef structure that
<>	144:ef7eb2e8f9f7	1687	* contains the configuration information for the PLLSAI2
<>	144:ef7eb2e8f9f7	1688	* @retval HAL status
<>	144:ef7eb2e8f9f7	1689	*/
<>	144:ef7eb2e8f9f7	1690	HAL_StatusTypeDef HAL_RCCEx_EnablePLLSAI2(RCC_PLLSAI2InitTypeDef *PLLSAI2Init)
<>	144:ef7eb2e8f9f7	1691	{
<>	144:ef7eb2e8f9f7	1692	uint32_t tickstart = 0U;
<>	144:ef7eb2e8f9f7	1693	HAL_StatusTypeDef status = HAL_OK;
<>	144:ef7eb2e8f9f7	1694
<>	144:ef7eb2e8f9f7	1695	/* check for PLLSAI2 Parameters used to output PLLSAI2CLK */
<>	144:ef7eb2e8f9f7	1696	assert_param(IS_RCC_PLLSAI2SOURCE(PLLSAI2Init->PLLSAI2Source));
<>	144:ef7eb2e8f9f7	1697	assert_param(IS_RCC_PLLSAI2M_VALUE(PLLSAI2Init->PLLSAI2M));
<>	144:ef7eb2e8f9f7	1698	assert_param(IS_RCC_PLLSAI2N_VALUE(PLLSAI2Init->PLLSAI2N));
<>	144:ef7eb2e8f9f7	1699	assert_param(IS_RCC_PLLSAI2P_VALUE(PLLSAI2Init->PLLSAI2P));
<>	144:ef7eb2e8f9f7	1700	assert_param(IS_RCC_PLLSAI2R_VALUE(PLLSAI2Init->PLLSAI2R));
<>	144:ef7eb2e8f9f7	1701	assert_param(IS_RCC_PLLSAI2CLOCKOUT_VALUE(PLLSAI2Init->PLLSAI2ClockOut));
<>	144:ef7eb2e8f9f7	1702
<>	144:ef7eb2e8f9f7	1703	/* Disable the PLLSAI2 */
<>	144:ef7eb2e8f9f7	1704	__HAL_RCC_PLLSAI2_DISABLE();
<>	144:ef7eb2e8f9f7	1705
<>	144:ef7eb2e8f9f7	1706	/* Get Start Tick*/
<>	144:ef7eb2e8f9f7	1707	tickstart = HAL_GetTick();
<>	144:ef7eb2e8f9f7	1708
<>	144:ef7eb2e8f9f7	1709	/* Wait till PLLSAI2 is ready to be updated */
<>	144:ef7eb2e8f9f7	1710	while(READ_BIT(RCC->CR, RCC_CR_PLLSAI2RDY) != RESET)
<>	144:ef7eb2e8f9f7	1711	{
<>	144:ef7eb2e8f9f7	1712	if((HAL_GetTick() - tickstart) > PLLSAI2_TIMEOUT_VALUE)
<>	144:ef7eb2e8f9f7	1713	{
<>	144:ef7eb2e8f9f7	1714	status = HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	1715	break;
<>	144:ef7eb2e8f9f7	1716	}
<>	144:ef7eb2e8f9f7	1717	}
<>	144:ef7eb2e8f9f7	1718
<>	144:ef7eb2e8f9f7	1719	if(status == HAL_OK)
<>	144:ef7eb2e8f9f7	1720	{
<>	144:ef7eb2e8f9f7	1721	/* Configure the PLLSAI2 Multiplication factor N */
<>	144:ef7eb2e8f9f7	1722	/* Configure the PLLSAI2 Division factors P and R */
<>	144:ef7eb2e8f9f7	1723	__HAL_RCC_PLLSAI2_CONFIG(PLLSAI2Init->PLLSAI2N, PLLSAI2Init->PLLSAI2P, PLLSAI2Init->PLLSAI2R);
<>	144:ef7eb2e8f9f7	1724	/* Configure the PLLSAI2 Clock output(s) */
<>	144:ef7eb2e8f9f7	1725	__HAL_RCC_PLLSAI2CLKOUT_ENABLE(PLLSAI2Init->PLLSAI2ClockOut);
<>	144:ef7eb2e8f9f7	1726
<>	144:ef7eb2e8f9f7	1727	/* Enable the PLLSAI2 again by setting PLLSAI2ON to 1*/
<>	144:ef7eb2e8f9f7	1728	__HAL_RCC_PLLSAI2_ENABLE();
<>	144:ef7eb2e8f9f7	1729
<>	144:ef7eb2e8f9f7	1730	/* Get Start Tick*/
<>	144:ef7eb2e8f9f7	1731	tickstart = HAL_GetTick();
<>	144:ef7eb2e8f9f7	1732
<>	144:ef7eb2e8f9f7	1733	/* Wait till PLLSAI2 is ready */
<>	144:ef7eb2e8f9f7	1734	while(READ_BIT(RCC->CR, RCC_CR_PLLSAI2RDY) == RESET)
<>	144:ef7eb2e8f9f7	1735	{
<>	144:ef7eb2e8f9f7	1736	if((HAL_GetTick() - tickstart) > PLLSAI2_TIMEOUT_VALUE)
<>	144:ef7eb2e8f9f7	1737	{
<>	144:ef7eb2e8f9f7	1738	status = HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	1739	break;
<>	144:ef7eb2e8f9f7	1740	}
<>	144:ef7eb2e8f9f7	1741	}
<>	144:ef7eb2e8f9f7	1742	}
<>	144:ef7eb2e8f9f7	1743
<>	144:ef7eb2e8f9f7	1744	return status;
<>	144:ef7eb2e8f9f7	1745	}
<>	144:ef7eb2e8f9f7	1746
<>	144:ef7eb2e8f9f7	1747	/**
<>	144:ef7eb2e8f9f7	1748	* @brief Disable PLLISAI2.
<>	144:ef7eb2e8f9f7	1749	* @retval HAL status
<>	144:ef7eb2e8f9f7	1750	*/
<>	144:ef7eb2e8f9f7	1751	HAL_StatusTypeDef HAL_RCCEx_DisablePLLSAI2(void)
<>	144:ef7eb2e8f9f7	1752	{
<>	144:ef7eb2e8f9f7	1753	uint32_t tickstart = 0U;
<>	144:ef7eb2e8f9f7	1754	HAL_StatusTypeDef status = HAL_OK;
<>	144:ef7eb2e8f9f7	1755
<>	144:ef7eb2e8f9f7	1756	/* Disable the PLLSAI2 */
<>	144:ef7eb2e8f9f7	1757	__HAL_RCC_PLLSAI2_DISABLE();
<>	144:ef7eb2e8f9f7	1758
<>	144:ef7eb2e8f9f7	1759	/* Get Start Tick*/
<>	144:ef7eb2e8f9f7	1760	tickstart = HAL_GetTick();
<>	144:ef7eb2e8f9f7	1761
<>	144:ef7eb2e8f9f7	1762	/* Wait till PLLSAI2 is ready */
<>	144:ef7eb2e8f9f7	1763	while(READ_BIT(RCC->CR, RCC_CR_PLLSAI2RDY) != RESET)
<>	144:ef7eb2e8f9f7	1764	{
<>	144:ef7eb2e8f9f7	1765	if((HAL_GetTick() - tickstart) > PLLSAI2_TIMEOUT_VALUE)
<>	144:ef7eb2e8f9f7	1766	{
<>	144:ef7eb2e8f9f7	1767	status = HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	1768	break;
<>	144:ef7eb2e8f9f7	1769	}
<>	144:ef7eb2e8f9f7	1770	}
<>	144:ef7eb2e8f9f7	1771
<>	144:ef7eb2e8f9f7	1772	/* Disable the PLLSAI2 Clock outputs */
<>	144:ef7eb2e8f9f7	1773	__HAL_RCC_PLLSAI2CLKOUT_DISABLE(RCC_PLLSAI2CFGR_PLLSAI2PEN\|RCC_PLLSAI2CFGR_PLLSAI2REN);
<>	144:ef7eb2e8f9f7	1774
<>	144:ef7eb2e8f9f7	1775	/* Reset PLL source to save power if no PLLs on */
<>	144:ef7eb2e8f9f7	1776	if((READ_BIT(RCC->CR, RCC_CR_PLLRDY) == RESET)
<>	144:ef7eb2e8f9f7	1777	&&
<>	144:ef7eb2e8f9f7	1778	(READ_BIT(RCC->CR, RCC_CR_PLLSAI1RDY) == RESET)
<>	144:ef7eb2e8f9f7	1779	)
<>	144:ef7eb2e8f9f7	1780	{
<>	144:ef7eb2e8f9f7	1781	MODIFY_REG(RCC->PLLCFGR, RCC_PLLCFGR_PLLSRC, RCC_PLLSOURCE_NONE);
<>	144:ef7eb2e8f9f7	1782	}
<>	144:ef7eb2e8f9f7	1783
<>	144:ef7eb2e8f9f7	1784	return status;
<>	144:ef7eb2e8f9f7	1785	}
<>	144:ef7eb2e8f9f7	1786
<>	144:ef7eb2e8f9f7	1787	#endif /* RCC_PLLSAI2_SUPPORT */
<>	144:ef7eb2e8f9f7	1788
<>	144:ef7eb2e8f9f7	1789	/**
<>	144:ef7eb2e8f9f7	1790	* @brief Configure the oscillator clock source for wakeup from Stop and CSS backup clock.
<>	144:ef7eb2e8f9f7	1791	* @param WakeUpClk Wakeup clock
<>	144:ef7eb2e8f9f7	1792	* This parameter can be one of the following values:
<>	144:ef7eb2e8f9f7	1793	* @arg @ref RCC_STOP_WAKEUPCLOCK_MSI MSI oscillator selection
<>	144:ef7eb2e8f9f7	1794	* @arg @ref RCC_STOP_WAKEUPCLOCK_HSI HSI oscillator selection
<>	144:ef7eb2e8f9f7	1795	* @note This function shall not be called after the Clock Security System on HSE has been
<>	144:ef7eb2e8f9f7	1796	* enabled.
<>	144:ef7eb2e8f9f7	1797	* @retval None
<>	144:ef7eb2e8f9f7	1798	*/
<>	144:ef7eb2e8f9f7	1799	void HAL_RCCEx_WakeUpStopCLKConfig(uint32_t WakeUpClk)
<>	144:ef7eb2e8f9f7	1800	{
<>	144:ef7eb2e8f9f7	1801	assert_param(IS_RCC_STOP_WAKEUPCLOCK(WakeUpClk));
<>	144:ef7eb2e8f9f7	1802
<>	144:ef7eb2e8f9f7	1803	__HAL_RCC_WAKEUPSTOP_CLK_CONFIG(WakeUpClk);
<>	144:ef7eb2e8f9f7	1804	}
<>	144:ef7eb2e8f9f7	1805
<>	144:ef7eb2e8f9f7	1806	/**
<>	144:ef7eb2e8f9f7	1807	* @brief Configure the MSI range after standby mode.
<>	144:ef7eb2e8f9f7	1808	* @note After Standby its frequency can be selected between 4 possible values (1, 2, 4 or 8 MHz).
<>	144:ef7eb2e8f9f7	1809	* @param MSIRange MSI range
<>	144:ef7eb2e8f9f7	1810	* This parameter can be one of the following values:
<>	144:ef7eb2e8f9f7	1811	* @arg @ref RCC_MSIRANGE_4 Range 4 around 1 MHz
<>	144:ef7eb2e8f9f7	1812	* @arg @ref RCC_MSIRANGE_5 Range 5 around 2 MHz
<>	144:ef7eb2e8f9f7	1813	* @arg @ref RCC_MSIRANGE_6 Range 6 around 4 MHz (reset value)
<>	144:ef7eb2e8f9f7	1814	* @arg @ref RCC_MSIRANGE_7 Range 7 around 8 MHz
<>	144:ef7eb2e8f9f7	1815	* @retval None
<>	144:ef7eb2e8f9f7	1816	*/
<>	144:ef7eb2e8f9f7	1817	void HAL_RCCEx_StandbyMSIRangeConfig(uint32_t MSIRange)
<>	144:ef7eb2e8f9f7	1818	{
<>	144:ef7eb2e8f9f7	1819	assert_param(IS_RCC_MSI_STANDBY_CLOCK_RANGE(MSIRange));
<>	144:ef7eb2e8f9f7	1820
<>	144:ef7eb2e8f9f7	1821	__HAL_RCC_MSI_STANDBY_RANGE_CONFIG(MSIRange);
<>	144:ef7eb2e8f9f7	1822	}
<>	144:ef7eb2e8f9f7	1823
<>	144:ef7eb2e8f9f7	1824	/**
<>	144:ef7eb2e8f9f7	1825	* @brief Enable the LSE Clock Security System.
<>	144:ef7eb2e8f9f7	1826	* @note Prior to enable the LSE Clock Security System, LSE oscillator is to be enabled
<>	144:ef7eb2e8f9f7	1827	* with HAL_RCC_OscConfig() and the LSE oscillator clock is to be selected as RTC
<>	144:ef7eb2e8f9f7	1828	* clock with HAL_RCCEx_PeriphCLKConfig().
<>	144:ef7eb2e8f9f7	1829	* @retval None
<>	144:ef7eb2e8f9f7	1830	*/
<>	144:ef7eb2e8f9f7	1831	void HAL_RCCEx_EnableLSECSS(void)
<>	144:ef7eb2e8f9f7	1832	{
<>	144:ef7eb2e8f9f7	1833	SET_BIT(RCC->BDCR, RCC_BDCR_LSECSSON) ;
<>	144:ef7eb2e8f9f7	1834	}
<>	144:ef7eb2e8f9f7	1835
<>	144:ef7eb2e8f9f7	1836	/**
<>	144:ef7eb2e8f9f7	1837	* @brief Disable the LSE Clock Security System.
<>	144:ef7eb2e8f9f7	1838	* @note LSE Clock Security System can only be disabled after a LSE failure detection.
<>	144:ef7eb2e8f9f7	1839	* @retval None
<>	144:ef7eb2e8f9f7	1840	*/
<>	144:ef7eb2e8f9f7	1841	void HAL_RCCEx_DisableLSECSS(void)
<>	144:ef7eb2e8f9f7	1842	{
<>	144:ef7eb2e8f9f7	1843	CLEAR_BIT(RCC->BDCR, RCC_BDCR_LSECSSON) ;
<>	144:ef7eb2e8f9f7	1844
<>	144:ef7eb2e8f9f7	1845	/* Disable LSE CSS IT if any */
<>	144:ef7eb2e8f9f7	1846	__HAL_RCC_DISABLE_IT(RCC_IT_LSECSS);
<>	144:ef7eb2e8f9f7	1847	}
<>	144:ef7eb2e8f9f7	1848
<>	144:ef7eb2e8f9f7	1849	/**
<>	144:ef7eb2e8f9f7	1850	* @brief Enable the LSE Clock Security System Interrupt & corresponding EXTI line.
<>	144:ef7eb2e8f9f7	1851	* @note LSE Clock Security System Interrupt is mapped on RTC EXTI line 19
<>	144:ef7eb2e8f9f7	1852	* @retval None
<>	144:ef7eb2e8f9f7	1853	*/
<>	144:ef7eb2e8f9f7	1854	void HAL_RCCEx_EnableLSECSS_IT(void)
<>	144:ef7eb2e8f9f7	1855	{
<>	144:ef7eb2e8f9f7	1856	/* Enable LSE CSS */
<>	144:ef7eb2e8f9f7	1857	SET_BIT(RCC->BDCR, RCC_BDCR_LSECSSON) ;
<>	144:ef7eb2e8f9f7	1858
<>	144:ef7eb2e8f9f7	1859	/* Enable LSE CSS IT */
<>	144:ef7eb2e8f9f7	1860	__HAL_RCC_ENABLE_IT(RCC_IT_LSECSS);
<>	144:ef7eb2e8f9f7	1861
<>	144:ef7eb2e8f9f7	1862	/* Enable IT on EXTI Line 19 */
<>	144:ef7eb2e8f9f7	1863	__HAL_RCC_LSECSS_EXTI_ENABLE_IT();
<>	144:ef7eb2e8f9f7	1864	__HAL_RCC_LSECSS_EXTI_ENABLE_RISING_EDGE();
<>	144:ef7eb2e8f9f7	1865	}
<>	144:ef7eb2e8f9f7	1866
<>	144:ef7eb2e8f9f7	1867	/**
<>	144:ef7eb2e8f9f7	1868	* @brief Handle the RCC LSE Clock Security System interrupt request.
<>	144:ef7eb2e8f9f7	1869	* @retval None
<>	144:ef7eb2e8f9f7	1870	*/
<>	144:ef7eb2e8f9f7	1871	void HAL_RCCEx_LSECSS_IRQHandler(void)
<>	144:ef7eb2e8f9f7	1872	{
<>	144:ef7eb2e8f9f7	1873	/* Check RCC LSE CSSF flag */
<>	144:ef7eb2e8f9f7	1874	if(__HAL_RCC_GET_IT(RCC_IT_LSECSS))
<>	144:ef7eb2e8f9f7	1875	{
<>	144:ef7eb2e8f9f7	1876	/* RCC LSE Clock Security System interrupt user callback */
<>	144:ef7eb2e8f9f7	1877	HAL_RCCEx_LSECSS_Callback();
<>	144:ef7eb2e8f9f7	1878
<>	144:ef7eb2e8f9f7	1879	/* Clear RCC LSE CSS pending bit */
<>	144:ef7eb2e8f9f7	1880	__HAL_RCC_CLEAR_IT(RCC_IT_LSECSS);
<>	144:ef7eb2e8f9f7	1881	}
<>	144:ef7eb2e8f9f7	1882	}
<>	144:ef7eb2e8f9f7	1883
<>	144:ef7eb2e8f9f7	1884	/**
<>	144:ef7eb2e8f9f7	1885	* @brief RCCEx LSE Clock Security System interrupt callback.
<>	144:ef7eb2e8f9f7	1886	* @retval none
<>	144:ef7eb2e8f9f7	1887	*/
<>	144:ef7eb2e8f9f7	1888	__weak void HAL_RCCEx_LSECSS_Callback(void)
<>	144:ef7eb2e8f9f7	1889	{
<>	144:ef7eb2e8f9f7	1890	/* NOTE : This function should not be modified, when the callback is needed,
<>	144:ef7eb2e8f9f7	1891	the @ref HAL_RCCEx_LSECSS_Callback should be implemented in the user file
<>	144:ef7eb2e8f9f7	1892	*/
<>	144:ef7eb2e8f9f7	1893	}
<>	144:ef7eb2e8f9f7	1894
<>	144:ef7eb2e8f9f7	1895	/**
<>	144:ef7eb2e8f9f7	1896	* @brief Select the Low Speed clock source to output on LSCO pin (PA2).
<>	144:ef7eb2e8f9f7	1897	* @param LSCOSource specifies the Low Speed clock source to output.
<>	144:ef7eb2e8f9f7	1898	* This parameter can be one of the following values:
<>	144:ef7eb2e8f9f7	1899	* @arg @ref RCC_LSCOSOURCE_LSI LSI clock selected as LSCO source
<>	144:ef7eb2e8f9f7	1900	* @arg @ref RCC_LSCOSOURCE_LSE LSE clock selected as LSCO source
<>	144:ef7eb2e8f9f7	1901	* @retval None
<>	144:ef7eb2e8f9f7	1902	*/
<>	144:ef7eb2e8f9f7	1903	void HAL_RCCEx_EnableLSCO(uint32_t LSCOSource)
<>	144:ef7eb2e8f9f7	1904	{
<>	144:ef7eb2e8f9f7	1905	GPIO_InitTypeDef GPIO_InitStruct;
<>	144:ef7eb2e8f9f7	1906	FlagStatus pwrclkchanged = RESET;
<>	144:ef7eb2e8f9f7	1907	FlagStatus backupchanged = RESET;
<>	144:ef7eb2e8f9f7	1908
<>	144:ef7eb2e8f9f7	1909	/* Check the parameters */
<>	144:ef7eb2e8f9f7	1910	assert_param(IS_RCC_LSCOSOURCE(LSCOSource));
<>	144:ef7eb2e8f9f7	1911
<>	144:ef7eb2e8f9f7	1912	/* LSCO Pin Clock Enable */
<>	144:ef7eb2e8f9f7	1913	__LSCO_CLK_ENABLE();
<>	144:ef7eb2e8f9f7	1914
<>	144:ef7eb2e8f9f7	1915	/* Configue the LSCO pin in analog mode */
<>	144:ef7eb2e8f9f7	1916	GPIO_InitStruct.Pin = LSCO_PIN;
<>	144:ef7eb2e8f9f7	1917	GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
<>	144:ef7eb2e8f9f7	1918	GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
<>	144:ef7eb2e8f9f7	1919	GPIO_InitStruct.Pull = GPIO_NOPULL;
<>	144:ef7eb2e8f9f7	1920	HAL_GPIO_Init(LSCO_GPIO_PORT, &GPIO_InitStruct);
<>	144:ef7eb2e8f9f7	1921
<>	144:ef7eb2e8f9f7	1922	/* Update LSCOSEL clock source in Backup Domain control register */
<>	144:ef7eb2e8f9f7	1923	if(__HAL_RCC_PWR_IS_CLK_DISABLED())
<>	144:ef7eb2e8f9f7	1924	{
<>	144:ef7eb2e8f9f7	1925	__HAL_RCC_PWR_CLK_ENABLE();
<>	144:ef7eb2e8f9f7	1926	pwrclkchanged = SET;
<>	144:ef7eb2e8f9f7	1927	}
<>	144:ef7eb2e8f9f7	1928	if(HAL_IS_BIT_CLR(PWR->CR1, PWR_CR1_DBP))
<>	144:ef7eb2e8f9f7	1929	{
<>	144:ef7eb2e8f9f7	1930	HAL_PWR_EnableBkUpAccess();
<>	144:ef7eb2e8f9f7	1931	backupchanged = SET;
<>	144:ef7eb2e8f9f7	1932	}
<>	144:ef7eb2e8f9f7	1933
<>	144:ef7eb2e8f9f7	1934	MODIFY_REG(RCC->BDCR, RCC_BDCR_LSCOSEL \| RCC_BDCR_LSCOEN, LSCOSource \| RCC_BDCR_LSCOEN);
<>	144:ef7eb2e8f9f7	1935
<>	144:ef7eb2e8f9f7	1936	if(backupchanged == SET)
<>	144:ef7eb2e8f9f7	1937	{
<>	144:ef7eb2e8f9f7	1938	HAL_PWR_DisableBkUpAccess();
<>	144:ef7eb2e8f9f7	1939	}
<>	144:ef7eb2e8f9f7	1940	if(pwrclkchanged == SET)
<>	144:ef7eb2e8f9f7	1941	{
<>	144:ef7eb2e8f9f7	1942	__HAL_RCC_PWR_CLK_DISABLE();
<>	144:ef7eb2e8f9f7	1943	}
<>	144:ef7eb2e8f9f7	1944	}
<>	144:ef7eb2e8f9f7	1945
<>	144:ef7eb2e8f9f7	1946	/**
<>	144:ef7eb2e8f9f7	1947	* @brief Disable the Low Speed clock output.
<>	144:ef7eb2e8f9f7	1948	* @retval None
<>	144:ef7eb2e8f9f7	1949	*/
<>	144:ef7eb2e8f9f7	1950	void HAL_RCCEx_DisableLSCO(void)
<>	144:ef7eb2e8f9f7	1951	{
<>	144:ef7eb2e8f9f7	1952	FlagStatus pwrclkchanged = RESET;
<>	144:ef7eb2e8f9f7	1953	FlagStatus backupchanged = RESET;
<>	144:ef7eb2e8f9f7	1954
<>	144:ef7eb2e8f9f7	1955	/* Update LSCOEN bit in Backup Domain control register */
<>	144:ef7eb2e8f9f7	1956	if(__HAL_RCC_PWR_IS_CLK_DISABLED())
<>	144:ef7eb2e8f9f7	1957	{
<>	144:ef7eb2e8f9f7	1958	__HAL_RCC_PWR_CLK_ENABLE();
<>	144:ef7eb2e8f9f7	1959	pwrclkchanged = SET;
<>	144:ef7eb2e8f9f7	1960	}
<>	144:ef7eb2e8f9f7	1961	if(HAL_IS_BIT_CLR(PWR->CR1, PWR_CR1_DBP))
<>	144:ef7eb2e8f9f7	1962	{
<>	144:ef7eb2e8f9f7	1963	/* Enable access to the backup domain */
<>	144:ef7eb2e8f9f7	1964	HAL_PWR_EnableBkUpAccess();
<>	144:ef7eb2e8f9f7	1965	backupchanged = SET;
<>	144:ef7eb2e8f9f7	1966	}
<>	144:ef7eb2e8f9f7	1967
<>	144:ef7eb2e8f9f7	1968	CLEAR_BIT(RCC->BDCR, RCC_BDCR_LSCOEN);
<>	144:ef7eb2e8f9f7	1969
<>	144:ef7eb2e8f9f7	1970	/* Restore previous configuration */
<>	144:ef7eb2e8f9f7	1971	if(backupchanged == SET)
<>	144:ef7eb2e8f9f7	1972	{
<>	144:ef7eb2e8f9f7	1973	/* Disable access to the backup domain */
<>	144:ef7eb2e8f9f7	1974	HAL_PWR_DisableBkUpAccess();
<>	144:ef7eb2e8f9f7	1975	}
<>	144:ef7eb2e8f9f7	1976	if(pwrclkchanged == SET)
<>	144:ef7eb2e8f9f7	1977	{
<>	144:ef7eb2e8f9f7	1978	__HAL_RCC_PWR_CLK_DISABLE();
<>	144:ef7eb2e8f9f7	1979	}
<>	144:ef7eb2e8f9f7	1980	}
<>	144:ef7eb2e8f9f7	1981
<>	144:ef7eb2e8f9f7	1982	/**
<>	144:ef7eb2e8f9f7	1983	* @brief Enable the PLL-mode of the MSI.
<>	144:ef7eb2e8f9f7	1984	* @note Prior to enable the PLL-mode of the MSI for automatic hardware
<>	144:ef7eb2e8f9f7	1985	* calibration LSE oscillator is to be enabled with HAL_RCC_OscConfig().
<>	144:ef7eb2e8f9f7	1986	* @retval None
<>	144:ef7eb2e8f9f7	1987	*/
<>	144:ef7eb2e8f9f7	1988	void HAL_RCCEx_EnableMSIPLLMode(void)
<>	144:ef7eb2e8f9f7	1989	{
<>	144:ef7eb2e8f9f7	1990	SET_BIT(RCC->CR, RCC_CR_MSIPLLEN) ;
<>	144:ef7eb2e8f9f7	1991	}
<>	144:ef7eb2e8f9f7	1992
<>	144:ef7eb2e8f9f7	1993	/**
<>	144:ef7eb2e8f9f7	1994	* @brief Disable the PLL-mode of the MSI.
<>	144:ef7eb2e8f9f7	1995	* @note PLL-mode of the MSI is automatically reset when LSE oscillator is disabled.
<>	144:ef7eb2e8f9f7	1996	* @retval None
<>	144:ef7eb2e8f9f7	1997	*/
<>	144:ef7eb2e8f9f7	1998	void HAL_RCCEx_DisableMSIPLLMode(void)
<>	144:ef7eb2e8f9f7	1999	{
<>	144:ef7eb2e8f9f7	2000	CLEAR_BIT(RCC->CR, RCC_CR_MSIPLLEN) ;
<>	144:ef7eb2e8f9f7	2001	}
<>	144:ef7eb2e8f9f7	2002
<>	144:ef7eb2e8f9f7	2003	/**
<>	144:ef7eb2e8f9f7	2004	* @}
<>	144:ef7eb2e8f9f7	2005	*/
<>	144:ef7eb2e8f9f7	2006
<>	144:ef7eb2e8f9f7	2007	#if defined(CRS)
<>	144:ef7eb2e8f9f7	2008
<>	144:ef7eb2e8f9f7	2009	/** @defgroup RCCEx_Exported_Functions_Group3 Extended Clock Recovery System Control functions
<>	144:ef7eb2e8f9f7	2010	* @brief Extended Clock Recovery System Control functions
<>	144:ef7eb2e8f9f7	2011	*
<>	144:ef7eb2e8f9f7	2012	@verbatim
<>	144:ef7eb2e8f9f7	2013	===============================================================================
<>	144:ef7eb2e8f9f7	2014	##### Extended Clock Recovery System Control functions #####
<>	144:ef7eb2e8f9f7	2015	===============================================================================
<>	144:ef7eb2e8f9f7	2016	[..]
<>	144:ef7eb2e8f9f7	2017	For devices with Clock Recovery System feature (CRS), RCC Extention HAL driver can be used as follows:
<>	144:ef7eb2e8f9f7	2018
<>	144:ef7eb2e8f9f7	2019	(#) In System clock config, HSI48 needs to be enabled
<>	144:ef7eb2e8f9f7	2020
<>	144:ef7eb2e8f9f7	2021	(#) Enable CRS clock in IP MSP init which will use CRS functions
<>	144:ef7eb2e8f9f7	2022
<>	144:ef7eb2e8f9f7	2023	(#) Call CRS functions as follows:
<>	144:ef7eb2e8f9f7	2024	(##) Prepare synchronization configuration necessary for HSI48 calibration
<>	144:ef7eb2e8f9f7	2025	(+++) Default values can be set for frequency Error Measurement (reload and error limit)
<>	144:ef7eb2e8f9f7	2026	and also HSI48 oscillator smooth trimming.
<>	144:ef7eb2e8f9f7	2027	(+++) Macro __HAL_RCC_CRS_RELOADVALUE_CALCULATE can be also used to calculate
<>	144:ef7eb2e8f9f7	2028	directly reload value with target and sychronization frequencies values
<>	144:ef7eb2e8f9f7	2029	(##) Call function HAL_RCCEx_CRSConfig which
<>	144:ef7eb2e8f9f7	2030	(+++) Resets CRS registers to their default values.
<>	144:ef7eb2e8f9f7	2031	(+++) Configures CRS registers with synchronization configuration
<>	144:ef7eb2e8f9f7	2032	(+++) Enables automatic calibration and frequency error counter feature
<>	144:ef7eb2e8f9f7	2033	Note: When using USB LPM (Link Power Management) and the device is in Sleep mode, the
<>	144:ef7eb2e8f9f7	2034	periodic USB SOF will not be generated by the host. No SYNC signal will therefore be
<>	144:ef7eb2e8f9f7	2035	provided to the CRS to calibrate the HSI48 on the run. To guarantee the required clock
<>	144:ef7eb2e8f9f7	2036	precision after waking up from Sleep mode, the LSE or reference clock on the GPIOs
<>	144:ef7eb2e8f9f7	2037	should be used as SYNC signal.
<>	144:ef7eb2e8f9f7	2038
<>	144:ef7eb2e8f9f7	2039	(##) A polling function is provided to wait for complete synchronization
<>	144:ef7eb2e8f9f7	2040	(+++) Call function HAL_RCCEx_CRSWaitSynchronization()
<>	144:ef7eb2e8f9f7	2041	(+++) According to CRS status, user can decide to adjust again the calibration or continue
<>	144:ef7eb2e8f9f7	2042	application if synchronization is OK
<>	144:ef7eb2e8f9f7	2043
<>	144:ef7eb2e8f9f7	2044	(#) User can retrieve information related to synchronization in calling function
<>	144:ef7eb2e8f9f7	2045	HAL_RCCEx_CRSGetSynchronizationInfo()
<>	144:ef7eb2e8f9f7	2046
<>	144:ef7eb2e8f9f7	2047	(#) Regarding synchronization status and synchronization information, user can try a new calibration
<>	144:ef7eb2e8f9f7	2048	in changing synchronization configuration and call again HAL_RCCEx_CRSConfig.
<>	144:ef7eb2e8f9f7	2049	Note: When the SYNC event is detected during the downcounting phase (before reaching the zero value),
<>	144:ef7eb2e8f9f7	2050	it means that the actual frequency is lower than the target (and so, that the TRIM value should be
<>	144:ef7eb2e8f9f7	2051	incremented), while when it is detected during the upcounting phase it means that the actual frequency
<>	144:ef7eb2e8f9f7	2052	is higher (and that the TRIM value should be decremented).
<>	144:ef7eb2e8f9f7	2053
<>	144:ef7eb2e8f9f7	2054	(#) In interrupt mode, user can resort to the available macros (__HAL_RCC_CRS_XXX_IT). Interrupts will go
<>	144:ef7eb2e8f9f7	2055	through CRS Handler (CRS_IRQn/CRS_IRQHandler)
<>	144:ef7eb2e8f9f7	2056	(++) Call function HAL_RCCEx_CRSConfig()
<>	144:ef7eb2e8f9f7	2057	(++) Enable CRS_IRQn (thanks to NVIC functions)
<>	144:ef7eb2e8f9f7	2058	(++) Enable CRS interrupt (__HAL_RCC_CRS_ENABLE_IT)
<>	144:ef7eb2e8f9f7	2059	(++) Implement CRS status management in the following user callbacks called from
<>	144:ef7eb2e8f9f7	2060	HAL_RCCEx_CRS_IRQHandler():
<>	144:ef7eb2e8f9f7	2061	(+++) HAL_RCCEx_CRS_SyncOkCallback()
<>	144:ef7eb2e8f9f7	2062	(+++) HAL_RCCEx_CRS_SyncWarnCallback()
<>	144:ef7eb2e8f9f7	2063	(+++) HAL_RCCEx_CRS_ExpectedSyncCallback()
<>	144:ef7eb2e8f9f7	2064	(+++) HAL_RCCEx_CRS_ErrorCallback()
<>	144:ef7eb2e8f9f7	2065
<>	144:ef7eb2e8f9f7	2066	(#) To force a SYNC EVENT, user can use the function HAL_RCCEx_CRSSoftwareSynchronizationGenerate().
<>	144:ef7eb2e8f9f7	2067	This function can be called before calling HAL_RCCEx_CRSConfig (for instance in Systick handler)
<>	144:ef7eb2e8f9f7	2068
<>	144:ef7eb2e8f9f7	2069	@endverbatim
<>	144:ef7eb2e8f9f7	2070	* @{
<>	144:ef7eb2e8f9f7	2071	*/
<>	144:ef7eb2e8f9f7	2072
<>	144:ef7eb2e8f9f7	2073	/**
<>	144:ef7eb2e8f9f7	2074	* @brief Start automatic synchronization for polling mode
<>	144:ef7eb2e8f9f7	2075	* @param pInit Pointer on RCC_CRSInitTypeDef structure
<>	144:ef7eb2e8f9f7	2076	* @retval None
<>	144:ef7eb2e8f9f7	2077	*/
<>	144:ef7eb2e8f9f7	2078	void HAL_RCCEx_CRSConfig(RCC_CRSInitTypeDef *pInit)
<>	144:ef7eb2e8f9f7	2079	{
<>	144:ef7eb2e8f9f7	2080	uint32_t value = 0;
<>	144:ef7eb2e8f9f7	2081
<>	144:ef7eb2e8f9f7	2082	/* Check the parameters */
<>	144:ef7eb2e8f9f7	2083	assert_param(IS_RCC_CRS_SYNC_DIV(pInit->Prescaler));
<>	144:ef7eb2e8f9f7	2084	assert_param(IS_RCC_CRS_SYNC_SOURCE(pInit->Source));
<>	144:ef7eb2e8f9f7	2085	assert_param(IS_RCC_CRS_SYNC_POLARITY(pInit->Polarity));
<>	144:ef7eb2e8f9f7	2086	assert_param(IS_RCC_CRS_RELOADVALUE(pInit->ReloadValue));
<>	144:ef7eb2e8f9f7	2087	assert_param(IS_RCC_CRS_ERRORLIMIT(pInit->ErrorLimitValue));
<>	144:ef7eb2e8f9f7	2088	assert_param(IS_RCC_CRS_HSI48CALIBRATION(pInit->HSI48CalibrationValue));
<>	144:ef7eb2e8f9f7	2089
<>	144:ef7eb2e8f9f7	2090	/* CONFIGURATION */
<>	144:ef7eb2e8f9f7	2091
<>	144:ef7eb2e8f9f7	2092	/* Before configuration, reset CRS registers to their default values*/
<>	144:ef7eb2e8f9f7	2093	__HAL_RCC_CRS_FORCE_RESET();
<>	144:ef7eb2e8f9f7	2094	__HAL_RCC_CRS_RELEASE_RESET();
<>	144:ef7eb2e8f9f7	2095
<>	144:ef7eb2e8f9f7	2096	/* Set the SYNCDIV[2:0] bits according to Prescaler value */
<>	144:ef7eb2e8f9f7	2097	/* Set the SYNCSRC[1:0] bits according to Source value */
<>	144:ef7eb2e8f9f7	2098	/* Set the SYNCSPOL bit according to Polarity value */
<>	144:ef7eb2e8f9f7	2099	value = (pInit->Prescaler \| pInit->Source \| pInit->Polarity);
<>	144:ef7eb2e8f9f7	2100	/* Set the RELOAD[15:0] bits according to ReloadValue value */
<>	144:ef7eb2e8f9f7	2101	value \|= pInit->ReloadValue;
<>	144:ef7eb2e8f9f7	2102	/* Set the FELIM[7:0] bits according to ErrorLimitValue value */
<>	144:ef7eb2e8f9f7	2103	value \|= (pInit->ErrorLimitValue << POSITION_VAL(CRS_CFGR_FELIM));
<>	144:ef7eb2e8f9f7	2104	WRITE_REG(CRS->CFGR, value);
<>	144:ef7eb2e8f9f7	2105
<>	144:ef7eb2e8f9f7	2106	/* Adjust HSI48 oscillator smooth trimming */
<>	144:ef7eb2e8f9f7	2107	/* Set the TRIM[5:0] bits according to RCC_CRS_HSI48CalibrationValue value */
<>	144:ef7eb2e8f9f7	2108	MODIFY_REG(CRS->CR, CRS_CR_TRIM, (pInit->HSI48CalibrationValue << POSITION_VAL(CRS_CR_TRIM)));
<>	144:ef7eb2e8f9f7	2109
<>	144:ef7eb2e8f9f7	2110	/* START AUTOMATIC SYNCHRONIZATION*/
<>	144:ef7eb2e8f9f7	2111
<>	144:ef7eb2e8f9f7	2112	/* Enable Automatic trimming & Frequency error counter */
<>	144:ef7eb2e8f9f7	2113	SET_BIT(CRS->CR, CRS_CR_AUTOTRIMEN \| CRS_CR_CEN);
<>	144:ef7eb2e8f9f7	2114	}
<>	144:ef7eb2e8f9f7	2115
<>	144:ef7eb2e8f9f7	2116	/**
<>	144:ef7eb2e8f9f7	2117	* @brief Generate the software synchronization event
<>	144:ef7eb2e8f9f7	2118	* @retval None
<>	144:ef7eb2e8f9f7	2119	*/
<>	144:ef7eb2e8f9f7	2120	void HAL_RCCEx_CRSSoftwareSynchronizationGenerate(void)
<>	144:ef7eb2e8f9f7	2121	{
<>	144:ef7eb2e8f9f7	2122	SET_BIT(CRS->CR, CRS_CR_SWSYNC);
<>	144:ef7eb2e8f9f7	2123	}
<>	144:ef7eb2e8f9f7	2124
<>	144:ef7eb2e8f9f7	2125	/**
<>	144:ef7eb2e8f9f7	2126	* @brief Return synchronization info
<>	144:ef7eb2e8f9f7	2127	* @param pSynchroInfo Pointer on RCC_CRSSynchroInfoTypeDef structure
<>	144:ef7eb2e8f9f7	2128	* @retval None
<>	144:ef7eb2e8f9f7	2129	*/
<>	144:ef7eb2e8f9f7	2130	void HAL_RCCEx_CRSGetSynchronizationInfo(RCC_CRSSynchroInfoTypeDef *pSynchroInfo)
<>	144:ef7eb2e8f9f7	2131	{
<>	144:ef7eb2e8f9f7	2132	/* Check the parameter */
<>	144:ef7eb2e8f9f7	2133	assert_param(pSynchroInfo != NULL);
<>	144:ef7eb2e8f9f7	2134
<>	144:ef7eb2e8f9f7	2135	/* Get the reload value */
<>	144:ef7eb2e8f9f7	2136	pSynchroInfo->ReloadValue = (uint32_t)(READ_BIT(CRS->CFGR, CRS_CFGR_RELOAD));
<>	144:ef7eb2e8f9f7	2137
<>	144:ef7eb2e8f9f7	2138	/* Get HSI48 oscillator smooth trimming */
<>	144:ef7eb2e8f9f7	2139	pSynchroInfo->HSI48CalibrationValue = (uint32_t)(READ_BIT(CRS->CR, CRS_CR_TRIM) >> POSITION_VAL(CRS_CR_TRIM));
<>	144:ef7eb2e8f9f7	2140
<>	144:ef7eb2e8f9f7	2141	/* Get Frequency error capture */
<>	144:ef7eb2e8f9f7	2142	pSynchroInfo->FreqErrorCapture = (uint32_t)(READ_BIT(CRS->ISR, CRS_ISR_FECAP) >> POSITION_VAL(CRS_ISR_FECAP));
<>	144:ef7eb2e8f9f7	2143
<>	144:ef7eb2e8f9f7	2144	/* Get Frequency error direction */
<>	144:ef7eb2e8f9f7	2145	pSynchroInfo->FreqErrorDirection = (uint32_t)(READ_BIT(CRS->ISR, CRS_ISR_FEDIR));
<>	144:ef7eb2e8f9f7	2146	}
<>	144:ef7eb2e8f9f7	2147
<>	144:ef7eb2e8f9f7	2148	/**
<>	144:ef7eb2e8f9f7	2149	* @brief Wait for CRS Synchronization status.
<>	144:ef7eb2e8f9f7	2150	* @param Timeout Duration of the timeout
<>	144:ef7eb2e8f9f7	2151	* @note Timeout is based on the maximum time to receive a SYNC event based on synchronization
<>	144:ef7eb2e8f9f7	2152	* frequency.
<>	144:ef7eb2e8f9f7	2153	* @note If Timeout set to HAL_MAX_DELAY, HAL_TIMEOUT will be never returned.
<>	144:ef7eb2e8f9f7	2154	* @retval Combination of Synchronization status
<>	144:ef7eb2e8f9f7	2155	* This parameter can be a combination of the following values:
<>	144:ef7eb2e8f9f7	2156	* @arg @ref RCC_CRS_TIMEOUT
<>	144:ef7eb2e8f9f7	2157	* @arg @ref RCC_CRS_SYNCOK
<>	144:ef7eb2e8f9f7	2158	* @arg @ref RCC_CRS_SYNCWARN
<>	144:ef7eb2e8f9f7	2159	* @arg @ref RCC_CRS_SYNCERR
<>	144:ef7eb2e8f9f7	2160	* @arg @ref RCC_CRS_SYNCMISS
<>	144:ef7eb2e8f9f7	2161	* @arg @ref RCC_CRS_TRIMOVF
<>	144:ef7eb2e8f9f7	2162	*/
<>	144:ef7eb2e8f9f7	2163	uint32_t HAL_RCCEx_CRSWaitSynchronization(uint32_t Timeout)
<>	144:ef7eb2e8f9f7	2164	{
<>	144:ef7eb2e8f9f7	2165	uint32_t crsstatus = RCC_CRS_NONE;
<>	144:ef7eb2e8f9f7	2166	uint32_t tickstart = 0U;
<>	144:ef7eb2e8f9f7	2167
<>	144:ef7eb2e8f9f7	2168	/* Get timeout */
<>	144:ef7eb2e8f9f7	2169	tickstart = HAL_GetTick();
<>	144:ef7eb2e8f9f7	2170
<>	144:ef7eb2e8f9f7	2171	/* Wait for CRS flag or timeout detection */
<>	144:ef7eb2e8f9f7	2172	do
<>	144:ef7eb2e8f9f7	2173	{
<>	144:ef7eb2e8f9f7	2174	if(Timeout != HAL_MAX_DELAY)
<>	144:ef7eb2e8f9f7	2175	{
<>	144:ef7eb2e8f9f7	2176	if((Timeout == 0U) \|\| ((HAL_GetTick() - tickstart) > Timeout))
<>	144:ef7eb2e8f9f7	2177	{
<>	144:ef7eb2e8f9f7	2178	crsstatus = RCC_CRS_TIMEOUT;
<>	144:ef7eb2e8f9f7	2179	}
<>	144:ef7eb2e8f9f7	2180	}
<>	144:ef7eb2e8f9f7	2181	/* Check CRS SYNCOK flag */
<>	144:ef7eb2e8f9f7	2182	if(__HAL_RCC_CRS_GET_FLAG(RCC_CRS_FLAG_SYNCOK))
<>	144:ef7eb2e8f9f7	2183	{
<>	144:ef7eb2e8f9f7	2184	/* CRS SYNC event OK */
<>	144:ef7eb2e8f9f7	2185	crsstatus \|= RCC_CRS_SYNCOK;
<>	144:ef7eb2e8f9f7	2186
<>	144:ef7eb2e8f9f7	2187	/* Clear CRS SYNC event OK bit */
<>	144:ef7eb2e8f9f7	2188	__HAL_RCC_CRS_CLEAR_FLAG(RCC_CRS_FLAG_SYNCOK);
<>	144:ef7eb2e8f9f7	2189	}
<>	144:ef7eb2e8f9f7	2190
<>	144:ef7eb2e8f9f7	2191	/* Check CRS SYNCWARN flag */
<>	144:ef7eb2e8f9f7	2192	if(__HAL_RCC_CRS_GET_FLAG(RCC_CRS_FLAG_SYNCWARN))
<>	144:ef7eb2e8f9f7	2193	{
<>	144:ef7eb2e8f9f7	2194	/* CRS SYNC warning */
<>	144:ef7eb2e8f9f7	2195	crsstatus \|= RCC_CRS_SYNCWARN;
<>	144:ef7eb2e8f9f7	2196
<>	144:ef7eb2e8f9f7	2197	/* Clear CRS SYNCWARN bit */
<>	144:ef7eb2e8f9f7	2198	__HAL_RCC_CRS_CLEAR_FLAG(RCC_CRS_FLAG_SYNCWARN);
<>	144:ef7eb2e8f9f7	2199	}
<>	144:ef7eb2e8f9f7	2200
<>	144:ef7eb2e8f9f7	2201	/* Check CRS TRIM overflow flag */
<>	144:ef7eb2e8f9f7	2202	if(__HAL_RCC_CRS_GET_FLAG(RCC_CRS_FLAG_TRIMOVF))
<>	144:ef7eb2e8f9f7	2203	{
<>	144:ef7eb2e8f9f7	2204	/* CRS SYNC Error */
<>	144:ef7eb2e8f9f7	2205	crsstatus \|= RCC_CRS_TRIMOVF;
<>	144:ef7eb2e8f9f7	2206
<>	144:ef7eb2e8f9f7	2207	/* Clear CRS Error bit */
<>	144:ef7eb2e8f9f7	2208	__HAL_RCC_CRS_CLEAR_FLAG(RCC_CRS_FLAG_TRIMOVF);
<>	144:ef7eb2e8f9f7	2209	}
<>	144:ef7eb2e8f9f7	2210
<>	144:ef7eb2e8f9f7	2211	/* Check CRS Error flag */
<>	144:ef7eb2e8f9f7	2212	if(__HAL_RCC_CRS_GET_FLAG(RCC_CRS_FLAG_SYNCERR))
<>	144:ef7eb2e8f9f7	2213	{
<>	144:ef7eb2e8f9f7	2214	/* CRS SYNC Error */
<>	144:ef7eb2e8f9f7	2215	crsstatus \|= RCC_CRS_SYNCERR;
<>	144:ef7eb2e8f9f7	2216
<>	144:ef7eb2e8f9f7	2217	/* Clear CRS Error bit */
<>	144:ef7eb2e8f9f7	2218	__HAL_RCC_CRS_CLEAR_FLAG(RCC_CRS_FLAG_SYNCERR);
<>	144:ef7eb2e8f9f7	2219	}
<>	144:ef7eb2e8f9f7	2220
<>	144:ef7eb2e8f9f7	2221	/* Check CRS SYNC Missed flag */
<>	144:ef7eb2e8f9f7	2222	if(__HAL_RCC_CRS_GET_FLAG(RCC_CRS_FLAG_SYNCMISS))
<>	144:ef7eb2e8f9f7	2223	{
<>	144:ef7eb2e8f9f7	2224	/* CRS SYNC Missed */
<>	144:ef7eb2e8f9f7	2225	crsstatus \|= RCC_CRS_SYNCMISS;
<>	144:ef7eb2e8f9f7	2226
<>	144:ef7eb2e8f9f7	2227	/* Clear CRS SYNC Missed bit */
<>	144:ef7eb2e8f9f7	2228	__HAL_RCC_CRS_CLEAR_FLAG(RCC_CRS_FLAG_SYNCMISS);
<>	144:ef7eb2e8f9f7	2229	}
<>	144:ef7eb2e8f9f7	2230
<>	144:ef7eb2e8f9f7	2231	/* Check CRS Expected SYNC flag */
<>	144:ef7eb2e8f9f7	2232	if(__HAL_RCC_CRS_GET_FLAG(RCC_CRS_FLAG_ESYNC))
<>	144:ef7eb2e8f9f7	2233	{
<>	144:ef7eb2e8f9f7	2234	/* frequency error counter reached a zero value */
<>	144:ef7eb2e8f9f7	2235	__HAL_RCC_CRS_CLEAR_FLAG(RCC_CRS_FLAG_ESYNC);
<>	144:ef7eb2e8f9f7	2236	}
<>	144:ef7eb2e8f9f7	2237	} while(RCC_CRS_NONE == crsstatus);
<>	144:ef7eb2e8f9f7	2238
<>	144:ef7eb2e8f9f7	2239	return crsstatus;
<>	144:ef7eb2e8f9f7	2240	}
<>	144:ef7eb2e8f9f7	2241
<>	144:ef7eb2e8f9f7	2242	/**
<>	144:ef7eb2e8f9f7	2243	* @brief Handle the Clock Recovery System interrupt request.
<>	144:ef7eb2e8f9f7	2244	* @retval None
<>	144:ef7eb2e8f9f7	2245	*/
<>	144:ef7eb2e8f9f7	2246	void HAL_RCCEx_CRS_IRQHandler(void)
<>	144:ef7eb2e8f9f7	2247	{
<>	144:ef7eb2e8f9f7	2248	uint32_t crserror = RCC_CRS_NONE;
<>	144:ef7eb2e8f9f7	2249	/* Get current IT flags and IT sources values */
<>	144:ef7eb2e8f9f7	2250	uint32_t itflags = READ_REG(CRS->ISR);
<>	144:ef7eb2e8f9f7	2251	uint32_t itsources = READ_REG(CRS->CR);
<>	144:ef7eb2e8f9f7	2252
<>	144:ef7eb2e8f9f7	2253	/* Check CRS SYNCOK flag */
<>	144:ef7eb2e8f9f7	2254	if(((itflags & RCC_CRS_FLAG_SYNCOK) != RESET) && ((itsources & RCC_CRS_IT_SYNCOK) != RESET))
<>	144:ef7eb2e8f9f7	2255	{
<>	144:ef7eb2e8f9f7	2256	/* Clear CRS SYNC event OK flag */
<>	144:ef7eb2e8f9f7	2257	WRITE_REG(CRS->ICR, CRS_ICR_SYNCOKC);
<>	144:ef7eb2e8f9f7	2258
<>	144:ef7eb2e8f9f7	2259	/* user callback */
<>	144:ef7eb2e8f9f7	2260	HAL_RCCEx_CRS_SyncOkCallback();
<>	144:ef7eb2e8f9f7	2261	}
<>	144:ef7eb2e8f9f7	2262	/* Check CRS SYNCWARN flag */
<>	144:ef7eb2e8f9f7	2263	else if(((itflags & RCC_CRS_FLAG_SYNCWARN) != RESET) && ((itsources & RCC_CRS_IT_SYNCWARN) != RESET))
<>	144:ef7eb2e8f9f7	2264	{
<>	144:ef7eb2e8f9f7	2265	/* Clear CRS SYNCWARN flag */
<>	144:ef7eb2e8f9f7	2266	WRITE_REG(CRS->ICR, CRS_ICR_SYNCWARNC);
<>	144:ef7eb2e8f9f7	2267
<>	144:ef7eb2e8f9f7	2268	/* user callback */
<>	144:ef7eb2e8f9f7	2269	HAL_RCCEx_CRS_SyncWarnCallback();
<>	144:ef7eb2e8f9f7	2270	}
<>	144:ef7eb2e8f9f7	2271	/* Check CRS Expected SYNC flag */
<>	144:ef7eb2e8f9f7	2272	else if(((itflags & RCC_CRS_FLAG_ESYNC) != RESET) && ((itsources & RCC_CRS_IT_ESYNC) != RESET))
<>	144:ef7eb2e8f9f7	2273	{
<>	144:ef7eb2e8f9f7	2274	/* frequency error counter reached a zero value */
<>	144:ef7eb2e8f9f7	2275	WRITE_REG(CRS->ICR, CRS_ICR_ESYNCC);
<>	144:ef7eb2e8f9f7	2276
<>	144:ef7eb2e8f9f7	2277	/* user callback */
<>	144:ef7eb2e8f9f7	2278	HAL_RCCEx_CRS_ExpectedSyncCallback();
<>	144:ef7eb2e8f9f7	2279	}
<>	144:ef7eb2e8f9f7	2280	/* Check CRS Error flags */
<>	144:ef7eb2e8f9f7	2281	else
<>	144:ef7eb2e8f9f7	2282	{
<>	144:ef7eb2e8f9f7	2283	if(((itflags & RCC_CRS_FLAG_ERR) != RESET) && ((itsources & RCC_CRS_IT_ERR) != RESET))
<>	144:ef7eb2e8f9f7	2284	{
<>	144:ef7eb2e8f9f7	2285	if((itflags & RCC_CRS_FLAG_SYNCERR) != RESET)
<>	144:ef7eb2e8f9f7	2286	{
<>	144:ef7eb2e8f9f7	2287	crserror \|= RCC_CRS_SYNCERR;
<>	144:ef7eb2e8f9f7	2288	}
<>	144:ef7eb2e8f9f7	2289	if((itflags & RCC_CRS_FLAG_SYNCMISS) != RESET)
<>	144:ef7eb2e8f9f7	2290	{
<>	144:ef7eb2e8f9f7	2291	crserror \|= RCC_CRS_SYNCMISS;
<>	144:ef7eb2e8f9f7	2292	}
<>	144:ef7eb2e8f9f7	2293	if((itflags & RCC_CRS_FLAG_TRIMOVF) != RESET)
<>	144:ef7eb2e8f9f7	2294	{
<>	144:ef7eb2e8f9f7	2295	crserror \|= RCC_CRS_TRIMOVF;
<>	144:ef7eb2e8f9f7	2296	}
<>	144:ef7eb2e8f9f7	2297
<>	144:ef7eb2e8f9f7	2298	/* Clear CRS Error flags */
<>	144:ef7eb2e8f9f7	2299	WRITE_REG(CRS->ICR, CRS_ICR_ERRC);
<>	144:ef7eb2e8f9f7	2300
<>	144:ef7eb2e8f9f7	2301	/* user error callback */
<>	144:ef7eb2e8f9f7	2302	HAL_RCCEx_CRS_ErrorCallback(crserror);
<>	144:ef7eb2e8f9f7	2303	}
<>	144:ef7eb2e8f9f7	2304	}
<>	144:ef7eb2e8f9f7	2305	}
<>	144:ef7eb2e8f9f7	2306
<>	144:ef7eb2e8f9f7	2307	/**
<>	144:ef7eb2e8f9f7	2308	* @brief RCCEx Clock Recovery System SYNCOK interrupt callback.
<>	144:ef7eb2e8f9f7	2309	* @retval none
<>	144:ef7eb2e8f9f7	2310	*/
<>	144:ef7eb2e8f9f7	2311	__weak void HAL_RCCEx_CRS_SyncOkCallback(void)
<>	144:ef7eb2e8f9f7	2312	{
<>	144:ef7eb2e8f9f7	2313	/* NOTE : This function should not be modified, when the callback is needed,
<>	144:ef7eb2e8f9f7	2314	the @ref HAL_RCCEx_CRS_SyncOkCallback should be implemented in the user file
<>	144:ef7eb2e8f9f7	2315	*/
<>	144:ef7eb2e8f9f7	2316	}
<>	144:ef7eb2e8f9f7	2317
<>	144:ef7eb2e8f9f7	2318	/**
<>	144:ef7eb2e8f9f7	2319	* @brief RCCEx Clock Recovery System SYNCWARN interrupt callback.
<>	144:ef7eb2e8f9f7	2320	* @retval none
<>	144:ef7eb2e8f9f7	2321	*/
<>	144:ef7eb2e8f9f7	2322	__weak void HAL_RCCEx_CRS_SyncWarnCallback(void)
<>	144:ef7eb2e8f9f7	2323	{
<>	144:ef7eb2e8f9f7	2324	/* NOTE : This function should not be modified, when the callback is needed,
<>	144:ef7eb2e8f9f7	2325	the @ref HAL_RCCEx_CRS_SyncWarnCallback should be implemented in the user file
<>	144:ef7eb2e8f9f7	2326	*/
<>	144:ef7eb2e8f9f7	2327	}
<>	144:ef7eb2e8f9f7	2328
<>	144:ef7eb2e8f9f7	2329	/**
<>	144:ef7eb2e8f9f7	2330	* @brief RCCEx Clock Recovery System Expected SYNC interrupt callback.
<>	144:ef7eb2e8f9f7	2331	* @retval none
<>	144:ef7eb2e8f9f7	2332	*/
<>	144:ef7eb2e8f9f7	2333	__weak void HAL_RCCEx_CRS_ExpectedSyncCallback(void)
<>	144:ef7eb2e8f9f7	2334	{
<>	144:ef7eb2e8f9f7	2335	/* NOTE : This function should not be modified, when the callback is needed,
<>	144:ef7eb2e8f9f7	2336	the @ref HAL_RCCEx_CRS_ExpectedSyncCallback should be implemented in the user file
<>	144:ef7eb2e8f9f7	2337	*/
<>	144:ef7eb2e8f9f7	2338	}
<>	144:ef7eb2e8f9f7	2339
<>	144:ef7eb2e8f9f7	2340	/**
<>	144:ef7eb2e8f9f7	2341	* @brief RCCEx Clock Recovery System Error interrupt callback.
<>	144:ef7eb2e8f9f7	2342	* @param Error Combination of Error status.
<>	144:ef7eb2e8f9f7	2343	* This parameter can be a combination of the following values:
<>	144:ef7eb2e8f9f7	2344	* @arg @ref RCC_CRS_SYNCERR
<>	144:ef7eb2e8f9f7	2345	* @arg @ref RCC_CRS_SYNCMISS
<>	144:ef7eb2e8f9f7	2346	* @arg @ref RCC_CRS_TRIMOVF
<>	144:ef7eb2e8f9f7	2347	* @retval none
<>	144:ef7eb2e8f9f7	2348	*/
<>	144:ef7eb2e8f9f7	2349	__weak void HAL_RCCEx_CRS_ErrorCallback(uint32_t Error)
<>	144:ef7eb2e8f9f7	2350	{
<>	144:ef7eb2e8f9f7	2351	/* Prevent unused argument(s) compilation warning */
<>	144:ef7eb2e8f9f7	2352	UNUSED(Error);
<>	144:ef7eb2e8f9f7	2353
<>	144:ef7eb2e8f9f7	2354	/* NOTE : This function should not be modified, when the callback is needed,
<>	144:ef7eb2e8f9f7	2355	the @ref HAL_RCCEx_CRS_ErrorCallback should be implemented in the user file
<>	144:ef7eb2e8f9f7	2356	*/
<>	144:ef7eb2e8f9f7	2357	}
<>	144:ef7eb2e8f9f7	2358
<>	144:ef7eb2e8f9f7	2359	/**
<>	144:ef7eb2e8f9f7	2360	* @}
<>	144:ef7eb2e8f9f7	2361	*/
<>	144:ef7eb2e8f9f7	2362
<>	144:ef7eb2e8f9f7	2363	#endif /* CRS */
<>	144:ef7eb2e8f9f7	2364
<>	144:ef7eb2e8f9f7	2365	/**
<>	144:ef7eb2e8f9f7	2366	* @}
<>	144:ef7eb2e8f9f7	2367	*/
<>	144:ef7eb2e8f9f7	2368
<>	144:ef7eb2e8f9f7	2369	/** @addtogroup RCCEx_Private_Functions
<>	144:ef7eb2e8f9f7	2370	* @{
<>	144:ef7eb2e8f9f7	2371	*/
<>	144:ef7eb2e8f9f7	2372
<>	144:ef7eb2e8f9f7	2373	/**
<>	144:ef7eb2e8f9f7	2374	* @brief Configure the parameters N & P & optionally M of PLLSAI1 and enable PLLSAI1 output clock(s).
<>	144:ef7eb2e8f9f7	2375	* @param PllSai1 pointer to an RCC_PLLSAI1InitTypeDef structure that
<>	144:ef7eb2e8f9f7	2376	* contains the configuration parameters N & P & optionally M as well as PLLSAI1 output clock(s)
<>	144:ef7eb2e8f9f7	2377	* @param Divider divider parameter to be updated
<>	144:ef7eb2e8f9f7	2378	*
<>	144:ef7eb2e8f9f7	2379	* @note PLLSAI1 is temporary disable to apply new parameters
<>	144:ef7eb2e8f9f7	2380	*
<>	144:ef7eb2e8f9f7	2381	* @retval HAL status
<>	144:ef7eb2e8f9f7	2382	*/
<>	144:ef7eb2e8f9f7	2383	static HAL_StatusTypeDef RCCEx_PLLSAI1_Config(RCC_PLLSAI1InitTypeDef *PllSai1, uint32_t Divider)
<>	144:ef7eb2e8f9f7	2384	{
<>	144:ef7eb2e8f9f7	2385	uint32_t tickstart = 0U;
<>	144:ef7eb2e8f9f7	2386	HAL_StatusTypeDef status = HAL_OK;
<>	144:ef7eb2e8f9f7	2387
<>	144:ef7eb2e8f9f7	2388	/* check for PLLSAI1 Parameters used to output PLLSAI1CLK */
<>	144:ef7eb2e8f9f7	2389	/* P, Q and R dividers are verified in each specific divider case below */
<>	144:ef7eb2e8f9f7	2390	assert_param(IS_RCC_PLLSAI1SOURCE(PllSai1->PLLSAI1Source));
<>	144:ef7eb2e8f9f7	2391	assert_param(IS_RCC_PLLSAI1M_VALUE(PllSai1->PLLSAI1M));
<>	144:ef7eb2e8f9f7	2392	assert_param(IS_RCC_PLLSAI1N_VALUE(PllSai1->PLLSAI1N));
<>	144:ef7eb2e8f9f7	2393	assert_param(IS_RCC_PLLSAI1CLOCKOUT_VALUE(PllSai1->PLLSAI1ClockOut));
<>	144:ef7eb2e8f9f7	2394
<>	144:ef7eb2e8f9f7	2395	/* Check that PLLSAI1 clock source and divider M can be applied */
<>	144:ef7eb2e8f9f7	2396	if(__HAL_RCC_GET_PLL_OSCSOURCE() != RCC_PLLSOURCE_NONE)
<>	144:ef7eb2e8f9f7	2397	{
<>	144:ef7eb2e8f9f7	2398	/* PLL clock source and divider M already set, check that no request for change */
<>	144:ef7eb2e8f9f7	2399	if((__HAL_RCC_GET_PLL_OSCSOURCE() != PllSai1->PLLSAI1Source)
<>	144:ef7eb2e8f9f7	2400	\|\|
<>	144:ef7eb2e8f9f7	2401	(PllSai1->PLLSAI1Source == RCC_PLLSOURCE_NONE)
<>	144:ef7eb2e8f9f7	2402	\|\|
<>	144:ef7eb2e8f9f7	2403	(((READ_BIT(RCC->PLLCFGR, RCC_PLLCFGR_PLLM) >> POSITION_VAL(RCC_PLLCFGR_PLLM)) + 1U) != PllSai1->PLLSAI1M)
<>	144:ef7eb2e8f9f7	2404	)
<>	144:ef7eb2e8f9f7	2405	{
<>	144:ef7eb2e8f9f7	2406	status = HAL_ERROR;
<>	144:ef7eb2e8f9f7	2407	}
<>	144:ef7eb2e8f9f7	2408	}
<>	144:ef7eb2e8f9f7	2409	else
<>	144:ef7eb2e8f9f7	2410	{
<>	144:ef7eb2e8f9f7	2411	/* Check PLLSAI1 clock source availability */
<>	144:ef7eb2e8f9f7	2412	switch(PllSai1->PLLSAI1Source)
<>	144:ef7eb2e8f9f7	2413	{
<>	144:ef7eb2e8f9f7	2414	case RCC_PLLSOURCE_MSI:
<>	144:ef7eb2e8f9f7	2415	if(HAL_IS_BIT_CLR(RCC->CR, RCC_CR_MSIRDY))
<>	144:ef7eb2e8f9f7	2416	{
<>	144:ef7eb2e8f9f7	2417	status = HAL_ERROR;
<>	144:ef7eb2e8f9f7	2418	}
<>	144:ef7eb2e8f9f7	2419	break;
<>	144:ef7eb2e8f9f7	2420	case RCC_PLLSOURCE_HSI:
<>	144:ef7eb2e8f9f7	2421	if(HAL_IS_BIT_CLR(RCC->CR, RCC_CR_HSIRDY))
<>	144:ef7eb2e8f9f7	2422	{
<>	144:ef7eb2e8f9f7	2423	status = HAL_ERROR;
<>	144:ef7eb2e8f9f7	2424	}
<>	144:ef7eb2e8f9f7	2425	break;
<>	144:ef7eb2e8f9f7	2426	case RCC_PLLSOURCE_HSE:
<>	144:ef7eb2e8f9f7	2427	if(HAL_IS_BIT_CLR(RCC->CR, RCC_CR_HSERDY) && HAL_IS_BIT_CLR(RCC->CR, RCC_CR_HSEBYP))
<>	144:ef7eb2e8f9f7	2428	{
<>	144:ef7eb2e8f9f7	2429	status = HAL_ERROR;
<>	144:ef7eb2e8f9f7	2430	}
<>	144:ef7eb2e8f9f7	2431	break;
<>	144:ef7eb2e8f9f7	2432	default:
<>	144:ef7eb2e8f9f7	2433	status = HAL_ERROR;
<>	144:ef7eb2e8f9f7	2434	break;
<>	144:ef7eb2e8f9f7	2435	}
<>	144:ef7eb2e8f9f7	2436
<>	144:ef7eb2e8f9f7	2437	if(status == HAL_OK)
<>	144:ef7eb2e8f9f7	2438	{
<>	144:ef7eb2e8f9f7	2439	/* Set PLLSAI1 clock source and divider M */
<>	144:ef7eb2e8f9f7	2440	MODIFY_REG(RCC->PLLCFGR, RCC_PLLCFGR_PLLSRC \| RCC_PLLCFGR_PLLM, PllSai1->PLLSAI1Source \| (PllSai1->PLLSAI1M - 1U) << POSITION_VAL(RCC_PLLCFGR_PLLM));
<>	144:ef7eb2e8f9f7	2441	}
<>	144:ef7eb2e8f9f7	2442	}
<>	144:ef7eb2e8f9f7	2443
<>	144:ef7eb2e8f9f7	2444	if(status == HAL_OK)
<>	144:ef7eb2e8f9f7	2445	{
<>	144:ef7eb2e8f9f7	2446	/* Disable the PLLSAI1 */
<>	144:ef7eb2e8f9f7	2447	__HAL_RCC_PLLSAI1_DISABLE();
<>	144:ef7eb2e8f9f7	2448
<>	144:ef7eb2e8f9f7	2449	/* Get Start Tick*/
<>	144:ef7eb2e8f9f7	2450	tickstart = HAL_GetTick();
<>	144:ef7eb2e8f9f7	2451
<>	144:ef7eb2e8f9f7	2452	/* Wait till PLLSAI1 is ready to be updated */
<>	144:ef7eb2e8f9f7	2453	while(READ_BIT(RCC->CR, RCC_CR_PLLSAI1RDY) != RESET)
<>	144:ef7eb2e8f9f7	2454	{
<>	144:ef7eb2e8f9f7	2455	if((HAL_GetTick() - tickstart) > PLLSAI1_TIMEOUT_VALUE)
<>	144:ef7eb2e8f9f7	2456	{
<>	144:ef7eb2e8f9f7	2457	status = HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	2458	break;
<>	144:ef7eb2e8f9f7	2459	}
<>	144:ef7eb2e8f9f7	2460	}
<>	144:ef7eb2e8f9f7	2461
<>	144:ef7eb2e8f9f7	2462	if(status == HAL_OK)
<>	144:ef7eb2e8f9f7	2463	{
<>	144:ef7eb2e8f9f7	2464	if(Divider == DIVIDER_P_UPDATE)
<>	144:ef7eb2e8f9f7	2465	{
<>	144:ef7eb2e8f9f7	2466	assert_param(IS_RCC_PLLSAI1P_VALUE(PllSai1->PLLSAI1P));
<>	144:ef7eb2e8f9f7	2467	/* Configure the PLLSAI1 Division factor P and Multiplication factor N*/
<>	144:ef7eb2e8f9f7	2468	#if defined(RCC_PLLSAI1P_DIV_2_31_SUPPORT)
<>	144:ef7eb2e8f9f7	2469	MODIFY_REG(RCC->PLLSAI1CFGR,
<>	144:ef7eb2e8f9f7	2470	RCC_PLLSAI1CFGR_PLLSAI1N \| RCC_PLLSAI1CFGR_PLLSAI1PDIV,
<>	144:ef7eb2e8f9f7	2471	(PllSai1->PLLSAI1N << POSITION_VAL(RCC_PLLSAI1CFGR_PLLSAI1N)) \|
<>	144:ef7eb2e8f9f7	2472	(PllSai1->PLLSAI1P << POSITION_VAL(RCC_PLLSAI1CFGR_PLLSAI1PDIV)));
<>	144:ef7eb2e8f9f7	2473	#else
<>	144:ef7eb2e8f9f7	2474	MODIFY_REG(RCC->PLLSAI1CFGR,
<>	144:ef7eb2e8f9f7	2475	RCC_PLLSAI1CFGR_PLLSAI1N \| RCC_PLLSAI1CFGR_PLLSAI1P,
<>	144:ef7eb2e8f9f7	2476	(PllSai1->PLLSAI1N << POSITION_VAL(RCC_PLLSAI1CFGR_PLLSAI1N)) \|
<>	144:ef7eb2e8f9f7	2477	((PllSai1->PLLSAI1P >> 4U) << POSITION_VAL(RCC_PLLSAI1CFGR_PLLSAI1P)));
<>	144:ef7eb2e8f9f7	2478	#endif /* RCC_PLLSAI1P_DIV_2_31_SUPPORT */
<>	144:ef7eb2e8f9f7	2479	}
<>	144:ef7eb2e8f9f7	2480	else if(Divider == DIVIDER_Q_UPDATE)
<>	144:ef7eb2e8f9f7	2481	{
<>	144:ef7eb2e8f9f7	2482	assert_param(IS_RCC_PLLSAI1Q_VALUE(PllSai1->PLLSAI1Q));
<>	144:ef7eb2e8f9f7	2483	/* Configure the PLLSAI1 Division factor Q and Multiplication factor N*/
<>	144:ef7eb2e8f9f7	2484	MODIFY_REG(RCC->PLLSAI1CFGR,
<>	144:ef7eb2e8f9f7	2485	RCC_PLLSAI1CFGR_PLLSAI1N \| RCC_PLLSAI1CFGR_PLLSAI1Q,
<>	144:ef7eb2e8f9f7	2486	(PllSai1->PLLSAI1N << POSITION_VAL(RCC_PLLSAI1CFGR_PLLSAI1N)) \|
<>	144:ef7eb2e8f9f7	2487	(((PllSai1->PLLSAI1Q >> 1U) - 1U) << POSITION_VAL(RCC_PLLSAI1CFGR_PLLSAI1Q)));
<>	144:ef7eb2e8f9f7	2488	}
<>	144:ef7eb2e8f9f7	2489	else
<>	144:ef7eb2e8f9f7	2490	{
<>	144:ef7eb2e8f9f7	2491	assert_param(IS_RCC_PLLSAI1R_VALUE(PllSai1->PLLSAI1R));
<>	144:ef7eb2e8f9f7	2492	/* Configure the PLLSAI1 Division factor R and Multiplication factor N*/
<>	144:ef7eb2e8f9f7	2493	MODIFY_REG(RCC->PLLSAI1CFGR,
<>	144:ef7eb2e8f9f7	2494	RCC_PLLSAI1CFGR_PLLSAI1N \| RCC_PLLSAI1CFGR_PLLSAI1R,
<>	144:ef7eb2e8f9f7	2495	(PllSai1->PLLSAI1N << POSITION_VAL(RCC_PLLSAI1CFGR_PLLSAI1N)) \|
<>	144:ef7eb2e8f9f7	2496	(((PllSai1->PLLSAI1R >> 1U) - 1U) << POSITION_VAL(RCC_PLLSAI1CFGR_PLLSAI1R)));
<>	144:ef7eb2e8f9f7	2497	}
<>	144:ef7eb2e8f9f7	2498
<>	144:ef7eb2e8f9f7	2499	/* Enable the PLLSAI1 again by setting PLLSAI1ON to 1*/
<>	144:ef7eb2e8f9f7	2500	__HAL_RCC_PLLSAI1_ENABLE();
<>	144:ef7eb2e8f9f7	2501
<>	144:ef7eb2e8f9f7	2502	/* Get Start Tick*/
<>	144:ef7eb2e8f9f7	2503	tickstart = HAL_GetTick();
<>	144:ef7eb2e8f9f7	2504
<>	144:ef7eb2e8f9f7	2505	/* Wait till PLLSAI1 is ready */
<>	144:ef7eb2e8f9f7	2506	while(READ_BIT(RCC->CR, RCC_CR_PLLSAI1RDY) == RESET)
<>	144:ef7eb2e8f9f7	2507	{
<>	144:ef7eb2e8f9f7	2508	if((HAL_GetTick() - tickstart) > PLLSAI1_TIMEOUT_VALUE)
<>	144:ef7eb2e8f9f7	2509	{
<>	144:ef7eb2e8f9f7	2510	status = HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	2511	break;
<>	144:ef7eb2e8f9f7	2512	}
<>	144:ef7eb2e8f9f7	2513	}
<>	144:ef7eb2e8f9f7	2514
<>	144:ef7eb2e8f9f7	2515	if(status == HAL_OK)
<>	144:ef7eb2e8f9f7	2516	{
<>	144:ef7eb2e8f9f7	2517	/* Configure the PLLSAI1 Clock output(s) */
<>	144:ef7eb2e8f9f7	2518	__HAL_RCC_PLLSAI1CLKOUT_ENABLE(PllSai1->PLLSAI1ClockOut);
<>	144:ef7eb2e8f9f7	2519	}
<>	144:ef7eb2e8f9f7	2520	}
<>	144:ef7eb2e8f9f7	2521	}
<>	144:ef7eb2e8f9f7	2522
<>	144:ef7eb2e8f9f7	2523	return status;
<>	144:ef7eb2e8f9f7	2524	}
<>	144:ef7eb2e8f9f7	2525
<>	144:ef7eb2e8f9f7	2526	#if defined(RCC_PLLSAI2_SUPPORT)
<>	144:ef7eb2e8f9f7	2527
<>	144:ef7eb2e8f9f7	2528	/**
<>	144:ef7eb2e8f9f7	2529	* @brief Configure the parameters N & P & optionally M of PLLSAI2 and enable PLLSAI2 output clock(s).
<>	144:ef7eb2e8f9f7	2530	* @param PllSai2 pointer to an RCC_PLLSAI2InitTypeDef structure that
<>	144:ef7eb2e8f9f7	2531	* contains the configuration parameters N & P & optionally M as well as PLLSAI2 output clock(s)
<>	144:ef7eb2e8f9f7	2532	* @param Divider divider parameter to be updated
<>	144:ef7eb2e8f9f7	2533	*
<>	144:ef7eb2e8f9f7	2534	* @note PLLSAI2 is temporary disable to apply new parameters
<>	144:ef7eb2e8f9f7	2535	*
<>	144:ef7eb2e8f9f7	2536	* @retval HAL status
<>	144:ef7eb2e8f9f7	2537	*/
<>	144:ef7eb2e8f9f7	2538	static HAL_StatusTypeDef RCCEx_PLLSAI2_Config(RCC_PLLSAI2InitTypeDef *PllSai2, uint32_t Divider)
<>	144:ef7eb2e8f9f7	2539	{
<>	144:ef7eb2e8f9f7	2540	uint32_t tickstart = 0U;
<>	144:ef7eb2e8f9f7	2541	HAL_StatusTypeDef status = HAL_OK;
<>	144:ef7eb2e8f9f7	2542
<>	144:ef7eb2e8f9f7	2543	/* check for PLLSAI2 Parameters used to output PLLSAI2CLK */
<>	144:ef7eb2e8f9f7	2544	/* P, Q and R dividers are verified in each specific divider case below */
<>	144:ef7eb2e8f9f7	2545	assert_param(IS_RCC_PLLSAI2SOURCE(PllSai2->PLLSAI2Source));
<>	144:ef7eb2e8f9f7	2546	assert_param(IS_RCC_PLLSAI2M_VALUE(PllSai2->PLLSAI2M));
<>	144:ef7eb2e8f9f7	2547	assert_param(IS_RCC_PLLSAI2N_VALUE(PllSai2->PLLSAI2N));
<>	144:ef7eb2e8f9f7	2548	assert_param(IS_RCC_PLLSAI2CLOCKOUT_VALUE(PllSai2->PLLSAI2ClockOut));
<>	144:ef7eb2e8f9f7	2549
<>	144:ef7eb2e8f9f7	2550	/* Check that PLLSAI2 clock source and divider M can be applied */
<>	144:ef7eb2e8f9f7	2551	if(__HAL_RCC_GET_PLL_OSCSOURCE() != RCC_PLLSOURCE_NONE)
<>	144:ef7eb2e8f9f7	2552	{
<>	144:ef7eb2e8f9f7	2553	/* PLL clock source and divider M already set, check that no request for change */
<>	144:ef7eb2e8f9f7	2554	if((__HAL_RCC_GET_PLL_OSCSOURCE() != PllSai2->PLLSAI2Source)
<>	144:ef7eb2e8f9f7	2555	\|\|
<>	144:ef7eb2e8f9f7	2556	(PllSai2->PLLSAI2Source == RCC_PLLSOURCE_NONE)
<>	144:ef7eb2e8f9f7	2557	\|\|
<>	144:ef7eb2e8f9f7	2558	(((READ_BIT(RCC->PLLCFGR, RCC_PLLCFGR_PLLM) >> POSITION_VAL(RCC_PLLCFGR_PLLM)) + 1U) != PllSai2->PLLSAI2M)
<>	144:ef7eb2e8f9f7	2559	)
<>	144:ef7eb2e8f9f7	2560	{
<>	144:ef7eb2e8f9f7	2561	status = HAL_ERROR;
<>	144:ef7eb2e8f9f7	2562	}
<>	144:ef7eb2e8f9f7	2563	}
<>	144:ef7eb2e8f9f7	2564	else
<>	144:ef7eb2e8f9f7	2565	{
<>	144:ef7eb2e8f9f7	2566	/* Check PLLSAI2 clock source availability */
<>	144:ef7eb2e8f9f7	2567	switch(PllSai2->PLLSAI2Source)
<>	144:ef7eb2e8f9f7	2568	{
<>	144:ef7eb2e8f9f7	2569	case RCC_PLLSOURCE_MSI:
<>	144:ef7eb2e8f9f7	2570	if(HAL_IS_BIT_CLR(RCC->CR, RCC_CR_MSIRDY))
<>	144:ef7eb2e8f9f7	2571	{
<>	144:ef7eb2e8f9f7	2572	status = HAL_ERROR;
<>	144:ef7eb2e8f9f7	2573	}
<>	144:ef7eb2e8f9f7	2574	break;
<>	144:ef7eb2e8f9f7	2575	case RCC_PLLSOURCE_HSI:
<>	144:ef7eb2e8f9f7	2576	if(HAL_IS_BIT_CLR(RCC->CR, RCC_CR_HSIRDY))
<>	144:ef7eb2e8f9f7	2577	{
<>	144:ef7eb2e8f9f7	2578	status = HAL_ERROR;
<>	144:ef7eb2e8f9f7	2579	}
<>	144:ef7eb2e8f9f7	2580	break;
<>	144:ef7eb2e8f9f7	2581	case RCC_PLLSOURCE_HSE:
<>	144:ef7eb2e8f9f7	2582	if(HAL_IS_BIT_CLR(RCC->CR, RCC_CR_HSERDY) && HAL_IS_BIT_CLR(RCC->CR, RCC_CR_HSEBYP))
<>	144:ef7eb2e8f9f7	2583	{
<>	144:ef7eb2e8f9f7	2584	status = HAL_ERROR;
<>	144:ef7eb2e8f9f7	2585	}
<>	144:ef7eb2e8f9f7	2586	break;
<>	144:ef7eb2e8f9f7	2587	default:
<>	144:ef7eb2e8f9f7	2588	status = HAL_ERROR;
<>	144:ef7eb2e8f9f7	2589	break;
<>	144:ef7eb2e8f9f7	2590	}
<>	144:ef7eb2e8f9f7	2591
<>	144:ef7eb2e8f9f7	2592	if(status == HAL_OK)
<>	144:ef7eb2e8f9f7	2593	{
<>	144:ef7eb2e8f9f7	2594	/* Set PLLSAI2 clock source and divider M */
<>	144:ef7eb2e8f9f7	2595	MODIFY_REG(RCC->PLLCFGR, RCC_PLLCFGR_PLLSRC \| RCC_PLLCFGR_PLLM, PllSai2->PLLSAI2Source \| (PllSai2->PLLSAI2M - 1U) << POSITION_VAL(RCC_PLLCFGR_PLLM));
<>	144:ef7eb2e8f9f7	2596	}
<>	144:ef7eb2e8f9f7	2597	}
<>	144:ef7eb2e8f9f7	2598
<>	144:ef7eb2e8f9f7	2599	if(status == HAL_OK)
<>	144:ef7eb2e8f9f7	2600	{
<>	144:ef7eb2e8f9f7	2601	/* Disable the PLLSAI2 */
<>	144:ef7eb2e8f9f7	2602	__HAL_RCC_PLLSAI2_DISABLE();
<>	144:ef7eb2e8f9f7	2603
<>	144:ef7eb2e8f9f7	2604	/* Get Start Tick*/
<>	144:ef7eb2e8f9f7	2605	tickstart = HAL_GetTick();
<>	144:ef7eb2e8f9f7	2606
<>	144:ef7eb2e8f9f7	2607	/* Wait till PLLSAI2 is ready to be updated */
<>	144:ef7eb2e8f9f7	2608	while(READ_BIT(RCC->CR, RCC_CR_PLLSAI2RDY) != RESET)
<>	144:ef7eb2e8f9f7	2609	{
<>	144:ef7eb2e8f9f7	2610	if((HAL_GetTick() - tickstart) > PLLSAI2_TIMEOUT_VALUE)
<>	144:ef7eb2e8f9f7	2611	{
<>	144:ef7eb2e8f9f7	2612	status = HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	2613	break;
<>	144:ef7eb2e8f9f7	2614	}
<>	144:ef7eb2e8f9f7	2615	}
<>	144:ef7eb2e8f9f7	2616
<>	144:ef7eb2e8f9f7	2617	if(status == HAL_OK)
<>	144:ef7eb2e8f9f7	2618	{
<>	144:ef7eb2e8f9f7	2619	if(Divider == DIVIDER_P_UPDATE)
<>	144:ef7eb2e8f9f7	2620	{
<>	144:ef7eb2e8f9f7	2621	assert_param(IS_RCC_PLLSAI2P_VALUE(PllSai2->PLLSAI2P));
<>	144:ef7eb2e8f9f7	2622	/* Configure the PLLSAI2 Division factor P and Multiplication factor N*/
<>	144:ef7eb2e8f9f7	2623	#if defined(RCC_PLLSAI2P_DIV_2_31_SUPPORT)
<>	144:ef7eb2e8f9f7	2624	MODIFY_REG(RCC->PLLSAI2CFGR,
<>	144:ef7eb2e8f9f7	2625	RCC_PLLSAI2CFGR_PLLSAI2N \| RCC_PLLSAI2CFGR_PLLSAI2PDIV,
<>	144:ef7eb2e8f9f7	2626	(PllSai2->PLLSAI2N << POSITION_VAL(RCC_PLLSAI2CFGR_PLLSAI2N)) \|
<>	144:ef7eb2e8f9f7	2627	(PllSai2->PLLSAI2P << POSITION_VAL(RCC_PLLSAI2CFGR_PLLSAI2PDIV)));
<>	144:ef7eb2e8f9f7	2628	#else
<>	144:ef7eb2e8f9f7	2629	MODIFY_REG(RCC->PLLSAI2CFGR,
<>	144:ef7eb2e8f9f7	2630	RCC_PLLSAI2CFGR_PLLSAI2N \| RCC_PLLSAI2CFGR_PLLSAI2P,
<>	144:ef7eb2e8f9f7	2631	(PllSai2->PLLSAI2N << POSITION_VAL(RCC_PLLSAI2CFGR_PLLSAI2N)) \|
<>	144:ef7eb2e8f9f7	2632	((PllSai2->PLLSAI2P >> 4U) << POSITION_VAL(RCC_PLLSAI2CFGR_PLLSAI2P)));
<>	144:ef7eb2e8f9f7	2633	#endif /* RCC_PLLSAI2P_DIV_2_31_SUPPORT */
<>	144:ef7eb2e8f9f7	2634	}
<>	144:ef7eb2e8f9f7	2635	else
<>	144:ef7eb2e8f9f7	2636	{
<>	144:ef7eb2e8f9f7	2637	assert_param(IS_RCC_PLLSAI2R_VALUE(PllSai2->PLLSAI2R));
<>	144:ef7eb2e8f9f7	2638	/* Configure the PLLSAI2 Division factor R and Multiplication factor N*/
<>	144:ef7eb2e8f9f7	2639	MODIFY_REG(RCC->PLLSAI2CFGR,
<>	144:ef7eb2e8f9f7	2640	RCC_PLLSAI2CFGR_PLLSAI2N \| RCC_PLLSAI2CFGR_PLLSAI2R,
<>	144:ef7eb2e8f9f7	2641	(PllSai2->PLLSAI2N << POSITION_VAL(RCC_PLLSAI2CFGR_PLLSAI2N)) \|
<>	144:ef7eb2e8f9f7	2642	(((PllSai2->PLLSAI2R >> 1U) - 1U) << POSITION_VAL(RCC_PLLSAI2CFGR_PLLSAI2R)));
<>	144:ef7eb2e8f9f7	2643	}
<>	144:ef7eb2e8f9f7	2644
<>	144:ef7eb2e8f9f7	2645	/* Enable the PLLSAI2 again by setting PLLSAI2ON to 1*/
<>	144:ef7eb2e8f9f7	2646	__HAL_RCC_PLLSAI2_ENABLE();
<>	144:ef7eb2e8f9f7	2647
<>	144:ef7eb2e8f9f7	2648	/* Get Start Tick*/
<>	144:ef7eb2e8f9f7	2649	tickstart = HAL_GetTick();
<>	144:ef7eb2e8f9f7	2650
<>	144:ef7eb2e8f9f7	2651	/* Wait till PLLSAI2 is ready */
<>	144:ef7eb2e8f9f7	2652	while(READ_BIT(RCC->CR, RCC_CR_PLLSAI2RDY) == RESET)
<>	144:ef7eb2e8f9f7	2653	{
<>	144:ef7eb2e8f9f7	2654	if((HAL_GetTick() - tickstart) > PLLSAI2_TIMEOUT_VALUE)
<>	144:ef7eb2e8f9f7	2655	{
<>	144:ef7eb2e8f9f7	2656	status = HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	2657	break;
<>	144:ef7eb2e8f9f7	2658	}
<>	144:ef7eb2e8f9f7	2659	}
<>	144:ef7eb2e8f9f7	2660
<>	144:ef7eb2e8f9f7	2661	if(status == HAL_OK)
<>	144:ef7eb2e8f9f7	2662	{
<>	144:ef7eb2e8f9f7	2663	/* Configure the PLLSAI2 Clock output(s) */
<>	144:ef7eb2e8f9f7	2664	__HAL_RCC_PLLSAI2CLKOUT_ENABLE(PllSai2->PLLSAI2ClockOut);
<>	144:ef7eb2e8f9f7	2665	}
<>	144:ef7eb2e8f9f7	2666	}
<>	144:ef7eb2e8f9f7	2667	}
<>	144:ef7eb2e8f9f7	2668
<>	144:ef7eb2e8f9f7	2669	return status;
<>	144:ef7eb2e8f9f7	2670	}
<>	144:ef7eb2e8f9f7	2671
<>	144:ef7eb2e8f9f7	2672	#endif /* RCC_PLLSAI2_SUPPORT */
<>	144:ef7eb2e8f9f7	2673
<>	144:ef7eb2e8f9f7	2674	/**
<>	144:ef7eb2e8f9f7	2675	* @}
<>	144:ef7eb2e8f9f7	2676	*/
<>	144:ef7eb2e8f9f7	2677
<>	144:ef7eb2e8f9f7	2678	/**
<>	144:ef7eb2e8f9f7	2679	* @}
<>	144:ef7eb2e8f9f7	2680	*/
<>	144:ef7eb2e8f9f7	2681
<>	144:ef7eb2e8f9f7	2682	#endif /* HAL_RCC_MODULE_ENABLED */
<>	144:ef7eb2e8f9f7	2683	/**
<>	144:ef7eb2e8f9f7	2684	* @}
<>	144:ef7eb2e8f9f7	2685	*/
<>	144:ef7eb2e8f9f7	2686
<>	144:ef7eb2e8f9f7	2687	/**
<>	144:ef7eb2e8f9f7	2688	* @}
<>	144:ef7eb2e8f9f7	2689	*/
<>	144:ef7eb2e8f9f7	2690
<>	144:ef7eb2e8f9f7	2691	/********************** (C) COPYRIGHT STMicroelectronics *END OF FILE**/
<>	144:ef7eb2e8f9f7	2692

Repository toolbox

Repository details

Type:	Library
Created:	03 Nov 2016
Imports:	2
Forks:	0
Commits:	151
Dependents:	0
Dependencies:	0
Followers:	1

Important changes to repositories hosted on mbed.com

targets/TARGET_STM/TARGET_STM32L4/device/stm32l4xx_hal_rcc_ex.c@149:156823d33999, 2016-10-28 (annotated)

Who changed what in which revision?

Repository toolbox

Repository details

Important Information for this Arm website

Important changes to repositories hosted on mbed.com

targets/TARGET_STM/TARGET_STM32L4/device/stm32l4xx_hal_rcc_ex.c@149:156823d33999, 2016-10-28 (annotated)

Who changed what in which revision?

Repository toolbox

Repository details

Important Information for this Arm website

Access Warning