STM32L4xx_HAL_Driver - Hal Drivers for L4

Users » EricLew » Code » STM32L4xx_HAL_Driver

Hal Drivers for L4

Dependents: BSP OneHopeOnePrayer FINAL_AUDIO_RECORD AudioDemo

Fork of STM32L4xx_HAL_Driver by Senior Design: Sound Monitor

Src/stm32l4xx_hal_dfsdm.c@2:7aef7655b0a8, 2015-11-25 (annotated)

Committer:: EricLew
Date:: Wed Nov 25 17:30:43 2015 +0000
Revision:: 2:7aef7655b0a8
Parent:: 0:80ee8f3b695e

commit;

Who changed what in which revision?

User	Revision	Line number	New contents of line
EricLew	0:80ee8f3b695e	1	/**
EricLew	0:80ee8f3b695e	2	******************************************************************************
EricLew	0:80ee8f3b695e	3	* @file stm32l4xx_hal_dfsdm.c
EricLew	0:80ee8f3b695e	4	* @author MCD Application Team
EricLew	0:80ee8f3b695e	5	* @version V1.1.0
EricLew	0:80ee8f3b695e	6	* @date 16-September-2015
EricLew	0:80ee8f3b695e	7	* @brief This file provides firmware functions to manage the following
EricLew	0:80ee8f3b695e	8	* functionalities of the Digital Filter for Sigma-Delta Modulators
EricLew	0:80ee8f3b695e	9	* (DFSDM) peripherals:
EricLew	0:80ee8f3b695e	10	* + Initialization and configuration of channels and filters
EricLew	0:80ee8f3b695e	11	* + Regular channels configuration
EricLew	0:80ee8f3b695e	12	* + Injected channels configuration
EricLew	0:80ee8f3b695e	13	* + Regular/Injected Channels DMA Configuration
EricLew	0:80ee8f3b695e	14	* + Interrupts and flags management
EricLew	0:80ee8f3b695e	15	* + Analog watchdog feature
EricLew	0:80ee8f3b695e	16	* + Short-circuit detector feature
EricLew	0:80ee8f3b695e	17	* + Extremes detector feature
EricLew	0:80ee8f3b695e	18	* + Clock absence detector feature
EricLew	0:80ee8f3b695e	19	* + Break generation on analog watchdog or short-circuit event
EricLew	0:80ee8f3b695e	20	*
EricLew	0:80ee8f3b695e	21	@verbatim
EricLew	0:80ee8f3b695e	22	==============================================================================
EricLew	0:80ee8f3b695e	23	##### How to use this driver #####
EricLew	0:80ee8f3b695e	24	==============================================================================
EricLew	0:80ee8f3b695e	25	[..]
EricLew	0:80ee8f3b695e	26	* Channel initialization *
EricLew	0:80ee8f3b695e	27	==============================
EricLew	0:80ee8f3b695e	28	[..]
EricLew	0:80ee8f3b695e	29	(#) User has first to initialize channels (before filters initialization).
EricLew	0:80ee8f3b695e	30	(#) As prerequisite, fill in the HAL_DFSDM_ChannelMspInit() :
EricLew	0:80ee8f3b695e	31	(++) Enable DFSDM clock interface with __HAL_RCC_DFSDM_CLK_ENABLE().
EricLew	0:80ee8f3b695e	32	(++) Enable the clocks for the DFSDM GPIOS with __HAL_RCC_GPIOx_CLK_ENABLE().
EricLew	0:80ee8f3b695e	33	(++) Configure these DFSDM pins in alternate mode using HAL_GPIO_Init().
EricLew	0:80ee8f3b695e	34	(++) If interrupt mode is used, enable and configure DFSDM1 global
EricLew	0:80ee8f3b695e	35	interrupt with HAL_NVIC_SetPriority() and HAL_NVIC_EnableIRQ().
EricLew	0:80ee8f3b695e	36	(#) Configure the output clock, input, serial interface, analog watchdog,
EricLew	0:80ee8f3b695e	37	offset and data right bit shift parameters for this channel using the
EricLew	0:80ee8f3b695e	38	HAL_DFSDM_ChannelInit() function.
EricLew	0:80ee8f3b695e	39
EricLew	0:80ee8f3b695e	40	* Channel clock absence detector *
EricLew	0:80ee8f3b695e	41	======================================
EricLew	0:80ee8f3b695e	42	[..]
EricLew	0:80ee8f3b695e	43	(#) Start clock absence detector using HAL_DFSDM_ChannelCkabStart() or
EricLew	0:80ee8f3b695e	44	HAL_DFSDM_ChannelCkabStart_IT().
EricLew	0:80ee8f3b695e	45	(#) In polling mode, use HAL_DFSDM_ChannelPollForCkab() to detect the clock
EricLew	0:80ee8f3b695e	46	absence.
EricLew	0:80ee8f3b695e	47	(#) In interrupt mode, HAL_DFSDM_ChannelCkabCallback() will be called if
EricLew	0:80ee8f3b695e	48	clock absence is detected.
EricLew	0:80ee8f3b695e	49	(#) Stop clock absence detector using HAL_DFSDM_ChannelCkabStop() or
EricLew	0:80ee8f3b695e	50	HAL_DFSDM_ChannelCkabStop_IT().
EricLew	0:80ee8f3b695e	51	(#) Please note that the same mode (polling or interrupt) has to be used
EricLew	0:80ee8f3b695e	52	for all channels because the channels are sharing the same interrupt.
EricLew	0:80ee8f3b695e	53	(#) Please note also that in interrupt mode, if clock absence detector is
EricLew	0:80ee8f3b695e	54	stopped for one channel, interrupt will be disabled for all channels.
EricLew	0:80ee8f3b695e	55
EricLew	0:80ee8f3b695e	56	* Channel short circuit detector *
EricLew	0:80ee8f3b695e	57	======================================
EricLew	0:80ee8f3b695e	58	[..]
EricLew	0:80ee8f3b695e	59	(#) Start short circuit detector using HAL_DFSDM_ChannelScdStart() or
EricLew	0:80ee8f3b695e	60	or HAL_DFSDM_ChannelScdStart_IT().
EricLew	0:80ee8f3b695e	61	(#) In polling mode, use HAL_DFSDM_ChannelPollForScd() to detect short
EricLew	0:80ee8f3b695e	62	circuit.
EricLew	0:80ee8f3b695e	63	(#) In interrupt mode, HAL_DFSDM_ChannelScdCallback() will be called if
EricLew	0:80ee8f3b695e	64	short circuit is detected.
EricLew	0:80ee8f3b695e	65	(#) Stop short circuit detector using HAL_DFSDM_ChannelScdStop() or
EricLew	0:80ee8f3b695e	66	or HAL_DFSDM_ChannelScdStop_IT().
EricLew	0:80ee8f3b695e	67	(#) Please note that the same mode (polling or interrupt) has to be used
EricLew	0:80ee8f3b695e	68	for all channels because the channels are sharing the same interrupt.
EricLew	0:80ee8f3b695e	69	(#) Please note also that in interrupt mode, if short circuit detector is
EricLew	0:80ee8f3b695e	70	stopped for one channel, interrupt will be disabled for all channels.
EricLew	0:80ee8f3b695e	71
EricLew	0:80ee8f3b695e	72	* Channel analog watchdog value *
EricLew	0:80ee8f3b695e	73	=====================================
EricLew	0:80ee8f3b695e	74	[..]
EricLew	0:80ee8f3b695e	75	(#) Get analog watchdog filter value of a channel using
EricLew	0:80ee8f3b695e	76	HAL_DFSDM_ChannelGetAwdValue().
EricLew	0:80ee8f3b695e	77
EricLew	0:80ee8f3b695e	78	* Channel offset value *
EricLew	0:80ee8f3b695e	79	=====================================
EricLew	0:80ee8f3b695e	80	[..]
EricLew	0:80ee8f3b695e	81	(#) Modify offset value of a channel using HAL_DFSDM_ChannelModifyOffset().
EricLew	0:80ee8f3b695e	82
EricLew	0:80ee8f3b695e	83	* Filter initialization *
EricLew	0:80ee8f3b695e	84	=============================
EricLew	0:80ee8f3b695e	85	[..]
EricLew	0:80ee8f3b695e	86	(#) After channel initialization, user has to init filters.
EricLew	0:80ee8f3b695e	87	(#) As prerequisite, fill in the HAL_DFSDM_FilterMspInit() :
EricLew	0:80ee8f3b695e	88	(++) If interrupt mode is used , enable and configure DFSDMx global
EricLew	0:80ee8f3b695e	89	interrupt with HAL_NVIC_SetPriority() and HAL_NVIC_EnableIRQ().
EricLew	0:80ee8f3b695e	90	Please note that DFSDM0 global interrupt could be already
EricLew	0:80ee8f3b695e	91	enabled if interrupt is used for channel.
EricLew	0:80ee8f3b695e	92	(++) If DMA mode is used, configure DMA with HAL_DMA_Init() and link it
EricLew	0:80ee8f3b695e	93	with DFSDMx filter handle using __HAL_LINKDMA().
EricLew	0:80ee8f3b695e	94	(#) Configure the regular conversion, injected conversion and filter
EricLew	0:80ee8f3b695e	95	parameters for this filter using the HAL_DFSDM_FilterInit() function.
EricLew	0:80ee8f3b695e	96
EricLew	0:80ee8f3b695e	97	* Filter regular channel conversion *
EricLew	0:80ee8f3b695e	98	=========================================
EricLew	0:80ee8f3b695e	99	[..]
EricLew	0:80ee8f3b695e	100	(#) Select regular channel and enable/disable continuous mode using
EricLew	0:80ee8f3b695e	101	HAL_DFSDM_FilterConfigRegChannel().
EricLew	0:80ee8f3b695e	102	(#) Start regular conversion using HAL_DFSDM_FilterRegularStart(),
EricLew	0:80ee8f3b695e	103	HAL_DFSDM_FilterRegularStart_IT(), HAL_DFSDM_FilterRegularStart_DMA() or
EricLew	0:80ee8f3b695e	104	HAL_DFSDM_FilterRegularMsbStart_DMA().
EricLew	0:80ee8f3b695e	105	(#) In polling mode, use HAL_DFSDM_FilterPollForRegConversion() to detect
EricLew	0:80ee8f3b695e	106	the end of regular conversion.
EricLew	0:80ee8f3b695e	107	(#) In interrupt mode, HAL_DFSDM_FilterRegConvCpltCallback() will be called
EricLew	0:80ee8f3b695e	108	at the end of regular conversion.
EricLew	0:80ee8f3b695e	109	(#) Get value of regular conversion and corresponding channel using
EricLew	0:80ee8f3b695e	110	HAL_DFSDM_FilterGetRegularValue().
EricLew	0:80ee8f3b695e	111	(#) In DMA mode, HAL_DFSDM_FilterRegConvHalfCpltCallback() and
EricLew	0:80ee8f3b695e	112	HAL_DFSDM_FilterRegConvCpltCallback() will be called respectively at the
EricLew	0:80ee8f3b695e	113	half transfer and at the transfer complete. Please note that
EricLew	0:80ee8f3b695e	114	HAL_DFSDM_FilterRegConvHalfCpltCallback() will be called only in DMA
EricLew	0:80ee8f3b695e	115	circular mode.
EricLew	0:80ee8f3b695e	116	(#) Stop regular conversion using HAL_DFSDM_FilterRegularStop(),
EricLew	0:80ee8f3b695e	117	HAL_DFSDM_FilterRegularStop_IT() or HAL_DFSDM_FilterRegularStop_DMA().
EricLew	0:80ee8f3b695e	118
EricLew	0:80ee8f3b695e	119	* Filter injected channels conversion *
EricLew	0:80ee8f3b695e	120	===========================================
EricLew	0:80ee8f3b695e	121	[..]
EricLew	0:80ee8f3b695e	122	(#) Select injected channels using HAL_DFSDM_FilterConfigInjChannel().
EricLew	0:80ee8f3b695e	123	(#) Start injected conversion using HAL_DFSDM_FilterInjectedStart(),
EricLew	0:80ee8f3b695e	124	HAL_DFSDM_FilterInjectedStart_IT(), HAL_DFSDM_FilterInjectedStart_DMA() or
EricLew	0:80ee8f3b695e	125	HAL_DFSDM_FilterInjectedMsbStart_DMA().
EricLew	0:80ee8f3b695e	126	(#) In polling mode, use HAL_DFSDM_FilterPollForInjConversion() to detect
EricLew	0:80ee8f3b695e	127	the end of injected conversion.
EricLew	0:80ee8f3b695e	128	(#) In interrupt mode, HAL_DFSDM_FilterInjConvCpltCallback() will be called
EricLew	0:80ee8f3b695e	129	at the end of injected conversion.
EricLew	0:80ee8f3b695e	130	(#) Get value of injected conversion and corresponding channel using
EricLew	0:80ee8f3b695e	131	HAL_DFSDM_FilterGetInjectedValue().
EricLew	0:80ee8f3b695e	132	(#) In DMA mode, HAL_DFSDM_FilterInjConvHalfCpltCallback() and
EricLew	0:80ee8f3b695e	133	HAL_DFSDM_FilterInjConvCpltCallback() will be called respectively at the
EricLew	0:80ee8f3b695e	134	half transfer and at the transfer complete. Please note that
EricLew	0:80ee8f3b695e	135	HAL_DFSDM_FilterInjConvCpltCallback() will be called only in DMA
EricLew	0:80ee8f3b695e	136	circular mode.
EricLew	0:80ee8f3b695e	137	(#) Stop injected conversion using HAL_DFSDM_FilterInjectedStop(),
EricLew	0:80ee8f3b695e	138	HAL_DFSDM_FilterInjectedStop_IT() or HAL_DFSDM_FilterInjectedStop_DMA().
EricLew	0:80ee8f3b695e	139
EricLew	0:80ee8f3b695e	140	* Filter analog watchdog *
EricLew	0:80ee8f3b695e	141	==============================
EricLew	0:80ee8f3b695e	142	[..]
EricLew	0:80ee8f3b695e	143	(#) Start filter analog watchdog using HAL_DFSDM_FilterAwdStart_IT().
EricLew	0:80ee8f3b695e	144	(#) HAL_DFSDM_FilterAwdCallback() will be called if analog watchdog occurs.
EricLew	0:80ee8f3b695e	145	(#) Stop filter analog watchdog using HAL_DFSDM_FilterAwdStop_IT().
EricLew	0:80ee8f3b695e	146
EricLew	0:80ee8f3b695e	147	* Filter extreme detector *
EricLew	0:80ee8f3b695e	148	===============================
EricLew	0:80ee8f3b695e	149	[..]
EricLew	0:80ee8f3b695e	150	(#) Start filter extreme detector using HAL_DFSDM_FilterExdStart().
EricLew	0:80ee8f3b695e	151	(#) Get extreme detector maximum value using HAL_DFSDM_FilterGetExdMaxValue().
EricLew	0:80ee8f3b695e	152	(#) Get extreme detector minimum value using HAL_DFSDM_FilterGetExdMinValue().
EricLew	0:80ee8f3b695e	153	(#) Start filter extreme detector using HAL_DFSDM_FilterExdStop().
EricLew	0:80ee8f3b695e	154
EricLew	0:80ee8f3b695e	155	* Filter conversion time *
EricLew	0:80ee8f3b695e	156	==============================
EricLew	0:80ee8f3b695e	157	[..]
EricLew	0:80ee8f3b695e	158	(#) Get conversion time value using HAL_DFSDM_FilterGetConvTimeValue().
EricLew	0:80ee8f3b695e	159
EricLew	0:80ee8f3b695e	160	@endverbatim
EricLew	0:80ee8f3b695e	161	******************************************************************************
EricLew	0:80ee8f3b695e	162	* @attention
EricLew	0:80ee8f3b695e	163	*
EricLew	0:80ee8f3b695e	164	* <h2><center>© COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
EricLew	0:80ee8f3b695e	165	*
EricLew	0:80ee8f3b695e	166	* Redistribution and use in source and binary forms, with or without modification,
EricLew	0:80ee8f3b695e	167	* are permitted provided that the following conditions are met:
EricLew	0:80ee8f3b695e	168	* 1. Redistributions of source code must retain the above copyright notice,
EricLew	0:80ee8f3b695e	169	* this list of conditions and the following disclaimer.
EricLew	0:80ee8f3b695e	170	* 2. Redistributions in binary form must reproduce the above copyright notice,
EricLew	0:80ee8f3b695e	171	* this list of conditions and the following disclaimer in the documentation
EricLew	0:80ee8f3b695e	172	* and/or other materials provided with the distribution.
EricLew	0:80ee8f3b695e	173	* 3. Neither the name of STMicroelectronics nor the names of its contributors
EricLew	0:80ee8f3b695e	174	* may be used to endorse or promote products derived from this software
EricLew	0:80ee8f3b695e	175	* without specific prior written permission.
EricLew	0:80ee8f3b695e	176	*
EricLew	0:80ee8f3b695e	177	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
EricLew	0:80ee8f3b695e	178	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
EricLew	0:80ee8f3b695e	179	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
EricLew	0:80ee8f3b695e	180	* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
EricLew	0:80ee8f3b695e	181	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
EricLew	0:80ee8f3b695e	182	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
EricLew	0:80ee8f3b695e	183	* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
EricLew	0:80ee8f3b695e	184	* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
EricLew	0:80ee8f3b695e	185	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
EricLew	0:80ee8f3b695e	186	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
EricLew	0:80ee8f3b695e	187	*
EricLew	0:80ee8f3b695e	188	******************************************************************************
EricLew	0:80ee8f3b695e	189	*/
EricLew	0:80ee8f3b695e	190
EricLew	0:80ee8f3b695e	191	/* Includes ------------------------------------------------------------------*/
EricLew	0:80ee8f3b695e	192	#include "stm32l4xx_hal.h"
EricLew	0:80ee8f3b695e	193
EricLew	0:80ee8f3b695e	194	/** @addtogroup STM32L4xx_HAL_Driver
EricLew	0:80ee8f3b695e	195	* @{
EricLew	0:80ee8f3b695e	196	*/
EricLew	0:80ee8f3b695e	197	#ifdef HAL_DFSDM_MODULE_ENABLED
EricLew	0:80ee8f3b695e	198	/** @defgroup DFSDM DFSDM
EricLew	0:80ee8f3b695e	199	* @brief DFSDM HAL driver module
EricLew	0:80ee8f3b695e	200	* @{
EricLew	0:80ee8f3b695e	201	*/
EricLew	0:80ee8f3b695e	202
EricLew	0:80ee8f3b695e	203	/* Private typedef -----------------------------------------------------------*/
EricLew	0:80ee8f3b695e	204	/* Private define ------------------------------------------------------------*/
EricLew	0:80ee8f3b695e	205	/** @defgroup DFSDM_Private_Define DFSDM Private Define
EricLew	0:80ee8f3b695e	206	* @{
EricLew	0:80ee8f3b695e	207	*/
EricLew	0:80ee8f3b695e	208	#define DFSDM_CHCFGR1_CLK_DIV_OFFSET POSITION_VAL(DFSDM_CHCFGR1_CKOUTDIV)
EricLew	0:80ee8f3b695e	209	#define DFSDM_AWSCDR_BKSCD_OFFSET POSITION_VAL(DFSDM_AWSCDR_BKSCD)
EricLew	0:80ee8f3b695e	210	#define DFSDM_AWSCDR_FOSR_OFFSET POSITION_VAL(DFSDM_AWSCDR_AWFOSR)
EricLew	0:80ee8f3b695e	211	#define DFSDM_CHCFGR2_OFFSET_OFFSET POSITION_VAL(DFSDM_CHCFGR2_OFFSET)
EricLew	0:80ee8f3b695e	212	#define DFSDM_CHCFGR2_DTRBS_OFFSET POSITION_VAL(DFSDM_CHCFGR2_DTRBS)
EricLew	0:80ee8f3b695e	213	#define DFSDM_FCR_FOSR_OFFSET POSITION_VAL(DFSDM_FCR_FOSR)
EricLew	0:80ee8f3b695e	214	#define DFSDM_CR1_MSB_RCH_OFFSET 8
EricLew	0:80ee8f3b695e	215	#define DFSDM_CR2_EXCH_OFFSET POSITION_VAL(DFSDM_CR2_EXCH)
EricLew	0:80ee8f3b695e	216	#define DFSDM_CR2_AWDCH_OFFSET POSITION_VAL(DFSDM_CR2_AWDCH)
EricLew	0:80ee8f3b695e	217	#define DFSDM_ISR_CKABF_OFFSET POSITION_VAL(DFSDM_ISR_CKABF)
EricLew	0:80ee8f3b695e	218	#define DFSDM_ISR_SCDF_OFFSET POSITION_VAL(DFSDM_ISR_SCDF)
EricLew	0:80ee8f3b695e	219	#define DFSDM_ICR_CLRCKABF_OFFSET POSITION_VAL(DFSDM_ICR_CLRCKABF)
EricLew	0:80ee8f3b695e	220	#define DFSDM_ICR_CLRSCDF_OFFSET POSITION_VAL(DFSDM_ICR_CLRSCSDF)
EricLew	0:80ee8f3b695e	221	#define DFSDM_RDATAR_DATA_OFFSET POSITION_VAL(DFSDM_RDATAR_RDATA)
EricLew	0:80ee8f3b695e	222	#define DFSDM_JDATAR_DATA_OFFSET POSITION_VAL(DFSDM_JDATAR_JDATA)
EricLew	0:80ee8f3b695e	223	#define DFSDM_AWHTR_THRESHOLD_OFFSET POSITION_VAL(DFSDM_AWHTR_AWHT)
EricLew	0:80ee8f3b695e	224	#define DFSDM_AWLTR_THRESHOLD_OFFSET POSITION_VAL(DFSDM_AWLTR_AWLT)
EricLew	0:80ee8f3b695e	225	#define DFSDM_EXMAX_DATA_OFFSET POSITION_VAL(DFSDM_EXMAX_EXMAX)
EricLew	0:80ee8f3b695e	226	#define DFSDM_EXMIN_DATA_OFFSET POSITION_VAL(DFSDM_EXMIN_EXMIN)
EricLew	0:80ee8f3b695e	227	#define DFSDM_CNVTIMR_DATA_OFFSET POSITION_VAL(DFSDM_CNVTIMR_CNVCNT)
EricLew	0:80ee8f3b695e	228	#define DFSDM_AWSR_HIGH_OFFSET POSITION_VAL(DFSDM_AWSR_AWHTF)
EricLew	0:80ee8f3b695e	229	#define DFSDM_MSB_MASK 0xFFFF0000
EricLew	0:80ee8f3b695e	230	#define DFSDM_LSB_MASK 0x0000FFFF
EricLew	0:80ee8f3b695e	231	#define DFSDM_CKAB_TIMEOUT 5000
EricLew	0:80ee8f3b695e	232	#define DFSDM_CHANNEL_NUMBER 8
EricLew	0:80ee8f3b695e	233	/**
EricLew	0:80ee8f3b695e	234	* @}
EricLew	0:80ee8f3b695e	235	*/
EricLew	0:80ee8f3b695e	236
EricLew	0:80ee8f3b695e	237	/* Private macro -------------------------------------------------------------*/
EricLew	0:80ee8f3b695e	238	/* Private variables ---------------------------------------------------------*/
EricLew	0:80ee8f3b695e	239	/** @defgroup DFSDM_Private_Variables DFSDM Private Variables
EricLew	0:80ee8f3b695e	240	* @{
EricLew	0:80ee8f3b695e	241	*/
EricLew	0:80ee8f3b695e	242	__IO uint32_t v_dfsdmChannelCounter = 0;
EricLew	0:80ee8f3b695e	243	DFSDM_Channel_HandleTypeDef* a_dfsdmChannelHandle[DFSDM_CHANNEL_NUMBER] = {(DFSDM_Channel_HandleTypeDef *) NULL};
EricLew	0:80ee8f3b695e	244	/**
EricLew	0:80ee8f3b695e	245	* @}
EricLew	0:80ee8f3b695e	246	*/
EricLew	0:80ee8f3b695e	247
EricLew	0:80ee8f3b695e	248	/* Private function prototypes -----------------------------------------------*/
EricLew	0:80ee8f3b695e	249	/** @defgroup DFSDM_Private_Functions DFSDM Private Functions
EricLew	0:80ee8f3b695e	250	* @{
EricLew	0:80ee8f3b695e	251	*/
EricLew	0:80ee8f3b695e	252	static uint32_t DFSDM_GetInjChannelsNbr(uint32_t Channels);
EricLew	0:80ee8f3b695e	253	static uint32_t DFSDM_GetChannelFromInstance(DFSDM_Channel_TypeDef* Instance);
EricLew	0:80ee8f3b695e	254	static void DFSDM_RegConvStart(DFSDM_Filter_HandleTypeDef *hdfsdm_filter);
EricLew	0:80ee8f3b695e	255	static void DFSDM_RegConvStop(DFSDM_Filter_HandleTypeDef* hdfsdm_filter);
EricLew	0:80ee8f3b695e	256	static void DFSDM_InjConvStart(DFSDM_Filter_HandleTypeDef* hdfsdm_filter);
EricLew	0:80ee8f3b695e	257	static void DFSDM_InjConvStop(DFSDM_Filter_HandleTypeDef* hdfsdm_filter);
EricLew	0:80ee8f3b695e	258	static void DFSDM_DMARegularHalfConvCplt(DMA_HandleTypeDef *hdma);
EricLew	0:80ee8f3b695e	259	static void DFSDM_DMARegularConvCplt(DMA_HandleTypeDef *hdma);
EricLew	0:80ee8f3b695e	260	static void DFSDM_DMAInjectedHalfConvCplt(DMA_HandleTypeDef *hdma);
EricLew	0:80ee8f3b695e	261	static void DFSDM_DMAInjectedConvCplt(DMA_HandleTypeDef *hdma);
EricLew	0:80ee8f3b695e	262	static void DFSDM_DMAError(DMA_HandleTypeDef *hdma);
EricLew	0:80ee8f3b695e	263	/**
EricLew	0:80ee8f3b695e	264	* @}
EricLew	0:80ee8f3b695e	265	*/
EricLew	0:80ee8f3b695e	266
EricLew	0:80ee8f3b695e	267	/* Exported functions --------------------------------------------------------*/
EricLew	0:80ee8f3b695e	268	/** @defgroup DFSDM_Exported_Functions DFSDM Exported Functions
EricLew	0:80ee8f3b695e	269	* @{
EricLew	0:80ee8f3b695e	270	*/
EricLew	0:80ee8f3b695e	271
EricLew	0:80ee8f3b695e	272	/** @defgroup DFSDM_Exported_Functions_Group1_Channel Channel initialization and de-initialization functions
EricLew	0:80ee8f3b695e	273	* @brief Channel initialization and de-initialization functions
EricLew	0:80ee8f3b695e	274	*
EricLew	0:80ee8f3b695e	275	@verbatim
EricLew	0:80ee8f3b695e	276	==============================================================================
EricLew	0:80ee8f3b695e	277	##### Channel initialization and de-initialization functions #####
EricLew	0:80ee8f3b695e	278	==============================================================================
EricLew	0:80ee8f3b695e	279	[..] This section provides functions allowing to:
EricLew	0:80ee8f3b695e	280	(+) Initialize the DFSDM channel.
EricLew	0:80ee8f3b695e	281	(+) De-initialize the DFSDM channel.
EricLew	0:80ee8f3b695e	282	@endverbatim
EricLew	0:80ee8f3b695e	283	* @{
EricLew	0:80ee8f3b695e	284	*/
EricLew	0:80ee8f3b695e	285
EricLew	0:80ee8f3b695e	286	/**
EricLew	0:80ee8f3b695e	287	* @brief Initialize the DFSDM channel according to the specified parameters
EricLew	0:80ee8f3b695e	288	* in the DFSDM_ChannelInitTypeDef structure and initialize the associated handle.
EricLew	0:80ee8f3b695e	289	* @param hdfsdm_channel : DFSDM channel handle.
EricLew	0:80ee8f3b695e	290	* @retval HAL status.
EricLew	0:80ee8f3b695e	291	*/
EricLew	0:80ee8f3b695e	292	HAL_StatusTypeDef HAL_DFSDM_ChannelInit(DFSDM_Channel_HandleTypeDef *hdfsdm_channel)
EricLew	0:80ee8f3b695e	293	{
EricLew	0:80ee8f3b695e	294	/* Check parameters */
EricLew	0:80ee8f3b695e	295	assert_param(IS_DFSDM_CHANNEL_ALL_INSTANCE(hdfsdm_channel->Instance));
EricLew	0:80ee8f3b695e	296	assert_param(IS_FUNCTIONAL_STATE(hdfsdm_channel->Init.OutputClock.Activation));
EricLew	0:80ee8f3b695e	297	assert_param(IS_DFSDM_CHANNEL_INPUT(hdfsdm_channel->Init.Input.Multiplexer));
EricLew	0:80ee8f3b695e	298	assert_param(IS_DFSDM_CHANNEL_DATA_PACKING(hdfsdm_channel->Init.Input.DataPacking));
EricLew	0:80ee8f3b695e	299	assert_param(IS_DFSDM_CHANNEL_INPUT_PINS(hdfsdm_channel->Init.Input.Pins));
EricLew	0:80ee8f3b695e	300	assert_param(IS_DFSDM_CHANNEL_SERIAL_INTERFACE_TYPE(hdfsdm_channel->Init.SerialInterface.Type));
EricLew	0:80ee8f3b695e	301	assert_param(IS_DFSDM_CHANNEL_SPI_CLOCK(hdfsdm_channel->Init.SerialInterface.SpiClock));
EricLew	0:80ee8f3b695e	302	assert_param(IS_DFSDM_CHANNEL_FILTER_ORDER(hdfsdm_channel->Init.Awd.FilterOrder));
EricLew	0:80ee8f3b695e	303	assert_param(IS_DFSDM_CHANNEL_FILTER_OVS_RATIO(hdfsdm_channel->Init.Awd.Oversampling));
EricLew	0:80ee8f3b695e	304	assert_param(IS_DFSDM_CHANNEL_OFFSET(hdfsdm_channel->Init.Offset));
EricLew	0:80ee8f3b695e	305	assert_param(IS_DFSDM_CHANNEL_RIGHT_BIT_SHIFT(hdfsdm_channel->Init.RightBitShift));
EricLew	0:80ee8f3b695e	306
EricLew	0:80ee8f3b695e	307	/* Check DFSDM Channel handle */
EricLew	0:80ee8f3b695e	308	if(hdfsdm_channel == NULL)
EricLew	0:80ee8f3b695e	309	{
EricLew	0:80ee8f3b695e	310	return HAL_ERROR;
EricLew	0:80ee8f3b695e	311	}
EricLew	0:80ee8f3b695e	312	/* Check that channel has not been already initialized */
EricLew	0:80ee8f3b695e	313	if(a_dfsdmChannelHandle[DFSDM_GetChannelFromInstance(hdfsdm_channel->Instance)] != NULL)
EricLew	0:80ee8f3b695e	314	{
EricLew	0:80ee8f3b695e	315	return HAL_ERROR;
EricLew	0:80ee8f3b695e	316	}
EricLew	0:80ee8f3b695e	317
EricLew	0:80ee8f3b695e	318	/* Call MSP init function */
EricLew	0:80ee8f3b695e	319	HAL_DFSDM_ChannelMspInit(hdfsdm_channel);
EricLew	0:80ee8f3b695e	320
EricLew	0:80ee8f3b695e	321	/* Update the channel counter */
EricLew	0:80ee8f3b695e	322	v_dfsdmChannelCounter++;
EricLew	0:80ee8f3b695e	323
EricLew	0:80ee8f3b695e	324	/* Configure output serial clock and enable global DFSDM interface only for first channel */
EricLew	0:80ee8f3b695e	325	if(v_dfsdmChannelCounter == 1)
EricLew	0:80ee8f3b695e	326	{
EricLew	0:80ee8f3b695e	327	assert_param(IS_DFSDM_CHANNEL_OUTPUT_CLOCK(hdfsdm_channel->Init.OutputClock.Selection));
EricLew	0:80ee8f3b695e	328	/* Set the output serial clock source */
EricLew	0:80ee8f3b695e	329	DFSDM_Channel0->CHCFGR1 &= ~(DFSDM_CHCFGR1_CKOUTSRC);
EricLew	0:80ee8f3b695e	330	DFSDM_Channel0->CHCFGR1 \|= hdfsdm_channel->Init.OutputClock.Selection;
EricLew	0:80ee8f3b695e	331
EricLew	0:80ee8f3b695e	332	/* Reset clock divider */
EricLew	0:80ee8f3b695e	333	DFSDM_Channel0->CHCFGR1 &= ~(DFSDM_CHCFGR1_CKOUTDIV);
EricLew	0:80ee8f3b695e	334	if(hdfsdm_channel->Init.OutputClock.Activation == ENABLE)
EricLew	0:80ee8f3b695e	335	{
EricLew	0:80ee8f3b695e	336	assert_param(IS_DFSDM_CHANNEL_OUTPUT_CLOCK_DIVIDER(hdfsdm_channel->Init.OutputClock.Divider));
EricLew	0:80ee8f3b695e	337	/* Set the output clock divider */
EricLew	0:80ee8f3b695e	338	DFSDM_Channel0->CHCFGR1 \|= (uint32_t) ((hdfsdm_channel->Init.OutputClock.Divider - 1) <<
EricLew	0:80ee8f3b695e	339	DFSDM_CHCFGR1_CLK_DIV_OFFSET);
EricLew	0:80ee8f3b695e	340	}
EricLew	0:80ee8f3b695e	341
EricLew	0:80ee8f3b695e	342	/* enable the DFSDM global interface */
EricLew	0:80ee8f3b695e	343	DFSDM_Channel0->CHCFGR1 \|= DFSDM_CHCFGR1_DFSDMEN;
EricLew	0:80ee8f3b695e	344	}
EricLew	0:80ee8f3b695e	345
EricLew	0:80ee8f3b695e	346	/* Set channel input parameters */
EricLew	0:80ee8f3b695e	347	hdfsdm_channel->Instance->CHCFGR1 &= ~(DFSDM_CHCFGR1_DATPACK \| DFSDM_CHCFGR1_DATMPX \|
EricLew	0:80ee8f3b695e	348	DFSDM_CHCFGR1_CHINSEL);
EricLew	0:80ee8f3b695e	349	hdfsdm_channel->Instance->CHCFGR1 \|= (hdfsdm_channel->Init.Input.Multiplexer \|
EricLew	0:80ee8f3b695e	350	hdfsdm_channel->Init.Input.DataPacking \|
EricLew	0:80ee8f3b695e	351	hdfsdm_channel->Init.Input.Pins);
EricLew	0:80ee8f3b695e	352
EricLew	0:80ee8f3b695e	353	/* Set serial interface parameters */
EricLew	0:80ee8f3b695e	354	hdfsdm_channel->Instance->CHCFGR1 &= ~(DFSDM_CHCFGR1_SITP \| DFSDM_CHCFGR1_SPICKSEL);
EricLew	0:80ee8f3b695e	355	hdfsdm_channel->Instance->CHCFGR1 \|= (hdfsdm_channel->Init.SerialInterface.Type \|
EricLew	0:80ee8f3b695e	356	hdfsdm_channel->Init.SerialInterface.SpiClock);
EricLew	0:80ee8f3b695e	357
EricLew	0:80ee8f3b695e	358	/* Set analog watchdog parameters */
EricLew	0:80ee8f3b695e	359	hdfsdm_channel->Instance->AWSCDR &= ~(DFSDM_AWSCDR_AWFORD \| DFSDM_AWSCDR_AWFOSR);
EricLew	0:80ee8f3b695e	360	hdfsdm_channel->Instance->AWSCDR \|= (hdfsdm_channel->Init.Awd.FilterOrder \|
EricLew	0:80ee8f3b695e	361	((hdfsdm_channel->Init.Awd.Oversampling - 1) << DFSDM_AWSCDR_FOSR_OFFSET));
EricLew	0:80ee8f3b695e	362
EricLew	0:80ee8f3b695e	363	/* Set channel offset and right bit shift */
EricLew	0:80ee8f3b695e	364	hdfsdm_channel->Instance->CHCFGR2 &= ~(DFSDM_CHCFGR2_OFFSET \| DFSDM_CHCFGR2_DTRBS);
EricLew	0:80ee8f3b695e	365	hdfsdm_channel->Instance->CHCFGR2 \|= ((hdfsdm_channel->Init.Offset << DFSDM_CHCFGR2_OFFSET_OFFSET) \|
EricLew	0:80ee8f3b695e	366	(hdfsdm_channel->Init.RightBitShift << DFSDM_CHCFGR2_DTRBS_OFFSET));
EricLew	0:80ee8f3b695e	367
EricLew	0:80ee8f3b695e	368	/* Enable DFSDM channel */
EricLew	0:80ee8f3b695e	369	hdfsdm_channel->Instance->CHCFGR1 \|= DFSDM_CHCFGR1_CHEN;
EricLew	0:80ee8f3b695e	370
EricLew	0:80ee8f3b695e	371	/* Set DFSDM Channel to ready state */
EricLew	0:80ee8f3b695e	372	hdfsdm_channel->State = HAL_DFSDM_CHANNEL_STATE_READY;
EricLew	0:80ee8f3b695e	373
EricLew	0:80ee8f3b695e	374	/* Store channel handle in DFSDM channel handle table */
EricLew	0:80ee8f3b695e	375	a_dfsdmChannelHandle[DFSDM_GetChannelFromInstance(hdfsdm_channel->Instance)] = hdfsdm_channel;
EricLew	0:80ee8f3b695e	376
EricLew	0:80ee8f3b695e	377	return HAL_OK;
EricLew	0:80ee8f3b695e	378	}
EricLew	0:80ee8f3b695e	379
EricLew	0:80ee8f3b695e	380	/**
EricLew	0:80ee8f3b695e	381	* @brief De-initialize the DFSDM channel.
EricLew	0:80ee8f3b695e	382	* @param hdfsdm_channel : DFSDM channel handle.
EricLew	0:80ee8f3b695e	383	* @retval HAL status.
EricLew	0:80ee8f3b695e	384	*/
EricLew	0:80ee8f3b695e	385	HAL_StatusTypeDef HAL_DFSDM_ChannelDeInit(DFSDM_Channel_HandleTypeDef *hdfsdm_channel)
EricLew	0:80ee8f3b695e	386	{
EricLew	0:80ee8f3b695e	387	/* Check parameters */
EricLew	0:80ee8f3b695e	388	assert_param(IS_DFSDM_CHANNEL_ALL_INSTANCE(hdfsdm_channel->Instance));
EricLew	0:80ee8f3b695e	389
EricLew	0:80ee8f3b695e	390	/* Check DFSDM Channel handle */
EricLew	0:80ee8f3b695e	391	if(hdfsdm_channel == NULL)
EricLew	0:80ee8f3b695e	392	{
EricLew	0:80ee8f3b695e	393	return HAL_ERROR;
EricLew	0:80ee8f3b695e	394	}
EricLew	0:80ee8f3b695e	395	/* Check that channel has not been already deinitialized */
EricLew	0:80ee8f3b695e	396	if(a_dfsdmChannelHandle[DFSDM_GetChannelFromInstance(hdfsdm_channel->Instance)] == NULL)
EricLew	0:80ee8f3b695e	397	{
EricLew	0:80ee8f3b695e	398	return HAL_ERROR;
EricLew	0:80ee8f3b695e	399	}
EricLew	0:80ee8f3b695e	400
EricLew	0:80ee8f3b695e	401	/* Disable the DFSDM channel */
EricLew	0:80ee8f3b695e	402	hdfsdm_channel->Instance->CHCFGR1 &= ~(DFSDM_CHCFGR1_CHEN);
EricLew	0:80ee8f3b695e	403
EricLew	0:80ee8f3b695e	404	/* Update the channel counter */
EricLew	0:80ee8f3b695e	405	v_dfsdmChannelCounter--;
EricLew	0:80ee8f3b695e	406
EricLew	0:80ee8f3b695e	407	/* Disable global DFSDM at deinit of last channel */
EricLew	0:80ee8f3b695e	408	if(v_dfsdmChannelCounter == 0)
EricLew	0:80ee8f3b695e	409	{
EricLew	0:80ee8f3b695e	410	DFSDM_Channel0->CHCFGR1 &= ~(DFSDM_CHCFGR1_DFSDMEN);
EricLew	0:80ee8f3b695e	411	}
EricLew	0:80ee8f3b695e	412
EricLew	0:80ee8f3b695e	413	/* Call MSP deinit function */
EricLew	0:80ee8f3b695e	414	HAL_DFSDM_ChannelMspDeInit(hdfsdm_channel);
EricLew	0:80ee8f3b695e	415
EricLew	0:80ee8f3b695e	416	/* Set DFSDM Channel in reset state */
EricLew	0:80ee8f3b695e	417	hdfsdm_channel->State = HAL_DFSDM_CHANNEL_STATE_RESET;
EricLew	0:80ee8f3b695e	418
EricLew	0:80ee8f3b695e	419	/* Reset channel handle in DFSDM channel handle table */
EricLew	0:80ee8f3b695e	420	a_dfsdmChannelHandle[DFSDM_GetChannelFromInstance(hdfsdm_channel->Instance)] = (DFSDM_Channel_HandleTypeDef *) NULL;
EricLew	0:80ee8f3b695e	421
EricLew	0:80ee8f3b695e	422	return HAL_OK;
EricLew	0:80ee8f3b695e	423	}
EricLew	0:80ee8f3b695e	424
EricLew	0:80ee8f3b695e	425	/**
EricLew	0:80ee8f3b695e	426	* @brief Initialize the DFSDM channel MSP.
EricLew	0:80ee8f3b695e	427	* @param hdfsdm_channel : DFSDM channel handle.
EricLew	0:80ee8f3b695e	428	* @retval None
EricLew	0:80ee8f3b695e	429	*/
EricLew	0:80ee8f3b695e	430	__weak void HAL_DFSDM_ChannelMspInit(DFSDM_Channel_HandleTypeDef *hdfsdm_channel)
EricLew	0:80ee8f3b695e	431	{
EricLew	0:80ee8f3b695e	432	/* NOTE : This function should not be modified, when the function is needed,
EricLew	0:80ee8f3b695e	433	the HAL_DFSDM_ChannelMspInit could be implemented in the user file.
EricLew	0:80ee8f3b695e	434	*/
EricLew	0:80ee8f3b695e	435	}
EricLew	0:80ee8f3b695e	436
EricLew	0:80ee8f3b695e	437	/**
EricLew	0:80ee8f3b695e	438	* @brief De-initialize the DFSDM channel MSP.
EricLew	0:80ee8f3b695e	439	* @param hdfsdm_channel : DFSDM channel handle.
EricLew	0:80ee8f3b695e	440	* @retval None
EricLew	0:80ee8f3b695e	441	*/
EricLew	0:80ee8f3b695e	442	__weak void HAL_DFSDM_ChannelMspDeInit(DFSDM_Channel_HandleTypeDef *hdfsdm_channel)
EricLew	0:80ee8f3b695e	443	{
EricLew	0:80ee8f3b695e	444	/* NOTE : This function should not be modified, when the function is needed,
EricLew	0:80ee8f3b695e	445	the HAL_DFSDM_ChannelMspDeInit could be implemented in the user file.
EricLew	0:80ee8f3b695e	446	*/
EricLew	0:80ee8f3b695e	447	}
EricLew	0:80ee8f3b695e	448
EricLew	0:80ee8f3b695e	449	/**
EricLew	0:80ee8f3b695e	450	* @}
EricLew	0:80ee8f3b695e	451	*/
EricLew	0:80ee8f3b695e	452
EricLew	0:80ee8f3b695e	453	/** @defgroup DFSDM_Exported_Functions_Group2_Channel Channel operation functions
EricLew	0:80ee8f3b695e	454	* @brief Channel operation functions
EricLew	0:80ee8f3b695e	455	*
EricLew	0:80ee8f3b695e	456	@verbatim
EricLew	0:80ee8f3b695e	457	==============================================================================
EricLew	0:80ee8f3b695e	458	##### Channel operation functions #####
EricLew	0:80ee8f3b695e	459	==============================================================================
EricLew	0:80ee8f3b695e	460	[..] This section provides functions allowing to:
EricLew	0:80ee8f3b695e	461	(+) Manage clock absence detector feature.
EricLew	0:80ee8f3b695e	462	(+) Manage short circuit detector feature.
EricLew	0:80ee8f3b695e	463	(+) Get analog watchdog value.
EricLew	0:80ee8f3b695e	464	(+) Modify offset value.
EricLew	0:80ee8f3b695e	465	@endverbatim
EricLew	0:80ee8f3b695e	466	* @{
EricLew	0:80ee8f3b695e	467	*/
EricLew	0:80ee8f3b695e	468
EricLew	0:80ee8f3b695e	469	/**
EricLew	0:80ee8f3b695e	470	* @brief This function allows to start clock absence detection in polling mode.
EricLew	0:80ee8f3b695e	471	* @note Same mode has to be used for all channels.
EricLew	0:80ee8f3b695e	472	* @note If clock is not available on this channel during 5 seconds,
EricLew	0:80ee8f3b695e	473	* clock absence detection will not be activated and function
EricLew	0:80ee8f3b695e	474	* will return HAL_TIMEOUT error.
EricLew	0:80ee8f3b695e	475	* @param hdfsdm_channel : DFSDM channel handle.
EricLew	0:80ee8f3b695e	476	* @retval HAL status
EricLew	0:80ee8f3b695e	477	*/
EricLew	0:80ee8f3b695e	478	HAL_StatusTypeDef HAL_DFSDM_ChannelCkabStart(DFSDM_Channel_HandleTypeDef *hdfsdm_channel)
EricLew	0:80ee8f3b695e	479	{
EricLew	0:80ee8f3b695e	480	HAL_StatusTypeDef status = HAL_OK;
EricLew	0:80ee8f3b695e	481	uint32_t channel;
EricLew	0:80ee8f3b695e	482	uint32_t tickstart;
EricLew	0:80ee8f3b695e	483
EricLew	0:80ee8f3b695e	484	/* Check parameters */
EricLew	0:80ee8f3b695e	485	assert_param(IS_DFSDM_CHANNEL_ALL_INSTANCE(hdfsdm_channel->Instance));
EricLew	0:80ee8f3b695e	486
EricLew	0:80ee8f3b695e	487	/* Check DFSDM channel state */
EricLew	0:80ee8f3b695e	488	if(hdfsdm_channel->State != HAL_DFSDM_CHANNEL_STATE_READY)
EricLew	0:80ee8f3b695e	489	{
EricLew	0:80ee8f3b695e	490	/* Return error status */
EricLew	0:80ee8f3b695e	491	status = HAL_ERROR;
EricLew	0:80ee8f3b695e	492	}
EricLew	0:80ee8f3b695e	493	else
EricLew	0:80ee8f3b695e	494	{
EricLew	0:80ee8f3b695e	495	/* Get channel number from channel instance */
EricLew	0:80ee8f3b695e	496	channel = DFSDM_GetChannelFromInstance(hdfsdm_channel->Instance);
EricLew	0:80ee8f3b695e	497
EricLew	0:80ee8f3b695e	498	/* Get timeout */
EricLew	0:80ee8f3b695e	499	tickstart = HAL_GetTick();
EricLew	0:80ee8f3b695e	500
EricLew	0:80ee8f3b695e	501	/* Clear clock absence flag */
EricLew	0:80ee8f3b695e	502	while((((DFSDM_Filter0->ISR & DFSDM_ISR_CKABF) >> (DFSDM_ISR_CKABF_OFFSET + channel)) & 1) != 0)
EricLew	0:80ee8f3b695e	503	{
EricLew	0:80ee8f3b695e	504	DFSDM_Filter0->ICR = (1 << (DFSDM_ICR_CLRCKABF_OFFSET + channel));
EricLew	0:80ee8f3b695e	505
EricLew	0:80ee8f3b695e	506	/* Check the Timeout */
EricLew	0:80ee8f3b695e	507	if((HAL_GetTick()-tickstart) > DFSDM_CKAB_TIMEOUT)
EricLew	0:80ee8f3b695e	508	{
EricLew	0:80ee8f3b695e	509	/* Set timeout status */
EricLew	0:80ee8f3b695e	510	status = HAL_TIMEOUT;
EricLew	0:80ee8f3b695e	511	break;
EricLew	0:80ee8f3b695e	512	}
EricLew	0:80ee8f3b695e	513	}
EricLew	0:80ee8f3b695e	514
EricLew	0:80ee8f3b695e	515	if(status == HAL_OK)
EricLew	0:80ee8f3b695e	516	{
EricLew	0:80ee8f3b695e	517	/* Start clock absence detection */
EricLew	0:80ee8f3b695e	518	hdfsdm_channel->Instance->CHCFGR1 \|= DFSDM_CHCFGR1_CKABEN;
EricLew	0:80ee8f3b695e	519	}
EricLew	0:80ee8f3b695e	520	}
EricLew	0:80ee8f3b695e	521	/* Return function status */
EricLew	0:80ee8f3b695e	522	return status;
EricLew	0:80ee8f3b695e	523	}
EricLew	0:80ee8f3b695e	524
EricLew	0:80ee8f3b695e	525	/**
EricLew	0:80ee8f3b695e	526	* @brief This function allows to poll for the clock absence detection.
EricLew	0:80ee8f3b695e	527	* @param hdfsdm_channel : DFSDM channel handle.
EricLew	0:80ee8f3b695e	528	* @param Timeout : Timeout value in milliseconds.
EricLew	0:80ee8f3b695e	529	* @retval HAL status
EricLew	0:80ee8f3b695e	530	*/
EricLew	0:80ee8f3b695e	531	HAL_StatusTypeDef HAL_DFSDM_ChannelPollForCkab(DFSDM_Channel_HandleTypeDef *hdfsdm_channel,
EricLew	0:80ee8f3b695e	532	uint32_t Timeout)
EricLew	0:80ee8f3b695e	533	{
EricLew	0:80ee8f3b695e	534	uint32_t tickstart;
EricLew	0:80ee8f3b695e	535	uint32_t channel;
EricLew	0:80ee8f3b695e	536
EricLew	0:80ee8f3b695e	537	/* Check parameters */
EricLew	0:80ee8f3b695e	538	assert_param(IS_DFSDM_CHANNEL_ALL_INSTANCE(hdfsdm_channel->Instance));
EricLew	0:80ee8f3b695e	539
EricLew	0:80ee8f3b695e	540	/* Check DFSDM channel state */
EricLew	0:80ee8f3b695e	541	if(hdfsdm_channel->State != HAL_DFSDM_CHANNEL_STATE_READY)
EricLew	0:80ee8f3b695e	542	{
EricLew	0:80ee8f3b695e	543	/* Return error status */
EricLew	0:80ee8f3b695e	544	return HAL_ERROR;
EricLew	0:80ee8f3b695e	545	}
EricLew	0:80ee8f3b695e	546	else
EricLew	0:80ee8f3b695e	547	{
EricLew	0:80ee8f3b695e	548	/* Get channel number from channel instance */
EricLew	0:80ee8f3b695e	549	channel = DFSDM_GetChannelFromInstance(hdfsdm_channel->Instance);
EricLew	0:80ee8f3b695e	550
EricLew	0:80ee8f3b695e	551	/* Get timeout */
EricLew	0:80ee8f3b695e	552	tickstart = HAL_GetTick();
EricLew	0:80ee8f3b695e	553
EricLew	0:80ee8f3b695e	554	/* Wait clock absence detection */
EricLew	0:80ee8f3b695e	555	while((((DFSDM_Filter0->ISR & DFSDM_ISR_CKABF) >> (DFSDM_ISR_CKABF_OFFSET + channel)) & 1) == 0)
EricLew	0:80ee8f3b695e	556	{
EricLew	0:80ee8f3b695e	557	/* Check the Timeout */
EricLew	0:80ee8f3b695e	558	if(Timeout != HAL_MAX_DELAY)
EricLew	0:80ee8f3b695e	559	{
EricLew	0:80ee8f3b695e	560	if((Timeout == 0) \|\| ((HAL_GetTick()-tickstart) > Timeout))
EricLew	0:80ee8f3b695e	561	{
EricLew	0:80ee8f3b695e	562	/* Return timeout status */
EricLew	0:80ee8f3b695e	563	return HAL_TIMEOUT;
EricLew	0:80ee8f3b695e	564	}
EricLew	0:80ee8f3b695e	565	}
EricLew	0:80ee8f3b695e	566	}
EricLew	0:80ee8f3b695e	567
EricLew	0:80ee8f3b695e	568	/* Clear clock absence detection flag */
EricLew	0:80ee8f3b695e	569	DFSDM_Filter0->ICR = (1 << (DFSDM_ICR_CLRCKABF_OFFSET + channel));
EricLew	0:80ee8f3b695e	570
EricLew	0:80ee8f3b695e	571	/* Return function status */
EricLew	0:80ee8f3b695e	572	return HAL_OK;
EricLew	0:80ee8f3b695e	573	}
EricLew	0:80ee8f3b695e	574	}
EricLew	0:80ee8f3b695e	575
EricLew	0:80ee8f3b695e	576	/**
EricLew	0:80ee8f3b695e	577	* @brief This function allows to stop clock absence detection in polling mode.
EricLew	0:80ee8f3b695e	578	* @param hdfsdm_channel : DFSDM channel handle.
EricLew	0:80ee8f3b695e	579	* @retval HAL status
EricLew	0:80ee8f3b695e	580	*/
EricLew	0:80ee8f3b695e	581	HAL_StatusTypeDef HAL_DFSDM_ChannelCkabStop(DFSDM_Channel_HandleTypeDef *hdfsdm_channel)
EricLew	0:80ee8f3b695e	582	{
EricLew	0:80ee8f3b695e	583	HAL_StatusTypeDef status = HAL_OK;
EricLew	0:80ee8f3b695e	584	uint32_t channel;
EricLew	0:80ee8f3b695e	585
EricLew	0:80ee8f3b695e	586	/* Check parameters */
EricLew	0:80ee8f3b695e	587	assert_param(IS_DFSDM_CHANNEL_ALL_INSTANCE(hdfsdm_channel->Instance));
EricLew	0:80ee8f3b695e	588
EricLew	0:80ee8f3b695e	589	/* Check DFSDM channel state */
EricLew	0:80ee8f3b695e	590	if(hdfsdm_channel->State != HAL_DFSDM_CHANNEL_STATE_READY)
EricLew	0:80ee8f3b695e	591	{
EricLew	0:80ee8f3b695e	592	/* Return error status */
EricLew	0:80ee8f3b695e	593	status = HAL_ERROR;
EricLew	0:80ee8f3b695e	594	}
EricLew	0:80ee8f3b695e	595	else
EricLew	0:80ee8f3b695e	596	{
EricLew	0:80ee8f3b695e	597	/* Stop clock absence detection */
EricLew	0:80ee8f3b695e	598	hdfsdm_channel->Instance->CHCFGR1 &= ~(DFSDM_CHCFGR1_CKABEN);
EricLew	0:80ee8f3b695e	599
EricLew	0:80ee8f3b695e	600	/* Clear clock absence flag */
EricLew	0:80ee8f3b695e	601	channel = DFSDM_GetChannelFromInstance(hdfsdm_channel->Instance);
EricLew	0:80ee8f3b695e	602	DFSDM_Filter0->ICR = (1 << (DFSDM_ICR_CLRCKABF_OFFSET + channel));
EricLew	0:80ee8f3b695e	603	}
EricLew	0:80ee8f3b695e	604	/* Return function status */
EricLew	0:80ee8f3b695e	605	return status;
EricLew	0:80ee8f3b695e	606	}
EricLew	0:80ee8f3b695e	607
EricLew	0:80ee8f3b695e	608	/**
EricLew	0:80ee8f3b695e	609	* @brief This function allows to start clock absence detection in interrupt mode.
EricLew	0:80ee8f3b695e	610	* @note Same mode has to be used for all channels.
EricLew	0:80ee8f3b695e	611	* @note If clock is not available on this channel during 5 seconds,
EricLew	0:80ee8f3b695e	612	* clock absence detection will not be activated and function
EricLew	0:80ee8f3b695e	613	* will return HAL_TIMEOUT error.
EricLew	0:80ee8f3b695e	614	* @param hdfsdm_channel : DFSDM channel handle.
EricLew	0:80ee8f3b695e	615	* @retval HAL status
EricLew	0:80ee8f3b695e	616	*/
EricLew	0:80ee8f3b695e	617	HAL_StatusTypeDef HAL_DFSDM_ChannelCkabStart_IT(DFSDM_Channel_HandleTypeDef *hdfsdm_channel)
EricLew	0:80ee8f3b695e	618	{
EricLew	0:80ee8f3b695e	619	HAL_StatusTypeDef status = HAL_OK;
EricLew	0:80ee8f3b695e	620	uint32_t channel;
EricLew	0:80ee8f3b695e	621	uint32_t tickstart;
EricLew	0:80ee8f3b695e	622
EricLew	0:80ee8f3b695e	623	/* Check parameters */
EricLew	0:80ee8f3b695e	624	assert_param(IS_DFSDM_CHANNEL_ALL_INSTANCE(hdfsdm_channel->Instance));
EricLew	0:80ee8f3b695e	625
EricLew	0:80ee8f3b695e	626	/* Check DFSDM channel state */
EricLew	0:80ee8f3b695e	627	if(hdfsdm_channel->State != HAL_DFSDM_CHANNEL_STATE_READY)
EricLew	0:80ee8f3b695e	628	{
EricLew	0:80ee8f3b695e	629	/* Return error status */
EricLew	0:80ee8f3b695e	630	status = HAL_ERROR;
EricLew	0:80ee8f3b695e	631	}
EricLew	0:80ee8f3b695e	632	else
EricLew	0:80ee8f3b695e	633	{
EricLew	0:80ee8f3b695e	634	/* Get channel number from channel instance */
EricLew	0:80ee8f3b695e	635	channel = DFSDM_GetChannelFromInstance(hdfsdm_channel->Instance);
EricLew	0:80ee8f3b695e	636
EricLew	0:80ee8f3b695e	637	/* Get timeout */
EricLew	0:80ee8f3b695e	638	tickstart = HAL_GetTick();
EricLew	0:80ee8f3b695e	639
EricLew	0:80ee8f3b695e	640	/* Clear clock absence flag */
EricLew	0:80ee8f3b695e	641	while((((DFSDM_Filter0->ISR & DFSDM_ISR_CKABF) >> (DFSDM_ISR_CKABF_OFFSET + channel)) & 1) != 0)
EricLew	0:80ee8f3b695e	642	{
EricLew	0:80ee8f3b695e	643	DFSDM_Filter0->ICR = (1 << (DFSDM_ICR_CLRCKABF_OFFSET + channel));
EricLew	0:80ee8f3b695e	644
EricLew	0:80ee8f3b695e	645	/* Check the Timeout */
EricLew	0:80ee8f3b695e	646	if((HAL_GetTick()-tickstart) > DFSDM_CKAB_TIMEOUT)
EricLew	0:80ee8f3b695e	647	{
EricLew	0:80ee8f3b695e	648	/* Set timeout status */
EricLew	0:80ee8f3b695e	649	status = HAL_TIMEOUT;
EricLew	0:80ee8f3b695e	650	break;
EricLew	0:80ee8f3b695e	651	}
EricLew	0:80ee8f3b695e	652	}
EricLew	0:80ee8f3b695e	653
EricLew	0:80ee8f3b695e	654	if(status == HAL_OK)
EricLew	0:80ee8f3b695e	655	{
EricLew	0:80ee8f3b695e	656	/* Activate clock absence detection interrupt */
EricLew	0:80ee8f3b695e	657	DFSDM_Filter0->CR2 \|= DFSDM_CR2_CKABIE;
EricLew	0:80ee8f3b695e	658
EricLew	0:80ee8f3b695e	659	/* Start clock absence detection */
EricLew	0:80ee8f3b695e	660	hdfsdm_channel->Instance->CHCFGR1 \|= DFSDM_CHCFGR1_CKABEN;
EricLew	0:80ee8f3b695e	661	}
EricLew	0:80ee8f3b695e	662	}
EricLew	0:80ee8f3b695e	663	/* Return function status */
EricLew	0:80ee8f3b695e	664	return status;
EricLew	0:80ee8f3b695e	665	}
EricLew	0:80ee8f3b695e	666
EricLew	0:80ee8f3b695e	667	/**
EricLew	0:80ee8f3b695e	668	* @brief Clock absence detection callback.
EricLew	0:80ee8f3b695e	669	* @param hdfsdm_channel : DFSDM channel handle.
EricLew	0:80ee8f3b695e	670	* @retval None
EricLew	0:80ee8f3b695e	671	*/
EricLew	0:80ee8f3b695e	672	__weak void HAL_DFSDM_ChannelCkabCallback(DFSDM_Channel_HandleTypeDef *hdfsdm_channel)
EricLew	0:80ee8f3b695e	673	{
EricLew	0:80ee8f3b695e	674	/* NOTE : This function should not be modified, when the callback is needed,
EricLew	0:80ee8f3b695e	675	the HAL_DFSDM_ChannelCkabCallback could be implemented in the user file
EricLew	0:80ee8f3b695e	676	*/
EricLew	0:80ee8f3b695e	677	}
EricLew	0:80ee8f3b695e	678
EricLew	0:80ee8f3b695e	679	/**
EricLew	0:80ee8f3b695e	680	* @brief This function allows to stop clock absence detection in interrupt mode.
EricLew	0:80ee8f3b695e	681	* @note Interrupt will be disabled for all channels
EricLew	0:80ee8f3b695e	682	* @param hdfsdm_channel : DFSDM channel handle.
EricLew	0:80ee8f3b695e	683	* @retval HAL status
EricLew	0:80ee8f3b695e	684	*/
EricLew	0:80ee8f3b695e	685	HAL_StatusTypeDef HAL_DFSDM_ChannelCkabStop_IT(DFSDM_Channel_HandleTypeDef *hdfsdm_channel)
EricLew	0:80ee8f3b695e	686	{
EricLew	0:80ee8f3b695e	687	HAL_StatusTypeDef status = HAL_OK;
EricLew	0:80ee8f3b695e	688	uint32_t channel;
EricLew	0:80ee8f3b695e	689
EricLew	0:80ee8f3b695e	690	/* Check parameters */
EricLew	0:80ee8f3b695e	691	assert_param(IS_DFSDM_CHANNEL_ALL_INSTANCE(hdfsdm_channel->Instance));
EricLew	0:80ee8f3b695e	692
EricLew	0:80ee8f3b695e	693	/* Check DFSDM channel state */
EricLew	0:80ee8f3b695e	694	if(hdfsdm_channel->State != HAL_DFSDM_CHANNEL_STATE_READY)
EricLew	0:80ee8f3b695e	695	{
EricLew	0:80ee8f3b695e	696	/* Return error status */
EricLew	0:80ee8f3b695e	697	status = HAL_ERROR;
EricLew	0:80ee8f3b695e	698	}
EricLew	0:80ee8f3b695e	699	else
EricLew	0:80ee8f3b695e	700	{
EricLew	0:80ee8f3b695e	701	/* Stop clock absence detection */
EricLew	0:80ee8f3b695e	702	hdfsdm_channel->Instance->CHCFGR1 &= ~(DFSDM_CHCFGR1_CKABEN);
EricLew	0:80ee8f3b695e	703
EricLew	0:80ee8f3b695e	704	/* Clear clock absence flag */
EricLew	0:80ee8f3b695e	705	channel = DFSDM_GetChannelFromInstance(hdfsdm_channel->Instance);
EricLew	0:80ee8f3b695e	706	DFSDM_Filter0->ICR = (1 << (DFSDM_ICR_CLRCKABF_OFFSET + channel));
EricLew	0:80ee8f3b695e	707
EricLew	0:80ee8f3b695e	708	/* Disable clock absence detection interrupt */
EricLew	0:80ee8f3b695e	709	DFSDM_Filter0->CR2 &= ~(DFSDM_CR2_CKABIE);
EricLew	0:80ee8f3b695e	710	}
EricLew	0:80ee8f3b695e	711	/* Return function status */
EricLew	0:80ee8f3b695e	712	return status;
EricLew	0:80ee8f3b695e	713	}
EricLew	0:80ee8f3b695e	714
EricLew	0:80ee8f3b695e	715	/**
EricLew	0:80ee8f3b695e	716	* @brief This function allows to start short circuit detection in polling mode.
EricLew	0:80ee8f3b695e	717	* @note Same mode has to be used for all channels
EricLew	0:80ee8f3b695e	718	* @param hdfsdm_channel : DFSDM channel handle.
EricLew	0:80ee8f3b695e	719	* @param Threshold : Short circuit detector threshold.
EricLew	0:80ee8f3b695e	720	* This parameter must be a number between Min_Data = 0 and Max_Data = 255.
EricLew	0:80ee8f3b695e	721	* @param BreakSignal : Break signals assigned to short circuit event.
EricLew	0:80ee8f3b695e	722	* This parameter can be a values combination of @ref DFSDM_BreakSignals.
EricLew	0:80ee8f3b695e	723	* @retval HAL status
EricLew	0:80ee8f3b695e	724	*/
EricLew	0:80ee8f3b695e	725	HAL_StatusTypeDef HAL_DFSDM_ChannelScdStart(DFSDM_Channel_HandleTypeDef *hdfsdm_channel,
EricLew	0:80ee8f3b695e	726	uint32_t Threshold,
EricLew	0:80ee8f3b695e	727	uint32_t BreakSignal)
EricLew	0:80ee8f3b695e	728	{
EricLew	0:80ee8f3b695e	729	HAL_StatusTypeDef status = HAL_OK;
EricLew	0:80ee8f3b695e	730
EricLew	0:80ee8f3b695e	731	/* Check parameters */
EricLew	0:80ee8f3b695e	732	assert_param(IS_DFSDM_CHANNEL_ALL_INSTANCE(hdfsdm_channel->Instance));
EricLew	0:80ee8f3b695e	733	assert_param(IS_DFSDM_CHANNEL_SCD_THRESHOLD(Threshold));
EricLew	0:80ee8f3b695e	734	assert_param(IS_DFSDM_BREAK_SIGNALS(BreakSignal));
EricLew	0:80ee8f3b695e	735
EricLew	0:80ee8f3b695e	736	/* Check DFSDM channel state */
EricLew	0:80ee8f3b695e	737	if(hdfsdm_channel->State != HAL_DFSDM_CHANNEL_STATE_READY)
EricLew	0:80ee8f3b695e	738	{
EricLew	0:80ee8f3b695e	739	/* Return error status */
EricLew	0:80ee8f3b695e	740	status = HAL_ERROR;
EricLew	0:80ee8f3b695e	741	}
EricLew	0:80ee8f3b695e	742	else
EricLew	0:80ee8f3b695e	743	{
EricLew	0:80ee8f3b695e	744	/* Configure threshold and break signals */
EricLew	0:80ee8f3b695e	745	hdfsdm_channel->Instance->AWSCDR &= ~(DFSDM_AWSCDR_BKSCD \| DFSDM_AWSCDR_SCDT);
EricLew	0:80ee8f3b695e	746	hdfsdm_channel->Instance->AWSCDR \|= ((BreakSignal << DFSDM_AWSCDR_BKSCD_OFFSET) \| \
EricLew	0:80ee8f3b695e	747	Threshold);
EricLew	0:80ee8f3b695e	748
EricLew	0:80ee8f3b695e	749	/* Start short circuit detection */
EricLew	0:80ee8f3b695e	750	hdfsdm_channel->Instance->CHCFGR1 \|= DFSDM_CHCFGR1_SCDEN;
EricLew	0:80ee8f3b695e	751	}
EricLew	0:80ee8f3b695e	752	/* Return function status */
EricLew	0:80ee8f3b695e	753	return status;
EricLew	0:80ee8f3b695e	754	}
EricLew	0:80ee8f3b695e	755
EricLew	0:80ee8f3b695e	756	/**
EricLew	0:80ee8f3b695e	757	* @brief This function allows to poll for the short circuit detection.
EricLew	0:80ee8f3b695e	758	* @param hdfsdm_channel : DFSDM channel handle.
EricLew	0:80ee8f3b695e	759	* @param Timeout : Timeout value in milliseconds.
EricLew	0:80ee8f3b695e	760	* @retval HAL status
EricLew	0:80ee8f3b695e	761	*/
EricLew	0:80ee8f3b695e	762	HAL_StatusTypeDef HAL_DFSDM_ChannelPollForScd(DFSDM_Channel_HandleTypeDef *hdfsdm_channel,
EricLew	0:80ee8f3b695e	763	uint32_t Timeout)
EricLew	0:80ee8f3b695e	764	{
EricLew	0:80ee8f3b695e	765	uint32_t tickstart;
EricLew	0:80ee8f3b695e	766	uint32_t channel;
EricLew	0:80ee8f3b695e	767
EricLew	0:80ee8f3b695e	768	/* Check parameters */
EricLew	0:80ee8f3b695e	769	assert_param(IS_DFSDM_CHANNEL_ALL_INSTANCE(hdfsdm_channel->Instance));
EricLew	0:80ee8f3b695e	770
EricLew	0:80ee8f3b695e	771	/* Check DFSDM channel state */
EricLew	0:80ee8f3b695e	772	if(hdfsdm_channel->State != HAL_DFSDM_CHANNEL_STATE_READY)
EricLew	0:80ee8f3b695e	773	{
EricLew	0:80ee8f3b695e	774	/* Return error status */
EricLew	0:80ee8f3b695e	775	return HAL_ERROR;
EricLew	0:80ee8f3b695e	776	}
EricLew	0:80ee8f3b695e	777	else
EricLew	0:80ee8f3b695e	778	{
EricLew	0:80ee8f3b695e	779	/* Get channel number from channel instance */
EricLew	0:80ee8f3b695e	780	channel = DFSDM_GetChannelFromInstance(hdfsdm_channel->Instance);
EricLew	0:80ee8f3b695e	781
EricLew	0:80ee8f3b695e	782	/* Get timeout */
EricLew	0:80ee8f3b695e	783	tickstart = HAL_GetTick();
EricLew	0:80ee8f3b695e	784
EricLew	0:80ee8f3b695e	785	/* Wait short circuit detection */
EricLew	0:80ee8f3b695e	786	while(((DFSDM_Filter0->ISR & DFSDM_ISR_SCDF) >> (DFSDM_ISR_SCDF_OFFSET + channel)) == 0)
EricLew	0:80ee8f3b695e	787	{
EricLew	0:80ee8f3b695e	788	/* Check the Timeout */
EricLew	0:80ee8f3b695e	789	if(Timeout != HAL_MAX_DELAY)
EricLew	0:80ee8f3b695e	790	{
EricLew	0:80ee8f3b695e	791	if((Timeout == 0) \|\| ((HAL_GetTick()-tickstart) > Timeout))
EricLew	0:80ee8f3b695e	792	{
EricLew	0:80ee8f3b695e	793	/* Return timeout status */
EricLew	0:80ee8f3b695e	794	return HAL_TIMEOUT;
EricLew	0:80ee8f3b695e	795	}
EricLew	0:80ee8f3b695e	796	}
EricLew	0:80ee8f3b695e	797	}
EricLew	0:80ee8f3b695e	798
EricLew	0:80ee8f3b695e	799	/* Clear short circuit detection flag */
EricLew	0:80ee8f3b695e	800	DFSDM_Filter0->ICR = (1 << (DFSDM_ICR_CLRSCDF_OFFSET + channel));
EricLew	0:80ee8f3b695e	801
EricLew	0:80ee8f3b695e	802	/* Return function status */
EricLew	0:80ee8f3b695e	803	return HAL_OK;
EricLew	0:80ee8f3b695e	804	}
EricLew	0:80ee8f3b695e	805	}
EricLew	0:80ee8f3b695e	806
EricLew	0:80ee8f3b695e	807	/**
EricLew	0:80ee8f3b695e	808	* @brief This function allows to stop short circuit detection in polling mode.
EricLew	0:80ee8f3b695e	809	* @param hdfsdm_channel : DFSDM channel handle.
EricLew	0:80ee8f3b695e	810	* @retval HAL status
EricLew	0:80ee8f3b695e	811	*/
EricLew	0:80ee8f3b695e	812	HAL_StatusTypeDef HAL_DFSDM_ChannelScdStop(DFSDM_Channel_HandleTypeDef *hdfsdm_channel)
EricLew	0:80ee8f3b695e	813	{
EricLew	0:80ee8f3b695e	814	HAL_StatusTypeDef status = HAL_OK;
EricLew	0:80ee8f3b695e	815	uint32_t channel;
EricLew	0:80ee8f3b695e	816
EricLew	0:80ee8f3b695e	817	/* Check parameters */
EricLew	0:80ee8f3b695e	818	assert_param(IS_DFSDM_CHANNEL_ALL_INSTANCE(hdfsdm_channel->Instance));
EricLew	0:80ee8f3b695e	819
EricLew	0:80ee8f3b695e	820	/* Check DFSDM channel state */
EricLew	0:80ee8f3b695e	821	if(hdfsdm_channel->State != HAL_DFSDM_CHANNEL_STATE_READY)
EricLew	0:80ee8f3b695e	822	{
EricLew	0:80ee8f3b695e	823	/* Return error status */
EricLew	0:80ee8f3b695e	824	status = HAL_ERROR;
EricLew	0:80ee8f3b695e	825	}
EricLew	0:80ee8f3b695e	826	else
EricLew	0:80ee8f3b695e	827	{
EricLew	0:80ee8f3b695e	828	/* Stop short circuit detection */
EricLew	0:80ee8f3b695e	829	hdfsdm_channel->Instance->CHCFGR1 &= ~(DFSDM_CHCFGR1_SCDEN);
EricLew	0:80ee8f3b695e	830
EricLew	0:80ee8f3b695e	831	/* Clear short circuit detection flag */
EricLew	0:80ee8f3b695e	832	channel = DFSDM_GetChannelFromInstance(hdfsdm_channel->Instance);
EricLew	0:80ee8f3b695e	833	DFSDM_Filter0->ICR = (1 << (DFSDM_ICR_CLRSCDF_OFFSET + channel));
EricLew	0:80ee8f3b695e	834	}
EricLew	0:80ee8f3b695e	835	/* Return function status */
EricLew	0:80ee8f3b695e	836	return status;
EricLew	0:80ee8f3b695e	837	}
EricLew	0:80ee8f3b695e	838
EricLew	0:80ee8f3b695e	839	/**
EricLew	0:80ee8f3b695e	840	* @brief This function allows to start short circuit detection in interrupt mode.
EricLew	0:80ee8f3b695e	841	* @note Same mode has to be used for all channels
EricLew	0:80ee8f3b695e	842	* @param hdfsdm_channel : DFSDM channel handle.
EricLew	0:80ee8f3b695e	843	* @param Threshold : Short circuit detector threshold.
EricLew	0:80ee8f3b695e	844	* This parameter must be a number between Min_Data = 0 and Max_Data = 255.
EricLew	0:80ee8f3b695e	845	* @param BreakSignal : Break signals assigned to short circuit event.
EricLew	0:80ee8f3b695e	846	* This parameter can be a values combination of @ref DFSDM_BreakSignals.
EricLew	0:80ee8f3b695e	847	* @retval HAL status
EricLew	0:80ee8f3b695e	848	*/
EricLew	0:80ee8f3b695e	849	HAL_StatusTypeDef HAL_DFSDM_ChannelScdStart_IT(DFSDM_Channel_HandleTypeDef *hdfsdm_channel,
EricLew	0:80ee8f3b695e	850	uint32_t Threshold,
EricLew	0:80ee8f3b695e	851	uint32_t BreakSignal)
EricLew	0:80ee8f3b695e	852	{
EricLew	0:80ee8f3b695e	853	HAL_StatusTypeDef status = HAL_OK;
EricLew	0:80ee8f3b695e	854
EricLew	0:80ee8f3b695e	855	/* Check parameters */
EricLew	0:80ee8f3b695e	856	assert_param(IS_DFSDM_CHANNEL_ALL_INSTANCE(hdfsdm_channel->Instance));
EricLew	0:80ee8f3b695e	857	assert_param(IS_DFSDM_CHANNEL_SCD_THRESHOLD(Threshold));
EricLew	0:80ee8f3b695e	858	assert_param(IS_DFSDM_BREAK_SIGNALS(BreakSignal));
EricLew	0:80ee8f3b695e	859
EricLew	0:80ee8f3b695e	860	/* Check DFSDM channel state */
EricLew	0:80ee8f3b695e	861	if(hdfsdm_channel->State != HAL_DFSDM_CHANNEL_STATE_READY)
EricLew	0:80ee8f3b695e	862	{
EricLew	0:80ee8f3b695e	863	/* Return error status */
EricLew	0:80ee8f3b695e	864	status = HAL_ERROR;
EricLew	0:80ee8f3b695e	865	}
EricLew	0:80ee8f3b695e	866	else
EricLew	0:80ee8f3b695e	867	{
EricLew	0:80ee8f3b695e	868	/* Activate short circuit detection interrupt */
EricLew	0:80ee8f3b695e	869	DFSDM_Filter0->CR2 \|= DFSDM_CR2_SCDIE;
EricLew	0:80ee8f3b695e	870
EricLew	0:80ee8f3b695e	871	/* Configure threshold and break signals */
EricLew	0:80ee8f3b695e	872	hdfsdm_channel->Instance->AWSCDR &= ~(DFSDM_AWSCDR_BKSCD \| DFSDM_AWSCDR_SCDT);
EricLew	0:80ee8f3b695e	873	hdfsdm_channel->Instance->AWSCDR \|= ((BreakSignal << DFSDM_AWSCDR_BKSCD_OFFSET) \| \
EricLew	0:80ee8f3b695e	874	Threshold);
EricLew	0:80ee8f3b695e	875
EricLew	0:80ee8f3b695e	876	/* Start short circuit detection */
EricLew	0:80ee8f3b695e	877	hdfsdm_channel->Instance->CHCFGR1 \|= DFSDM_CHCFGR1_SCDEN;
EricLew	0:80ee8f3b695e	878	}
EricLew	0:80ee8f3b695e	879	/* Return function status */
EricLew	0:80ee8f3b695e	880	return status;
EricLew	0:80ee8f3b695e	881	}
EricLew	0:80ee8f3b695e	882
EricLew	0:80ee8f3b695e	883	/**
EricLew	0:80ee8f3b695e	884	* @brief Short circuit detection callback.
EricLew	0:80ee8f3b695e	885	* @param hdfsdm_channel : DFSDM channel handle.
EricLew	0:80ee8f3b695e	886	* @retval None
EricLew	0:80ee8f3b695e	887	*/
EricLew	0:80ee8f3b695e	888	__weak void HAL_DFSDM_ChannelScdCallback(DFSDM_Channel_HandleTypeDef *hdfsdm_channel)
EricLew	0:80ee8f3b695e	889	{
EricLew	0:80ee8f3b695e	890	/* NOTE : This function should not be modified, when the callback is needed,
EricLew	0:80ee8f3b695e	891	the HAL_DFSDM_ChannelScdCallback could be implemented in the user file
EricLew	0:80ee8f3b695e	892	*/
EricLew	0:80ee8f3b695e	893	}
EricLew	0:80ee8f3b695e	894
EricLew	0:80ee8f3b695e	895	/**
EricLew	0:80ee8f3b695e	896	* @brief This function allows to stop short circuit detection in interrupt mode.
EricLew	0:80ee8f3b695e	897	* @note Interrupt will be disabled for all channels
EricLew	0:80ee8f3b695e	898	* @param hdfsdm_channel : DFSDM channel handle.
EricLew	0:80ee8f3b695e	899	* @retval HAL status
EricLew	0:80ee8f3b695e	900	*/
EricLew	0:80ee8f3b695e	901	HAL_StatusTypeDef HAL_DFSDM_ChannelScdStop_IT(DFSDM_Channel_HandleTypeDef *hdfsdm_channel)
EricLew	0:80ee8f3b695e	902	{
EricLew	0:80ee8f3b695e	903	HAL_StatusTypeDef status = HAL_OK;
EricLew	0:80ee8f3b695e	904	uint32_t channel;
EricLew	0:80ee8f3b695e	905
EricLew	0:80ee8f3b695e	906	/* Check parameters */
EricLew	0:80ee8f3b695e	907	assert_param(IS_DFSDM_CHANNEL_ALL_INSTANCE(hdfsdm_channel->Instance));
EricLew	0:80ee8f3b695e	908
EricLew	0:80ee8f3b695e	909	/* Check DFSDM channel state */
EricLew	0:80ee8f3b695e	910	if(hdfsdm_channel->State != HAL_DFSDM_CHANNEL_STATE_READY)
EricLew	0:80ee8f3b695e	911	{
EricLew	0:80ee8f3b695e	912	/* Return error status */
EricLew	0:80ee8f3b695e	913	status = HAL_ERROR;
EricLew	0:80ee8f3b695e	914	}
EricLew	0:80ee8f3b695e	915	else
EricLew	0:80ee8f3b695e	916	{
EricLew	0:80ee8f3b695e	917	/* Stop short circuit detection */
EricLew	0:80ee8f3b695e	918	hdfsdm_channel->Instance->CHCFGR1 &= ~(DFSDM_CHCFGR1_SCDEN);
EricLew	0:80ee8f3b695e	919
EricLew	0:80ee8f3b695e	920	/* Clear short circuit detection flag */
EricLew	0:80ee8f3b695e	921	channel = DFSDM_GetChannelFromInstance(hdfsdm_channel->Instance);
EricLew	0:80ee8f3b695e	922	DFSDM_Filter0->ICR = (1 << (DFSDM_ICR_CLRSCDF_OFFSET + channel));
EricLew	0:80ee8f3b695e	923
EricLew	0:80ee8f3b695e	924	/* Disable short circuit detection interrupt */
EricLew	0:80ee8f3b695e	925	DFSDM_Filter0->CR2 &= ~(DFSDM_CR2_SCDIE);
EricLew	0:80ee8f3b695e	926	}
EricLew	0:80ee8f3b695e	927	/* Return function status */
EricLew	0:80ee8f3b695e	928	return status;
EricLew	0:80ee8f3b695e	929	}
EricLew	0:80ee8f3b695e	930
EricLew	0:80ee8f3b695e	931	/**
EricLew	0:80ee8f3b695e	932	* @brief This function allows to get channel analog watchdog value.
EricLew	0:80ee8f3b695e	933	* @param hdfsdm_channel : DFSDM channel handle.
EricLew	0:80ee8f3b695e	934	* @retval Channel analog watchdog value.
EricLew	0:80ee8f3b695e	935	*/
EricLew	0:80ee8f3b695e	936	int16_t HAL_DFSDM_ChannelGetAwdValue(DFSDM_Channel_HandleTypeDef *hdfsdm_channel)
EricLew	0:80ee8f3b695e	937	{
EricLew	0:80ee8f3b695e	938	return (int16_t) hdfsdm_channel->Instance->CHWDATAR;
EricLew	0:80ee8f3b695e	939	}
EricLew	0:80ee8f3b695e	940
EricLew	0:80ee8f3b695e	941	/**
EricLew	0:80ee8f3b695e	942	* @brief This function allows to modify channel offset value.
EricLew	0:80ee8f3b695e	943	* @param hdfsdm_channel : DFSDM channel handle.
EricLew	0:80ee8f3b695e	944	* @param Offset : DFSDM channel offset.
EricLew	0:80ee8f3b695e	945	* This parameter must be a number between Min_Data = -8388608 and Max_Data = 8388607.
EricLew	0:80ee8f3b695e	946	* @retval HAL status.
EricLew	0:80ee8f3b695e	947	*/
EricLew	0:80ee8f3b695e	948	HAL_StatusTypeDef HAL_DFSDM_ChannelModifyOffset(DFSDM_Channel_HandleTypeDef *hdfsdm_channel,
EricLew	0:80ee8f3b695e	949	int32_t Offset)
EricLew	0:80ee8f3b695e	950	{
EricLew	0:80ee8f3b695e	951	HAL_StatusTypeDef status = HAL_OK;
EricLew	0:80ee8f3b695e	952
EricLew	0:80ee8f3b695e	953	/* Check parameters */
EricLew	0:80ee8f3b695e	954	assert_param(IS_DFSDM_CHANNEL_ALL_INSTANCE(hdfsdm_channel->Instance));
EricLew	0:80ee8f3b695e	955	assert_param(IS_DFSDM_CHANNEL_OFFSET(Offset));
EricLew	0:80ee8f3b695e	956
EricLew	0:80ee8f3b695e	957	/* Check DFSDM channel state */
EricLew	0:80ee8f3b695e	958	if(hdfsdm_channel->State != HAL_DFSDM_CHANNEL_STATE_READY)
EricLew	0:80ee8f3b695e	959	{
EricLew	0:80ee8f3b695e	960	/* Return error status */
EricLew	0:80ee8f3b695e	961	status = HAL_ERROR;
EricLew	0:80ee8f3b695e	962	}
EricLew	0:80ee8f3b695e	963	else
EricLew	0:80ee8f3b695e	964	{
EricLew	0:80ee8f3b695e	965	/* Modify channel offset */
EricLew	0:80ee8f3b695e	966	hdfsdm_channel->Instance->CHCFGR2 &= ~(DFSDM_CHCFGR2_OFFSET);
EricLew	0:80ee8f3b695e	967	hdfsdm_channel->Instance->CHCFGR2 \|= (Offset << DFSDM_CHCFGR2_OFFSET_OFFSET);
EricLew	0:80ee8f3b695e	968	}
EricLew	0:80ee8f3b695e	969	/* Return function status */
EricLew	0:80ee8f3b695e	970	return status;
EricLew	0:80ee8f3b695e	971	}
EricLew	0:80ee8f3b695e	972
EricLew	0:80ee8f3b695e	973	/**
EricLew	0:80ee8f3b695e	974	* @}
EricLew	0:80ee8f3b695e	975	*/
EricLew	0:80ee8f3b695e	976
EricLew	0:80ee8f3b695e	977	/** @defgroup DFSDM_Exported_Functions_Group3_Channel Channel state function
EricLew	0:80ee8f3b695e	978	* @brief Channel state function
EricLew	0:80ee8f3b695e	979	*
EricLew	0:80ee8f3b695e	980	@verbatim
EricLew	0:80ee8f3b695e	981	==============================================================================
EricLew	0:80ee8f3b695e	982	##### Channel state function #####
EricLew	0:80ee8f3b695e	983	==============================================================================
EricLew	0:80ee8f3b695e	984	[..] This section provides function allowing to:
EricLew	0:80ee8f3b695e	985	(+) Get channel handle state.
EricLew	0:80ee8f3b695e	986	@endverbatim
EricLew	0:80ee8f3b695e	987	* @{
EricLew	0:80ee8f3b695e	988	*/
EricLew	0:80ee8f3b695e	989
EricLew	0:80ee8f3b695e	990	/**
EricLew	0:80ee8f3b695e	991	* @brief This function allows to get the current DFSDM channel handle state.
EricLew	0:80ee8f3b695e	992	* @param hdfsdm_channel : DFSDM channel handle.
EricLew	0:80ee8f3b695e	993	* @retval DFSDM channel state.
EricLew	0:80ee8f3b695e	994	*/
EricLew	0:80ee8f3b695e	995	HAL_DFSDM_Channel_StateTypeDef HAL_DFSDM_ChannelGetState(DFSDM_Channel_HandleTypeDef *hdfsdm_channel)
EricLew	0:80ee8f3b695e	996	{
EricLew	0:80ee8f3b695e	997	/* Return DFSDM channel handle state */
EricLew	0:80ee8f3b695e	998	return hdfsdm_channel->State;
EricLew	0:80ee8f3b695e	999	}
EricLew	0:80ee8f3b695e	1000
EricLew	0:80ee8f3b695e	1001	/**
EricLew	0:80ee8f3b695e	1002	* @}
EricLew	0:80ee8f3b695e	1003	*/
EricLew	0:80ee8f3b695e	1004
EricLew	0:80ee8f3b695e	1005	/** @defgroup DFSDM_Exported_Functions_Group1_Filter Filter initialization and de-initialization functions
EricLew	0:80ee8f3b695e	1006	* @brief Filter initialization and de-initialization functions
EricLew	0:80ee8f3b695e	1007	*
EricLew	0:80ee8f3b695e	1008	@verbatim
EricLew	0:80ee8f3b695e	1009	==============================================================================
EricLew	0:80ee8f3b695e	1010	##### Filter initialization and de-initialization functions #####
EricLew	0:80ee8f3b695e	1011	==============================================================================
EricLew	0:80ee8f3b695e	1012	[..] This section provides functions allowing to:
EricLew	0:80ee8f3b695e	1013	(+) Initialize the DFSDM filter.
EricLew	0:80ee8f3b695e	1014	(+) De-initialize the DFSDM filter.
EricLew	0:80ee8f3b695e	1015	@endverbatim
EricLew	0:80ee8f3b695e	1016	* @{
EricLew	0:80ee8f3b695e	1017	*/
EricLew	0:80ee8f3b695e	1018
EricLew	0:80ee8f3b695e	1019	/**
EricLew	0:80ee8f3b695e	1020	* @brief Initialize the DFSDM filter according to the specified parameters
EricLew	0:80ee8f3b695e	1021	* in the DFSDM_FilterInitTypeDef structure and initialize the associated handle.
EricLew	0:80ee8f3b695e	1022	* @param hdfsdm_filter : DFSDM filter handle.
EricLew	0:80ee8f3b695e	1023	* @retval HAL status.
EricLew	0:80ee8f3b695e	1024	*/
EricLew	0:80ee8f3b695e	1025	HAL_StatusTypeDef HAL_DFSDM_FilterInit(DFSDM_Filter_HandleTypeDef *hdfsdm_filter)
EricLew	0:80ee8f3b695e	1026	{
EricLew	0:80ee8f3b695e	1027	/* Check parameters */
EricLew	0:80ee8f3b695e	1028	assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance));
EricLew	0:80ee8f3b695e	1029	assert_param(IS_DFSDM_FILTER_REG_TRIGGER(hdfsdm_filter->Init.RegularParam.Trigger));
EricLew	0:80ee8f3b695e	1030	assert_param(IS_FUNCTIONAL_STATE(hdfsdm_filter->Init.RegularParam.FastMode));
EricLew	0:80ee8f3b695e	1031	assert_param(IS_FUNCTIONAL_STATE(hdfsdm_filter->Init.RegularParam.DmaMode));
EricLew	0:80ee8f3b695e	1032	assert_param(IS_DFSDM_FILTER_INJ_TRIGGER(hdfsdm_filter->Init.InjectedParam.Trigger));
EricLew	0:80ee8f3b695e	1033	assert_param(IS_FUNCTIONAL_STATE(hdfsdm_filter->Init.InjectedParam.ScanMode));
EricLew	0:80ee8f3b695e	1034	assert_param(IS_FUNCTIONAL_STATE(hdfsdm_filter->Init.InjectedParam.DmaMode));
EricLew	0:80ee8f3b695e	1035	assert_param(IS_DFSDM_FILTER_SINC_ORDER(hdfsdm_filter->Init.FilterParam.SincOrder));
EricLew	0:80ee8f3b695e	1036	assert_param(IS_DFSDM_FILTER_OVS_RATIO(hdfsdm_filter->Init.FilterParam.Oversampling));
EricLew	0:80ee8f3b695e	1037	assert_param(IS_DFSDM_FILTER_INTEGRATOR_OVS_RATIO(hdfsdm_filter->Init.FilterParam.IntOversampling));
EricLew	0:80ee8f3b695e	1038
EricLew	0:80ee8f3b695e	1039	/* Check DFSDM Channel handle */
EricLew	0:80ee8f3b695e	1040	if(hdfsdm_filter == NULL)
EricLew	0:80ee8f3b695e	1041	{
EricLew	0:80ee8f3b695e	1042	return HAL_ERROR;
EricLew	0:80ee8f3b695e	1043	}
EricLew	0:80ee8f3b695e	1044
EricLew	0:80ee8f3b695e	1045	/* Check parameters compatibility */
EricLew	0:80ee8f3b695e	1046	if((hdfsdm_filter->Instance == DFSDM_Filter0) &&
EricLew	0:80ee8f3b695e	1047	((hdfsdm_filter->Init.RegularParam.Trigger == DFSDM_FILTER_SYNC_TRIGGER) \|\|
EricLew	0:80ee8f3b695e	1048	(hdfsdm_filter->Init.InjectedParam.Trigger == DFSDM_FILTER_SYNC_TRIGGER)))
EricLew	0:80ee8f3b695e	1049	{
EricLew	0:80ee8f3b695e	1050	return HAL_ERROR;
EricLew	0:80ee8f3b695e	1051	}
EricLew	0:80ee8f3b695e	1052
EricLew	0:80ee8f3b695e	1053	/* Initialize DFSDM filter variables with default values */
EricLew	0:80ee8f3b695e	1054	hdfsdm_filter->RegularContMode = DFSDM_CONTINUOUS_CONV_OFF;
EricLew	0:80ee8f3b695e	1055	hdfsdm_filter->InjectedChannelsNbr = 1;
EricLew	0:80ee8f3b695e	1056	hdfsdm_filter->InjConvRemaining = 1;
EricLew	0:80ee8f3b695e	1057	hdfsdm_filter->ErrorCode = DFSDM_FILTER_ERROR_NONE;
EricLew	0:80ee8f3b695e	1058
EricLew	0:80ee8f3b695e	1059	/* Call MSP init function */
EricLew	0:80ee8f3b695e	1060	HAL_DFSDM_FilterMspInit(hdfsdm_filter);
EricLew	0:80ee8f3b695e	1061
EricLew	0:80ee8f3b695e	1062	/* Set regular parameters */
EricLew	0:80ee8f3b695e	1063	hdfsdm_filter->Instance->CR1 &= ~(DFSDM_CR1_RSYNC);
EricLew	0:80ee8f3b695e	1064	if(hdfsdm_filter->Init.RegularParam.FastMode == ENABLE)
EricLew	0:80ee8f3b695e	1065	{
EricLew	0:80ee8f3b695e	1066	hdfsdm_filter->Instance->CR1 \|= DFSDM_CR1_FAST;
EricLew	0:80ee8f3b695e	1067	}
EricLew	0:80ee8f3b695e	1068	else
EricLew	0:80ee8f3b695e	1069	{
EricLew	0:80ee8f3b695e	1070	hdfsdm_filter->Instance->CR1 &= ~(DFSDM_CR1_FAST);
EricLew	0:80ee8f3b695e	1071	}
EricLew	0:80ee8f3b695e	1072
EricLew	0:80ee8f3b695e	1073	if(hdfsdm_filter->Init.RegularParam.DmaMode == ENABLE)
EricLew	0:80ee8f3b695e	1074	{
EricLew	0:80ee8f3b695e	1075	hdfsdm_filter->Instance->CR1 \|= DFSDM_CR1_RDMAEN;
EricLew	0:80ee8f3b695e	1076	}
EricLew	0:80ee8f3b695e	1077	else
EricLew	0:80ee8f3b695e	1078	{
EricLew	0:80ee8f3b695e	1079	hdfsdm_filter->Instance->CR1 &= ~(DFSDM_CR1_RDMAEN);
EricLew	0:80ee8f3b695e	1080	}
EricLew	0:80ee8f3b695e	1081
EricLew	0:80ee8f3b695e	1082	/* Set injected parameters */
EricLew	0:80ee8f3b695e	1083	hdfsdm_filter->Instance->CR1 &= ~(DFSDM_CR1_JSYNC \| DFSDM_CR1_JEXTEN \| DFSDM_CR1_JEXTSEL);
EricLew	0:80ee8f3b695e	1084	if(hdfsdm_filter->Init.InjectedParam.Trigger == DFSDM_FILTER_EXT_TRIGGER)
EricLew	0:80ee8f3b695e	1085	{
EricLew	0:80ee8f3b695e	1086	assert_param(IS_DFSDM_FILTER_EXT_TRIG(hdfsdm_filter->Init.InjectedParam.ExtTrigger));
EricLew	0:80ee8f3b695e	1087	assert_param(IS_DFSDM_FILTER_EXT_TRIG_EDGE(hdfsdm_filter->Init.InjectedParam.ExtTriggerEdge));
EricLew	0:80ee8f3b695e	1088	hdfsdm_filter->Instance->CR1 \|= (hdfsdm_filter->Init.InjectedParam.ExtTrigger);
EricLew	0:80ee8f3b695e	1089	}
EricLew	0:80ee8f3b695e	1090
EricLew	0:80ee8f3b695e	1091	if(hdfsdm_filter->Init.InjectedParam.ScanMode == ENABLE)
EricLew	0:80ee8f3b695e	1092	{
EricLew	0:80ee8f3b695e	1093	hdfsdm_filter->Instance->CR1 \|= DFSDM_CR1_JSCAN;
EricLew	0:80ee8f3b695e	1094	}
EricLew	0:80ee8f3b695e	1095	else
EricLew	0:80ee8f3b695e	1096	{
EricLew	0:80ee8f3b695e	1097	hdfsdm_filter->Instance->CR1 &= ~(DFSDM_CR1_JSCAN);
EricLew	0:80ee8f3b695e	1098	}
EricLew	0:80ee8f3b695e	1099
EricLew	0:80ee8f3b695e	1100	if(hdfsdm_filter->Init.InjectedParam.DmaMode == ENABLE)
EricLew	0:80ee8f3b695e	1101	{
EricLew	0:80ee8f3b695e	1102	hdfsdm_filter->Instance->CR1 \|= DFSDM_CR1_JDMAEN;
EricLew	0:80ee8f3b695e	1103	}
EricLew	0:80ee8f3b695e	1104	else
EricLew	0:80ee8f3b695e	1105	{
EricLew	0:80ee8f3b695e	1106	hdfsdm_filter->Instance->CR1 &= ~(DFSDM_CR1_JDMAEN);
EricLew	0:80ee8f3b695e	1107	}
EricLew	0:80ee8f3b695e	1108
EricLew	0:80ee8f3b695e	1109	/* Set filter parameters */
EricLew	0:80ee8f3b695e	1110	hdfsdm_filter->Instance->FCR &= ~(DFSDM_FCR_FORD \| DFSDM_FCR_FOSR \| DFSDM_FCR_IOSR);
EricLew	0:80ee8f3b695e	1111	hdfsdm_filter->Instance->FCR \|= (hdfsdm_filter->Init.FilterParam.SincOrder \|
EricLew	0:80ee8f3b695e	1112	((hdfsdm_filter->Init.FilterParam.Oversampling - 1) << DFSDM_FCR_FOSR_OFFSET) \|
EricLew	0:80ee8f3b695e	1113	(hdfsdm_filter->Init.FilterParam.IntOversampling - 1));
EricLew	0:80ee8f3b695e	1114
EricLew	0:80ee8f3b695e	1115	/* Store regular and injected triggers and injected scan mode*/
EricLew	0:80ee8f3b695e	1116	hdfsdm_filter->RegularTrigger = hdfsdm_filter->Init.RegularParam.Trigger;
EricLew	0:80ee8f3b695e	1117	hdfsdm_filter->InjectedTrigger = hdfsdm_filter->Init.InjectedParam.Trigger;
EricLew	0:80ee8f3b695e	1118	hdfsdm_filter->ExtTriggerEdge = hdfsdm_filter->Init.InjectedParam.ExtTriggerEdge;
EricLew	0:80ee8f3b695e	1119	hdfsdm_filter->InjectedScanMode = hdfsdm_filter->Init.InjectedParam.ScanMode;
EricLew	0:80ee8f3b695e	1120
EricLew	0:80ee8f3b695e	1121	/* Enable DFSDM filter */
EricLew	0:80ee8f3b695e	1122	hdfsdm_filter->Instance->CR1 \|= DFSDM_CR1_DFEN;
EricLew	0:80ee8f3b695e	1123
EricLew	0:80ee8f3b695e	1124	/* Set DFSDM filter to ready state */
EricLew	0:80ee8f3b695e	1125	hdfsdm_filter->State = HAL_DFSDM_FILTER_STATE_READY;
EricLew	0:80ee8f3b695e	1126
EricLew	0:80ee8f3b695e	1127	return HAL_OK;
EricLew	0:80ee8f3b695e	1128	}
EricLew	0:80ee8f3b695e	1129
EricLew	0:80ee8f3b695e	1130	/**
EricLew	0:80ee8f3b695e	1131	* @brief De-initializes the DFSDM filter.
EricLew	0:80ee8f3b695e	1132	* @param hdfsdm_filter : DFSDM filter handle.
EricLew	0:80ee8f3b695e	1133	* @retval HAL status.
EricLew	0:80ee8f3b695e	1134	*/
EricLew	0:80ee8f3b695e	1135	HAL_StatusTypeDef HAL_DFSDM_FilterDeInit(DFSDM_Filter_HandleTypeDef *hdfsdm_filter)
EricLew	0:80ee8f3b695e	1136	{
EricLew	0:80ee8f3b695e	1137	/* Check parameters */
EricLew	0:80ee8f3b695e	1138	assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance));
EricLew	0:80ee8f3b695e	1139
EricLew	0:80ee8f3b695e	1140	/* Check DFSDM filter handle */
EricLew	0:80ee8f3b695e	1141	if(hdfsdm_filter == NULL)
EricLew	0:80ee8f3b695e	1142	{
EricLew	0:80ee8f3b695e	1143	return HAL_ERROR;
EricLew	0:80ee8f3b695e	1144	}
EricLew	0:80ee8f3b695e	1145
EricLew	0:80ee8f3b695e	1146	/* Disable the DFSDM filter */
EricLew	0:80ee8f3b695e	1147	hdfsdm_filter->Instance->CR1 &= ~(DFSDM_CR1_DFEN);
EricLew	0:80ee8f3b695e	1148
EricLew	0:80ee8f3b695e	1149	/* Call MSP deinit function */
EricLew	0:80ee8f3b695e	1150	HAL_DFSDM_FilterMspDeInit(hdfsdm_filter);
EricLew	0:80ee8f3b695e	1151
EricLew	0:80ee8f3b695e	1152	/* Set DFSDM filter in reset state */
EricLew	0:80ee8f3b695e	1153	hdfsdm_filter->State = HAL_DFSDM_FILTER_STATE_RESET;
EricLew	0:80ee8f3b695e	1154
EricLew	0:80ee8f3b695e	1155	return HAL_OK;
EricLew	0:80ee8f3b695e	1156	}
EricLew	0:80ee8f3b695e	1157
EricLew	0:80ee8f3b695e	1158	/**
EricLew	0:80ee8f3b695e	1159	* @brief Initializes the DFSDM filter MSP.
EricLew	0:80ee8f3b695e	1160	* @param hdfsdm_filter : DFSDM filter handle.
EricLew	0:80ee8f3b695e	1161	* @retval None
EricLew	0:80ee8f3b695e	1162	*/
EricLew	0:80ee8f3b695e	1163	__weak void HAL_DFSDM_FilterMspInit(DFSDM_Filter_HandleTypeDef *hdfsdm_filter)
EricLew	0:80ee8f3b695e	1164	{
EricLew	0:80ee8f3b695e	1165	/* NOTE : This function should not be modified, when the function is needed,
EricLew	0:80ee8f3b695e	1166	the HAL_DFSDM_FilterMspInit could be implemented in the user file.
EricLew	0:80ee8f3b695e	1167	*/
EricLew	0:80ee8f3b695e	1168	}
EricLew	0:80ee8f3b695e	1169
EricLew	0:80ee8f3b695e	1170	/**
EricLew	0:80ee8f3b695e	1171	* @brief De-initializes the DFSDM filter MSP.
EricLew	0:80ee8f3b695e	1172	* @param hdfsdm_filter : DFSDM filter handle.
EricLew	0:80ee8f3b695e	1173	* @retval None
EricLew	0:80ee8f3b695e	1174	*/
EricLew	0:80ee8f3b695e	1175	__weak void HAL_DFSDM_FilterMspDeInit(DFSDM_Filter_HandleTypeDef *hdfsdm_filter)
EricLew	0:80ee8f3b695e	1176	{
EricLew	0:80ee8f3b695e	1177	/* NOTE : This function should not be modified, when the function is needed,
EricLew	0:80ee8f3b695e	1178	the HAL_DFSDM_FilterMspDeInit could be implemented in the user file.
EricLew	0:80ee8f3b695e	1179	*/
EricLew	0:80ee8f3b695e	1180	}
EricLew	0:80ee8f3b695e	1181
EricLew	0:80ee8f3b695e	1182	/**
EricLew	0:80ee8f3b695e	1183	* @}
EricLew	0:80ee8f3b695e	1184	*/
EricLew	0:80ee8f3b695e	1185
EricLew	0:80ee8f3b695e	1186	/** @defgroup DFSDM_Exported_Functions_Group2_Filter Filter control functions
EricLew	0:80ee8f3b695e	1187	* @brief Filter control functions
EricLew	0:80ee8f3b695e	1188	*
EricLew	0:80ee8f3b695e	1189	@verbatim
EricLew	0:80ee8f3b695e	1190	==============================================================================
EricLew	0:80ee8f3b695e	1191	##### Filter control functions #####
EricLew	0:80ee8f3b695e	1192	==============================================================================
EricLew	0:80ee8f3b695e	1193	[..] This section provides functions allowing to:
EricLew	0:80ee8f3b695e	1194	(+) Select channel and enable/disable continuous mode for regular conversion.
EricLew	0:80ee8f3b695e	1195	(+) Select channels for injected conversion.
EricLew	0:80ee8f3b695e	1196	@endverbatim
EricLew	0:80ee8f3b695e	1197	* @{
EricLew	0:80ee8f3b695e	1198	*/
EricLew	0:80ee8f3b695e	1199
EricLew	0:80ee8f3b695e	1200	/**
EricLew	0:80ee8f3b695e	1201	* @brief This function allows to select channel and to enable/disable
EricLew	0:80ee8f3b695e	1202	* continuous mode for regular conversion.
EricLew	0:80ee8f3b695e	1203	* @param hdfsdm_filter : DFSDM filter handle.
EricLew	0:80ee8f3b695e	1204	* @param Channel : Channel for regular conversion.
EricLew	0:80ee8f3b695e	1205	* This parameter can be a value of @ref DFSDM_Channel_Selection.
EricLew	0:80ee8f3b695e	1206	* @param ContinuousMode : Enable/disable continuous mode for regular conversion.
EricLew	0:80ee8f3b695e	1207	* This parameter can be a value of @ref DFSDM_ContinuousMode.
EricLew	0:80ee8f3b695e	1208	* @retval HAL status
EricLew	0:80ee8f3b695e	1209	*/
EricLew	0:80ee8f3b695e	1210	HAL_StatusTypeDef HAL_DFSDM_FilterConfigRegChannel(DFSDM_Filter_HandleTypeDef *hdfsdm_filter,
EricLew	0:80ee8f3b695e	1211	uint32_t Channel,
EricLew	0:80ee8f3b695e	1212	uint32_t ContinuousMode)
EricLew	0:80ee8f3b695e	1213	{
EricLew	0:80ee8f3b695e	1214	HAL_StatusTypeDef status = HAL_OK;
EricLew	0:80ee8f3b695e	1215
EricLew	0:80ee8f3b695e	1216	/* Check parameters */
EricLew	0:80ee8f3b695e	1217	assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance));
EricLew	0:80ee8f3b695e	1218	assert_param(IS_DFSDM_REGULAR_CHANNEL(Channel));
EricLew	0:80ee8f3b695e	1219	assert_param(IS_DFSDM_CONTINUOUS_MODE(ContinuousMode));
EricLew	0:80ee8f3b695e	1220
EricLew	0:80ee8f3b695e	1221	/* Check DFSDM filter state */
EricLew	0:80ee8f3b695e	1222	if((hdfsdm_filter->State != HAL_DFSDM_FILTER_STATE_RESET) &&
EricLew	0:80ee8f3b695e	1223	(hdfsdm_filter->State != HAL_DFSDM_FILTER_STATE_ERROR))
EricLew	0:80ee8f3b695e	1224	{
EricLew	0:80ee8f3b695e	1225	/* Configure channel and continuous mode for regular conversion */
EricLew	0:80ee8f3b695e	1226	hdfsdm_filter->Instance->CR1 &= ~(DFSDM_CR1_RCH \| DFSDM_CR1_RCONT);
EricLew	0:80ee8f3b695e	1227	if(ContinuousMode == DFSDM_CONTINUOUS_CONV_ON)
EricLew	0:80ee8f3b695e	1228	{
EricLew	0:80ee8f3b695e	1229	hdfsdm_filter->Instance->CR1 \|= (uint32_t) (((Channel & DFSDM_MSB_MASK) << DFSDM_CR1_MSB_RCH_OFFSET) \|
EricLew	0:80ee8f3b695e	1230	DFSDM_CR1_RCONT);
EricLew	0:80ee8f3b695e	1231	}
EricLew	0:80ee8f3b695e	1232	else
EricLew	0:80ee8f3b695e	1233	{
EricLew	0:80ee8f3b695e	1234	hdfsdm_filter->Instance->CR1 \|= (uint32_t) ((Channel & DFSDM_MSB_MASK) << DFSDM_CR1_MSB_RCH_OFFSET);
EricLew	0:80ee8f3b695e	1235	}
EricLew	0:80ee8f3b695e	1236	/* Store continuous mode information */
EricLew	0:80ee8f3b695e	1237	hdfsdm_filter->RegularContMode = ContinuousMode;
EricLew	0:80ee8f3b695e	1238	}
EricLew	0:80ee8f3b695e	1239	else
EricLew	0:80ee8f3b695e	1240	{
EricLew	0:80ee8f3b695e	1241	status = HAL_ERROR;
EricLew	0:80ee8f3b695e	1242	}
EricLew	0:80ee8f3b695e	1243
EricLew	0:80ee8f3b695e	1244	/* Return function status */
EricLew	0:80ee8f3b695e	1245	return status;
EricLew	0:80ee8f3b695e	1246	}
EricLew	0:80ee8f3b695e	1247
EricLew	0:80ee8f3b695e	1248	/**
EricLew	0:80ee8f3b695e	1249	* @brief This function allows to select channels for injected conversion.
EricLew	0:80ee8f3b695e	1250	* @param hdfsdm_filter : DFSDM filter handle.
EricLew	0:80ee8f3b695e	1251	* @param Channel : Channels for injected conversion.
EricLew	0:80ee8f3b695e	1252	* This parameter can be a values combination of @ref DFSDM_Channel_Selection.
EricLew	0:80ee8f3b695e	1253	* @retval HAL status
EricLew	0:80ee8f3b695e	1254	*/
EricLew	0:80ee8f3b695e	1255	HAL_StatusTypeDef HAL_DFSDM_FilterConfigInjChannel(DFSDM_Filter_HandleTypeDef *hdfsdm_filter,
EricLew	0:80ee8f3b695e	1256	uint32_t Channel)
EricLew	0:80ee8f3b695e	1257	{
EricLew	0:80ee8f3b695e	1258	HAL_StatusTypeDef status = HAL_OK;
EricLew	0:80ee8f3b695e	1259
EricLew	0:80ee8f3b695e	1260	/* Check parameters */
EricLew	0:80ee8f3b695e	1261	assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance));
EricLew	0:80ee8f3b695e	1262	assert_param(IS_DFSDM_INJECTED_CHANNEL(Channel));
EricLew	0:80ee8f3b695e	1263
EricLew	0:80ee8f3b695e	1264	/* Check DFSDM filter state */
EricLew	0:80ee8f3b695e	1265	if((hdfsdm_filter->State != HAL_DFSDM_FILTER_STATE_RESET) &&
EricLew	0:80ee8f3b695e	1266	(hdfsdm_filter->State != HAL_DFSDM_FILTER_STATE_ERROR))
EricLew	0:80ee8f3b695e	1267	{
EricLew	0:80ee8f3b695e	1268	/* Configure channel for injected conversion */
EricLew	0:80ee8f3b695e	1269	hdfsdm_filter->Instance->JCHGR = (uint32_t) (Channel & DFSDM_LSB_MASK);
EricLew	0:80ee8f3b695e	1270	/* Store number of injected channels */
EricLew	0:80ee8f3b695e	1271	hdfsdm_filter->InjectedChannelsNbr = DFSDM_GetInjChannelsNbr(Channel);
EricLew	0:80ee8f3b695e	1272	/* Update number of injected channels remaining */
EricLew	0:80ee8f3b695e	1273	hdfsdm_filter->InjConvRemaining = (hdfsdm_filter->InjectedScanMode == ENABLE) ? \
EricLew	0:80ee8f3b695e	1274	hdfsdm_filter->InjectedChannelsNbr : 1;
EricLew	0:80ee8f3b695e	1275	}
EricLew	0:80ee8f3b695e	1276	else
EricLew	0:80ee8f3b695e	1277	{
EricLew	0:80ee8f3b695e	1278	status = HAL_ERROR;
EricLew	0:80ee8f3b695e	1279	}
EricLew	0:80ee8f3b695e	1280	/* Return function status */
EricLew	0:80ee8f3b695e	1281	return status;
EricLew	0:80ee8f3b695e	1282	}
EricLew	0:80ee8f3b695e	1283
EricLew	0:80ee8f3b695e	1284	/**
EricLew	0:80ee8f3b695e	1285	* @}
EricLew	0:80ee8f3b695e	1286	*/
EricLew	0:80ee8f3b695e	1287
EricLew	0:80ee8f3b695e	1288	/** @defgroup DFSDM_Exported_Functions_Group3_Filter Filter operation functions
EricLew	0:80ee8f3b695e	1289	* @brief Filter operation functions
EricLew	0:80ee8f3b695e	1290	*
EricLew	0:80ee8f3b695e	1291	@verbatim
EricLew	0:80ee8f3b695e	1292	==============================================================================
EricLew	0:80ee8f3b695e	1293	##### Filter operation functions #####
EricLew	0:80ee8f3b695e	1294	==============================================================================
EricLew	0:80ee8f3b695e	1295	[..] This section provides functions allowing to:
EricLew	0:80ee8f3b695e	1296	(+) Start conversion of regular/injected channel.
EricLew	0:80ee8f3b695e	1297	(+) Poll for the end of regular/injected conversion.
EricLew	0:80ee8f3b695e	1298	(+) Stop conversion of regular/injected channel.
EricLew	0:80ee8f3b695e	1299	(+) Start conversion of regular/injected channel and enable interrupt.
EricLew	0:80ee8f3b695e	1300	(+) Call the callback functions at the end of regular/injected conversions.
EricLew	0:80ee8f3b695e	1301	(+) Stop conversion of regular/injected channel and disable interrupt.
EricLew	0:80ee8f3b695e	1302	(+) Start conversion of regular/injected channel and enable DMA transfer.
EricLew	0:80ee8f3b695e	1303	(+) Stop conversion of regular/injected channel and disable DMA transfer.
EricLew	0:80ee8f3b695e	1304	(+) Start analog watchdog and enable interrupt.
EricLew	0:80ee8f3b695e	1305	(+) Call the callback function when analog watchdog occurs.
EricLew	0:80ee8f3b695e	1306	(+) Stop analog watchdog and disable interrupt.
EricLew	0:80ee8f3b695e	1307	(+) Start extreme detector.
EricLew	0:80ee8f3b695e	1308	(+) Stop extreme detector.
EricLew	0:80ee8f3b695e	1309	(+) Get result of regular channel conversion.
EricLew	0:80ee8f3b695e	1310	(+) Get result of injected channel conversion.
EricLew	0:80ee8f3b695e	1311	(+) Get extreme detector maximum and minimum values.
EricLew	0:80ee8f3b695e	1312	(+) Get conversion time.
EricLew	0:80ee8f3b695e	1313	(+) Handle DFSDM interrupt request.
EricLew	0:80ee8f3b695e	1314	@endverbatim
EricLew	0:80ee8f3b695e	1315	* @{
EricLew	0:80ee8f3b695e	1316	*/
EricLew	0:80ee8f3b695e	1317
EricLew	0:80ee8f3b695e	1318	/**
EricLew	0:80ee8f3b695e	1319	* @brief This function allows to start regular conversion in polling mode.
EricLew	0:80ee8f3b695e	1320	* @note This function should be called only when DFSDM filter instance is
EricLew	0:80ee8f3b695e	1321	* in idle state or if injected conversion is ongoing.
EricLew	0:80ee8f3b695e	1322	* @param hdfsdm_filter : DFSDM filter handle.
EricLew	0:80ee8f3b695e	1323	* @retval HAL status
EricLew	0:80ee8f3b695e	1324	*/
EricLew	0:80ee8f3b695e	1325	HAL_StatusTypeDef HAL_DFSDM_FilterRegularStart(DFSDM_Filter_HandleTypeDef *hdfsdm_filter)
EricLew	0:80ee8f3b695e	1326	{
EricLew	0:80ee8f3b695e	1327	HAL_StatusTypeDef status = HAL_OK;
EricLew	0:80ee8f3b695e	1328
EricLew	0:80ee8f3b695e	1329	/* Check parameters */
EricLew	0:80ee8f3b695e	1330	assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance));
EricLew	0:80ee8f3b695e	1331
EricLew	0:80ee8f3b695e	1332	/* Check DFSDM filter state */
EricLew	0:80ee8f3b695e	1333	if((hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_READY) \|\| \
EricLew	0:80ee8f3b695e	1334	(hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_INJ))
EricLew	0:80ee8f3b695e	1335	{
EricLew	0:80ee8f3b695e	1336	/* Start regular conversion */
EricLew	0:80ee8f3b695e	1337	DFSDM_RegConvStart(hdfsdm_filter);
EricLew	0:80ee8f3b695e	1338	}
EricLew	0:80ee8f3b695e	1339	else
EricLew	0:80ee8f3b695e	1340	{
EricLew	0:80ee8f3b695e	1341	status = HAL_ERROR;
EricLew	0:80ee8f3b695e	1342	}
EricLew	0:80ee8f3b695e	1343	/* Return function status */
EricLew	0:80ee8f3b695e	1344	return status;
EricLew	0:80ee8f3b695e	1345	}
EricLew	0:80ee8f3b695e	1346
EricLew	0:80ee8f3b695e	1347	/**
EricLew	0:80ee8f3b695e	1348	* @brief This function allows to poll for the end of regular conversion.
EricLew	0:80ee8f3b695e	1349	* @note This function should be called only if regular conversion is ongoing.
EricLew	0:80ee8f3b695e	1350	* @param hdfsdm_filter : DFSDM filter handle.
EricLew	0:80ee8f3b695e	1351	* @param Timeout : Timeout value in milliseconds.
EricLew	0:80ee8f3b695e	1352	* @retval HAL status
EricLew	0:80ee8f3b695e	1353	*/
EricLew	0:80ee8f3b695e	1354	HAL_StatusTypeDef HAL_DFSDM_FilterPollForRegConversion(DFSDM_Filter_HandleTypeDef *hdfsdm_filter,
EricLew	0:80ee8f3b695e	1355	uint32_t Timeout)
EricLew	0:80ee8f3b695e	1356	{
EricLew	0:80ee8f3b695e	1357	uint32_t tickstart;
EricLew	0:80ee8f3b695e	1358
EricLew	0:80ee8f3b695e	1359	/* Check parameters */
EricLew	0:80ee8f3b695e	1360	assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance));
EricLew	0:80ee8f3b695e	1361
EricLew	0:80ee8f3b695e	1362	/* Check DFSDM filter state */
EricLew	0:80ee8f3b695e	1363	if((hdfsdm_filter->State != HAL_DFSDM_FILTER_STATE_REG) && \
EricLew	0:80ee8f3b695e	1364	(hdfsdm_filter->State != HAL_DFSDM_FILTER_STATE_REG_INJ))
EricLew	0:80ee8f3b695e	1365	{
EricLew	0:80ee8f3b695e	1366	/* Return error status */
EricLew	0:80ee8f3b695e	1367	return HAL_ERROR;
EricLew	0:80ee8f3b695e	1368	}
EricLew	0:80ee8f3b695e	1369	else
EricLew	0:80ee8f3b695e	1370	{
EricLew	0:80ee8f3b695e	1371	/* Get timeout */
EricLew	0:80ee8f3b695e	1372	tickstart = HAL_GetTick();
EricLew	0:80ee8f3b695e	1373
EricLew	0:80ee8f3b695e	1374	/* Wait end of regular conversion */
EricLew	0:80ee8f3b695e	1375	while((hdfsdm_filter->Instance->ISR & DFSDM_ISR_REOCF) != DFSDM_ISR_REOCF)
EricLew	0:80ee8f3b695e	1376	{
EricLew	0:80ee8f3b695e	1377	/* Check the Timeout */
EricLew	0:80ee8f3b695e	1378	if(Timeout != HAL_MAX_DELAY)
EricLew	0:80ee8f3b695e	1379	{
EricLew	0:80ee8f3b695e	1380	if((Timeout == 0) \|\| ((HAL_GetTick()-tickstart) > Timeout))
EricLew	0:80ee8f3b695e	1381	{
EricLew	0:80ee8f3b695e	1382	/* Return timeout status */
EricLew	0:80ee8f3b695e	1383	return HAL_TIMEOUT;
EricLew	0:80ee8f3b695e	1384	}
EricLew	0:80ee8f3b695e	1385	}
EricLew	0:80ee8f3b695e	1386	}
EricLew	0:80ee8f3b695e	1387	/* Check if overrun occurs */
EricLew	0:80ee8f3b695e	1388	if((hdfsdm_filter->Instance->ISR & DFSDM_ISR_ROVRF) == DFSDM_ISR_ROVRF)
EricLew	0:80ee8f3b695e	1389	{
EricLew	0:80ee8f3b695e	1390	/* Update error code and call error callback */
EricLew	0:80ee8f3b695e	1391	hdfsdm_filter->ErrorCode = DFSDM_FILTER_ERROR_REGULAR_OVERRUN;
EricLew	0:80ee8f3b695e	1392	HAL_DFSDM_FilterErrorCallback(hdfsdm_filter);
EricLew	0:80ee8f3b695e	1393
EricLew	0:80ee8f3b695e	1394	/* Clear regular overrun flag */
EricLew	0:80ee8f3b695e	1395	hdfsdm_filter->Instance->ICR = DFSDM_ICR_CLRROVRF;
EricLew	0:80ee8f3b695e	1396	}
EricLew	0:80ee8f3b695e	1397	/* Update DFSDM filter state only if not continuous conversion and SW trigger */
EricLew	0:80ee8f3b695e	1398	if((hdfsdm_filter->RegularContMode == DFSDM_CONTINUOUS_CONV_OFF) && \
EricLew	0:80ee8f3b695e	1399	(hdfsdm_filter->RegularTrigger == DFSDM_FILTER_SW_TRIGGER))
EricLew	0:80ee8f3b695e	1400	{
EricLew	0:80ee8f3b695e	1401	hdfsdm_filter->State = (hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_REG) ? \
EricLew	0:80ee8f3b695e	1402	HAL_DFSDM_FILTER_STATE_READY : HAL_DFSDM_FILTER_STATE_INJ;
EricLew	0:80ee8f3b695e	1403	}
EricLew	0:80ee8f3b695e	1404	/* Return function status */
EricLew	0:80ee8f3b695e	1405	return HAL_OK;
EricLew	0:80ee8f3b695e	1406	}
EricLew	0:80ee8f3b695e	1407	}
EricLew	0:80ee8f3b695e	1408
EricLew	0:80ee8f3b695e	1409	/**
EricLew	0:80ee8f3b695e	1410	* @brief This function allows to stop regular conversion in polling mode.
EricLew	0:80ee8f3b695e	1411	* @note This function should be called only if regular conversion is ongoing.
EricLew	0:80ee8f3b695e	1412	* @param hdfsdm_filter : DFSDM filter handle.
EricLew	0:80ee8f3b695e	1413	* @retval HAL status
EricLew	0:80ee8f3b695e	1414	*/
EricLew	0:80ee8f3b695e	1415	HAL_StatusTypeDef HAL_DFSDM_FilterRegularStop(DFSDM_Filter_HandleTypeDef *hdfsdm_filter)
EricLew	0:80ee8f3b695e	1416	{
EricLew	0:80ee8f3b695e	1417	HAL_StatusTypeDef status = HAL_OK;
EricLew	0:80ee8f3b695e	1418
EricLew	0:80ee8f3b695e	1419	/* Check parameters */
EricLew	0:80ee8f3b695e	1420	assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance));
EricLew	0:80ee8f3b695e	1421
EricLew	0:80ee8f3b695e	1422	/* Check DFSDM filter state */
EricLew	0:80ee8f3b695e	1423	if((hdfsdm_filter->State != HAL_DFSDM_FILTER_STATE_REG) && \
EricLew	0:80ee8f3b695e	1424	(hdfsdm_filter->State != HAL_DFSDM_FILTER_STATE_REG_INJ))
EricLew	0:80ee8f3b695e	1425	{
EricLew	0:80ee8f3b695e	1426	/* Return error status */
EricLew	0:80ee8f3b695e	1427	status = HAL_ERROR;
EricLew	0:80ee8f3b695e	1428	}
EricLew	0:80ee8f3b695e	1429	else
EricLew	0:80ee8f3b695e	1430	{
EricLew	0:80ee8f3b695e	1431	/* Stop regular conversion */
EricLew	0:80ee8f3b695e	1432	DFSDM_RegConvStop(hdfsdm_filter);
EricLew	0:80ee8f3b695e	1433	}
EricLew	0:80ee8f3b695e	1434	/* Return function status */
EricLew	0:80ee8f3b695e	1435	return status;
EricLew	0:80ee8f3b695e	1436	}
EricLew	0:80ee8f3b695e	1437
EricLew	0:80ee8f3b695e	1438	/**
EricLew	0:80ee8f3b695e	1439	* @brief This function allows to start regular conversion in interrupt mode.
EricLew	0:80ee8f3b695e	1440	* @note This function should be called only when DFSDM filter instance is
EricLew	0:80ee8f3b695e	1441	* in idle state or if injected conversion is ongoing.
EricLew	0:80ee8f3b695e	1442	* @param hdfsdm_filter : DFSDM filter handle.
EricLew	0:80ee8f3b695e	1443	* @retval HAL status
EricLew	0:80ee8f3b695e	1444	*/
EricLew	0:80ee8f3b695e	1445	HAL_StatusTypeDef HAL_DFSDM_FilterRegularStart_IT(DFSDM_Filter_HandleTypeDef *hdfsdm_filter)
EricLew	0:80ee8f3b695e	1446	{
EricLew	0:80ee8f3b695e	1447	HAL_StatusTypeDef status = HAL_OK;
EricLew	0:80ee8f3b695e	1448
EricLew	0:80ee8f3b695e	1449	/* Check parameters */
EricLew	0:80ee8f3b695e	1450	assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance));
EricLew	0:80ee8f3b695e	1451
EricLew	0:80ee8f3b695e	1452	/* Check DFSDM filter state */
EricLew	0:80ee8f3b695e	1453	if((hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_READY) \|\| \
EricLew	0:80ee8f3b695e	1454	(hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_INJ))
EricLew	0:80ee8f3b695e	1455	{
EricLew	0:80ee8f3b695e	1456	/* Enable interrupts for regular conversions */
EricLew	0:80ee8f3b695e	1457	hdfsdm_filter->Instance->CR2 \|= (DFSDM_CR2_REOCIE \| DFSDM_CR2_ROVRIE);
EricLew	0:80ee8f3b695e	1458
EricLew	0:80ee8f3b695e	1459	/* Start regular conversion */
EricLew	0:80ee8f3b695e	1460	DFSDM_RegConvStart(hdfsdm_filter);
EricLew	0:80ee8f3b695e	1461	}
EricLew	0:80ee8f3b695e	1462	else
EricLew	0:80ee8f3b695e	1463	{
EricLew	0:80ee8f3b695e	1464	status = HAL_ERROR;
EricLew	0:80ee8f3b695e	1465	}
EricLew	0:80ee8f3b695e	1466	/* Return function status */
EricLew	0:80ee8f3b695e	1467	return status;
EricLew	0:80ee8f3b695e	1468	}
EricLew	0:80ee8f3b695e	1469
EricLew	0:80ee8f3b695e	1470	/**
EricLew	0:80ee8f3b695e	1471	* @brief This function allows to stop regular conversion in interrupt mode.
EricLew	0:80ee8f3b695e	1472	* @note This function should be called only if regular conversion is ongoing.
EricLew	0:80ee8f3b695e	1473	* @param hdfsdm_filter : DFSDM filter handle.
EricLew	0:80ee8f3b695e	1474	* @retval HAL status
EricLew	0:80ee8f3b695e	1475	*/
EricLew	0:80ee8f3b695e	1476	HAL_StatusTypeDef HAL_DFSDM_FilterRegularStop_IT(DFSDM_Filter_HandleTypeDef *hdfsdm_filter)
EricLew	0:80ee8f3b695e	1477	{
EricLew	0:80ee8f3b695e	1478	HAL_StatusTypeDef status = HAL_OK;
EricLew	0:80ee8f3b695e	1479
EricLew	0:80ee8f3b695e	1480	/* Check parameters */
EricLew	0:80ee8f3b695e	1481	assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance));
EricLew	0:80ee8f3b695e	1482
EricLew	0:80ee8f3b695e	1483	/* Check DFSDM filter state */
EricLew	0:80ee8f3b695e	1484	if((hdfsdm_filter->State != HAL_DFSDM_FILTER_STATE_REG) && \
EricLew	0:80ee8f3b695e	1485	(hdfsdm_filter->State != HAL_DFSDM_FILTER_STATE_REG_INJ))
EricLew	0:80ee8f3b695e	1486	{
EricLew	0:80ee8f3b695e	1487	/* Return error status */
EricLew	0:80ee8f3b695e	1488	status = HAL_ERROR;
EricLew	0:80ee8f3b695e	1489	}
EricLew	0:80ee8f3b695e	1490	else
EricLew	0:80ee8f3b695e	1491	{
EricLew	0:80ee8f3b695e	1492	/* Disable interrupts for regular conversions */
EricLew	0:80ee8f3b695e	1493	hdfsdm_filter->Instance->CR2 &= ~(DFSDM_CR2_REOCIE \| DFSDM_CR2_ROVRIE);
EricLew	0:80ee8f3b695e	1494
EricLew	0:80ee8f3b695e	1495	/* Stop regular conversion */
EricLew	0:80ee8f3b695e	1496	DFSDM_RegConvStop(hdfsdm_filter);
EricLew	0:80ee8f3b695e	1497	}
EricLew	0:80ee8f3b695e	1498	/* Return function status */
EricLew	0:80ee8f3b695e	1499	return status;
EricLew	0:80ee8f3b695e	1500	}
EricLew	0:80ee8f3b695e	1501
EricLew	0:80ee8f3b695e	1502	/**
EricLew	0:80ee8f3b695e	1503	* @brief This function allows to start regular conversion in DMA mode.
EricLew	0:80ee8f3b695e	1504	* @note This function should be called only when DFSDM filter instance is
EricLew	0:80ee8f3b695e	1505	* in idle state or if injected conversion is ongoing.
EricLew	0:80ee8f3b695e	1506	* Please note that data on buffer will contain signed regular conversion
EricLew	0:80ee8f3b695e	1507	* value on 24 most significant bits and corresponding channel on 3 least
EricLew	0:80ee8f3b695e	1508	* significant bits.
EricLew	0:80ee8f3b695e	1509	* @param hdfsdm_filter : DFSDM filter handle.
EricLew	0:80ee8f3b695e	1510	* @param pData : The destination buffer address.
EricLew	0:80ee8f3b695e	1511	* @param Length : The length of data to be transferred from DFSDM filter to memory.
EricLew	0:80ee8f3b695e	1512	* @retval HAL status
EricLew	0:80ee8f3b695e	1513	*/
EricLew	0:80ee8f3b695e	1514	HAL_StatusTypeDef HAL_DFSDM_FilterRegularStart_DMA(DFSDM_Filter_HandleTypeDef *hdfsdm_filter,
EricLew	0:80ee8f3b695e	1515	int32_t *pData,
EricLew	0:80ee8f3b695e	1516	uint32_t Length)
EricLew	0:80ee8f3b695e	1517	{
EricLew	0:80ee8f3b695e	1518	HAL_StatusTypeDef status = HAL_OK;
EricLew	0:80ee8f3b695e	1519
EricLew	0:80ee8f3b695e	1520	/* Check parameters */
EricLew	0:80ee8f3b695e	1521	assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance));
EricLew	0:80ee8f3b695e	1522
EricLew	0:80ee8f3b695e	1523	/* Check destination address and length */
EricLew	0:80ee8f3b695e	1524	if((pData == NULL) \|\| (Length == 0))
EricLew	0:80ee8f3b695e	1525	{
EricLew	0:80ee8f3b695e	1526	status = HAL_ERROR;
EricLew	0:80ee8f3b695e	1527	}
EricLew	0:80ee8f3b695e	1528	/* Check that DMA is enabled for regular conversion */
EricLew	0:80ee8f3b695e	1529	else if((hdfsdm_filter->Instance->CR1 & DFSDM_CR1_RDMAEN) != DFSDM_CR1_RDMAEN)
EricLew	0:80ee8f3b695e	1530	{
EricLew	0:80ee8f3b695e	1531	status = HAL_ERROR;
EricLew	0:80ee8f3b695e	1532	}
EricLew	0:80ee8f3b695e	1533	/* Check parameters compatibility */
EricLew	0:80ee8f3b695e	1534	else if((hdfsdm_filter->RegularTrigger == DFSDM_FILTER_SW_TRIGGER) && \
EricLew	0:80ee8f3b695e	1535	(hdfsdm_filter->RegularContMode == DFSDM_CONTINUOUS_CONV_OFF) && \
EricLew	0:80ee8f3b695e	1536	(hdfsdm_filter->hdmaReg->Init.Mode == DMA_NORMAL) && \
EricLew	0:80ee8f3b695e	1537	(Length != 1))
EricLew	0:80ee8f3b695e	1538	{
EricLew	0:80ee8f3b695e	1539	status = HAL_ERROR;
EricLew	0:80ee8f3b695e	1540	}
EricLew	0:80ee8f3b695e	1541	else if((hdfsdm_filter->RegularTrigger == DFSDM_FILTER_SW_TRIGGER) && \
EricLew	0:80ee8f3b695e	1542	(hdfsdm_filter->RegularContMode == DFSDM_CONTINUOUS_CONV_OFF) && \
EricLew	0:80ee8f3b695e	1543	(hdfsdm_filter->hdmaReg->Init.Mode == DMA_CIRCULAR))
EricLew	0:80ee8f3b695e	1544	{
EricLew	0:80ee8f3b695e	1545	status = HAL_ERROR;
EricLew	0:80ee8f3b695e	1546	}
EricLew	0:80ee8f3b695e	1547	/* Check DFSDM filter state */
EricLew	0:80ee8f3b695e	1548	else if((hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_READY) \|\| \
EricLew	0:80ee8f3b695e	1549	(hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_INJ))
EricLew	0:80ee8f3b695e	1550	{
EricLew	0:80ee8f3b695e	1551	/* Set callbacks on DMA handler */
EricLew	0:80ee8f3b695e	1552	hdfsdm_filter->hdmaReg->XferCpltCallback = DFSDM_DMARegularConvCplt;
EricLew	0:80ee8f3b695e	1553	hdfsdm_filter->hdmaReg->XferErrorCallback = DFSDM_DMAError;
EricLew	0:80ee8f3b695e	1554	hdfsdm_filter->hdmaReg->XferHalfCpltCallback = (hdfsdm_filter->hdmaReg->Init.Mode == DMA_CIRCULAR) ?\
EricLew	0:80ee8f3b695e	1555	DFSDM_DMARegularHalfConvCplt : NULL;
EricLew	0:80ee8f3b695e	1556
EricLew	0:80ee8f3b695e	1557	/* Start DMA in interrupt mode */
EricLew	0:80ee8f3b695e	1558	if(HAL_DMA_Start_IT(hdfsdm_filter->hdmaReg, (uint32_t)&hdfsdm_filter->Instance->RDATAR, \
EricLew	0:80ee8f3b695e	1559	(uint32_t) pData, Length) != HAL_OK)
EricLew	0:80ee8f3b695e	1560	{
EricLew	0:80ee8f3b695e	1561	/* Set DFSDM filter in error state */
EricLew	0:80ee8f3b695e	1562	hdfsdm_filter->State = HAL_DFSDM_FILTER_STATE_ERROR;
EricLew	0:80ee8f3b695e	1563	status = HAL_ERROR;
EricLew	0:80ee8f3b695e	1564	}
EricLew	0:80ee8f3b695e	1565	else
EricLew	0:80ee8f3b695e	1566	{
EricLew	0:80ee8f3b695e	1567	/* Start regular conversion */
EricLew	0:80ee8f3b695e	1568	DFSDM_RegConvStart(hdfsdm_filter);
EricLew	0:80ee8f3b695e	1569	}
EricLew	0:80ee8f3b695e	1570	}
EricLew	0:80ee8f3b695e	1571	else
EricLew	0:80ee8f3b695e	1572	{
EricLew	0:80ee8f3b695e	1573	status = HAL_ERROR;
EricLew	0:80ee8f3b695e	1574	}
EricLew	0:80ee8f3b695e	1575	/* Return function status */
EricLew	0:80ee8f3b695e	1576	return status;
EricLew	0:80ee8f3b695e	1577	}
EricLew	0:80ee8f3b695e	1578
EricLew	0:80ee8f3b695e	1579	/**
EricLew	0:80ee8f3b695e	1580	* @brief This function allows to start regular conversion in DMA mode and to get
EricLew	0:80ee8f3b695e	1581	* only the 16 most significant bits of conversion.
EricLew	0:80ee8f3b695e	1582	* @note This function should be called only when DFSDM filter instance is
EricLew	0:80ee8f3b695e	1583	* in idle state or if injected conversion is ongoing.
EricLew	0:80ee8f3b695e	1584	* Please note that data on buffer will contain signed 16 most significant
EricLew	0:80ee8f3b695e	1585	* bits of regular conversion.
EricLew	0:80ee8f3b695e	1586	* @param hdfsdm_filter : DFSDM filter handle.
EricLew	0:80ee8f3b695e	1587	* @param pData : The destination buffer address.
EricLew	0:80ee8f3b695e	1588	* @param Length : The length of data to be transferred from DFSDM filter to memory.
EricLew	0:80ee8f3b695e	1589	* @retval HAL status
EricLew	0:80ee8f3b695e	1590	*/
EricLew	0:80ee8f3b695e	1591	HAL_StatusTypeDef HAL_DFSDM_FilterRegularMsbStart_DMA(DFSDM_Filter_HandleTypeDef *hdfsdm_filter,
EricLew	0:80ee8f3b695e	1592	int16_t *pData,
EricLew	0:80ee8f3b695e	1593	uint32_t Length)
EricLew	0:80ee8f3b695e	1594	{
EricLew	0:80ee8f3b695e	1595	HAL_StatusTypeDef status = HAL_OK;
EricLew	0:80ee8f3b695e	1596
EricLew	0:80ee8f3b695e	1597	/* Check parameters */
EricLew	0:80ee8f3b695e	1598	assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance));
EricLew	0:80ee8f3b695e	1599
EricLew	0:80ee8f3b695e	1600	/* Check destination address and length */
EricLew	0:80ee8f3b695e	1601	if((pData == NULL) \|\| (Length == 0))
EricLew	0:80ee8f3b695e	1602	{
EricLew	0:80ee8f3b695e	1603	status = HAL_ERROR;
EricLew	0:80ee8f3b695e	1604	}
EricLew	0:80ee8f3b695e	1605	/* Check that DMA is enabled for regular conversion */
EricLew	0:80ee8f3b695e	1606	else if((hdfsdm_filter->Instance->CR1 & DFSDM_CR1_RDMAEN) != DFSDM_CR1_RDMAEN)
EricLew	0:80ee8f3b695e	1607	{
EricLew	0:80ee8f3b695e	1608	status = HAL_ERROR;
EricLew	0:80ee8f3b695e	1609	}
EricLew	0:80ee8f3b695e	1610	/* Check parameters compatibility */
EricLew	0:80ee8f3b695e	1611	else if((hdfsdm_filter->RegularTrigger == DFSDM_FILTER_SW_TRIGGER) && \
EricLew	0:80ee8f3b695e	1612	(hdfsdm_filter->RegularContMode == DFSDM_CONTINUOUS_CONV_OFF) && \
EricLew	0:80ee8f3b695e	1613	(hdfsdm_filter->hdmaReg->Init.Mode == DMA_NORMAL) && \
EricLew	0:80ee8f3b695e	1614	(Length != 1))
EricLew	0:80ee8f3b695e	1615	{
EricLew	0:80ee8f3b695e	1616	status = HAL_ERROR;
EricLew	0:80ee8f3b695e	1617	}
EricLew	0:80ee8f3b695e	1618	else if((hdfsdm_filter->RegularTrigger == DFSDM_FILTER_SW_TRIGGER) && \
EricLew	0:80ee8f3b695e	1619	(hdfsdm_filter->RegularContMode == DFSDM_CONTINUOUS_CONV_OFF) && \
EricLew	0:80ee8f3b695e	1620	(hdfsdm_filter->hdmaReg->Init.Mode == DMA_CIRCULAR))
EricLew	0:80ee8f3b695e	1621	{
EricLew	0:80ee8f3b695e	1622	status = HAL_ERROR;
EricLew	0:80ee8f3b695e	1623	}
EricLew	0:80ee8f3b695e	1624	/* Check DFSDM filter state */
EricLew	0:80ee8f3b695e	1625	else if((hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_READY) \|\| \
EricLew	0:80ee8f3b695e	1626	(hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_INJ))
EricLew	0:80ee8f3b695e	1627	{
EricLew	0:80ee8f3b695e	1628	/* Set callbacks on DMA handler */
EricLew	0:80ee8f3b695e	1629	hdfsdm_filter->hdmaReg->XferCpltCallback = DFSDM_DMARegularConvCplt;
EricLew	0:80ee8f3b695e	1630	hdfsdm_filter->hdmaReg->XferErrorCallback = DFSDM_DMAError;
EricLew	0:80ee8f3b695e	1631	hdfsdm_filter->hdmaReg->XferHalfCpltCallback = (hdfsdm_filter->hdmaReg->Init.Mode == DMA_CIRCULAR) ?\
EricLew	0:80ee8f3b695e	1632	DFSDM_DMARegularHalfConvCplt : NULL;
EricLew	0:80ee8f3b695e	1633
EricLew	0:80ee8f3b695e	1634	/* Start DMA in interrupt mode */
EricLew	0:80ee8f3b695e	1635	if(HAL_DMA_Start_IT(hdfsdm_filter->hdmaReg, (uint32_t)(&hdfsdm_filter->Instance->RDATAR) + 2, \
EricLew	0:80ee8f3b695e	1636	(uint32_t) pData, Length) != HAL_OK)
EricLew	0:80ee8f3b695e	1637	{
EricLew	0:80ee8f3b695e	1638	/* Set DFSDM filter in error state */
EricLew	0:80ee8f3b695e	1639	hdfsdm_filter->State = HAL_DFSDM_FILTER_STATE_ERROR;
EricLew	0:80ee8f3b695e	1640	status = HAL_ERROR;
EricLew	0:80ee8f3b695e	1641	}
EricLew	0:80ee8f3b695e	1642	else
EricLew	0:80ee8f3b695e	1643	{
EricLew	0:80ee8f3b695e	1644	/* Start regular conversion */
EricLew	0:80ee8f3b695e	1645	DFSDM_RegConvStart(hdfsdm_filter);
EricLew	0:80ee8f3b695e	1646	}
EricLew	0:80ee8f3b695e	1647	}
EricLew	0:80ee8f3b695e	1648	else
EricLew	0:80ee8f3b695e	1649	{
EricLew	0:80ee8f3b695e	1650	status = HAL_ERROR;
EricLew	0:80ee8f3b695e	1651	}
EricLew	0:80ee8f3b695e	1652	/* Return function status */
EricLew	0:80ee8f3b695e	1653	return status;
EricLew	0:80ee8f3b695e	1654	}
EricLew	0:80ee8f3b695e	1655
EricLew	0:80ee8f3b695e	1656	/**
EricLew	0:80ee8f3b695e	1657	* @brief This function allows to stop regular conversion in DMA mode.
EricLew	0:80ee8f3b695e	1658	* @note This function should be called only if regular conversion is ongoing.
EricLew	0:80ee8f3b695e	1659	* @param hdfsdm_filter : DFSDM filter handle.
EricLew	0:80ee8f3b695e	1660	* @retval HAL status
EricLew	0:80ee8f3b695e	1661	*/
EricLew	0:80ee8f3b695e	1662	HAL_StatusTypeDef HAL_DFSDM_FilterRegularStop_DMA(DFSDM_Filter_HandleTypeDef *hdfsdm_filter)
EricLew	0:80ee8f3b695e	1663	{
EricLew	0:80ee8f3b695e	1664	HAL_StatusTypeDef status = HAL_OK;
EricLew	0:80ee8f3b695e	1665
EricLew	0:80ee8f3b695e	1666	/* Check parameters */
EricLew	0:80ee8f3b695e	1667	assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance));
EricLew	0:80ee8f3b695e	1668
EricLew	0:80ee8f3b695e	1669	/* Check DFSDM filter state */
EricLew	0:80ee8f3b695e	1670	if((hdfsdm_filter->State != HAL_DFSDM_FILTER_STATE_REG) && \
EricLew	0:80ee8f3b695e	1671	(hdfsdm_filter->State != HAL_DFSDM_FILTER_STATE_REG_INJ))
EricLew	0:80ee8f3b695e	1672	{
EricLew	0:80ee8f3b695e	1673	/* Return error status */
EricLew	0:80ee8f3b695e	1674	status = HAL_ERROR;
EricLew	0:80ee8f3b695e	1675	}
EricLew	0:80ee8f3b695e	1676	else
EricLew	0:80ee8f3b695e	1677	{
EricLew	0:80ee8f3b695e	1678	/* Stop current DMA transfer */
EricLew	0:80ee8f3b695e	1679	if(HAL_DMA_Abort(hdfsdm_filter->hdmaReg) != HAL_OK)
EricLew	0:80ee8f3b695e	1680	{
EricLew	0:80ee8f3b695e	1681	/* Set DFSDM filter in error state */
EricLew	0:80ee8f3b695e	1682	hdfsdm_filter->State = HAL_DFSDM_FILTER_STATE_ERROR;
EricLew	0:80ee8f3b695e	1683	status = HAL_ERROR;
EricLew	0:80ee8f3b695e	1684	}
EricLew	0:80ee8f3b695e	1685	else
EricLew	0:80ee8f3b695e	1686	{
EricLew	0:80ee8f3b695e	1687	/* Stop regular conversion */
EricLew	0:80ee8f3b695e	1688	DFSDM_RegConvStop(hdfsdm_filter);
EricLew	0:80ee8f3b695e	1689	}
EricLew	0:80ee8f3b695e	1690	}
EricLew	0:80ee8f3b695e	1691	/* Return function status */
EricLew	0:80ee8f3b695e	1692	return status;
EricLew	0:80ee8f3b695e	1693	}
EricLew	0:80ee8f3b695e	1694
EricLew	0:80ee8f3b695e	1695	/**
EricLew	0:80ee8f3b695e	1696	* @brief This function allows to get regular conversion value.
EricLew	0:80ee8f3b695e	1697	* @param hdfsdm_filter : DFSDM filter handle.
EricLew	0:80ee8f3b695e	1698	* @param Channel : Corresponding channel of regular conversion.
EricLew	0:80ee8f3b695e	1699	* @retval Regular conversion value
EricLew	0:80ee8f3b695e	1700	*/
EricLew	0:80ee8f3b695e	1701	int32_t HAL_DFSDM_FilterGetRegularValue(DFSDM_Filter_HandleTypeDef *hdfsdm_filter,
EricLew	0:80ee8f3b695e	1702	uint32_t *Channel)
EricLew	0:80ee8f3b695e	1703	{
EricLew	0:80ee8f3b695e	1704	uint32_t reg = 0;
EricLew	0:80ee8f3b695e	1705	int32_t value = 0;
EricLew	0:80ee8f3b695e	1706
EricLew	0:80ee8f3b695e	1707	/* Check parameters */
EricLew	0:80ee8f3b695e	1708	assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance));
EricLew	0:80ee8f3b695e	1709	assert_param(Channel != NULL);
EricLew	0:80ee8f3b695e	1710
EricLew	0:80ee8f3b695e	1711	/* Get value of data register for regular channel */
EricLew	0:80ee8f3b695e	1712	reg = hdfsdm_filter->Instance->RDATAR;
EricLew	0:80ee8f3b695e	1713
EricLew	0:80ee8f3b695e	1714	/* Extract channel and regular conversion value */
EricLew	0:80ee8f3b695e	1715	*Channel = (reg & DFSDM_RDATAR_RDATACH);
EricLew	0:80ee8f3b695e	1716	value = ((int32_t)(reg & DFSDM_RDATAR_RDATA) >> DFSDM_RDATAR_DATA_OFFSET);
EricLew	0:80ee8f3b695e	1717
EricLew	0:80ee8f3b695e	1718	/* return regular conversion value */
EricLew	0:80ee8f3b695e	1719	return value;
EricLew	0:80ee8f3b695e	1720	}
EricLew	0:80ee8f3b695e	1721
EricLew	0:80ee8f3b695e	1722	/**
EricLew	0:80ee8f3b695e	1723	* @brief This function allows to start injected conversion in polling mode.
EricLew	0:80ee8f3b695e	1724	* @note This function should be called only when DFSDM filter instance is
EricLew	0:80ee8f3b695e	1725	* in idle state or if regular conversion is ongoing.
EricLew	0:80ee8f3b695e	1726	* @param hdfsdm_filter : DFSDM filter handle.
EricLew	0:80ee8f3b695e	1727	* @retval HAL status
EricLew	0:80ee8f3b695e	1728	*/
EricLew	0:80ee8f3b695e	1729	HAL_StatusTypeDef HAL_DFSDM_FilterInjectedStart(DFSDM_Filter_HandleTypeDef *hdfsdm_filter)
EricLew	0:80ee8f3b695e	1730	{
EricLew	0:80ee8f3b695e	1731	HAL_StatusTypeDef status = HAL_OK;
EricLew	0:80ee8f3b695e	1732
EricLew	0:80ee8f3b695e	1733	/* Check parameters */
EricLew	0:80ee8f3b695e	1734	assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance));
EricLew	0:80ee8f3b695e	1735
EricLew	0:80ee8f3b695e	1736	/* Check DFSDM filter state */
EricLew	0:80ee8f3b695e	1737	if((hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_READY) \|\| \
EricLew	0:80ee8f3b695e	1738	(hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_REG))
EricLew	0:80ee8f3b695e	1739	{
EricLew	0:80ee8f3b695e	1740	/* Start injected conversion */
EricLew	0:80ee8f3b695e	1741	DFSDM_InjConvStart(hdfsdm_filter);
EricLew	0:80ee8f3b695e	1742	}
EricLew	0:80ee8f3b695e	1743	else
EricLew	0:80ee8f3b695e	1744	{
EricLew	0:80ee8f3b695e	1745	status = HAL_ERROR;
EricLew	0:80ee8f3b695e	1746	}
EricLew	0:80ee8f3b695e	1747	/* Return function status */
EricLew	0:80ee8f3b695e	1748	return status;
EricLew	0:80ee8f3b695e	1749	}
EricLew	0:80ee8f3b695e	1750
EricLew	0:80ee8f3b695e	1751	/**
EricLew	0:80ee8f3b695e	1752	* @brief This function allows to poll for the end of injected conversion.
EricLew	0:80ee8f3b695e	1753	* @note This function should be called only if injected conversion is ongoing.
EricLew	0:80ee8f3b695e	1754	* @param hdfsdm_filter : DFSDM filter handle.
EricLew	0:80ee8f3b695e	1755	* @param Timeout : Timeout value in milliseconds.
EricLew	0:80ee8f3b695e	1756	* @retval HAL status
EricLew	0:80ee8f3b695e	1757	*/
EricLew	0:80ee8f3b695e	1758	HAL_StatusTypeDef HAL_DFSDM_FilterPollForInjConversion(DFSDM_Filter_HandleTypeDef *hdfsdm_filter,
EricLew	0:80ee8f3b695e	1759	uint32_t Timeout)
EricLew	0:80ee8f3b695e	1760	{
EricLew	0:80ee8f3b695e	1761	uint32_t tickstart;
EricLew	0:80ee8f3b695e	1762
EricLew	0:80ee8f3b695e	1763	/* Check parameters */
EricLew	0:80ee8f3b695e	1764	assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance));
EricLew	0:80ee8f3b695e	1765
EricLew	0:80ee8f3b695e	1766	/* Check DFSDM filter state */
EricLew	0:80ee8f3b695e	1767	if((hdfsdm_filter->State != HAL_DFSDM_FILTER_STATE_INJ) && \
EricLew	0:80ee8f3b695e	1768	(hdfsdm_filter->State != HAL_DFSDM_FILTER_STATE_REG_INJ))
EricLew	0:80ee8f3b695e	1769	{
EricLew	0:80ee8f3b695e	1770	/* Return error status */
EricLew	0:80ee8f3b695e	1771	return HAL_ERROR;
EricLew	0:80ee8f3b695e	1772	}
EricLew	0:80ee8f3b695e	1773	else
EricLew	0:80ee8f3b695e	1774	{
EricLew	0:80ee8f3b695e	1775	/* Get timeout */
EricLew	0:80ee8f3b695e	1776	tickstart = HAL_GetTick();
EricLew	0:80ee8f3b695e	1777
EricLew	0:80ee8f3b695e	1778	/* Wait end of injected conversions */
EricLew	0:80ee8f3b695e	1779	while((hdfsdm_filter->Instance->ISR & DFSDM_ISR_JEOCF) != DFSDM_ISR_JEOCF)
EricLew	0:80ee8f3b695e	1780	{
EricLew	0:80ee8f3b695e	1781	/* Check the Timeout */
EricLew	0:80ee8f3b695e	1782	if(Timeout != HAL_MAX_DELAY)
EricLew	0:80ee8f3b695e	1783	{
EricLew	0:80ee8f3b695e	1784	if((Timeout == 0) \|\| ((HAL_GetTick()-tickstart) > Timeout))
EricLew	0:80ee8f3b695e	1785	{
EricLew	0:80ee8f3b695e	1786	/* Return timeout status */
EricLew	0:80ee8f3b695e	1787	return HAL_TIMEOUT;
EricLew	0:80ee8f3b695e	1788	}
EricLew	0:80ee8f3b695e	1789	}
EricLew	0:80ee8f3b695e	1790	}
EricLew	0:80ee8f3b695e	1791	/* Check if overrun occurs */
EricLew	0:80ee8f3b695e	1792	if((hdfsdm_filter->Instance->ISR & DFSDM_ISR_JOVRF) == DFSDM_ISR_JOVRF)
EricLew	0:80ee8f3b695e	1793	{
EricLew	0:80ee8f3b695e	1794	/* Update error code and call error callback */
EricLew	0:80ee8f3b695e	1795	hdfsdm_filter->ErrorCode = DFSDM_FILTER_ERROR_INJECTED_OVERRUN;
EricLew	0:80ee8f3b695e	1796	HAL_DFSDM_FilterErrorCallback(hdfsdm_filter);
EricLew	0:80ee8f3b695e	1797
EricLew	0:80ee8f3b695e	1798	/* Clear injected overrun flag */
EricLew	0:80ee8f3b695e	1799	hdfsdm_filter->Instance->ICR = DFSDM_ICR_CLRJOVRF;
EricLew	0:80ee8f3b695e	1800	}
EricLew	0:80ee8f3b695e	1801
EricLew	0:80ee8f3b695e	1802	/* Update remaining injected conversions */
EricLew	0:80ee8f3b695e	1803	hdfsdm_filter->InjConvRemaining--;
EricLew	0:80ee8f3b695e	1804	if(hdfsdm_filter->InjConvRemaining == 0)
EricLew	0:80ee8f3b695e	1805	{
EricLew	0:80ee8f3b695e	1806	/* Update DFSDM filter state only if trigger is software */
EricLew	0:80ee8f3b695e	1807	if(hdfsdm_filter->InjectedTrigger == DFSDM_FILTER_SW_TRIGGER)
EricLew	0:80ee8f3b695e	1808	{
EricLew	0:80ee8f3b695e	1809	hdfsdm_filter->State = (hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_INJ) ? \
EricLew	0:80ee8f3b695e	1810	HAL_DFSDM_FILTER_STATE_READY : HAL_DFSDM_FILTER_STATE_REG;
EricLew	0:80ee8f3b695e	1811	}
EricLew	0:80ee8f3b695e	1812
EricLew	0:80ee8f3b695e	1813	/* end of injected sequence, reset the value */
EricLew	0:80ee8f3b695e	1814	hdfsdm_filter->InjConvRemaining = (hdfsdm_filter->InjectedScanMode == ENABLE) ? \
EricLew	0:80ee8f3b695e	1815	hdfsdm_filter->InjectedChannelsNbr : 1;
EricLew	0:80ee8f3b695e	1816	}
EricLew	0:80ee8f3b695e	1817
EricLew	0:80ee8f3b695e	1818	/* Return function status */
EricLew	0:80ee8f3b695e	1819	return HAL_OK;
EricLew	0:80ee8f3b695e	1820	}
EricLew	0:80ee8f3b695e	1821	}
EricLew	0:80ee8f3b695e	1822
EricLew	0:80ee8f3b695e	1823	/**
EricLew	0:80ee8f3b695e	1824	* @brief This function allows to stop injected conversion in polling mode.
EricLew	0:80ee8f3b695e	1825	* @note This function should be called only if injected conversion is ongoing.
EricLew	0:80ee8f3b695e	1826	* @param hdfsdm_filter : DFSDM filter handle.
EricLew	0:80ee8f3b695e	1827	* @retval HAL status
EricLew	0:80ee8f3b695e	1828	*/
EricLew	0:80ee8f3b695e	1829	HAL_StatusTypeDef HAL_DFSDM_FilterInjectedStop(DFSDM_Filter_HandleTypeDef *hdfsdm_filter)
EricLew	0:80ee8f3b695e	1830	{
EricLew	0:80ee8f3b695e	1831	HAL_StatusTypeDef status = HAL_OK;
EricLew	0:80ee8f3b695e	1832
EricLew	0:80ee8f3b695e	1833	/* Check parameters */
EricLew	0:80ee8f3b695e	1834	assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance));
EricLew	0:80ee8f3b695e	1835
EricLew	0:80ee8f3b695e	1836	/* Check DFSDM filter state */
EricLew	0:80ee8f3b695e	1837	if((hdfsdm_filter->State != HAL_DFSDM_FILTER_STATE_INJ) && \
EricLew	0:80ee8f3b695e	1838	(hdfsdm_filter->State != HAL_DFSDM_FILTER_STATE_REG_INJ))
EricLew	0:80ee8f3b695e	1839	{
EricLew	0:80ee8f3b695e	1840	/* Return error status */
EricLew	0:80ee8f3b695e	1841	status = HAL_ERROR;
EricLew	0:80ee8f3b695e	1842	}
EricLew	0:80ee8f3b695e	1843	else
EricLew	0:80ee8f3b695e	1844	{
EricLew	0:80ee8f3b695e	1845	/* Stop injected conversion */
EricLew	0:80ee8f3b695e	1846	DFSDM_InjConvStop(hdfsdm_filter);
EricLew	0:80ee8f3b695e	1847	}
EricLew	0:80ee8f3b695e	1848	/* Return function status */
EricLew	0:80ee8f3b695e	1849	return status;
EricLew	0:80ee8f3b695e	1850	}
EricLew	0:80ee8f3b695e	1851
EricLew	0:80ee8f3b695e	1852	/**
EricLew	0:80ee8f3b695e	1853	* @brief This function allows to start injected conversion in interrupt mode.
EricLew	0:80ee8f3b695e	1854	* @note This function should be called only when DFSDM filter instance is
EricLew	0:80ee8f3b695e	1855	* in idle state or if regular conversion is ongoing.
EricLew	0:80ee8f3b695e	1856	* @param hdfsdm_filter : DFSDM filter handle.
EricLew	0:80ee8f3b695e	1857	* @retval HAL status
EricLew	0:80ee8f3b695e	1858	*/
EricLew	0:80ee8f3b695e	1859	HAL_StatusTypeDef HAL_DFSDM_FilterInjectedStart_IT(DFSDM_Filter_HandleTypeDef *hdfsdm_filter)
EricLew	0:80ee8f3b695e	1860	{
EricLew	0:80ee8f3b695e	1861	HAL_StatusTypeDef status = HAL_OK;
EricLew	0:80ee8f3b695e	1862
EricLew	0:80ee8f3b695e	1863	/* Check parameters */
EricLew	0:80ee8f3b695e	1864	assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance));
EricLew	0:80ee8f3b695e	1865
EricLew	0:80ee8f3b695e	1866	/* Check DFSDM filter state */
EricLew	0:80ee8f3b695e	1867	if((hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_READY) \|\| \
EricLew	0:80ee8f3b695e	1868	(hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_REG))
EricLew	0:80ee8f3b695e	1869	{
EricLew	0:80ee8f3b695e	1870	/* Enable interrupts for injected conversions */
EricLew	0:80ee8f3b695e	1871	hdfsdm_filter->Instance->CR2 \|= (DFSDM_CR2_JEOCIE \| DFSDM_CR2_JOVRIE);
EricLew	0:80ee8f3b695e	1872
EricLew	0:80ee8f3b695e	1873	/* Start injected conversion */
EricLew	0:80ee8f3b695e	1874	DFSDM_InjConvStart(hdfsdm_filter);
EricLew	0:80ee8f3b695e	1875	}
EricLew	0:80ee8f3b695e	1876	else
EricLew	0:80ee8f3b695e	1877	{
EricLew	0:80ee8f3b695e	1878	status = HAL_ERROR;
EricLew	0:80ee8f3b695e	1879	}
EricLew	0:80ee8f3b695e	1880	/* Return function status */
EricLew	0:80ee8f3b695e	1881	return status;
EricLew	0:80ee8f3b695e	1882	}
EricLew	0:80ee8f3b695e	1883
EricLew	0:80ee8f3b695e	1884	/**
EricLew	0:80ee8f3b695e	1885	* @brief This function allows to stop injected conversion in interrupt mode.
EricLew	0:80ee8f3b695e	1886	* @note This function should be called only if injected conversion is ongoing.
EricLew	0:80ee8f3b695e	1887	* @param hdfsdm_filter : DFSDM filter handle.
EricLew	0:80ee8f3b695e	1888	* @retval HAL status
EricLew	0:80ee8f3b695e	1889	*/
EricLew	0:80ee8f3b695e	1890	HAL_StatusTypeDef HAL_DFSDM_FilterInjectedStop_IT(DFSDM_Filter_HandleTypeDef *hdfsdm_filter)
EricLew	0:80ee8f3b695e	1891	{
EricLew	0:80ee8f3b695e	1892	HAL_StatusTypeDef status = HAL_OK;
EricLew	0:80ee8f3b695e	1893
EricLew	0:80ee8f3b695e	1894	/* Check parameters */
EricLew	0:80ee8f3b695e	1895	assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance));
EricLew	0:80ee8f3b695e	1896
EricLew	0:80ee8f3b695e	1897	/* Check DFSDM filter state */
EricLew	0:80ee8f3b695e	1898	if((hdfsdm_filter->State != HAL_DFSDM_FILTER_STATE_INJ) && \
EricLew	0:80ee8f3b695e	1899	(hdfsdm_filter->State != HAL_DFSDM_FILTER_STATE_REG_INJ))
EricLew	0:80ee8f3b695e	1900	{
EricLew	0:80ee8f3b695e	1901	/* Return error status */
EricLew	0:80ee8f3b695e	1902	status = HAL_ERROR;
EricLew	0:80ee8f3b695e	1903	}
EricLew	0:80ee8f3b695e	1904	else
EricLew	0:80ee8f3b695e	1905	{
EricLew	0:80ee8f3b695e	1906	/* Disable interrupts for injected conversions */
EricLew	0:80ee8f3b695e	1907	hdfsdm_filter->Instance->CR2 &= ~(DFSDM_CR2_JEOCIE \| DFSDM_CR2_JOVRIE);
EricLew	0:80ee8f3b695e	1908
EricLew	0:80ee8f3b695e	1909	/* Stop injected conversion */
EricLew	0:80ee8f3b695e	1910	DFSDM_InjConvStop(hdfsdm_filter);
EricLew	0:80ee8f3b695e	1911	}
EricLew	0:80ee8f3b695e	1912	/* Return function status */
EricLew	0:80ee8f3b695e	1913	return status;
EricLew	0:80ee8f3b695e	1914	}
EricLew	0:80ee8f3b695e	1915
EricLew	0:80ee8f3b695e	1916	/**
EricLew	0:80ee8f3b695e	1917	* @brief This function allows to start injected conversion in DMA mode.
EricLew	0:80ee8f3b695e	1918	* @note This function should be called only when DFSDM filter instance is
EricLew	0:80ee8f3b695e	1919	* in idle state or if regular conversion is ongoing.
EricLew	0:80ee8f3b695e	1920	* Please note that data on buffer will contain signed injected conversion
EricLew	0:80ee8f3b695e	1921	* value on 24 most significant bits and corresponding channel on 3 least
EricLew	0:80ee8f3b695e	1922	* significant bits.
EricLew	0:80ee8f3b695e	1923	* @param hdfsdm_filter : DFSDM filter handle.
EricLew	0:80ee8f3b695e	1924	* @param pData : The destination buffer address.
EricLew	0:80ee8f3b695e	1925	* @param Length : The length of data to be transferred from DFSDM filter to memory.
EricLew	0:80ee8f3b695e	1926	* @retval HAL status
EricLew	0:80ee8f3b695e	1927	*/
EricLew	0:80ee8f3b695e	1928	HAL_StatusTypeDef HAL_DFSDM_FilterInjectedStart_DMA(DFSDM_Filter_HandleTypeDef *hdfsdm_filter,
EricLew	0:80ee8f3b695e	1929	int32_t *pData,
EricLew	0:80ee8f3b695e	1930	uint32_t Length)
EricLew	0:80ee8f3b695e	1931	{
EricLew	0:80ee8f3b695e	1932	HAL_StatusTypeDef status = HAL_OK;
EricLew	0:80ee8f3b695e	1933
EricLew	0:80ee8f3b695e	1934	/* Check parameters */
EricLew	0:80ee8f3b695e	1935	assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance));
EricLew	0:80ee8f3b695e	1936
EricLew	0:80ee8f3b695e	1937	/* Check destination address and length */
EricLew	0:80ee8f3b695e	1938	if((pData == NULL) \|\| (Length == 0))
EricLew	0:80ee8f3b695e	1939	{
EricLew	0:80ee8f3b695e	1940	status = HAL_ERROR;
EricLew	0:80ee8f3b695e	1941	}
EricLew	0:80ee8f3b695e	1942	/* Check that DMA is enabled for injected conversion */
EricLew	0:80ee8f3b695e	1943	else if((hdfsdm_filter->Instance->CR1 & DFSDM_CR1_JDMAEN) != DFSDM_CR1_JDMAEN)
EricLew	0:80ee8f3b695e	1944	{
EricLew	0:80ee8f3b695e	1945	status = HAL_ERROR;
EricLew	0:80ee8f3b695e	1946	}
EricLew	0:80ee8f3b695e	1947	/* Check parameters compatibility */
EricLew	0:80ee8f3b695e	1948	else if((hdfsdm_filter->InjectedTrigger == DFSDM_FILTER_SW_TRIGGER) && \
EricLew	0:80ee8f3b695e	1949	(hdfsdm_filter->hdmaInj->Init.Mode == DMA_NORMAL) && \
EricLew	0:80ee8f3b695e	1950	(Length > hdfsdm_filter->InjConvRemaining))
EricLew	0:80ee8f3b695e	1951	{
EricLew	0:80ee8f3b695e	1952	status = HAL_ERROR;
EricLew	0:80ee8f3b695e	1953	}
EricLew	0:80ee8f3b695e	1954	else if((hdfsdm_filter->InjectedTrigger == DFSDM_FILTER_SW_TRIGGER) && \
EricLew	0:80ee8f3b695e	1955	(hdfsdm_filter->hdmaInj->Init.Mode == DMA_CIRCULAR))
EricLew	0:80ee8f3b695e	1956	{
EricLew	0:80ee8f3b695e	1957	status = HAL_ERROR;
EricLew	0:80ee8f3b695e	1958	}
EricLew	0:80ee8f3b695e	1959	/* Check DFSDM filter state */
EricLew	0:80ee8f3b695e	1960	else if((hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_READY) \|\| \
EricLew	0:80ee8f3b695e	1961	(hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_REG))
EricLew	0:80ee8f3b695e	1962	{
EricLew	0:80ee8f3b695e	1963	/* Set callbacks on DMA handler */
EricLew	0:80ee8f3b695e	1964	hdfsdm_filter->hdmaInj->XferCpltCallback = DFSDM_DMAInjectedConvCplt;
EricLew	0:80ee8f3b695e	1965	hdfsdm_filter->hdmaInj->XferErrorCallback = DFSDM_DMAError;
EricLew	0:80ee8f3b695e	1966	hdfsdm_filter->hdmaInj->XferHalfCpltCallback = (hdfsdm_filter->hdmaInj->Init.Mode == DMA_CIRCULAR) ?\
EricLew	0:80ee8f3b695e	1967	DFSDM_DMAInjectedHalfConvCplt : NULL;
EricLew	0:80ee8f3b695e	1968
EricLew	0:80ee8f3b695e	1969	/* Start DMA in interrupt mode */
EricLew	0:80ee8f3b695e	1970	if(HAL_DMA_Start_IT(hdfsdm_filter->hdmaInj, (uint32_t)&hdfsdm_filter->Instance->JDATAR, \
EricLew	0:80ee8f3b695e	1971	(uint32_t) pData, Length) != HAL_OK)
EricLew	0:80ee8f3b695e	1972	{
EricLew	0:80ee8f3b695e	1973	/* Set DFSDM filter in error state */
EricLew	0:80ee8f3b695e	1974	hdfsdm_filter->State = HAL_DFSDM_FILTER_STATE_ERROR;
EricLew	0:80ee8f3b695e	1975	status = HAL_ERROR;
EricLew	0:80ee8f3b695e	1976	}
EricLew	0:80ee8f3b695e	1977	else
EricLew	0:80ee8f3b695e	1978	{
EricLew	0:80ee8f3b695e	1979	/* Start injected conversion */
EricLew	0:80ee8f3b695e	1980	DFSDM_InjConvStart(hdfsdm_filter);
EricLew	0:80ee8f3b695e	1981	}
EricLew	0:80ee8f3b695e	1982	}
EricLew	0:80ee8f3b695e	1983	else
EricLew	0:80ee8f3b695e	1984	{
EricLew	0:80ee8f3b695e	1985	status = HAL_ERROR;
EricLew	0:80ee8f3b695e	1986	}
EricLew	0:80ee8f3b695e	1987	/* Return function status */
EricLew	0:80ee8f3b695e	1988	return status;
EricLew	0:80ee8f3b695e	1989	}
EricLew	0:80ee8f3b695e	1990
EricLew	0:80ee8f3b695e	1991	/**
EricLew	0:80ee8f3b695e	1992	* @brief This function allows to start injected conversion in DMA mode and to get
EricLew	0:80ee8f3b695e	1993	* only the 16 most significant bits of conversion.
EricLew	0:80ee8f3b695e	1994	* @note This function should be called only when DFSDM filter instance is
EricLew	0:80ee8f3b695e	1995	* in idle state or if regular conversion is ongoing.
EricLew	0:80ee8f3b695e	1996	* Please note that data on buffer will contain signed 16 most significant
EricLew	0:80ee8f3b695e	1997	* bits of injected conversion.
EricLew	0:80ee8f3b695e	1998	* @param hdfsdm_filter : DFSDM filter handle.
EricLew	0:80ee8f3b695e	1999	* @param pData : The destination buffer address.
EricLew	0:80ee8f3b695e	2000	* @param Length : The length of data to be transferred from DFSDM filter to memory.
EricLew	0:80ee8f3b695e	2001	* @retval HAL status
EricLew	0:80ee8f3b695e	2002	*/
EricLew	0:80ee8f3b695e	2003	HAL_StatusTypeDef HAL_DFSDM_FilterInjectedMsbStart_DMA(DFSDM_Filter_HandleTypeDef *hdfsdm_filter,
EricLew	0:80ee8f3b695e	2004	int16_t *pData,
EricLew	0:80ee8f3b695e	2005	uint32_t Length)
EricLew	0:80ee8f3b695e	2006	{
EricLew	0:80ee8f3b695e	2007	HAL_StatusTypeDef status = HAL_OK;
EricLew	0:80ee8f3b695e	2008
EricLew	0:80ee8f3b695e	2009	/* Check parameters */
EricLew	0:80ee8f3b695e	2010	assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance));
EricLew	0:80ee8f3b695e	2011
EricLew	0:80ee8f3b695e	2012	/* Check destination address and length */
EricLew	0:80ee8f3b695e	2013	if((pData == NULL) \|\| (Length == 0))
EricLew	0:80ee8f3b695e	2014	{
EricLew	0:80ee8f3b695e	2015	status = HAL_ERROR;
EricLew	0:80ee8f3b695e	2016	}
EricLew	0:80ee8f3b695e	2017	/* Check that DMA is enabled for injected conversion */
EricLew	0:80ee8f3b695e	2018	else if((hdfsdm_filter->Instance->CR1 & DFSDM_CR1_JDMAEN) != DFSDM_CR1_JDMAEN)
EricLew	0:80ee8f3b695e	2019	{
EricLew	0:80ee8f3b695e	2020	status = HAL_ERROR;
EricLew	0:80ee8f3b695e	2021	}
EricLew	0:80ee8f3b695e	2022	/* Check parameters compatibility */
EricLew	0:80ee8f3b695e	2023	else if((hdfsdm_filter->InjectedTrigger == DFSDM_FILTER_SW_TRIGGER) && \
EricLew	0:80ee8f3b695e	2024	(hdfsdm_filter->hdmaInj->Init.Mode == DMA_NORMAL) && \
EricLew	0:80ee8f3b695e	2025	(Length > hdfsdm_filter->InjConvRemaining))
EricLew	0:80ee8f3b695e	2026	{
EricLew	0:80ee8f3b695e	2027	status = HAL_ERROR;
EricLew	0:80ee8f3b695e	2028	}
EricLew	0:80ee8f3b695e	2029	else if((hdfsdm_filter->InjectedTrigger == DFSDM_FILTER_SW_TRIGGER) && \
EricLew	0:80ee8f3b695e	2030	(hdfsdm_filter->hdmaInj->Init.Mode == DMA_CIRCULAR))
EricLew	0:80ee8f3b695e	2031	{
EricLew	0:80ee8f3b695e	2032	status = HAL_ERROR;
EricLew	0:80ee8f3b695e	2033	}
EricLew	0:80ee8f3b695e	2034	/* Check DFSDM filter state */
EricLew	0:80ee8f3b695e	2035	else if((hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_READY) \|\| \
EricLew	0:80ee8f3b695e	2036	(hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_REG))
EricLew	0:80ee8f3b695e	2037	{
EricLew	0:80ee8f3b695e	2038	/* Set callbacks on DMA handler */
EricLew	0:80ee8f3b695e	2039	hdfsdm_filter->hdmaInj->XferCpltCallback = DFSDM_DMAInjectedConvCplt;
EricLew	0:80ee8f3b695e	2040	hdfsdm_filter->hdmaInj->XferErrorCallback = DFSDM_DMAError;
EricLew	0:80ee8f3b695e	2041	hdfsdm_filter->hdmaInj->XferHalfCpltCallback = (hdfsdm_filter->hdmaInj->Init.Mode == DMA_CIRCULAR) ?\
EricLew	0:80ee8f3b695e	2042	DFSDM_DMAInjectedHalfConvCplt : NULL;
EricLew	0:80ee8f3b695e	2043
EricLew	0:80ee8f3b695e	2044	/* Start DMA in interrupt mode */
EricLew	0:80ee8f3b695e	2045	if(HAL_DMA_Start_IT(hdfsdm_filter->hdmaInj, (uint32_t)(&hdfsdm_filter->Instance->JDATAR) + 2, \
EricLew	0:80ee8f3b695e	2046	(uint32_t) pData, Length) != HAL_OK)
EricLew	0:80ee8f3b695e	2047	{
EricLew	0:80ee8f3b695e	2048	/* Set DFSDM filter in error state */
EricLew	0:80ee8f3b695e	2049	hdfsdm_filter->State = HAL_DFSDM_FILTER_STATE_ERROR;
EricLew	0:80ee8f3b695e	2050	status = HAL_ERROR;
EricLew	0:80ee8f3b695e	2051	}
EricLew	0:80ee8f3b695e	2052	else
EricLew	0:80ee8f3b695e	2053	{
EricLew	0:80ee8f3b695e	2054	/* Start injected conversion */
EricLew	0:80ee8f3b695e	2055	DFSDM_InjConvStart(hdfsdm_filter);
EricLew	0:80ee8f3b695e	2056	}
EricLew	0:80ee8f3b695e	2057	}
EricLew	0:80ee8f3b695e	2058	else
EricLew	0:80ee8f3b695e	2059	{
EricLew	0:80ee8f3b695e	2060	status = HAL_ERROR;
EricLew	0:80ee8f3b695e	2061	}
EricLew	0:80ee8f3b695e	2062	/* Return function status */
EricLew	0:80ee8f3b695e	2063	return status;
EricLew	0:80ee8f3b695e	2064	}
EricLew	0:80ee8f3b695e	2065
EricLew	0:80ee8f3b695e	2066	/**
EricLew	0:80ee8f3b695e	2067	* @brief This function allows to stop injected conversion in DMA mode.
EricLew	0:80ee8f3b695e	2068	* @note This function should be called only if injected conversion is ongoing.
EricLew	0:80ee8f3b695e	2069	* @param hdfsdm_filter : DFSDM filter handle.
EricLew	0:80ee8f3b695e	2070	* @retval HAL status
EricLew	0:80ee8f3b695e	2071	*/
EricLew	0:80ee8f3b695e	2072	HAL_StatusTypeDef HAL_DFSDM_FilterInjectedStop_DMA(DFSDM_Filter_HandleTypeDef *hdfsdm_filter)
EricLew	0:80ee8f3b695e	2073	{
EricLew	0:80ee8f3b695e	2074	HAL_StatusTypeDef status = HAL_OK;
EricLew	0:80ee8f3b695e	2075
EricLew	0:80ee8f3b695e	2076	/* Check parameters */
EricLew	0:80ee8f3b695e	2077	assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance));
EricLew	0:80ee8f3b695e	2078
EricLew	0:80ee8f3b695e	2079	/* Check DFSDM filter state */
EricLew	0:80ee8f3b695e	2080	if((hdfsdm_filter->State != HAL_DFSDM_FILTER_STATE_INJ) && \
EricLew	0:80ee8f3b695e	2081	(hdfsdm_filter->State != HAL_DFSDM_FILTER_STATE_REG_INJ))
EricLew	0:80ee8f3b695e	2082	{
EricLew	0:80ee8f3b695e	2083	/* Return error status */
EricLew	0:80ee8f3b695e	2084	status = HAL_ERROR;
EricLew	0:80ee8f3b695e	2085	}
EricLew	0:80ee8f3b695e	2086	else
EricLew	0:80ee8f3b695e	2087	{
EricLew	0:80ee8f3b695e	2088	/* Stop current DMA transfer */
EricLew	0:80ee8f3b695e	2089	if(HAL_DMA_Abort(hdfsdm_filter->hdmaInj) != HAL_OK)
EricLew	0:80ee8f3b695e	2090	{
EricLew	0:80ee8f3b695e	2091	/* Set DFSDM filter in error state */
EricLew	0:80ee8f3b695e	2092	hdfsdm_filter->State = HAL_DFSDM_FILTER_STATE_ERROR;
EricLew	0:80ee8f3b695e	2093	status = HAL_ERROR;
EricLew	0:80ee8f3b695e	2094	}
EricLew	0:80ee8f3b695e	2095	else
EricLew	0:80ee8f3b695e	2096	{
EricLew	0:80ee8f3b695e	2097	/* Stop regular conversion */
EricLew	0:80ee8f3b695e	2098	DFSDM_InjConvStop(hdfsdm_filter);
EricLew	0:80ee8f3b695e	2099	}
EricLew	0:80ee8f3b695e	2100	}
EricLew	0:80ee8f3b695e	2101	/* Return function status */
EricLew	0:80ee8f3b695e	2102	return status;
EricLew	0:80ee8f3b695e	2103	}
EricLew	0:80ee8f3b695e	2104
EricLew	0:80ee8f3b695e	2105	/**
EricLew	0:80ee8f3b695e	2106	* @brief This function allows to get injected conversion value.
EricLew	0:80ee8f3b695e	2107	* @param hdfsdm_filter : DFSDM filter handle.
EricLew	0:80ee8f3b695e	2108	* @param Channel : Corresponding channel of injected conversion.
EricLew	0:80ee8f3b695e	2109	* @retval Injected conversion value
EricLew	0:80ee8f3b695e	2110	*/
EricLew	0:80ee8f3b695e	2111	int32_t HAL_DFSDM_FilterGetInjectedValue(DFSDM_Filter_HandleTypeDef *hdfsdm_filter,
EricLew	0:80ee8f3b695e	2112	uint32_t *Channel)
EricLew	0:80ee8f3b695e	2113	{
EricLew	0:80ee8f3b695e	2114	uint32_t reg = 0;
EricLew	0:80ee8f3b695e	2115	int32_t value = 0;
EricLew	0:80ee8f3b695e	2116
EricLew	0:80ee8f3b695e	2117	/* Check parameters */
EricLew	0:80ee8f3b695e	2118	assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance));
EricLew	0:80ee8f3b695e	2119	assert_param(Channel != NULL);
EricLew	0:80ee8f3b695e	2120
EricLew	0:80ee8f3b695e	2121	/* Get value of data register for injected channel */
EricLew	0:80ee8f3b695e	2122	reg = hdfsdm_filter->Instance->JDATAR;
EricLew	0:80ee8f3b695e	2123
EricLew	0:80ee8f3b695e	2124	/* Extract channel and injected conversion value */
EricLew	0:80ee8f3b695e	2125	*Channel = (reg & DFSDM_JDATAR_JDATACH);
EricLew	0:80ee8f3b695e	2126	value = ((int32_t)(reg & DFSDM_JDATAR_JDATA) >> DFSDM_JDATAR_DATA_OFFSET);
EricLew	0:80ee8f3b695e	2127
EricLew	0:80ee8f3b695e	2128	/* return regular conversion value */
EricLew	0:80ee8f3b695e	2129	return value;
EricLew	0:80ee8f3b695e	2130	}
EricLew	0:80ee8f3b695e	2131
EricLew	0:80ee8f3b695e	2132	/**
EricLew	0:80ee8f3b695e	2133	* @brief This function allows to start filter analog watchdog in interrupt mode.
EricLew	0:80ee8f3b695e	2134	* @param hdfsdm_filter : DFSDM filter handle.
EricLew	0:80ee8f3b695e	2135	* @param awdParam : DFSDM filter analog watchdog parameters.
EricLew	0:80ee8f3b695e	2136	* @retval HAL status
EricLew	0:80ee8f3b695e	2137	*/
EricLew	0:80ee8f3b695e	2138	HAL_StatusTypeDef HAL_DFSDM_FilterAwdStart_IT(DFSDM_Filter_HandleTypeDef *hdfsdm_filter,
EricLew	0:80ee8f3b695e	2139	DFSDM_Filter_AwdParamTypeDef *awdParam)
EricLew	0:80ee8f3b695e	2140	{
EricLew	0:80ee8f3b695e	2141	HAL_StatusTypeDef status = HAL_OK;
EricLew	0:80ee8f3b695e	2142
EricLew	0:80ee8f3b695e	2143	/* Check parameters */
EricLew	0:80ee8f3b695e	2144	assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance));
EricLew	0:80ee8f3b695e	2145	assert_param(IS_DFSDM_FILTER_AWD_DATA_SOURCE(awdParam->DataSource));
EricLew	0:80ee8f3b695e	2146	assert_param(IS_DFSDM_INJECTED_CHANNEL(awdParam->Channel));
EricLew	0:80ee8f3b695e	2147	assert_param(IS_DFSDM_FILTER_AWD_THRESHOLD(awdParam->HighThreshold));
EricLew	0:80ee8f3b695e	2148	assert_param(IS_DFSDM_FILTER_AWD_THRESHOLD(awdParam->LowThreshold));
EricLew	0:80ee8f3b695e	2149	assert_param(IS_DFSDM_BREAK_SIGNALS(awdParam->HighBreakSignal));
EricLew	0:80ee8f3b695e	2150	assert_param(IS_DFSDM_BREAK_SIGNALS(awdParam->LowBreakSignal));
EricLew	0:80ee8f3b695e	2151
EricLew	0:80ee8f3b695e	2152	/* Check DFSDM filter state */
EricLew	0:80ee8f3b695e	2153	if((hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_RESET) \|\| \
EricLew	0:80ee8f3b695e	2154	(hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_ERROR))
EricLew	0:80ee8f3b695e	2155	{
EricLew	0:80ee8f3b695e	2156	/* Return error status */
EricLew	0:80ee8f3b695e	2157	status = HAL_ERROR;
EricLew	0:80ee8f3b695e	2158	}
EricLew	0:80ee8f3b695e	2159	else
EricLew	0:80ee8f3b695e	2160	{
EricLew	0:80ee8f3b695e	2161	/* Set analog watchdog data source */
EricLew	0:80ee8f3b695e	2162	hdfsdm_filter->Instance->CR1 &= ~(DFSDM_CR1_AWFSEL);
EricLew	0:80ee8f3b695e	2163	hdfsdm_filter->Instance->CR1 \|= awdParam->DataSource;
EricLew	0:80ee8f3b695e	2164
EricLew	0:80ee8f3b695e	2165	/* Set thresholds and break signals */
EricLew	0:80ee8f3b695e	2166	hdfsdm_filter->Instance->AWHTR &= ~(DFSDM_AWHTR_AWHT \| DFSDM_AWHTR_BKAWH);
EricLew	0:80ee8f3b695e	2167	hdfsdm_filter->Instance->AWHTR \|= ((awdParam->HighThreshold << DFSDM_AWHTR_THRESHOLD_OFFSET) \| \
EricLew	0:80ee8f3b695e	2168	awdParam->HighBreakSignal);
EricLew	0:80ee8f3b695e	2169	hdfsdm_filter->Instance->AWLTR &= ~(DFSDM_AWLTR_AWLT \| DFSDM_AWLTR_BKAWL);
EricLew	0:80ee8f3b695e	2170	hdfsdm_filter->Instance->AWLTR \|= ((awdParam->LowThreshold << DFSDM_AWLTR_THRESHOLD_OFFSET) \| \
EricLew	0:80ee8f3b695e	2171	awdParam->LowBreakSignal);
EricLew	0:80ee8f3b695e	2172
EricLew	0:80ee8f3b695e	2173	/* Set channels and interrupt for analog watchdog */
EricLew	0:80ee8f3b695e	2174	hdfsdm_filter->Instance->CR2 &= ~(DFSDM_CR2_AWDCH);
EricLew	0:80ee8f3b695e	2175	hdfsdm_filter->Instance->CR2 \|= (((awdParam->Channel & DFSDM_LSB_MASK) << DFSDM_CR2_AWDCH_OFFSET) \| \
EricLew	0:80ee8f3b695e	2176	DFSDM_CR2_AWDIE);
EricLew	0:80ee8f3b695e	2177	}
EricLew	0:80ee8f3b695e	2178	/* Return function status */
EricLew	0:80ee8f3b695e	2179	return status;
EricLew	0:80ee8f3b695e	2180	}
EricLew	0:80ee8f3b695e	2181
EricLew	0:80ee8f3b695e	2182	/**
EricLew	0:80ee8f3b695e	2183	* @brief This function allows to stop filter analog watchdog in interrupt mode.
EricLew	0:80ee8f3b695e	2184	* @param hdfsdm_filter : DFSDM filter handle.
EricLew	0:80ee8f3b695e	2185	* @retval HAL status
EricLew	0:80ee8f3b695e	2186	*/
EricLew	0:80ee8f3b695e	2187	HAL_StatusTypeDef HAL_DFSDM_FilterAwdStop_IT(DFSDM_Filter_HandleTypeDef *hdfsdm_filter)
EricLew	0:80ee8f3b695e	2188	{
EricLew	0:80ee8f3b695e	2189	HAL_StatusTypeDef status = HAL_OK;
EricLew	0:80ee8f3b695e	2190
EricLew	0:80ee8f3b695e	2191	/* Check parameters */
EricLew	0:80ee8f3b695e	2192	assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance));
EricLew	0:80ee8f3b695e	2193
EricLew	0:80ee8f3b695e	2194	/* Check DFSDM filter state */
EricLew	0:80ee8f3b695e	2195	if((hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_RESET) \|\| \
EricLew	0:80ee8f3b695e	2196	(hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_ERROR))
EricLew	0:80ee8f3b695e	2197	{
EricLew	0:80ee8f3b695e	2198	/* Return error status */
EricLew	0:80ee8f3b695e	2199	status = HAL_ERROR;
EricLew	0:80ee8f3b695e	2200	}
EricLew	0:80ee8f3b695e	2201	else
EricLew	0:80ee8f3b695e	2202	{
EricLew	0:80ee8f3b695e	2203	/* Reset channels for analog watchdog and deactivate interrupt */
EricLew	0:80ee8f3b695e	2204	hdfsdm_filter->Instance->CR2 &= ~(DFSDM_CR2_AWDCH \| DFSDM_CR2_AWDIE);
EricLew	0:80ee8f3b695e	2205
EricLew	0:80ee8f3b695e	2206	/* Clear all analog watchdog flags */
EricLew	0:80ee8f3b695e	2207	hdfsdm_filter->Instance->AWCFR = (DFSDM_AWCFR_CLRAWHTF \| DFSDM_AWCFR_CLRAWLTF);
EricLew	0:80ee8f3b695e	2208
EricLew	0:80ee8f3b695e	2209	/* Reset thresholds and break signals */
EricLew	0:80ee8f3b695e	2210	hdfsdm_filter->Instance->AWHTR &= ~(DFSDM_AWHTR_AWHT \| DFSDM_AWHTR_BKAWH);
EricLew	0:80ee8f3b695e	2211	hdfsdm_filter->Instance->AWLTR &= ~(DFSDM_AWLTR_AWLT \| DFSDM_AWLTR_BKAWL);
EricLew	0:80ee8f3b695e	2212
EricLew	0:80ee8f3b695e	2213	/* Reset analog watchdog data source */
EricLew	0:80ee8f3b695e	2214	hdfsdm_filter->Instance->CR1 &= ~(DFSDM_CR1_AWFSEL);
EricLew	0:80ee8f3b695e	2215	}
EricLew	0:80ee8f3b695e	2216	/* Return function status */
EricLew	0:80ee8f3b695e	2217	return status;
EricLew	0:80ee8f3b695e	2218	}
EricLew	0:80ee8f3b695e	2219
EricLew	0:80ee8f3b695e	2220	/**
EricLew	0:80ee8f3b695e	2221	* @brief This function allows to start extreme detector feature.
EricLew	0:80ee8f3b695e	2222	* @param hdfsdm_filter : DFSDM filter handle.
EricLew	0:80ee8f3b695e	2223	* @param Channel : Channels where extreme detector is enabled.
EricLew	0:80ee8f3b695e	2224	* This parameter can be a values combination of @ref DFSDM_Channel_Selection.
EricLew	0:80ee8f3b695e	2225	* @retval HAL status
EricLew	0:80ee8f3b695e	2226	*/
EricLew	0:80ee8f3b695e	2227	HAL_StatusTypeDef HAL_DFSDM_FilterExdStart(DFSDM_Filter_HandleTypeDef *hdfsdm_filter,
EricLew	0:80ee8f3b695e	2228	uint32_t Channel)
EricLew	0:80ee8f3b695e	2229	{
EricLew	0:80ee8f3b695e	2230	HAL_StatusTypeDef status = HAL_OK;
EricLew	0:80ee8f3b695e	2231
EricLew	0:80ee8f3b695e	2232	/* Check parameters */
EricLew	0:80ee8f3b695e	2233	assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance));
EricLew	0:80ee8f3b695e	2234	assert_param(IS_DFSDM_INJECTED_CHANNEL(Channel));
EricLew	0:80ee8f3b695e	2235
EricLew	0:80ee8f3b695e	2236	/* Check DFSDM filter state */
EricLew	0:80ee8f3b695e	2237	if((hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_RESET) \|\| \
EricLew	0:80ee8f3b695e	2238	(hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_ERROR))
EricLew	0:80ee8f3b695e	2239	{
EricLew	0:80ee8f3b695e	2240	/* Return error status */
EricLew	0:80ee8f3b695e	2241	status = HAL_ERROR;
EricLew	0:80ee8f3b695e	2242	}
EricLew	0:80ee8f3b695e	2243	else
EricLew	0:80ee8f3b695e	2244	{
EricLew	0:80ee8f3b695e	2245	/* Set channels for extreme detector */
EricLew	0:80ee8f3b695e	2246	hdfsdm_filter->Instance->CR2 &= ~(DFSDM_CR2_EXCH);
EricLew	0:80ee8f3b695e	2247	hdfsdm_filter->Instance->CR2 \|= ((Channel & DFSDM_LSB_MASK) << DFSDM_CR2_EXCH_OFFSET);
EricLew	0:80ee8f3b695e	2248	}
EricLew	0:80ee8f3b695e	2249	/* Return function status */
EricLew	0:80ee8f3b695e	2250	return status;
EricLew	0:80ee8f3b695e	2251	}
EricLew	0:80ee8f3b695e	2252
EricLew	0:80ee8f3b695e	2253	/**
EricLew	0:80ee8f3b695e	2254	* @brief This function allows to stop extreme detector feature.
EricLew	0:80ee8f3b695e	2255	* @param hdfsdm_filter : DFSDM filter handle.
EricLew	0:80ee8f3b695e	2256	* @retval HAL status
EricLew	0:80ee8f3b695e	2257	*/
EricLew	0:80ee8f3b695e	2258	HAL_StatusTypeDef HAL_DFSDM_FilterExdStop(DFSDM_Filter_HandleTypeDef *hdfsdm_filter)
EricLew	0:80ee8f3b695e	2259	{
EricLew	0:80ee8f3b695e	2260	HAL_StatusTypeDef status = HAL_OK;
EricLew	0:80ee8f3b695e	2261	__IO uint32_t reg;
EricLew	0:80ee8f3b695e	2262
EricLew	0:80ee8f3b695e	2263	/* Check parameters */
EricLew	0:80ee8f3b695e	2264	assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance));
EricLew	0:80ee8f3b695e	2265
EricLew	0:80ee8f3b695e	2266	/* Check DFSDM filter state */
EricLew	0:80ee8f3b695e	2267	if((hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_RESET) \|\| \
EricLew	0:80ee8f3b695e	2268	(hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_ERROR))
EricLew	0:80ee8f3b695e	2269	{
EricLew	0:80ee8f3b695e	2270	/* Return error status */
EricLew	0:80ee8f3b695e	2271	status = HAL_ERROR;
EricLew	0:80ee8f3b695e	2272	}
EricLew	0:80ee8f3b695e	2273	else
EricLew	0:80ee8f3b695e	2274	{
EricLew	0:80ee8f3b695e	2275	/* Reset channels for extreme detector */
EricLew	0:80ee8f3b695e	2276	hdfsdm_filter->Instance->CR2 &= ~(DFSDM_CR2_EXCH);
EricLew	0:80ee8f3b695e	2277
EricLew	0:80ee8f3b695e	2278	/* Clear extreme detector values */
EricLew	0:80ee8f3b695e	2279	reg = hdfsdm_filter->Instance->EXMAX;
EricLew	0:80ee8f3b695e	2280	reg = hdfsdm_filter->Instance->EXMIN;
EricLew	0:80ee8f3b695e	2281	UNUSED(reg); /* To avoid GCC warning */
EricLew	0:80ee8f3b695e	2282	}
EricLew	0:80ee8f3b695e	2283	/* Return function status */
EricLew	0:80ee8f3b695e	2284	return status;
EricLew	0:80ee8f3b695e	2285	}
EricLew	0:80ee8f3b695e	2286
EricLew	0:80ee8f3b695e	2287	/**
EricLew	0:80ee8f3b695e	2288	* @brief This function allows to get extreme detector maximum value.
EricLew	0:80ee8f3b695e	2289	* @param hdfsdm_filter : DFSDM filter handle.
EricLew	0:80ee8f3b695e	2290	* @param Channel : Corresponding channel.
EricLew	0:80ee8f3b695e	2291	* @retval Extreme detector maximum value
EricLew	0:80ee8f3b695e	2292	* This value is between Min_Data = -8388608 and Max_Data = 8388607.
EricLew	0:80ee8f3b695e	2293	*/
EricLew	0:80ee8f3b695e	2294	int32_t HAL_DFSDM_FilterGetExdMaxValue(DFSDM_Filter_HandleTypeDef *hdfsdm_filter,
EricLew	0:80ee8f3b695e	2295	uint32_t *Channel)
EricLew	0:80ee8f3b695e	2296	{
EricLew	0:80ee8f3b695e	2297	uint32_t reg = 0;
EricLew	0:80ee8f3b695e	2298	int32_t value = 0;
EricLew	0:80ee8f3b695e	2299
EricLew	0:80ee8f3b695e	2300	/* Check parameters */
EricLew	0:80ee8f3b695e	2301	assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance));
EricLew	0:80ee8f3b695e	2302	assert_param(Channel != NULL);
EricLew	0:80ee8f3b695e	2303
EricLew	0:80ee8f3b695e	2304	/* Get value of extreme detector maximum register */
EricLew	0:80ee8f3b695e	2305	reg = hdfsdm_filter->Instance->EXMAX;
EricLew	0:80ee8f3b695e	2306
EricLew	0:80ee8f3b695e	2307	/* Extract channel and extreme detector maximum value */
EricLew	0:80ee8f3b695e	2308	*Channel = (reg & DFSDM_EXMAX_EXMAXCH);
EricLew	0:80ee8f3b695e	2309	value = ((int32_t)(reg & DFSDM_EXMAX_EXMAX) >> DFSDM_EXMAX_DATA_OFFSET);
EricLew	0:80ee8f3b695e	2310
EricLew	0:80ee8f3b695e	2311	/* return extreme detector maximum value */
EricLew	0:80ee8f3b695e	2312	return value;
EricLew	0:80ee8f3b695e	2313	}
EricLew	0:80ee8f3b695e	2314
EricLew	0:80ee8f3b695e	2315	/**
EricLew	0:80ee8f3b695e	2316	* @brief This function allows to get extreme detector minimum value.
EricLew	0:80ee8f3b695e	2317	* @param hdfsdm_filter : DFSDM filter handle.
EricLew	0:80ee8f3b695e	2318	* @param Channel : Corresponding channel.
EricLew	0:80ee8f3b695e	2319	* @retval Extreme detector minimum value
EricLew	0:80ee8f3b695e	2320	* This value is between Min_Data = -8388608 and Max_Data = 8388607.
EricLew	0:80ee8f3b695e	2321	*/
EricLew	0:80ee8f3b695e	2322	int32_t HAL_DFSDM_FilterGetExdMinValue(DFSDM_Filter_HandleTypeDef *hdfsdm_filter,
EricLew	0:80ee8f3b695e	2323	uint32_t *Channel)
EricLew	0:80ee8f3b695e	2324	{
EricLew	0:80ee8f3b695e	2325	uint32_t reg = 0;
EricLew	0:80ee8f3b695e	2326	int32_t value = 0;
EricLew	0:80ee8f3b695e	2327
EricLew	0:80ee8f3b695e	2328	/* Check parameters */
EricLew	0:80ee8f3b695e	2329	assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance));
EricLew	0:80ee8f3b695e	2330	assert_param(Channel != NULL);
EricLew	0:80ee8f3b695e	2331
EricLew	0:80ee8f3b695e	2332	/* Get value of extreme detector minimum register */
EricLew	0:80ee8f3b695e	2333	reg = hdfsdm_filter->Instance->EXMIN;
EricLew	0:80ee8f3b695e	2334
EricLew	0:80ee8f3b695e	2335	/* Extract channel and extreme detector minimum value */
EricLew	0:80ee8f3b695e	2336	*Channel = (reg & DFSDM_EXMIN_EXMINCH);
EricLew	0:80ee8f3b695e	2337	value = ((int32_t)(reg & DFSDM_EXMIN_EXMIN) >> DFSDM_EXMIN_DATA_OFFSET);
EricLew	0:80ee8f3b695e	2338
EricLew	0:80ee8f3b695e	2339	/* return extreme detector minimum value */
EricLew	0:80ee8f3b695e	2340	return value;
EricLew	0:80ee8f3b695e	2341	}
EricLew	0:80ee8f3b695e	2342
EricLew	0:80ee8f3b695e	2343	/**
EricLew	0:80ee8f3b695e	2344	* @brief This function allows to get conversion time value.
EricLew	0:80ee8f3b695e	2345	* @param hdfsdm_filter : DFSDM filter handle.
EricLew	0:80ee8f3b695e	2346	* @retval Conversion time value
EricLew	0:80ee8f3b695e	2347	* @note To get time in second, this value has to be divided by DFSDM clock frequency.
EricLew	0:80ee8f3b695e	2348	*/
EricLew	0:80ee8f3b695e	2349	uint32_t HAL_DFSDM_FilterGetConvTimeValue(DFSDM_Filter_HandleTypeDef *hdfsdm_filter)
EricLew	0:80ee8f3b695e	2350	{
EricLew	0:80ee8f3b695e	2351	uint32_t reg = 0;
EricLew	0:80ee8f3b695e	2352	uint32_t value = 0;
EricLew	0:80ee8f3b695e	2353
EricLew	0:80ee8f3b695e	2354	/* Check parameters */
EricLew	0:80ee8f3b695e	2355	assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance));
EricLew	0:80ee8f3b695e	2356
EricLew	0:80ee8f3b695e	2357	/* Get value of conversion timer register */
EricLew	0:80ee8f3b695e	2358	reg = hdfsdm_filter->Instance->CNVTIMR;
EricLew	0:80ee8f3b695e	2359
EricLew	0:80ee8f3b695e	2360	/* Extract conversion time value */
EricLew	0:80ee8f3b695e	2361	value = ((reg & DFSDM_CNVTIMR_CNVCNT) >> DFSDM_CNVTIMR_DATA_OFFSET);
EricLew	0:80ee8f3b695e	2362
EricLew	0:80ee8f3b695e	2363	/* return extreme detector minimum value */
EricLew	0:80ee8f3b695e	2364	return value;
EricLew	0:80ee8f3b695e	2365	}
EricLew	0:80ee8f3b695e	2366
EricLew	0:80ee8f3b695e	2367	/**
EricLew	0:80ee8f3b695e	2368	* @brief This function handles the DFSDM interrupts.
EricLew	0:80ee8f3b695e	2369	* @param hdfsdm_filter : DFSDM filter handle.
EricLew	0:80ee8f3b695e	2370	* @retval None
EricLew	0:80ee8f3b695e	2371	*/
EricLew	0:80ee8f3b695e	2372	void HAL_DFSDM_IRQHandler(DFSDM_Filter_HandleTypeDef *hdfsdm_filter)
EricLew	0:80ee8f3b695e	2373	{
EricLew	0:80ee8f3b695e	2374	/* Check if overrun occurs during regular conversion */
EricLew	0:80ee8f3b695e	2375	if(((hdfsdm_filter->Instance->ISR & DFSDM_ISR_ROVRF) != 0) && \
EricLew	0:80ee8f3b695e	2376	((hdfsdm_filter->Instance->CR2 & DFSDM_CR2_ROVRIE) != 0))
EricLew	0:80ee8f3b695e	2377	{
EricLew	0:80ee8f3b695e	2378	/* Clear regular overrun flag */
EricLew	0:80ee8f3b695e	2379	hdfsdm_filter->Instance->ICR = DFSDM_ICR_CLRROVRF;
EricLew	0:80ee8f3b695e	2380
EricLew	0:80ee8f3b695e	2381	/* Update error code */
EricLew	0:80ee8f3b695e	2382	hdfsdm_filter->ErrorCode = DFSDM_FILTER_ERROR_REGULAR_OVERRUN;
EricLew	0:80ee8f3b695e	2383
EricLew	0:80ee8f3b695e	2384	/* Call error callback */
EricLew	0:80ee8f3b695e	2385	HAL_DFSDM_FilterErrorCallback(hdfsdm_filter);
EricLew	0:80ee8f3b695e	2386	}
EricLew	0:80ee8f3b695e	2387	/* Check if overrun occurs during injected conversion */
EricLew	0:80ee8f3b695e	2388	else if(((hdfsdm_filter->Instance->ISR & DFSDM_ISR_JOVRF) != 0) && \
EricLew	0:80ee8f3b695e	2389	((hdfsdm_filter->Instance->CR2 & DFSDM_CR2_JOVRIE) != 0))
EricLew	0:80ee8f3b695e	2390	{
EricLew	0:80ee8f3b695e	2391	/* Clear injected overrun flag */
EricLew	0:80ee8f3b695e	2392	hdfsdm_filter->Instance->ICR = DFSDM_ICR_CLRJOVRF;
EricLew	0:80ee8f3b695e	2393
EricLew	0:80ee8f3b695e	2394	/* Update error code */
EricLew	0:80ee8f3b695e	2395	hdfsdm_filter->ErrorCode = DFSDM_FILTER_ERROR_INJECTED_OVERRUN;
EricLew	0:80ee8f3b695e	2396
EricLew	0:80ee8f3b695e	2397	/* Call error callback */
EricLew	0:80ee8f3b695e	2398	HAL_DFSDM_FilterErrorCallback(hdfsdm_filter);
EricLew	0:80ee8f3b695e	2399	}
EricLew	0:80ee8f3b695e	2400	/* Check if end of regular conversion */
EricLew	0:80ee8f3b695e	2401	else if(((hdfsdm_filter->Instance->ISR & DFSDM_ISR_REOCF) != 0) && \
EricLew	0:80ee8f3b695e	2402	((hdfsdm_filter->Instance->CR2 & DFSDM_CR2_REOCIE) != 0))
EricLew	0:80ee8f3b695e	2403	{
EricLew	0:80ee8f3b695e	2404	/* Call regular conversion complete callback */
EricLew	0:80ee8f3b695e	2405	HAL_DFSDM_FilterRegConvCpltCallback(hdfsdm_filter);
EricLew	0:80ee8f3b695e	2406
EricLew	0:80ee8f3b695e	2407	/* End of conversion if mode is not continuous and software trigger */
EricLew	0:80ee8f3b695e	2408	if((hdfsdm_filter->RegularContMode == DFSDM_CONTINUOUS_CONV_OFF) && \
EricLew	0:80ee8f3b695e	2409	(hdfsdm_filter->RegularTrigger == DFSDM_FILTER_SW_TRIGGER))
EricLew	0:80ee8f3b695e	2410	{
EricLew	0:80ee8f3b695e	2411	/* Disable interrupts for regular conversions */
EricLew	0:80ee8f3b695e	2412	hdfsdm_filter->Instance->CR2 &= ~(DFSDM_CR2_REOCIE);
EricLew	0:80ee8f3b695e	2413
EricLew	0:80ee8f3b695e	2414	/* Update DFSDM filter state */
EricLew	0:80ee8f3b695e	2415	hdfsdm_filter->State = (hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_REG) ? \
EricLew	0:80ee8f3b695e	2416	HAL_DFSDM_FILTER_STATE_READY : HAL_DFSDM_FILTER_STATE_INJ;
EricLew	0:80ee8f3b695e	2417	}
EricLew	0:80ee8f3b695e	2418	}
EricLew	0:80ee8f3b695e	2419	/* Check if end of injected conversion */
EricLew	0:80ee8f3b695e	2420	else if(((hdfsdm_filter->Instance->ISR & DFSDM_ISR_JEOCF) != 0) && \
EricLew	0:80ee8f3b695e	2421	((hdfsdm_filter->Instance->CR2 & DFSDM_CR2_JEOCIE) != 0))
EricLew	0:80ee8f3b695e	2422	{
EricLew	0:80ee8f3b695e	2423	/* Call injected conversion complete callback */
EricLew	0:80ee8f3b695e	2424	HAL_DFSDM_FilterInjConvCpltCallback(hdfsdm_filter);
EricLew	0:80ee8f3b695e	2425
EricLew	0:80ee8f3b695e	2426	/* Update remaining injected conversions */
EricLew	0:80ee8f3b695e	2427	hdfsdm_filter->InjConvRemaining--;
EricLew	0:80ee8f3b695e	2428	if(hdfsdm_filter->InjConvRemaining == 0)
EricLew	0:80ee8f3b695e	2429	{
EricLew	0:80ee8f3b695e	2430	/* End of conversion if trigger is software */
EricLew	0:80ee8f3b695e	2431	if(hdfsdm_filter->InjectedTrigger == DFSDM_FILTER_SW_TRIGGER)
EricLew	0:80ee8f3b695e	2432	{
EricLew	0:80ee8f3b695e	2433	/* Disable interrupts for injected conversions */
EricLew	0:80ee8f3b695e	2434	hdfsdm_filter->Instance->CR2 &= ~(DFSDM_CR2_JEOCIE);
EricLew	0:80ee8f3b695e	2435
EricLew	0:80ee8f3b695e	2436	/* Update DFSDM filter state */
EricLew	0:80ee8f3b695e	2437	hdfsdm_filter->State = (hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_INJ) ? \
EricLew	0:80ee8f3b695e	2438	HAL_DFSDM_FILTER_STATE_READY : HAL_DFSDM_FILTER_STATE_REG;
EricLew	0:80ee8f3b695e	2439	}
EricLew	0:80ee8f3b695e	2440	/* end of injected sequence, reset the value */
EricLew	0:80ee8f3b695e	2441	hdfsdm_filter->InjConvRemaining = (hdfsdm_filter->InjectedScanMode == ENABLE) ? \
EricLew	0:80ee8f3b695e	2442	hdfsdm_filter->InjectedChannelsNbr : 1;
EricLew	0:80ee8f3b695e	2443	}
EricLew	0:80ee8f3b695e	2444	}
EricLew	0:80ee8f3b695e	2445	/* Check if analog watchdog occurs */
EricLew	0:80ee8f3b695e	2446	else if(((hdfsdm_filter->Instance->ISR & DFSDM_ISR_AWDF) != 0) && \
EricLew	0:80ee8f3b695e	2447	((hdfsdm_filter->Instance->CR2 & DFSDM_CR2_AWDIE) != 0))
EricLew	0:80ee8f3b695e	2448	{
EricLew	0:80ee8f3b695e	2449	uint32_t reg = 0;
EricLew	0:80ee8f3b695e	2450	uint32_t threshold = 0;
EricLew	0:80ee8f3b695e	2451	uint32_t channel = 0;
EricLew	0:80ee8f3b695e	2452
EricLew	0:80ee8f3b695e	2453	/* Get channel and threshold */
EricLew	0:80ee8f3b695e	2454	reg = hdfsdm_filter->Instance->AWSR;
EricLew	0:80ee8f3b695e	2455	threshold = (reg & DFSDM_AWSR_AWLTF) ? DFSDM_AWD_LOW_THRESHOLD : DFSDM_AWD_HIGH_THRESHOLD;
EricLew	0:80ee8f3b695e	2456	if(threshold == DFSDM_AWD_HIGH_THRESHOLD)
EricLew	0:80ee8f3b695e	2457	{
EricLew	0:80ee8f3b695e	2458	reg = reg >> DFSDM_AWSR_HIGH_OFFSET;
EricLew	0:80ee8f3b695e	2459	}
EricLew	0:80ee8f3b695e	2460	while((reg & 1) == 0)
EricLew	0:80ee8f3b695e	2461	{
EricLew	0:80ee8f3b695e	2462	channel++;
EricLew	0:80ee8f3b695e	2463	reg = reg >> 1;
EricLew	0:80ee8f3b695e	2464	}
EricLew	0:80ee8f3b695e	2465	/* Clear analog watchdog flag */
EricLew	0:80ee8f3b695e	2466	hdfsdm_filter->Instance->AWCFR = (threshold == DFSDM_AWD_HIGH_THRESHOLD) ? \
EricLew	0:80ee8f3b695e	2467	(1 << (DFSDM_AWSR_HIGH_OFFSET + channel)) : \
EricLew	0:80ee8f3b695e	2468	(1 << channel);
EricLew	0:80ee8f3b695e	2469
EricLew	0:80ee8f3b695e	2470	/* Call analog watchdog callback */
EricLew	0:80ee8f3b695e	2471	HAL_DFSDM_FilterAwdCallback(hdfsdm_filter, channel, threshold);
EricLew	0:80ee8f3b695e	2472	}
EricLew	0:80ee8f3b695e	2473	/* Check if clock absence occurs */
EricLew	0:80ee8f3b695e	2474	else if((hdfsdm_filter->Instance == DFSDM_Filter0) && \
EricLew	0:80ee8f3b695e	2475	((hdfsdm_filter->Instance->ISR & DFSDM_ISR_CKABF) != 0) && \
EricLew	0:80ee8f3b695e	2476	((hdfsdm_filter->Instance->CR2 & DFSDM_CR2_CKABIE) != 0))
EricLew	0:80ee8f3b695e	2477	{
EricLew	0:80ee8f3b695e	2478	uint32_t reg = 0;
EricLew	0:80ee8f3b695e	2479	uint32_t channel = 0;
EricLew	0:80ee8f3b695e	2480
EricLew	0:80ee8f3b695e	2481	reg = ((hdfsdm_filter->Instance->ISR & DFSDM_ISR_CKABF) >> DFSDM_ISR_CKABF_OFFSET);
EricLew	0:80ee8f3b695e	2482
EricLew	0:80ee8f3b695e	2483	while(channel < DFSDM_CHANNEL_NUMBER)
EricLew	0:80ee8f3b695e	2484	{
EricLew	0:80ee8f3b695e	2485	/* Check if flag is set and corresponding channel is enabled */
EricLew	0:80ee8f3b695e	2486	if((reg & 1) && (a_dfsdmChannelHandle[channel] != NULL))
EricLew	0:80ee8f3b695e	2487	{
EricLew	0:80ee8f3b695e	2488	/* Check clock absence has been enabled for this channel */
EricLew	0:80ee8f3b695e	2489	if((a_dfsdmChannelHandle[channel]->Instance->CHCFGR1 & DFSDM_CHCFGR1_CKABEN) != 0)
EricLew	0:80ee8f3b695e	2490	{
EricLew	0:80ee8f3b695e	2491	/* Clear clock absence flag */
EricLew	0:80ee8f3b695e	2492	hdfsdm_filter->Instance->ICR = (1 << (DFSDM_ICR_CLRCKABF_OFFSET + channel));
EricLew	0:80ee8f3b695e	2493
EricLew	0:80ee8f3b695e	2494	/* Call clock absence callback */
EricLew	0:80ee8f3b695e	2495	HAL_DFSDM_ChannelCkabCallback(a_dfsdmChannelHandle[channel]);
EricLew	0:80ee8f3b695e	2496	}
EricLew	0:80ee8f3b695e	2497	}
EricLew	0:80ee8f3b695e	2498	channel++;
EricLew	0:80ee8f3b695e	2499	reg = reg >> 1;
EricLew	0:80ee8f3b695e	2500	}
EricLew	0:80ee8f3b695e	2501	}
EricLew	0:80ee8f3b695e	2502	/* Check if short circuit detection occurs */
EricLew	0:80ee8f3b695e	2503	else if((hdfsdm_filter->Instance == DFSDM_Filter0) && \
EricLew	0:80ee8f3b695e	2504	((hdfsdm_filter->Instance->ISR & DFSDM_ISR_SCDF) != 0) && \
EricLew	0:80ee8f3b695e	2505	((hdfsdm_filter->Instance->CR2 & DFSDM_CR2_SCDIE) != 0))
EricLew	0:80ee8f3b695e	2506	{
EricLew	0:80ee8f3b695e	2507	uint32_t reg = 0;
EricLew	0:80ee8f3b695e	2508	uint32_t channel = 0;
EricLew	0:80ee8f3b695e	2509
EricLew	0:80ee8f3b695e	2510	/* Get channel */
EricLew	0:80ee8f3b695e	2511	reg = ((hdfsdm_filter->Instance->ISR & DFSDM_ISR_SCDF) >> DFSDM_ISR_SCDF_OFFSET);
EricLew	0:80ee8f3b695e	2512	while((reg & 1) == 0)
EricLew	0:80ee8f3b695e	2513	{
EricLew	0:80ee8f3b695e	2514	channel++;
EricLew	0:80ee8f3b695e	2515	reg = reg >> 1;
EricLew	0:80ee8f3b695e	2516	}
EricLew	0:80ee8f3b695e	2517
EricLew	0:80ee8f3b695e	2518	/* Clear short circuit detection flag */
EricLew	0:80ee8f3b695e	2519	hdfsdm_filter->Instance->ICR = (1 << (DFSDM_ICR_CLRSCDF_OFFSET + channel));
EricLew	0:80ee8f3b695e	2520
EricLew	0:80ee8f3b695e	2521	/* Call short circuit detection callback */
EricLew	0:80ee8f3b695e	2522	HAL_DFSDM_ChannelScdCallback(a_dfsdmChannelHandle[channel]);
EricLew	0:80ee8f3b695e	2523	}
EricLew	0:80ee8f3b695e	2524	}
EricLew	0:80ee8f3b695e	2525
EricLew	0:80ee8f3b695e	2526	/**
EricLew	0:80ee8f3b695e	2527	* @brief Regular conversion complete callback.
EricLew	0:80ee8f3b695e	2528	* @note In interrupt mode, user has to read conversion value in this function
EricLew	0:80ee8f3b695e	2529	* using HAL_DFSDM_FilterGetRegularValue.
EricLew	0:80ee8f3b695e	2530	* @param hdfsdm_filter : DFSDM filter handle.
EricLew	0:80ee8f3b695e	2531	* @retval None
EricLew	0:80ee8f3b695e	2532	*/
EricLew	0:80ee8f3b695e	2533	__weak void HAL_DFSDM_FilterRegConvCpltCallback(DFSDM_Filter_HandleTypeDef *hdfsdm_filter)
EricLew	0:80ee8f3b695e	2534	{
EricLew	0:80ee8f3b695e	2535	/* NOTE : This function should not be modified, when the callback is needed,
EricLew	0:80ee8f3b695e	2536	the HAL_DFSDM_FilterRegConvCpltCallback could be implemented in the user file.
EricLew	0:80ee8f3b695e	2537	*/
EricLew	0:80ee8f3b695e	2538	}
EricLew	0:80ee8f3b695e	2539
EricLew	0:80ee8f3b695e	2540	/**
EricLew	0:80ee8f3b695e	2541	* @brief Half regular conversion complete callback.
EricLew	0:80ee8f3b695e	2542	* @param hdfsdm_filter : DFSDM filter handle.
EricLew	0:80ee8f3b695e	2543	* @retval None
EricLew	0:80ee8f3b695e	2544	*/
EricLew	0:80ee8f3b695e	2545	__weak void HAL_DFSDM_FilterRegConvHalfCpltCallback(DFSDM_Filter_HandleTypeDef *hdfsdm_filter)
EricLew	0:80ee8f3b695e	2546	{
EricLew	0:80ee8f3b695e	2547	/* NOTE : This function should not be modified, when the callback is needed,
EricLew	0:80ee8f3b695e	2548	the HAL_DFSDM_FilterRegConvHalfCpltCallback could be implemented in the user file.
EricLew	0:80ee8f3b695e	2549	*/
EricLew	0:80ee8f3b695e	2550	}
EricLew	0:80ee8f3b695e	2551
EricLew	0:80ee8f3b695e	2552	/**
EricLew	0:80ee8f3b695e	2553	* @brief Injected conversion complete callback.
EricLew	0:80ee8f3b695e	2554	* @note In interrupt mode, user has to read conversion value in this function
EricLew	0:80ee8f3b695e	2555	* using HAL_DFSDM_FilterGetInjectedValue.
EricLew	0:80ee8f3b695e	2556	* @param hdfsdm_filter : DFSDM filter handle.
EricLew	0:80ee8f3b695e	2557	* @retval None
EricLew	0:80ee8f3b695e	2558	*/
EricLew	0:80ee8f3b695e	2559	__weak void HAL_DFSDM_FilterInjConvCpltCallback(DFSDM_Filter_HandleTypeDef *hdfsdm_filter)
EricLew	0:80ee8f3b695e	2560	{
EricLew	0:80ee8f3b695e	2561	/* NOTE : This function should not be modified, when the callback is needed,
EricLew	0:80ee8f3b695e	2562	the HAL_DFSDM_FilterInjConvCpltCallback could be implemented in the user file.
EricLew	0:80ee8f3b695e	2563	*/
EricLew	0:80ee8f3b695e	2564	}
EricLew	0:80ee8f3b695e	2565
EricLew	0:80ee8f3b695e	2566	/**
EricLew	0:80ee8f3b695e	2567	* @brief Half injected conversion complete callback.
EricLew	0:80ee8f3b695e	2568	* @param hdfsdm_filter : DFSDM filter handle.
EricLew	0:80ee8f3b695e	2569	* @retval None
EricLew	0:80ee8f3b695e	2570	*/
EricLew	0:80ee8f3b695e	2571	__weak void HAL_DFSDM_FilterInjConvHalfCpltCallback(DFSDM_Filter_HandleTypeDef *hdfsdm_filter)
EricLew	0:80ee8f3b695e	2572	{
EricLew	0:80ee8f3b695e	2573	/* NOTE : This function should not be modified, when the callback is needed,
EricLew	0:80ee8f3b695e	2574	the HAL_DFSDM_FilterInjConvHalfCpltCallback could be implemented in the user file.
EricLew	0:80ee8f3b695e	2575	*/
EricLew	0:80ee8f3b695e	2576	}
EricLew	0:80ee8f3b695e	2577
EricLew	0:80ee8f3b695e	2578	/**
EricLew	0:80ee8f3b695e	2579	* @brief Filter analog watchdog callback.
EricLew	0:80ee8f3b695e	2580	* @param hdfsdm_filter : DFSDM filter handle.
EricLew	0:80ee8f3b695e	2581	* @param Channel : Corresponding channel.
EricLew	0:80ee8f3b695e	2582	* @param Threshold : Low or high threshold has been reached.
EricLew	0:80ee8f3b695e	2583	* @retval None
EricLew	0:80ee8f3b695e	2584	*/
EricLew	0:80ee8f3b695e	2585	__weak void HAL_DFSDM_FilterAwdCallback(DFSDM_Filter_HandleTypeDef *hdfsdm_filter,
EricLew	0:80ee8f3b695e	2586	uint32_t Channel, uint32_t Threshold)
EricLew	0:80ee8f3b695e	2587	{
EricLew	0:80ee8f3b695e	2588	/* NOTE : This function should not be modified, when the callback is needed,
EricLew	0:80ee8f3b695e	2589	the HAL_DFSDM_FilterAwdCallback could be implemented in the user file.
EricLew	0:80ee8f3b695e	2590	*/
EricLew	0:80ee8f3b695e	2591	}
EricLew	0:80ee8f3b695e	2592
EricLew	0:80ee8f3b695e	2593	/**
EricLew	0:80ee8f3b695e	2594	* @brief Error callback.
EricLew	0:80ee8f3b695e	2595	* @param hdfsdm_filter : DFSDM filter handle.
EricLew	0:80ee8f3b695e	2596	* @retval None
EricLew	0:80ee8f3b695e	2597	*/
EricLew	0:80ee8f3b695e	2598	__weak void HAL_DFSDM_FilterErrorCallback(DFSDM_Filter_HandleTypeDef *hdfsdm_filter)
EricLew	0:80ee8f3b695e	2599	{
EricLew	0:80ee8f3b695e	2600	/* NOTE : This function should not be modified, when the callback is needed,
EricLew	0:80ee8f3b695e	2601	the HAL_DFSDM_FilterErrorCallback could be implemented in the user file.
EricLew	0:80ee8f3b695e	2602	*/
EricLew	0:80ee8f3b695e	2603	}
EricLew	0:80ee8f3b695e	2604
EricLew	0:80ee8f3b695e	2605	/**
EricLew	0:80ee8f3b695e	2606	* @}
EricLew	0:80ee8f3b695e	2607	*/
EricLew	0:80ee8f3b695e	2608
EricLew	0:80ee8f3b695e	2609	/** @defgroup DFSDM_Exported_Functions_Group4_Filter Filter state functions
EricLew	0:80ee8f3b695e	2610	* @brief Filter state functions
EricLew	0:80ee8f3b695e	2611	*
EricLew	0:80ee8f3b695e	2612	@verbatim
EricLew	0:80ee8f3b695e	2613	==============================================================================
EricLew	0:80ee8f3b695e	2614	##### Filter state functions #####
EricLew	0:80ee8f3b695e	2615	==============================================================================
EricLew	0:80ee8f3b695e	2616	[..] This section provides functions allowing to:
EricLew	0:80ee8f3b695e	2617	(+) Get the DFSDM filter state.
EricLew	0:80ee8f3b695e	2618	(+) Get the DFSDM filter error.
EricLew	0:80ee8f3b695e	2619	@endverbatim
EricLew	0:80ee8f3b695e	2620	* @{
EricLew	0:80ee8f3b695e	2621	*/
EricLew	0:80ee8f3b695e	2622
EricLew	0:80ee8f3b695e	2623	/**
EricLew	0:80ee8f3b695e	2624	* @brief This function allows to get the current DFSDM filter handle state.
EricLew	0:80ee8f3b695e	2625	* @param hdfsdm_filter : DFSDM filter handle.
EricLew	0:80ee8f3b695e	2626	* @retval DFSDM filter state.
EricLew	0:80ee8f3b695e	2627	*/
EricLew	0:80ee8f3b695e	2628	HAL_DFSDM_Filter_StateTypeDef HAL_DFSDM_FilterGetState(DFSDM_Filter_HandleTypeDef *hdfsdm_filter)
EricLew	0:80ee8f3b695e	2629	{
EricLew	0:80ee8f3b695e	2630	/* Return DFSDM filter handle state */
EricLew	0:80ee8f3b695e	2631	return hdfsdm_filter->State;
EricLew	0:80ee8f3b695e	2632	}
EricLew	0:80ee8f3b695e	2633
EricLew	0:80ee8f3b695e	2634	/**
EricLew	0:80ee8f3b695e	2635	* @brief This function allows to get the current DFSDM filter error.
EricLew	0:80ee8f3b695e	2636	* @param hdfsdm_filter : DFSDM filter handle.
EricLew	0:80ee8f3b695e	2637	* @retval DFSDM filter error code.
EricLew	0:80ee8f3b695e	2638	*/
EricLew	0:80ee8f3b695e	2639	uint32_t HAL_DFSDM_FilterGetError(DFSDM_Filter_HandleTypeDef *hdfsdm_filter)
EricLew	0:80ee8f3b695e	2640	{
EricLew	0:80ee8f3b695e	2641	return hdfsdm_filter->ErrorCode;
EricLew	0:80ee8f3b695e	2642	}
EricLew	0:80ee8f3b695e	2643
EricLew	0:80ee8f3b695e	2644	/**
EricLew	0:80ee8f3b695e	2645	* @}
EricLew	0:80ee8f3b695e	2646	*/
EricLew	0:80ee8f3b695e	2647
EricLew	0:80ee8f3b695e	2648	/**
EricLew	0:80ee8f3b695e	2649	* @}
EricLew	0:80ee8f3b695e	2650	*/
EricLew	0:80ee8f3b695e	2651	/* End of exported functions -------------------------------------------------*/
EricLew	0:80ee8f3b695e	2652
EricLew	0:80ee8f3b695e	2653	/* Private functions ---------------------------------------------------------*/
EricLew	0:80ee8f3b695e	2654	/** @addtogroup DFSDM_Private_Functions DFSDM Private Functions
EricLew	0:80ee8f3b695e	2655	* @{
EricLew	0:80ee8f3b695e	2656	*/
EricLew	0:80ee8f3b695e	2657
EricLew	0:80ee8f3b695e	2658	/**
EricLew	0:80ee8f3b695e	2659	* @brief DMA half transfer complete callback for regular conversion.
EricLew	0:80ee8f3b695e	2660	* @param hdma : DMA handle.
EricLew	0:80ee8f3b695e	2661	* @retval None
EricLew	0:80ee8f3b695e	2662	*/
EricLew	0:80ee8f3b695e	2663	static void DFSDM_DMARegularHalfConvCplt(DMA_HandleTypeDef *hdma)
EricLew	0:80ee8f3b695e	2664	{
EricLew	0:80ee8f3b695e	2665	/* Get DFSDM filter handle */
EricLew	0:80ee8f3b695e	2666	DFSDM_Filter_HandleTypeDef* hdfsdm_filter = (DFSDM_Filter_HandleTypeDef) ((DMA_HandleTypeDef)hdma)->Parent;
EricLew	0:80ee8f3b695e	2667
EricLew	0:80ee8f3b695e	2668	/* Call regular half conversion complete callback */
EricLew	0:80ee8f3b695e	2669	HAL_DFSDM_FilterRegConvHalfCpltCallback(hdfsdm_filter);
EricLew	0:80ee8f3b695e	2670	}
EricLew	0:80ee8f3b695e	2671
EricLew	0:80ee8f3b695e	2672	/**
EricLew	0:80ee8f3b695e	2673	* @brief DMA transfer complete callback for regular conversion.
EricLew	0:80ee8f3b695e	2674	* @param hdma : DMA handle.
EricLew	0:80ee8f3b695e	2675	* @retval None
EricLew	0:80ee8f3b695e	2676	*/
EricLew	0:80ee8f3b695e	2677	static void DFSDM_DMARegularConvCplt(DMA_HandleTypeDef *hdma)
EricLew	0:80ee8f3b695e	2678	{
EricLew	0:80ee8f3b695e	2679	/* Get DFSDM filter handle */
EricLew	0:80ee8f3b695e	2680	DFSDM_Filter_HandleTypeDef* hdfsdm_filter = (DFSDM_Filter_HandleTypeDef) ((DMA_HandleTypeDef)hdma)->Parent;
EricLew	0:80ee8f3b695e	2681
EricLew	0:80ee8f3b695e	2682	/* Call regular conversion complete callback */
EricLew	0:80ee8f3b695e	2683	HAL_DFSDM_FilterRegConvCpltCallback(hdfsdm_filter);
EricLew	0:80ee8f3b695e	2684	}
EricLew	0:80ee8f3b695e	2685
EricLew	0:80ee8f3b695e	2686	/**
EricLew	0:80ee8f3b695e	2687	* @brief DMA half transfer complete callback for injected conversion.
EricLew	0:80ee8f3b695e	2688	* @param hdma : DMA handle.
EricLew	0:80ee8f3b695e	2689	* @retval None
EricLew	0:80ee8f3b695e	2690	*/
EricLew	0:80ee8f3b695e	2691	static void DFSDM_DMAInjectedHalfConvCplt(DMA_HandleTypeDef *hdma)
EricLew	0:80ee8f3b695e	2692	{
EricLew	0:80ee8f3b695e	2693	/* Get DFSDM filter handle */
EricLew	0:80ee8f3b695e	2694	DFSDM_Filter_HandleTypeDef* hdfsdm_filter = (DFSDM_Filter_HandleTypeDef) ((DMA_HandleTypeDef)hdma)->Parent;
EricLew	0:80ee8f3b695e	2695
EricLew	0:80ee8f3b695e	2696	/* Call injected half conversion complete callback */
EricLew	0:80ee8f3b695e	2697	HAL_DFSDM_FilterInjConvHalfCpltCallback(hdfsdm_filter);
EricLew	0:80ee8f3b695e	2698	}
EricLew	0:80ee8f3b695e	2699
EricLew	0:80ee8f3b695e	2700	/**
EricLew	0:80ee8f3b695e	2701	* @brief DMA transfer complete callback for injected conversion.
EricLew	0:80ee8f3b695e	2702	* @param hdma : DMA handle.
EricLew	0:80ee8f3b695e	2703	* @retval None
EricLew	0:80ee8f3b695e	2704	*/
EricLew	0:80ee8f3b695e	2705	static void DFSDM_DMAInjectedConvCplt(DMA_HandleTypeDef *hdma)
EricLew	0:80ee8f3b695e	2706	{
EricLew	0:80ee8f3b695e	2707	/* Get DFSDM filter handle */
EricLew	0:80ee8f3b695e	2708	DFSDM_Filter_HandleTypeDef* hdfsdm_filter = (DFSDM_Filter_HandleTypeDef) ((DMA_HandleTypeDef)hdma)->Parent;
EricLew	0:80ee8f3b695e	2709
EricLew	0:80ee8f3b695e	2710	/* Call injected conversion complete callback */
EricLew	0:80ee8f3b695e	2711	HAL_DFSDM_FilterInjConvCpltCallback(hdfsdm_filter);
EricLew	0:80ee8f3b695e	2712	}
EricLew	0:80ee8f3b695e	2713
EricLew	0:80ee8f3b695e	2714	/**
EricLew	0:80ee8f3b695e	2715	* @brief DMA error callback.
EricLew	0:80ee8f3b695e	2716	* @param hdma : DMA handle.
EricLew	0:80ee8f3b695e	2717	* @retval None
EricLew	0:80ee8f3b695e	2718	*/
EricLew	0:80ee8f3b695e	2719	static void DFSDM_DMAError(DMA_HandleTypeDef *hdma)
EricLew	0:80ee8f3b695e	2720	{
EricLew	0:80ee8f3b695e	2721	/* Get DFSDM filter handle */
EricLew	0:80ee8f3b695e	2722	DFSDM_Filter_HandleTypeDef* hdfsdm_filter = (DFSDM_Filter_HandleTypeDef) ((DMA_HandleTypeDef)hdma)->Parent;
EricLew	0:80ee8f3b695e	2723
EricLew	0:80ee8f3b695e	2724	/* Update error code */
EricLew	0:80ee8f3b695e	2725	hdfsdm_filter->ErrorCode = DFSDM_FILTER_ERROR_DMA;
EricLew	0:80ee8f3b695e	2726
EricLew	0:80ee8f3b695e	2727	/* Call error callback */
EricLew	0:80ee8f3b695e	2728	HAL_DFSDM_FilterErrorCallback(hdfsdm_filter);
EricLew	0:80ee8f3b695e	2729	}
EricLew	0:80ee8f3b695e	2730
EricLew	0:80ee8f3b695e	2731	/**
EricLew	0:80ee8f3b695e	2732	* @brief This function allows to get the number of injected channels.
EricLew	0:80ee8f3b695e	2733	* @param Channels : bitfield of injected channels.
EricLew	0:80ee8f3b695e	2734	* @retval Number of injected channels.
EricLew	0:80ee8f3b695e	2735	*/
EricLew	0:80ee8f3b695e	2736	static uint32_t DFSDM_GetInjChannelsNbr(uint32_t Channels)
EricLew	0:80ee8f3b695e	2737	{
EricLew	0:80ee8f3b695e	2738	uint32_t nbChannels = 0;
EricLew	0:80ee8f3b695e	2739	uint32_t tmp;
EricLew	0:80ee8f3b695e	2740
EricLew	0:80ee8f3b695e	2741	/* Get the number of channels from bitfield */
EricLew	0:80ee8f3b695e	2742	tmp = (uint32_t) (Channels & DFSDM_LSB_MASK);
EricLew	0:80ee8f3b695e	2743	while(tmp != 0)
EricLew	0:80ee8f3b695e	2744	{
EricLew	0:80ee8f3b695e	2745	if(tmp & 1)
EricLew	0:80ee8f3b695e	2746	{
EricLew	0:80ee8f3b695e	2747	nbChannels++;
EricLew	0:80ee8f3b695e	2748	}
EricLew	0:80ee8f3b695e	2749	tmp = (uint32_t) (tmp >> 1);
EricLew	0:80ee8f3b695e	2750	}
EricLew	0:80ee8f3b695e	2751	return nbChannels;
EricLew	0:80ee8f3b695e	2752	}
EricLew	0:80ee8f3b695e	2753
EricLew	0:80ee8f3b695e	2754	/**
EricLew	0:80ee8f3b695e	2755	* @brief This function allows to get the channel number from channel instance.
EricLew	0:80ee8f3b695e	2756	* @param Instance : DFSDM channel instance.
EricLew	0:80ee8f3b695e	2757	* @retval Channel number.
EricLew	0:80ee8f3b695e	2758	*/
EricLew	0:80ee8f3b695e	2759	static uint32_t DFSDM_GetChannelFromInstance(DFSDM_Channel_TypeDef* Instance)
EricLew	0:80ee8f3b695e	2760	{
EricLew	0:80ee8f3b695e	2761	uint32_t channel = 0;
EricLew	0:80ee8f3b695e	2762
EricLew	0:80ee8f3b695e	2763	/* Get channel from instance */
EricLew	0:80ee8f3b695e	2764	if(Instance == DFSDM_Channel0)
EricLew	0:80ee8f3b695e	2765	{
EricLew	0:80ee8f3b695e	2766	channel = 0;
EricLew	0:80ee8f3b695e	2767	}
EricLew	0:80ee8f3b695e	2768	else if(Instance == DFSDM_Channel1)
EricLew	0:80ee8f3b695e	2769	{
EricLew	0:80ee8f3b695e	2770	channel = 1;
EricLew	0:80ee8f3b695e	2771	}
EricLew	0:80ee8f3b695e	2772	else if(Instance == DFSDM_Channel2)
EricLew	0:80ee8f3b695e	2773	{
EricLew	0:80ee8f3b695e	2774	channel = 2;
EricLew	0:80ee8f3b695e	2775	}
EricLew	0:80ee8f3b695e	2776	else if(Instance == DFSDM_Channel3)
EricLew	0:80ee8f3b695e	2777	{
EricLew	0:80ee8f3b695e	2778	channel = 3;
EricLew	0:80ee8f3b695e	2779	}
EricLew	0:80ee8f3b695e	2780	else if(Instance == DFSDM_Channel4)
EricLew	0:80ee8f3b695e	2781	{
EricLew	0:80ee8f3b695e	2782	channel = 4;
EricLew	0:80ee8f3b695e	2783	}
EricLew	0:80ee8f3b695e	2784	else if(Instance == DFSDM_Channel5)
EricLew	0:80ee8f3b695e	2785	{
EricLew	0:80ee8f3b695e	2786	channel = 5;
EricLew	0:80ee8f3b695e	2787	}
EricLew	0:80ee8f3b695e	2788	else if(Instance == DFSDM_Channel6)
EricLew	0:80ee8f3b695e	2789	{
EricLew	0:80ee8f3b695e	2790	channel = 6;
EricLew	0:80ee8f3b695e	2791	}
EricLew	0:80ee8f3b695e	2792	else if(Instance == DFSDM_Channel7)
EricLew	0:80ee8f3b695e	2793	{
EricLew	0:80ee8f3b695e	2794	channel = 7;
EricLew	0:80ee8f3b695e	2795	}
EricLew	0:80ee8f3b695e	2796
EricLew	0:80ee8f3b695e	2797	return channel;
EricLew	0:80ee8f3b695e	2798	}
EricLew	0:80ee8f3b695e	2799
EricLew	0:80ee8f3b695e	2800	/**
EricLew	0:80ee8f3b695e	2801	* @brief This function allows to really start regular conversion.
EricLew	0:80ee8f3b695e	2802	* @param hdfsdm_filter : DFSDM filter handle.
EricLew	0:80ee8f3b695e	2803	* @retval None
EricLew	0:80ee8f3b695e	2804	*/
EricLew	0:80ee8f3b695e	2805	static void DFSDM_RegConvStart(DFSDM_Filter_HandleTypeDef* hdfsdm_filter)
EricLew	0:80ee8f3b695e	2806	{
EricLew	0:80ee8f3b695e	2807	/* Check regular trigger */
EricLew	0:80ee8f3b695e	2808	if(hdfsdm_filter->RegularTrigger == DFSDM_FILTER_SW_TRIGGER)
EricLew	0:80ee8f3b695e	2809	{
EricLew	0:80ee8f3b695e	2810	/* Software start of regular conversion */
EricLew	0:80ee8f3b695e	2811	hdfsdm_filter->Instance->CR1 \|= DFSDM_CR1_RSWSTART;
EricLew	0:80ee8f3b695e	2812	}
EricLew	0:80ee8f3b695e	2813	else /* synchronous trigger */
EricLew	0:80ee8f3b695e	2814	{
EricLew	0:80ee8f3b695e	2815	/* Disable DFSDM filter */
EricLew	0:80ee8f3b695e	2816	hdfsdm_filter->Instance->CR1 &= ~(DFSDM_CR1_DFEN);
EricLew	0:80ee8f3b695e	2817
EricLew	0:80ee8f3b695e	2818	/* Set RSYNC bit in DFSDM_CR1 register */
EricLew	0:80ee8f3b695e	2819	hdfsdm_filter->Instance->CR1 \|= DFSDM_CR1_RSYNC;
EricLew	0:80ee8f3b695e	2820
EricLew	0:80ee8f3b695e	2821	/* Enable DFSDM filter */
EricLew	0:80ee8f3b695e	2822	hdfsdm_filter->Instance->CR1 \|= DFSDM_CR1_DFEN;
EricLew	0:80ee8f3b695e	2823
EricLew	0:80ee8f3b695e	2824	/* If injected conversion was in progress, restart it */
EricLew	0:80ee8f3b695e	2825	if(hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_INJ)
EricLew	0:80ee8f3b695e	2826	{
EricLew	0:80ee8f3b695e	2827	if(hdfsdm_filter->InjectedTrigger == DFSDM_FILTER_SW_TRIGGER)
EricLew	0:80ee8f3b695e	2828	{
EricLew	0:80ee8f3b695e	2829	hdfsdm_filter->Instance->CR1 \|= DFSDM_CR1_JSWSTART;
EricLew	0:80ee8f3b695e	2830	}
EricLew	0:80ee8f3b695e	2831	/* Update remaining injected conversions */
EricLew	0:80ee8f3b695e	2832	hdfsdm_filter->InjConvRemaining = (hdfsdm_filter->InjectedScanMode == ENABLE) ? \
EricLew	0:80ee8f3b695e	2833	hdfsdm_filter->InjectedChannelsNbr : 1;
EricLew	0:80ee8f3b695e	2834	}
EricLew	0:80ee8f3b695e	2835	}
EricLew	0:80ee8f3b695e	2836	/* Update DFSDM filter state */
EricLew	0:80ee8f3b695e	2837	hdfsdm_filter->State = (hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_READY) ? \
EricLew	0:80ee8f3b695e	2838	HAL_DFSDM_FILTER_STATE_REG : HAL_DFSDM_FILTER_STATE_REG_INJ;
EricLew	0:80ee8f3b695e	2839	}
EricLew	0:80ee8f3b695e	2840
EricLew	0:80ee8f3b695e	2841	/**
EricLew	0:80ee8f3b695e	2842	* @brief This function allows to really stop regular conversion.
EricLew	0:80ee8f3b695e	2843	* @param hdfsdm_filter : DFSDM filter handle.
EricLew	0:80ee8f3b695e	2844	* @retval None
EricLew	0:80ee8f3b695e	2845	*/
EricLew	0:80ee8f3b695e	2846	static void DFSDM_RegConvStop(DFSDM_Filter_HandleTypeDef* hdfsdm_filter)
EricLew	0:80ee8f3b695e	2847	{
EricLew	0:80ee8f3b695e	2848	/* Disable DFSDM filter */
EricLew	0:80ee8f3b695e	2849	hdfsdm_filter->Instance->CR1 &= ~(DFSDM_CR1_DFEN);
EricLew	0:80ee8f3b695e	2850
EricLew	0:80ee8f3b695e	2851	/* If regular trigger was synchronous, reset RSYNC bit in DFSDM_CR1 register */
EricLew	0:80ee8f3b695e	2852	if(hdfsdm_filter->RegularTrigger == DFSDM_FILTER_SYNC_TRIGGER)
EricLew	0:80ee8f3b695e	2853	{
EricLew	0:80ee8f3b695e	2854	hdfsdm_filter->Instance->CR1 &= ~(DFSDM_CR1_RSYNC);
EricLew	0:80ee8f3b695e	2855	}
EricLew	0:80ee8f3b695e	2856
EricLew	0:80ee8f3b695e	2857	/* Enable DFSDM filter */
EricLew	0:80ee8f3b695e	2858	hdfsdm_filter->Instance->CR1 \|= DFSDM_CR1_DFEN;
EricLew	0:80ee8f3b695e	2859
EricLew	0:80ee8f3b695e	2860	/* If injected conversion was in progress, restart it */
EricLew	0:80ee8f3b695e	2861	if(hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_REG_INJ)
EricLew	0:80ee8f3b695e	2862	{
EricLew	0:80ee8f3b695e	2863	if(hdfsdm_filter->InjectedTrigger == DFSDM_FILTER_SW_TRIGGER)
EricLew	0:80ee8f3b695e	2864	{
EricLew	0:80ee8f3b695e	2865	hdfsdm_filter->Instance->CR1 \|= DFSDM_CR1_JSWSTART;
EricLew	0:80ee8f3b695e	2866	}
EricLew	0:80ee8f3b695e	2867	/* Update remaining injected conversions */
EricLew	0:80ee8f3b695e	2868	hdfsdm_filter->InjConvRemaining = (hdfsdm_filter->InjectedScanMode == ENABLE) ? \
EricLew	0:80ee8f3b695e	2869	hdfsdm_filter->InjectedChannelsNbr : 1;
EricLew	0:80ee8f3b695e	2870	}
EricLew	0:80ee8f3b695e	2871
EricLew	0:80ee8f3b695e	2872	/* Update DFSDM filter state */
EricLew	0:80ee8f3b695e	2873	hdfsdm_filter->State = (hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_REG) ? \
EricLew	0:80ee8f3b695e	2874	HAL_DFSDM_FILTER_STATE_READY : HAL_DFSDM_FILTER_STATE_INJ;
EricLew	0:80ee8f3b695e	2875	}
EricLew	0:80ee8f3b695e	2876
EricLew	0:80ee8f3b695e	2877	/**
EricLew	0:80ee8f3b695e	2878	* @brief This function allows to really start injected conversion.
EricLew	0:80ee8f3b695e	2879	* @param hdfsdm_filter : DFSDM filter handle.
EricLew	0:80ee8f3b695e	2880	* @retval None
EricLew	0:80ee8f3b695e	2881	*/
EricLew	0:80ee8f3b695e	2882	static void DFSDM_InjConvStart(DFSDM_Filter_HandleTypeDef* hdfsdm_filter)
EricLew	0:80ee8f3b695e	2883	{
EricLew	0:80ee8f3b695e	2884	/* Check injected trigger */
EricLew	0:80ee8f3b695e	2885	if(hdfsdm_filter->InjectedTrigger == DFSDM_FILTER_SW_TRIGGER)
EricLew	0:80ee8f3b695e	2886	{
EricLew	0:80ee8f3b695e	2887	/* Software start of injected conversion */
EricLew	0:80ee8f3b695e	2888	hdfsdm_filter->Instance->CR1 \|= DFSDM_CR1_JSWSTART;
EricLew	0:80ee8f3b695e	2889	}
EricLew	0:80ee8f3b695e	2890	else /* external or synchronous trigger */
EricLew	0:80ee8f3b695e	2891	{
EricLew	0:80ee8f3b695e	2892	/* Disable DFSDM filter */
EricLew	0:80ee8f3b695e	2893	hdfsdm_filter->Instance->CR1 &= ~(DFSDM_CR1_DFEN);
EricLew	0:80ee8f3b695e	2894
EricLew	0:80ee8f3b695e	2895	if(hdfsdm_filter->InjectedTrigger == DFSDM_FILTER_SYNC_TRIGGER)
EricLew	0:80ee8f3b695e	2896	{
EricLew	0:80ee8f3b695e	2897	/* Set JSYNC bit in DFSDM_CR1 register */
EricLew	0:80ee8f3b695e	2898	hdfsdm_filter->Instance->CR1 \|= DFSDM_CR1_JSYNC;
EricLew	0:80ee8f3b695e	2899	}
EricLew	0:80ee8f3b695e	2900	else /* external trigger */
EricLew	0:80ee8f3b695e	2901	{
EricLew	0:80ee8f3b695e	2902	/* Set JEXTEN[1:0] bits in DFSDM_CR1 register */
EricLew	0:80ee8f3b695e	2903	hdfsdm_filter->Instance->CR1 \|= hdfsdm_filter->ExtTriggerEdge;
EricLew	0:80ee8f3b695e	2904	}
EricLew	0:80ee8f3b695e	2905
EricLew	0:80ee8f3b695e	2906	/* Enable DFSDM filter */
EricLew	0:80ee8f3b695e	2907	hdfsdm_filter->Instance->CR1 \|= DFSDM_CR1_DFEN;
EricLew	0:80ee8f3b695e	2908
EricLew	0:80ee8f3b695e	2909	/* If regular conversion was in progress, restart it */
EricLew	0:80ee8f3b695e	2910	if((hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_REG) && \
EricLew	0:80ee8f3b695e	2911	(hdfsdm_filter->RegularTrigger == DFSDM_FILTER_SW_TRIGGER))
EricLew	0:80ee8f3b695e	2912	{
EricLew	0:80ee8f3b695e	2913	hdfsdm_filter->Instance->CR1 \|= DFSDM_CR1_RSWSTART;
EricLew	0:80ee8f3b695e	2914	}
EricLew	0:80ee8f3b695e	2915	}
EricLew	0:80ee8f3b695e	2916	/* Update DFSDM filter state */
EricLew	0:80ee8f3b695e	2917	hdfsdm_filter->State = (hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_READY) ? \
EricLew	0:80ee8f3b695e	2918	HAL_DFSDM_FILTER_STATE_INJ : HAL_DFSDM_FILTER_STATE_REG_INJ;
EricLew	0:80ee8f3b695e	2919	}
EricLew	0:80ee8f3b695e	2920
EricLew	0:80ee8f3b695e	2921	/**
EricLew	0:80ee8f3b695e	2922	* @brief This function allows to really stop injected conversion.
EricLew	0:80ee8f3b695e	2923	* @param hdfsdm_filter : DFSDM filter handle.
EricLew	0:80ee8f3b695e	2924	* @retval None
EricLew	0:80ee8f3b695e	2925	*/
EricLew	0:80ee8f3b695e	2926	static void DFSDM_InjConvStop(DFSDM_Filter_HandleTypeDef* hdfsdm_filter)
EricLew	0:80ee8f3b695e	2927	{
EricLew	0:80ee8f3b695e	2928	/* Disable DFSDM filter */
EricLew	0:80ee8f3b695e	2929	hdfsdm_filter->Instance->CR1 &= ~(DFSDM_CR1_DFEN);
EricLew	0:80ee8f3b695e	2930
EricLew	0:80ee8f3b695e	2931	/* If injected trigger was synchronous, reset JSYNC bit in DFSDM_CR1 register */
EricLew	0:80ee8f3b695e	2932	if(hdfsdm_filter->InjectedTrigger == DFSDM_FILTER_SYNC_TRIGGER)
EricLew	0:80ee8f3b695e	2933	{
EricLew	0:80ee8f3b695e	2934	hdfsdm_filter->Instance->CR1 &= ~(DFSDM_CR1_JSYNC);
EricLew	0:80ee8f3b695e	2935	}
EricLew	0:80ee8f3b695e	2936	else if(hdfsdm_filter->InjectedTrigger == DFSDM_FILTER_EXT_TRIGGER)
EricLew	0:80ee8f3b695e	2937	{
EricLew	0:80ee8f3b695e	2938	/* Reset JEXTEN[1:0] bits in DFSDM_CR1 register */
EricLew	0:80ee8f3b695e	2939	hdfsdm_filter->Instance->CR1 &= ~(DFSDM_CR1_JEXTEN);
EricLew	0:80ee8f3b695e	2940	}
EricLew	0:80ee8f3b695e	2941
EricLew	0:80ee8f3b695e	2942	/* Enable DFSDM filter */
EricLew	0:80ee8f3b695e	2943	hdfsdm_filter->Instance->CR1 \|= DFSDM_CR1_DFEN;
EricLew	0:80ee8f3b695e	2944
EricLew	0:80ee8f3b695e	2945	/* If regular conversion was in progress, restart it */
EricLew	0:80ee8f3b695e	2946	if((hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_REG_INJ) && \
EricLew	0:80ee8f3b695e	2947	(hdfsdm_filter->RegularTrigger == DFSDM_FILTER_SW_TRIGGER))
EricLew	0:80ee8f3b695e	2948	{
EricLew	0:80ee8f3b695e	2949	hdfsdm_filter->Instance->CR1 \|= DFSDM_CR1_RSWSTART;
EricLew	0:80ee8f3b695e	2950	}
EricLew	0:80ee8f3b695e	2951
EricLew	0:80ee8f3b695e	2952	/* Update remaining injected conversions */
EricLew	0:80ee8f3b695e	2953	hdfsdm_filter->InjConvRemaining = (hdfsdm_filter->InjectedScanMode == ENABLE) ? \
EricLew	0:80ee8f3b695e	2954	hdfsdm_filter->InjectedChannelsNbr : 1;
EricLew	0:80ee8f3b695e	2955
EricLew	0:80ee8f3b695e	2956	/* Update DFSDM filter state */
EricLew	0:80ee8f3b695e	2957	hdfsdm_filter->State = (hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_INJ) ? \
EricLew	0:80ee8f3b695e	2958	HAL_DFSDM_FILTER_STATE_READY : HAL_DFSDM_FILTER_STATE_REG;
EricLew	0:80ee8f3b695e	2959	}
EricLew	0:80ee8f3b695e	2960
EricLew	0:80ee8f3b695e	2961	/**
EricLew	0:80ee8f3b695e	2962	* @}
EricLew	0:80ee8f3b695e	2963	*/
EricLew	0:80ee8f3b695e	2964	/* End of private functions --------------------------------------------------*/
EricLew	0:80ee8f3b695e	2965
EricLew	0:80ee8f3b695e	2966	/**
EricLew	0:80ee8f3b695e	2967	* @}
EricLew	0:80ee8f3b695e	2968	*/
EricLew	0:80ee8f3b695e	2969	#endif /* HAL_DFSDM_MODULE_ENABLED */
EricLew	0:80ee8f3b695e	2970	/**
EricLew	0:80ee8f3b695e	2971	* @}
EricLew	0:80ee8f3b695e	2972	*/
EricLew	0:80ee8f3b695e	2973
EricLew	0:80ee8f3b695e	2974	/********************** (C) COPYRIGHT STMicroelectronics *END OF FILE**/
EricLew	0:80ee8f3b695e	2975

Repository toolbox

Export to desktop IDE

Repository details

Type:	Library
Created:	12 Nov 2015
Imports:	198
Forks:	0
Commits:	3
Dependents:	4
Dependencies:	0
Followers:	14

Src/stm32l4xx_hal_dfsdm.c@2:7aef7655b0a8, 2015-11-25 (annotated)

Who changed what in which revision?

Repository toolbox

Repository details

Important Information for this Arm website

Access Warning