gr55xx_ll_pdm.h
Go to the documentation of this file.
1 /**
2 ****************************************************************************************
3 *
4 * @file gr55xx_ll_pdm.h
5 * @author BLE Driver Team
6 * @brief Header file containing functions prototypes of PDM LL library.
7 *
8 ****************************************************************************************
9 * @attention
10 #####Copyright (c) 2019 GOODIX
11 All rights reserved.
12
13 Redistribution and use in source and binary forms, with or without
14 modification, are permitted provided that the following conditions are met:
15 * Redistributions of source code must retain the above copyright
16 notice, this list of conditions and the following disclaimer.
17 * Redistributions in binary form must reproduce the above copyright
18 notice, this list of conditions and the following disclaimer in the
19 documentation and/or other materials provided with the distribution.
20 * Neither the name of GOODIX nor the names of its contributors may be used
21 to endorse or promote products derived from this software without
22 specific prior written permission.
23
24 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
25 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27 ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDERS AND CONTRIBUTORS BE
28 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
29 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
30 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
31 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
32 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
33 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
34 POSSIBILITY OF SUCH DAMAGE.
35 ****************************************************************************************
36 */
37
38 /** @addtogroup PERIPHERAL Peripheral Driver
39 * @{
40 */
41
42 /** @addtogroup LL_DRIVER LL Driver
43 * @{
44 */
45
46 /** @defgroup LL_PDM PDM
47 * @brief PDM LL module driver.
48 * @{
49 */
50
51 /* Define to prevent recursive inclusion -------------------------------------*/
52 #ifndef __GR55xx_LL_PDM_H__
53 #define __GR55xx_LL_PDM_H__
54
55 #ifdef __cplusplus
56 extern "C" {
57 #endif
58
59 /* Includes ------------------------------------------------------------------*/
60 #include "gr55xx.h"
61
62 #if defined (PDM)
63
64
65 /** @defgroup PDM_LL_STRUCTURES Structures
66 * @{
67 */
68
69 /* Exported types ------------------------------------------------------------*/
70 /** @defgroup PDM_LL_ES_INIT PDM Exported init structures
71 * @{
72 */
73 /**
74 * @brief LL PDM init Structure definition
75 */
76 typedef struct _ll_pdm_init
77 {
78 uint32_t mode; /**< Specifies the sample rate.must be a value of @ref LL_PDM_MODE */
79
80 uint32_t gain_l; /**< Specifies the gain of left. must be a value between Min 0x0 ~ Max 0x3FFF. */
81
82 uint32_t gain_r; /**< Specifies the gain of right.must be a value between Min 0x0 ~ Max 0x3FFF. */
83
84 uint32_t sample_rate; /**< Specifies the sample rate.must be a value of @ref LL_PDM_SAMPLE_RATE */
85
86 } ll_pdm_init_t;
87
88 /** @} */
89
90 /** @} */
91
92 /**
93 * @defgroup PDM_LL_MACRO Defines
94 * @{
95 */
96
97 /* Exported constants --------------------------------------------------------*/
98 /** @defgroup PDM_LL_Exported_Constants PDM Exported Constants
99 * @{
100 */
101
102 /** @defgroup LL_PDM_SAMPLE_RATE PDM Sample Rate
103 * @{
104 */
105
106 /**
107 * @brief PDM sample rate.
108 */
109 #define LL_PDM_SAMPLE_RATE_15_625K PDM_CLK_SAMPLE_RATE_15_625K /**< PDM sample rate 15.625K */
110 #define LL_PDM_SAMPLE_RATE_16K PDM_CLK_SAMPLE_RATE_16K /**< PDM sample rate 16K */
111 #define LL_PDM_SAMPLE_RATE_8K PDM_CLK_SAMPLE_RATE_8K /**< PDM sample rate 8K */
112 /** @} */
113
114 /** @defgroup LL_PDM_MODE PDM Operation Mode
115 * @{
116 */
117
118 /**
119 * @brief PDM operation mode.
120 */
121 #define LL_PDM_MODE_LEFT ((uint32_t)0x00000000U) /**< PDM left mono */
122 #define LL_PDM_MODE_RIGHT ((uint32_t)0x00000001U) /**< PDM right mono */
123 #define LL_PDM_MODE_STEREO ((uint32_t)0x00000002U) /**< PDM stereo mono */
124 /** @} */
125
126 /** @defgroup LL_PDM_CLK_EN PDM Clock Enable
127 * @{
128 */
129 #define LL_PDM_CLK_ENABLE PDM_CLK_EN_ENABLE /**< PDM clk enable */
130 #define LL_PDM_CLK_DISABLE PDM_CLK_EN_DISABLE /**< PDM clk disable*/
131 /** @} */
132
133 /** @defgroup LL_PDM_RX_EN PDM Rx Enable
134 * @{
135 */
136 #define LL_PDM_LEFT_RX_ENABLE PDM_EN_L_EN_RX_ENABLE /**< PDM left rx enable*/
137 #define LL_PDM_LEFT_RX_DISABLE PDM_EN_L_EN_RX_DISABLE /**< PDM left rx disable*/
138 #define LL_PDM_RIGHT_RX_ENABLE PDM_EN_R_EN_RX_ENABLE /**< PDM right rx enable*/
139 #define LL_PDM_RIGHT_RX_DISABLE PDM_EN_R_EN_RX_DISABLE /**< PDM right rx disable*/
140 /** @} */
141
142 /** @defgroup LL_PDM_SAMPLE_DMIC_EN PDM Left Sample Dmic Enable
143 * @{
144 */
145 #define LL_PDM_LEFT_SAMPLE_DMIC_ENABLE PDM_EN_L_SMP_DMIC_ENABLE /**< PDM left sample dmic enable*/
146 #define LL_PDM_LEFT_SAMPLE_DMIC_DISABLE PDM_EN_L_SMP_DMIC_DISABLE /**< PDM left sample dmic disable*/
147 #define LL_PDM_RIGHT_SAMPLE_DMIC_ENABLE PDM_EN_R_SMP_DMIC_ENABLE /**< PDM right sample dmic enable*/
148 #define LL_PDM_RIGHT_SAMPLE_DMIC_DISABLE PDM_EN_R_SMP_DMIC_DISABLE /**< PDM right sample dmic disable*/
149 /** @} */
150
151 /** @defgroup LL_PDM_STAGE0_7_EN PDM Left Stage Enable
152 * @{
153 */
154 #define LL_PDM_LEFT_STAGE0_ENABLE PDM_EN_L_EN_STAGE0_ENABLE /**< PDM left stage0 enable*/
155 #define LL_PDM_LEFT_STAGE0_DISABLE PDM_EN_L_EN_STAGE0_DISABLE /**< PDM left stage0 disable*/
156 #define LL_PDM_LEFT_STAGE1_ENABLE PDM_EN_L_EN_STAGE1_ENABLE /**< PDM left stage1 enable*/
157 #define LL_PDM_LEFT_STAGE1_DISABLE PDM_EN_L_EN_STAGE1_DISABLE /**< PDM left stage1 disable*/
158 #define LL_PDM_LEFT_STAGE2_ENABLE PDM_EN_L_EN_STAGE2_ENABLE /**< PDM left stage2 enable*/
159 #define LL_PDM_LEFT_STAGE2_DISABLE PDM_EN_L_EN_STAGE2_DISABLE /**< PDM left stage2 disable*/
160 #define LL_PDM_LEFT_STAGE3_ENABLE PDM_EN_L_EN_STAGE3_ENABLE /**< PDM left stage3 enable*/
161 #define LL_PDM_LEFT_STAGE3_DISABLE PDM_EN_L_EN_STAGE3_DISABLE /**< PDM left stage3 disable*/
162 #define LL_PDM_LEFT_STAGE4_ENABLE PDM_EN_L_EN_STAGE4_ENABLE /**< PDM left stage4 enable*/
163 #define LL_PDM_LEFT_STAGE4_DISABLE PDM_EN_L_EN_STAGE4_DISABLE /**< PDM left stage4 disable*/
164 #define LL_PDM_LEFT_STAGE5_ENABLE PDM_EN_L_EN_STAGE5_ENABLE /**< PDM left stage5 enable*/
165 #define LL_PDM_LEFT_STAGE5_DISABLE PDM_EN_L_EN_STAGE5_DISABLE /**< PDM left stage5 disable*/
166 #define LL_PDM_LEFT_STAGE6_ENABLE PDM_EN_L_EN_STAGE6_ENABLE /**< PDM left stage6 enable*/
167 #define LL_PDM_LEFT_STAGE6_DISABLE PDM_EN_L_EN_STAGE6_DISABLE /**< PDM left stage6 disable*/
168 #define LL_PDM_LEFT_STAGE7_ENABLE PDM_EN_L_EN_STAGE7_ENABLE /**< PDM left stage7 enable*/
169 #define LL_PDM_LEFT_STAGE7_DISABLE PDM_EN_L_EN_STAGE7_DISABLE /**< PDM left stage7 disable*/
170 #define LL_PDM_RIGHT_STAGE0_ENABLE PDM_EN_R_EN_STAGE0_ENABLE /**< PDM right stage0 enable*/
171 #define LL_PDM_RIGHT_STAGE0_DISABLE PDM_EN_R_EN_STAGE0_DISABLE /**< PDM right stage0 disable*/
172 #define LL_PDM_RIGHT_STAGE1_ENABLE PDM_EN_R_EN_STAGE1_ENABLE /**< PDM right stage1 enable*/
173 #define LL_PDM_RIGHT_STAGE1_DISABLE PDM_EN_R_EN_STAGE1_DISABLE /**< PDM right stage1 disable*/
174 #define LL_PDM_RIGHT_STAGE2_ENABLE PDM_EN_R_EN_STAGE2_ENABLE /**< PDM right stage2 enable*/
175 #define LL_PDM_RIGHT_STAGE2_DISABLE PDM_EN_R_EN_STAGE2_DISABLE /**< PDM right stage2 disable*/
176 #define LL_PDM_RIGHT_STAGE3_ENABLE PDM_EN_R_EN_STAGE3_ENABLE /**< PDM right stage3 enable*/
177 #define LL_PDM_RIGHT_STAGE3_DISABLE PDM_EN_R_EN_STAGE3_DISABLE /**< PDM right stage3 disable*/
178 #define LL_PDM_RIGHT_STAGE4_ENABLE PDM_EN_R_EN_STAGE4_ENABLE /**< PDM right stage4 enable*/
179 #define LL_PDM_RIGHT_STAGE4_DISABLE PDM_EN_R_EN_STAGE4_DISABLE /**< PDM right stage4 disable*/
180 #define LL_PDM_RIGHT_STAGE5_ENABLE PDM_EN_R_EN_STAGE5_ENABLE /**< PDM right stage5 enable*/
181 #define LL_PDM_RIGHT_STAGE5_DISABLE PDM_EN_R_EN_STAGE5_DISABLE /**< PDM right stage5 disable*/
182 #define LL_PDM_RIGHT_STAGE6_ENABLE PDM_EN_R_EN_STAGE6_ENABLE /**< PDM right stage6 enable*/
183 #define LL_PDM_RIGHT_STAGE6_DISABLE PDM_EN_R_EN_STAGE6_DISABLE /**< PDM right stage6 disable*/
184 #define LL_PDM_RIGHT_STAGE7_ENABLE PDM_EN_R_EN_STAGE7_ENABLE /**< PDM right stage7 enable*/
185 #define LL_PDM_RIGHT_STAGE7_DISABLE PDM_EN_R_EN_STAGE7_DISABLE /**< PDM right stage7 disable*/
186 /** @} */
187
188 /** @defgroup LL_PDM_HPF_EN PDM Left Hpf Enable
189 * @{
190 */
191 #define LL_PDM_LEFT_HPF_ENABLE PDM_EN_L_EN_HPF_ENABLE /**< PDM left hpf enable*/
192 #define LL_PDM_LEFT_HPF_DISABLE PDM_EN_L_EN_HPF_DISABLE /**< PDM left hpf disable*/
193 #define LL_PDM_RIGHT_HPF_ENABLE PDM_EN_R_EN_HPF_ENABLE /**< PDM right hpf enable*/
194 #define LL_PDM_RIGHT_HPF_DISABLE PDM_EN_R_EN_HPF_DISABLE /**< PDM right hpf disable*/
195 /** @} */
196
197 /** @defgroup LL_PDM_HPF_BYPASS_EN PDM Left Hpf Bypass Enable
198 * @{
199 */
200 #define LL_PDM_LEFT_HPF_BYPASS_ENABLE PDM_HPF_CFG_L_BYPASS_ENABLE /**< PDM left hpf bypass enable*/
201 #define LL_PDM_LEFT_HPF_BYPASS_DISABLE PDM_HPF_CFG_L_BYPASS_DISABLE /**< PDM left hpf bypass disable*/
202 #define LL_PDM_RIGHT_HPF_BYPASS_ENABLE PDM_HPF_CFG_R_BYPASS_ENABLE /**< PDM right hpf bypass enable*/
203 #define LL_PDM_RIGHT_HPF_BYPASS_DISABLE PDM_HPF_CFG_R_BYPASS_DISABLE /**< PDM right hpf bypass disable*/
204 /** @} */
205
206 /** @defgroup LL_PDM_HPF_CORNER PDM Right Hpf Corner
207 * @{
208 */
209 #define LL_PDM_LEFT_HPF_CORNER_0_25 PDM_HPF_CFG_L_CORNER_0_25 /**< PDM right hpf corner 0.25*/
210 #define LL_PDM_LEFT_HPF_CORNER_1 PDM_HPF_CFG_L_CORNER_1 /**< PDM right hpf corner 1*/
211 #define LL_PDM_LEFT_HPF_CORNER_4 PDM_HPF_CFG_L_CORNER_4 /**< PDM right hpf corner 4*/
212 #define LL_PDM_LEFT_HPF_CORNER_16 PDM_HPF_CFG_L_CORNER_16 /**< PDM right hpf corner 16*/
213 #define LL_PDM_RIGHT_HPF_CORNER_0_25 PDM_HPF_CFG_R_CORNER_0_25 /**< PDM right hpf corner 0.25*/
214 #define LL_PDM_RIGHT_HPF_CORNER_1 PDM_HPF_CFG_R_CORNER_1 /**< PDM right hpf corner 1*/
215 #define LL_PDM_RIGHT_HPF_CORNER_4 PDM_HPF_CFG_R_CORNER_4 /**< PDM right hpf corner 4*/
216 #define LL_PDM_RIGHT_HPF_CORNER_16 PDM_HPF_CFG_R_CORNER_16 /**< PDM right hpf corner 16*/
217 /** @} */
218
219 /** @defgroup LL_PDM_HPF_FREEZE_EN PDM Left Hpf Freeze Enable
220 * @{
221 */
222 #define LL_PDM_LEFT_HPF_FREEZE_ENABLE PDM_HPF_CFG_L_FREEZE_ENABLE /**< PDM left hpf freeze enable*/
223 #define LL_PDM_LEFT_HPF_FREEZE_DISABLE PDM_HPF_CFG_L_FREEZE_DISABLE /**< PDM left hpf freeze disable*/
224 #define LL_PDM_RIGHT_HPF_FREEZE_ENABLE PDM_HPF_CFG_R_FREEZE_ENABLE /**< PDM right hpf freeze enable*/
225 #define LL_PDM_RIGHT_HPF_FREEZE_DISABLE PDM_HPF_CFG_R_FREEZE_DISABLE /**< PDM right hpf freeze disable*/
226 /** @} */
227
228 /** @} */
229 /* Exported macro ------------------------------------------------------------*/
230 /** @defgroup PDM_LL_Exported_Macros PDM Exported Macros
231 * @{
232 */
233
234 /** @defgroup PDM_LL_EM_WRITE_READ Common Write and read registers Macros
235 * @{
236 */
237
238 /**
239 * @brief Write a value in PDM register
240 * @param __instance__ PDM instance
241 * @param __REG__ Register to be written
242 * @param __VALUE__ Value to be written in the register
243 * @retval None
244 */
245 #define LL_PDM_WriteReg(__instance__, __REG__, __VALUE__) WRITE_REG(__instance__->__REG__, (__VALUE__))
246
247 /**
248 * @brief Read a value in PDM register
249 * @param __instance__ PDM instance
250 * @param __REG__ Register to be read
251 * @retval Register value
252 */
253 #define LL_PDM_ReadReg(__instance__, __REG__) READ_REG(__instance__->__REG__)
254
255 /** @} */
256
257 /** @} */
258
259 /** @} */
260
261 /* Exported functions --------------------------------------------------------*/
262 /** @defgroup PDM_LL_DRIVER_FUNCTIONS Functions
263 * @{
264 */
265
266 /** @defgroup PDM_LL_EF_Configuration Configuration functions
267 * @{
268 */
269
270 /**
271 * @brief Enable PDM Module CLK.
272 * @note This function is used to enable the PDM Module CLK.
273 *
274 * Register|BitsName
275 * --------|--------
276 * PDM_CLK | EN
277 *
278 * @param PDMx instance.
279 * @retval None
280 */
281 __STATIC_INLINE void ll_pdm_enable_clk(pdm_regs_t *PDMx)
282 {
283 MODIFY_REG(PDMx->CLK, PDM_CLK_EN, LL_PDM_CLK_ENABLE);
284 }
285
286 /**
287 * @brief Disable PDM Module CLK.
288 * @note This function is used to enable the PDM Module CLK.
289 *
290 * Register|BitsName
291 * --------|--------
292 * PDM_CLK | EN
293 *
294 * @param PDMx instance.
295 * @retval None
296 */
297 __STATIC_INLINE void ll_pdm_disable_clk(pdm_regs_t *PDMx)
298 {
299 MODIFY_REG(PDMx->CLK, PDM_CLK_EN, LL_PDM_CLK_DISABLE);
300 }
301
302 /**
303 * @brief Disable PDM Module CLK.
304 * @note This function is used to check the PDM Module CLK is enabled.
305 *
306 * Register|BitsName
307 * --------|--------
308 * PDM_CLK | EN
309 *
310 * @param PDMx instance.
311 * @retval None
312 */
313 __STATIC_INLINE uint32_t ll_pdm_is_enable_clk(pdm_regs_t *PDMx)
314 {
315 return (READ_BITS(PDMx->CLK, PDM_CLK_EN) == LL_PDM_CLK_ENABLE);
316 }
317
318 /**
319 * @brief Set PDM sample rate
320 * @note This function is Configures the sample rate for PDM
321 *
322 * Register|BitsName
323 * --------|--------
324 * PDM_CLK | SMAPLE_RATE
325 *
326 * @param PDMx instance
327 * @param sample_rate This parameter can be one of the following values:
328 * @arg @ref LL_PDM_SAMPLE_RATE_15_625K
329 * @arg @ref LL_PDM_SAMPLE_RATE_16K
330 * @arg @ref LL_PDM_SAMPLE_RATE_8K
331 * @retval None
332 */
333 __STATIC_INLINE void ll_pdm_set_sample_rate(pdm_regs_t *PDMx, uint32_t sample_rate)
334 {
335 MODIFY_REG(PDMx->CLK, PDM_CLK_SAMPLE_RATE, sample_rate);
336 }
337
338 /**
339 * @brief Get PDM sample rate
340 *
341 * Register|BitsName
342 * --------|--------
343 * PDM_CLK | SMAPLE_RATE
344 *
345 * @param PDMx instance
346 * @retval one of the following values:
347 * @arg @ref LL_PDM_SAMPLE_RATE_15_625K
348 * @arg @ref LL_PDM_SAMPLE_RATE_16K
349 * @arg @ref LL_PDM_SAMPLE_RATE_8K
350 */
351 __STATIC_INLINE uint32_t ll_pdm_get_sample_rate(pdm_regs_t *PDMx)
352 {
353 return (READ_BITS(PDMx->CLK, PDM_CLK_SAMPLE_RATE));
354 }
355
356 /**
357 * @brief Set PDM posedge en pulse cfg
358 * @note This function is Configures how many 16MHz clock cycles after rising edge of PDM_CLK to sample data (rising edge capture)
359 *
360 * Register|BitsName
361 * --------|--------
362 * PDM_CLK_DIV | TARGET
363 *
364 * @param PDMx instance
365 * @param target This parameter can be one of the following values:
366 * Min_Data = 0 and Max_Data = 0xF
367 * @retval None
368 */
369 __STATIC_INLINE void ll_pdm_set_posedge_en_pulse_cfg(pdm_regs_t *PDMx, uint32_t target)
370 {
371 MODIFY_REG(PDMx->CLK_DIV, PDM_CLK_DIV_POSEDGE_EN_PULSE_CFG, (target << PDM_CLK_DIV_POSEDGE_EN_PULSE_CFG_POS));
372 }
373
374 /**
375 * @brief Get PDM posedge en pulse cfg
376 *
377 * Register|BitsName
378 * --------|--------
379 * PDM_CLK_DIV | TARGET
380 *
381 * @param PDMx instance
382 * @retval None
383 */
384 __STATIC_INLINE uint32_t ll_pdm_get_posedge_en_pulse_cfg(pdm_regs_t *PDMx)
385 {
386 return (READ_BITS(PDMx->CLK_DIV, PDM_CLK_DIV_POSEDGE_EN_PULSE_CFG) >> PDM_CLK_DIV_POSEDGE_EN_PULSE_CFG_POS);
387 }
388
389 /**
390 * @brief Set PDM negedge en pulse cfg
391 * @note This function is Configures how many 16MHz clock cycles after rising edge of PDM_CLK to sample data (negative edge capture)
392 *
393 * Register|BitsName
394 * --------|--------
395 * PDM_CLK_DIV | TARGET
396 *
397 * @param PDMx instance
398 * @param target This parameter can be one of the following values:
399 * Min_Data = 0 and Max_Data = 0xF
400 * @retval None
401 */
402 __STATIC_INLINE void ll_pdm_set_negedge_en_pulse_cfg(pdm_regs_t *PDMx, uint32_t target)
403 {
404 MODIFY_REG(PDMx->CLK_DIV, PDM_CLK_DIV_NEGEDGE_EN_PULSE_CFG, (target << PDM_CLK_DIV_NEGEDGE_EN_PULSE_CFG_POS));
405 }
406
407 /**
408 * @brief Get PDM posedge en pulse cfg
409 *
410 * Register|BitsName
411 * --------|--------
412 * PDM_CLK_DIV | TARGET
413 *
414 * @param PDMx instance
415 * @retval None
416 */
417 __STATIC_INLINE uint32_t ll_pdm_get_negedge_en_pulse_cfg(pdm_regs_t *PDMx)
418 {
419 return (READ_BITS(PDMx->CLK_DIV, PDM_CLK_DIV_NEGEDGE_EN_PULSE_CFG) >> PDM_CLK_DIV_NEGEDGE_EN_PULSE_CFG_POS);
420 }
421
422 /**
423 * @brief PDM Module enable left channel sample dmic.
424 * @note This function is used to set PDM left enable register
425 *
426 * Register|BitsName
427 * --------|--------
428 * EN_L | ENABLE_RX
429 *
430 * @param PDMx instance
431 * @retval None
432 */
433 __STATIC_INLINE void ll_pdm_enable_left_channel(pdm_regs_t *PDMx)
434 {
435
436 MODIFY_REG(PDMx->EN_L, PDM_EN_L_EN_RX | PDM_EN_L_EN_STAGE0 | PDM_EN_L_EN_STAGE1 |\
437 PDM_EN_L_EN_STAGE2 | PDM_EN_L_EN_STAGE3 | PDM_EN_L_EN_STAGE4 |\
438 PDM_EN_L_EN_STAGE5 | PDM_EN_L_EN_STAGE6 | PDM_EN_L_EN_STAGE7 |\
439 PDM_EN_L_SMP_DMIC | PDM_EN_L_EN_HPF, \
440 PDM_EN_L_EN_RX_ENABLE | PDM_EN_L_SMP_DMIC_ENABLE | PDM_EN_L_EN_STAGE0_DISABLE |\
441 PDM_EN_L_EN_STAGE1_DISABLE | PDM_EN_L_EN_STAGE2_ENABLE | PDM_EN_L_EN_STAGE3_ENABLE |\
442 PDM_EN_L_EN_STAGE4_ENABLE | PDM_EN_L_EN_STAGE5_ENABLE | PDM_EN_L_EN_STAGE6_ENABLE |\
443 PDM_EN_L_EN_STAGE7_ENABLE | PDM_EN_L_EN_HPF_ENABLE);
444 }
445
446 /**
447 * @brief PDM Module disable left channel sample dmic.
448 * @note This function is used to set PDM left disable register
449 *
450 * Register|BitsName
451 * --------|--------
452 * EN_L | ENABLE_RX
453 *
454 * @param PDMx instance
455 * @retval None
456 */
457 __STATIC_INLINE void ll_pdm_disable_left_channel(pdm_regs_t *PDMx)
458 {
459
460 MODIFY_REG(PDMx->EN_L, PDM_EN_L_EN_RX | PDM_EN_L_EN_STAGE0 | PDM_EN_L_EN_STAGE1 |\
461 PDM_EN_L_EN_STAGE2 | PDM_EN_L_EN_STAGE3 | PDM_EN_L_EN_STAGE4 |\
462 PDM_EN_L_EN_STAGE5 | PDM_EN_L_EN_STAGE6 | PDM_EN_L_EN_STAGE7 |\
463 PDM_EN_L_SMP_DMIC | PDM_EN_L_EN_HPF, \
464 PDM_EN_L_EN_RX_DISABLE | PDM_EN_L_SMP_DMIC_DISABLE | PDM_EN_L_EN_STAGE0_DISABLE |\
465 PDM_EN_L_EN_STAGE1_DISABLE | PDM_EN_L_EN_STAGE2_DISABLE | PDM_EN_L_EN_STAGE3_DISABLE |\
466 PDM_EN_L_EN_STAGE4_DISABLE | PDM_EN_L_EN_STAGE5_DISABLE | PDM_EN_L_EN_STAGE6_DISABLE |\
467 PDM_EN_L_EN_STAGE7_DISABLE | PDM_EN_L_EN_HPF_DISABLE);
468 }
469
470 /**
471 * @brief PDM Module enable right channel sample dmic..
472 * @note This function is used to set PDM right enable register
473 *
474 * Register|BitsName
475 * --------|--------
476 * EN_L | ENABLE_RX
477 *
478 * @param PDMx instance
479 * @retval None
480 */
481 __STATIC_INLINE void ll_pdm_enable_right_channel(pdm_regs_t *PDMx)
482 {
483
484 MODIFY_REG(PDMx->EN_R, PDM_EN_R_EN_RX | PDM_EN_R_EN_STAGE0 | PDM_EN_R_EN_STAGE1 |\
485 PDM_EN_R_EN_STAGE2 | PDM_EN_R_EN_STAGE3 | PDM_EN_R_EN_STAGE4 |\
486 PDM_EN_R_EN_STAGE5 | PDM_EN_R_EN_STAGE6 | PDM_EN_R_EN_STAGE7 |\
487 PDM_EN_R_SMP_DMIC | PDM_EN_R_EN_HPF, \
488 PDM_EN_R_EN_RX_ENABLE | PDM_EN_R_SMP_DMIC_ENABLE | PDM_EN_R_EN_STAGE0_DISABLE |\
489 PDM_EN_R_EN_STAGE1_DISABLE | PDM_EN_R_EN_STAGE2_ENABLE | PDM_EN_R_EN_STAGE3_ENABLE |\
490 PDM_EN_R_EN_STAGE4_ENABLE | PDM_EN_R_EN_STAGE5_ENABLE | PDM_EN_R_EN_STAGE6_ENABLE |\
491 PDM_EN_R_EN_STAGE7_ENABLE | PDM_EN_R_EN_HPF_ENABLE);
492 }
493
494 /**
495 * @brief PDM Module disable right channel sample dmic..
496 * @note This function is used to set PDM right disable register
497 *
498 * Register|BitsName
499 * --------|--------
500 * EN_L | ENABLE_RX
501 *
502 * @param PDMx instance
503 * @retval None
504 */
505 __STATIC_INLINE void ll_pdm_disable_right_channel(pdm_regs_t *PDMx)
506 {
507
508 MODIFY_REG(PDMx->EN_R, PDM_EN_R_EN_RX | PDM_EN_R_EN_STAGE0 | PDM_EN_R_EN_STAGE1 |\
509 PDM_EN_R_EN_STAGE2 | PDM_EN_R_EN_STAGE3 | PDM_EN_R_EN_STAGE4 |\
510 PDM_EN_R_EN_STAGE5 | PDM_EN_R_EN_STAGE6 | PDM_EN_R_EN_STAGE7 |\
511 PDM_EN_R_SMP_DMIC | PDM_EN_R_EN_HPF, \
512 PDM_EN_R_EN_RX_DISABLE | PDM_EN_R_SMP_DMIC_DISABLE | PDM_EN_R_EN_STAGE0_DISABLE |\
513 PDM_EN_R_EN_STAGE1_DISABLE | PDM_EN_R_EN_STAGE2_DISABLE | PDM_EN_R_EN_STAGE3_DISABLE |\
514 PDM_EN_R_EN_STAGE4_DISABLE | PDM_EN_R_EN_STAGE5_DISABLE | PDM_EN_R_EN_STAGE6_DISABLE |\
515 PDM_EN_R_EN_STAGE7_DISABLE | PDM_EN_R_EN_HPF_DISABLE);
516 }
517
518 /**
519 * @brief Enable PDM Module Left RX.
520 * @note This function is used to set PDM left RX enable
521 *
522 * Register|BitsName
523 * --------|--------
524 * EN_L | ENABLE_RX
525 *
526 * @param PDMx instance
527 * @retval None
528 */
529 __STATIC_INLINE void ll_pdm_enable_left_rx(pdm_regs_t *PDMx)
530 {
531 MODIFY_REG(PDMx->EN_L, PDM_EN_L_EN_RX, LL_PDM_LEFT_RX_ENABLE);
532 }
533
534 /**
535 * @brief Disable PDM Module Left RX.
536 * @note This function is used to set PDM left RX disable
537 *
538 * Register|BitsName
539 * --------|--------
540 * EN_L | ENABLE_RX
541 *
542 * @param PDMx instance
543 * @retval None
544 */
545 __STATIC_INLINE void ll_pdm_disable_left_rx(pdm_regs_t *PDMx)
546 {
547 MODIFY_REG(PDMx->EN_L, PDM_EN_L_EN_RX, LL_PDM_LEFT_RX_DISABLE);
548 }
549
550 /**
551 * @brief is PDM enables left rx
552 * @note This function is used to check the PDM Module left rx is enabled.
553 *
554 * Register|BitsName
555 * --------|--------
556 * EN_L | ENABLE_RX
557 *
558 * @param PDMx instance.
559 * @retval None
560 */
561 __STATIC_INLINE uint32_t ll_pdm_is_enable_left_rx(pdm_regs_t *PDMx)
562 {
563 return (READ_BITS(PDMx->EN_L, PDM_EN_L_EN_RX) == LL_PDM_LEFT_RX_ENABLE);
564 }
565
566
567 /**
568 * @brief Enable PDM Module right RX.
569 * @note This function is used to set PDM right RX enable
570 *
571 * Register|BitsName
572 * --------|--------
573 * EN_R | ENABLE_RX
574 *
575 * @param PDMx instance
576 * @retval None
577 */
578 __STATIC_INLINE void ll_pdm_enable_right_rx(pdm_regs_t *PDMx)
579 {
580 MODIFY_REG(PDMx->EN_R, PDM_EN_R_EN_RX, LL_PDM_RIGHT_RX_ENABLE);
581 }
582
583 /**
584 * @brief Disable PDM Module right RX.
585 * @note This function is used to set PDM right RX disable
586 *
587 * Register|BitsName
588 * --------|--------
589 * EN_R | ENABLE_RX
590 *
591 * @param PDMx instance
592 * @retval None
593 */
594 __STATIC_INLINE void ll_pdm_disable_right_rx(pdm_regs_t *PDMx)
595 {
596 MODIFY_REG(PDMx->EN_R, PDM_EN_R_EN_RX, LL_PDM_RIGHT_RX_DISABLE);
597 }
598
599 /**
600 * @brief is PDM enables right rx
601 * @note This function is used to check the PDM Module right rx is enabled.
602 *
603 * Register|BitsName
604 * --------|--------
605 * EN_R | EN
606 *
607 * @param PDMx instance.
608 * @retval None
609 */
610 __STATIC_INLINE uint32_t ll_pdm_is_enable_right_rx(pdm_regs_t *PDMx)
611 {
612 return (READ_BITS(PDMx->EN_R, PDM_EN_R_EN_RX) == LL_PDM_RIGHT_RX_ENABLE);
613 }
614
615
616 /**
617 * @brief Enable PDM Module Left sample dmic.
618 * @note This function is used to set PDM Left sample dmic enable
619 *
620 * Register|BitsName
621 * --------|--------
622 * EN_L | SAMPLE_DMIC
623 *
624 * @param PDMx instance
625 * @retval None
626 */
627 __STATIC_INLINE void ll_pdm_enable_left_sample_dmic(pdm_regs_t *PDMx)
628 {
629 MODIFY_REG(PDMx->EN_L, PDM_EN_L_SMP_DMIC, LL_PDM_LEFT_SAMPLE_DMIC_ENABLE);
630 }
631
632 /**
633 * @brief Disable PDM Module Left sample dmic.
634 * @note This function is used to set PDM Left sample dmic enable
635
636 * Register|BitsName
637 * --------|--------
638 * EN_L | SAMPLE_DMIC
639 *
640 * @param PDMx instance
641 * @retval None
642 */
643 __STATIC_INLINE void ll_pdm_disable_left_sample_dmic(pdm_regs_t *PDMx)
644 {
645 MODIFY_REG(PDMx->EN_L, PDM_EN_L_SMP_DMIC, LL_PDM_LEFT_SAMPLE_DMIC_DISABLE);
646 }
647
648 /**
649 * @brief is PDM enables left rx
650 * @note This function is used to check the PDM Module left rx is enabled.
651 *
652 * Register|BitsName
653 * --------|--------
654 * EN_L | SAMPLE_DMIC
655 *
656 * @param PDMx instance.
657 * @retval None
658 */
659 __STATIC_INLINE uint32_t ll_pdm_is_enable_left_sample_dmic(pdm_regs_t *PDMx)
660 {
661 return (READ_BITS(PDMx->EN_L, PDM_EN_L_SMP_DMIC) == LL_PDM_LEFT_SAMPLE_DMIC_ENABLE);
662 }
663
664 /**
665 * @brief Enable PDM Module right sample dmic.
666 * @note This function is used to set PDM right sample dmic enable
667 *
668 * Register|BitsName
669 * --------|--------
670 * EN_R | SAMPLE_DMIC
671 *
672 * @param PDMx instance
673 * @retval None
674 */
675 __STATIC_INLINE void ll_pdm_enable_right_sample_dmic(pdm_regs_t *PDMx)
676 {
677 MODIFY_REG(PDMx->EN_R, PDM_EN_R_SMP_DMIC, LL_PDM_RIGHT_SAMPLE_DMIC_ENABLE);
678 }
679
680 /**
681 * @brief Disable PDM Module right sample dmic.
682 * @note This function is used to set PDM right sample dmic enable
683
684 * Register|BitsName
685 * --------|--------
686 * EN_R | SAMPLE_DMIC
687 *
688 * @param PDMx instance
689 * @retval None
690 */
691 __STATIC_INLINE void ll_pdm_disable_right_sample_dmic(pdm_regs_t *PDMx)
692 {
693 MODIFY_REG(PDMx->EN_R, PDM_EN_R_SMP_DMIC, LL_PDM_RIGHT_SAMPLE_DMIC_DISABLE);
694 }
695
696 /**
697 * @brief is PDM enables right rx
698 * @note This function is used to check the PDM Module right rx is enabled.
699 *
700 * Register|BitsName
701 * --------|--------
702 * EN_R | SAMPLE_DMIC
703 *
704 * @param PDMx instance.
705 * @retval None
706 */
707 __STATIC_INLINE uint32_t ll_pdm_is_enable_right_sample_dmic(pdm_regs_t *PDMx)
708 {
709 return (READ_BITS(PDMx->EN_R, PDM_EN_R_SMP_DMIC) == LL_PDM_RIGHT_SAMPLE_DMIC_ENABLE);
710 }
711
712 /**
713 * @brief Enable PDM Module Left stage0.
714 * @note This function is used to set PDM Left stage0 enable
715 *
716 * Register|BitsName
717 * --------|--------
718 * EN_L | EN_STAGE0
719 *
720 * @param PDMx instance
721 * @retval None
722 */
723 __STATIC_INLINE void ll_pdm_enable_left_stage0(pdm_regs_t *PDMx)
724 {
725 MODIFY_REG(PDMx->EN_L, PDM_EN_L_EN_STAGE0, LL_PDM_LEFT_STAGE0_ENABLE);
726 }
727
728 /**
729 * @brief Disable PDM Module Left stage0.
730 * @note This function is used to set PDM Left stage0 enable
731
732 * Register|BitsName
733 * --------|--------
734 * EN_L | EN_STAGE0
735 *
736 * @param PDMx instance
737 * @retval None
738 */
739 __STATIC_INLINE void ll_pdm_disable_left_stage0(pdm_regs_t *PDMx)
740 {
741 MODIFY_REG(PDMx->EN_L, PDM_EN_L_EN_STAGE0, LL_PDM_LEFT_STAGE0_DISABLE);
742 }
743
744 /**
745 * @brief is PDM enables left stage0
746 * @note This function is used to check the PDM Module left stage0 is enabled.
747 *
748 * Register|BitsName
749 * --------|--------
750 * EN_L | EN_STAGE0
751 *
752 * @param PDMx instance.
753 * @retval None
754 */
755 __STATIC_INLINE uint32_t ll_pdm_is_enable_left_stage0(pdm_regs_t *PDMx)
756 {
757 return (READ_BITS(PDMx->EN_L, PDM_EN_L_EN_STAGE0) == LL_PDM_LEFT_STAGE0_ENABLE);
758 }
759
760 /**
761 * @brief Enable PDM Module right stage0
762 * @note This function is used to set PDM right stage0 enable
763 *
764 * Register|BitsName
765 * --------|--------
766 * EN_R | EN_STAGE0
767 *
768 * @param PDMx instance
769 * @retval None
770 */
771 __STATIC_INLINE void ll_pdm_enable_right_stage0(pdm_regs_t *PDMx)
772 {
773 MODIFY_REG(PDMx->EN_R, PDM_EN_R_EN_STAGE0, LL_PDM_RIGHT_STAGE0_ENABLE);
774 }
775
776 /**
777 * @brief Disable PDM Module right stage0
778 * @note This function is used to set PDM right stage0 enable
779
780 * Register|BitsName
781 * --------|--------
782 * EN_R | EN_STAGE0
783 *
784 * @param PDMx instance
785 * @retval None
786 */
787 __STATIC_INLINE void ll_pdm_disable_right_stage0(pdm_regs_t *PDMx)
788 {
789 MODIFY_REG(PDMx->EN_R, PDM_EN_R_EN_STAGE0, LL_PDM_RIGHT_STAGE0_DISABLE);
790 }
791
792 /**
793 * @brief is PDM enables right stage0
794 * @note This function is used to check the PDM Module right stage0is enabled.
795 *
796 * Register|BitsName
797 * --------|--------
798 * EN_R | EN_STAGE0
799 *
800 * @param PDMx instance.
801 * @retval None
802 */
803 __STATIC_INLINE uint32_t ll_pdm_is_enable_right_stage0(pdm_regs_t *PDMx)
804 {
805 return (READ_BITS(PDMx->EN_R, PDM_EN_R_EN_STAGE0) == LL_PDM_RIGHT_STAGE0_ENABLE);
806 }
807
808 /**
809 * @brief Enable PDM Module Left stage1.
810 * @note This function is used to set PDM Left stage1 enable
811 *
812 * Register|BitsName
813 * --------|--------
814 * EN_L | EN_STAGE1
815 *
816 * @param PDMx instance
817 * @retval None
818 */
819 __STATIC_INLINE void ll_pdm_enable_left_stage1(pdm_regs_t *PDMx)
820 {
821 MODIFY_REG(PDMx->EN_L, PDM_EN_L_EN_STAGE1, LL_PDM_LEFT_STAGE1_ENABLE);
822 }
823
824 /**
825 * @brief Disable PDM Module Left stage1.
826 * @note This function is used to set PDM Left stage1 enable
827
828 * Register|BitsName
829 * --------|--------
830 * EN_L | EN_STAGE1
831 *
832 * @param PDMx instance
833 * @retval None
834 */
835 __STATIC_INLINE void ll_pdm_disable_left_stage1(pdm_regs_t *PDMx)
836 {
837 MODIFY_REG(PDMx->EN_L, PDM_EN_L_EN_STAGE1, LL_PDM_LEFT_STAGE1_DISABLE);
838 }
839
840 /**
841 * @brief is PDM enables left stage1
842 * @note This function is used to check the PDM Module left stage1 is enabled.
843 *
844 * Register|BitsName
845 * --------|--------
846 * EN_L | EN_STAGE1
847 *
848 * @param PDMx instance.
849 * @retval None
850 */
851 __STATIC_INLINE uint32_t ll_pdm_is_enable_left_stage1(pdm_regs_t *PDMx)
852 {
853 return (READ_BITS(PDMx->EN_L, PDM_EN_L_EN_STAGE1) == LL_PDM_LEFT_STAGE1_ENABLE);
854 }
855
856 /**
857 * @brief Enable PDM Module right stage1
858 * @note This function is used to set PDM right stage1 enable
859 *
860 * Register|BitsName
861 * --------|--------
862 * EN_R | EN_STAGE1
863 *
864 * @param PDMx instance
865 * @retval None
866 */
867 __STATIC_INLINE void ll_pdm_enable_right_stage1(pdm_regs_t *PDMx)
868 {
869 MODIFY_REG(PDMx->EN_R, PDM_EN_R_EN_STAGE1, LL_PDM_RIGHT_STAGE1_ENABLE);
870 }
871
872 /**
873 * @brief Disable PDM Module right stage1
874 * @note This function is used to set PDM right stage1 enable
875
876 * Register|BitsName
877 * --------|--------
878 * EN_R | EN_STAGE1
879 *
880 * @param PDMx instance
881 * @retval None
882 */
883 __STATIC_INLINE void ll_pdm_disable_right_stage1(pdm_regs_t *PDMx)
884 {
885 MODIFY_REG(PDMx->EN_R, PDM_EN_R_EN_STAGE1, LL_PDM_RIGHT_STAGE1_DISABLE);
886 }
887
888 /**
889 * @brief is PDM enables right stage1
890 * @note This function is used to check the PDM Module right stage1is enabled.
891 *
892 * Register|BitsName
893 * --------|--------
894 * EN_R | EN_STAGE1
895 *
896 * @param PDMx instance.
897 * @retval None
898 */
899 __STATIC_INLINE uint32_t ll_pdm_is_enable_right_stage1(pdm_regs_t *PDMx)
900 {
901 return (READ_BITS(PDMx->EN_R, PDM_EN_R_EN_STAGE1) == LL_PDM_RIGHT_STAGE1_ENABLE);
902 }
903
904 /**
905 * @brief Enable PDM Module Left stage2.
906 * @note This function is used to set PDM Left stage2 enable
907 *
908 * Register|BitsName
909 * --------|--------
910 * EN_L | EN_STAGE2
911 *
912 * @param PDMx instance
913 * @retval None
914 */
915 __STATIC_INLINE void ll_pdm_enable_left_stage2(pdm_regs_t *PDMx)
916 {
917 MODIFY_REG(PDMx->EN_L, PDM_EN_L_EN_STAGE2, LL_PDM_LEFT_STAGE2_ENABLE);
918 }
919
920 /**
921 * @brief Disable PDM Module Left stage2.
922 * @note This function is used to set PDM Left stage1 enable
923
924 * Register|BitsName
925 * --------|--------
926 * EN_L | EN_STAGE2
927 *
928 * @param PDMx instance
929 * @retval None
930 */
931 __STATIC_INLINE void ll_pdm_disable_left_stage2(pdm_regs_t *PDMx)
932 {
933 MODIFY_REG(PDMx->EN_L, PDM_EN_L_EN_STAGE2, LL_PDM_LEFT_STAGE2_DISABLE);
934 }
935
936 /**
937 * @brief is PDM enables left stage2
938 * @note This function is used to check the PDM Module left stage2 is enabled.
939 *
940 * Register|BitsName
941 * --------|--------
942 * EN_L | EN_STAGE2
943 *
944 * @param PDMx instance.
945 * @retval None
946 */
947 __STATIC_INLINE uint32_t ll_pdm_is_enable_left_stage2(pdm_regs_t *PDMx)
948 {
949 return (READ_BITS(PDMx->EN_L, PDM_EN_L_EN_STAGE2) == LL_PDM_LEFT_STAGE2_ENABLE);
950 }
951
952 /**
953 * @brief Enable PDM Module right stage2
954 * @note This function is used to set PDM right stage2 enable
955 *
956 * Register|BitsName
957 * --------|--------
958 * EN_R | EN_STAGE2
959 *
960 * @param PDMx instance
961 * @retval None
962 */
963 __STATIC_INLINE void ll_pdm_enable_right_stage2(pdm_regs_t *PDMx)
964 {
965 MODIFY_REG(PDMx->EN_R, PDM_EN_R_EN_STAGE2, LL_PDM_RIGHT_STAGE2_ENABLE);
966 }
967
968 /**
969 * @brief Disable PDM Module right stage2
970 * @note This function is used to set PDM right stage2 enable
971
972 * Register|BitsName
973 * --------|--------
974 * EN_R | EN_STAGE2
975 *
976 * @param PDMx instance
977 * @retval None
978 */
979 __STATIC_INLINE void ll_pdm_disable_right_stage2(pdm_regs_t *PDMx)
980 {
981 MODIFY_REG(PDMx->EN_R, PDM_EN_R_EN_STAGE2, LL_PDM_RIGHT_STAGE2_DISABLE);
982 }
983
984 /**
985 * @brief is PDM enables right stage2
986 * @note This function is used to check the PDM Module right stage2 is enabled.
987 *
988 * Register|BitsName
989 * --------|--------
990 * EN_R | EN_STAGE2
991 *
992 * @param PDMx instance.
993 * @retval None
994 */
995 __STATIC_INLINE uint32_t ll_pdm_is_enable_right_stage2(pdm_regs_t *PDMx)
996 {
997 return (READ_BITS(PDMx->EN_R, PDM_EN_R_EN_STAGE2) == LL_PDM_RIGHT_STAGE2_ENABLE);
998 }
999
1000 /**
1001 * @brief Enable PDM Module Left stage3.
1002 * @note This function is used to set PDM Left stage3 enable
1003 *
1004 * Register|BitsName
1005 * --------|--------
1006 * EN_L | EN_STAGE3
1007 *
1008 * @param PDMx instance
1009 * @retval None
1010 */
1011 __STATIC_INLINE void ll_pdm_enable_left_stage3(pdm_regs_t *PDMx)
1012 {
1013 MODIFY_REG(PDMx->EN_L, PDM_EN_L_EN_STAGE3, LL_PDM_LEFT_STAGE3_ENABLE);
1014 }
1015
1016 /**
1017 * @brief Disable PDM Module Left stage3.
1018 * @note This function is used to set PDM Left stage3 enable
1019
1020 * Register|BitsName
1021 * --------|--------
1022 * EN_L | EN_STAGE3
1023 *
1024 * @param PDMx instance
1025 * @retval None
1026 */
1027 __STATIC_INLINE void ll_pdm_disable_left_stage3(pdm_regs_t *PDMx)
1028 {
1029 MODIFY_REG(PDMx->EN_L, PDM_EN_L_EN_STAGE3, LL_PDM_LEFT_STAGE3_DISABLE);
1030 }
1031
1032 /**
1033 * @brief is PDM enables left stage3
1034 * @note This function is used to check the PDM Module left stage3 is enabled.
1035 *
1036 * Register|BitsName
1037 * --------|--------
1038 * EN_L | EN_STAGE3
1039 *
1040 * @param PDMx instance.
1041 * @retval None
1042 */
1043 __STATIC_INLINE uint32_t ll_pdm_is_enable_left_stage3(pdm_regs_t *PDMx)
1044 {
1045 return (READ_BITS(PDMx->EN_L, PDM_EN_L_EN_STAGE3) == LL_PDM_LEFT_STAGE3_ENABLE);
1046 }
1047
1048 /**
1049 * @brief Enable PDM Module right stage3
1050 * @note This function is used to set PDM right stage3 enable
1051 *
1052 * Register|BitsName
1053 * --------|--------
1054 * EN_R | EN_STAGE3
1055 *
1056 * @param PDMx instance
1057 * @retval None
1058 */
1059 __STATIC_INLINE void ll_pdm_enable_right_stage3(pdm_regs_t *PDMx)
1060 {
1061 MODIFY_REG(PDMx->EN_R, PDM_EN_R_EN_STAGE3, LL_PDM_RIGHT_STAGE3_ENABLE);
1062 }
1063
1064 /**
1065 * @brief Disable PDM Module right stage3
1066 * @note This function is used to set PDM right stage3 enable
1067
1068 * Register|BitsName
1069 * --------|--------
1070 * EN_R | EN_STAGE3
1071 *
1072 * @param PDMx instance
1073 * @retval None
1074 */
1075 __STATIC_INLINE void ll_pdm_disable_right_stage3(pdm_regs_t *PDMx)
1076 {
1077 MODIFY_REG(PDMx->EN_R, PDM_EN_R_EN_STAGE3, LL_PDM_RIGHT_STAGE3_DISABLE);
1078 }
1079
1080 /**
1081 * @brief is PDM enables right stage3
1082 * @note This function is used to check the PDM Module right stage3 is enabled.
1083 *
1084 * Register|BitsName
1085 * --------|--------
1086 * EN_R | EN_STAGE3
1087 *
1088 * @param PDMx instance.
1089 * @retval None
1090 */
1091 __STATIC_INLINE uint32_t ll_pdm_is_enable_right_stage3(pdm_regs_t *PDMx)
1092 {
1093 return (READ_BITS(PDMx->EN_R, PDM_EN_R_EN_STAGE3) == LL_PDM_RIGHT_STAGE3_ENABLE);
1094 }
1095
1096 /**
1097 * @brief Enable PDM Module Left stage4.
1098 * @note This function is used to set PDM Left stage4 enable
1099 *
1100 * Register|BitsName
1101 * --------|--------
1102 * EN_L | EN_STAGE4
1103 *
1104 * @param PDMx instance
1105 * @retval None
1106 */
1107 __STATIC_INLINE void ll_pdm_enable_left_stage4(pdm_regs_t *PDMx)
1108 {
1109 MODIFY_REG(PDMx->EN_L, PDM_EN_L_EN_STAGE4, LL_PDM_LEFT_STAGE4_ENABLE);
1110 }
1111
1112 /**
1113 * @brief Disable PDM Module Left stage4.
1114 * @note This function is used to set PDM Left stage4 enable
1115
1116 * Register|BitsName
1117 * --------|--------
1118 * EN_L | EN_STAGE4
1119 *
1120 * @param PDMx instance
1121 * @retval None
1122 */
1123 __STATIC_INLINE void ll_pdm_disable_left_stage4(pdm_regs_t *PDMx)
1124 {
1125 MODIFY_REG(PDMx->EN_L, PDM_EN_L_EN_STAGE4, LL_PDM_LEFT_STAGE4_DISABLE);
1126 }
1127
1128 /**
1129 * @brief is PDM enables left stage4
1130 * @note This function is used to check the PDM Module left stage4 is enabled.
1131 *
1132 * Register|BitsName
1133 * --------|--------
1134 * EN_L | EN_STAGE4
1135 *
1136 * @param PDMx instance.
1137 * @retval None
1138 */
1139 __STATIC_INLINE uint32_t ll_pdm_is_enable_left_stage4(pdm_regs_t *PDMx)
1140 {
1141 return (READ_BITS(PDMx->EN_L, PDM_EN_L_EN_STAGE4) == LL_PDM_LEFT_STAGE4_ENABLE);
1142 }
1143
1144 /**
1145 * @brief Enable PDM Module right stage4
1146 * @note This function is used to set PDM right stage4 enable
1147 *
1148 * Register|BitsName
1149 * --------|--------
1150 * EN_R | EN_STAGE4
1151 *
1152 * @param PDMx instance
1153 * @retval None
1154 */
1155 __STATIC_INLINE void ll_pdm_enable_right_stage4(pdm_regs_t *PDMx)
1156 {
1157 MODIFY_REG(PDMx->EN_R, PDM_EN_R_EN_STAGE4, LL_PDM_RIGHT_STAGE4_ENABLE);
1158 }
1159
1160 /**
1161 * @brief Disable PDM Module right stage4
1162 * @note This function is used to set PDM right stage4 enable
1163
1164 * Register|BitsName
1165 * --------|--------
1166 * EN_R | EN_STAGE4
1167 *
1168 * @param PDMx instance
1169 * @retval None
1170 */
1171 __STATIC_INLINE void ll_pdm_disable_right_stage4(pdm_regs_t *PDMx)
1172 {
1173 MODIFY_REG(PDMx->EN_R, PDM_EN_R_EN_STAGE4, LL_PDM_RIGHT_STAGE4_DISABLE);
1174 }
1175
1176 /**
1177 * @brief is PDM enables right stage4
1178 * @note This function is used to check the PDM Module right stage4 is enabled.
1179 *
1180 * Register|BitsName
1181 * --------|--------
1182 * EN_R | EN_STAGE4
1183 *
1184 * @param PDMx instance.
1185 * @retval None
1186 */
1187 __STATIC_INLINE uint32_t ll_pdm_is_enable_right_stage4(pdm_regs_t *PDMx)
1188 {
1189 return (READ_BITS(PDMx->EN_R, PDM_EN_R_EN_STAGE4) == LL_PDM_RIGHT_STAGE4_ENABLE);
1190 }
1191
1192 /**
1193 * @brief Enable PDM Module Left stage5.
1194 * @note This function is used to set PDM Left stage5 enable
1195 *
1196 * Register|BitsName
1197 * --------|--------
1198 * EN_L | EN_STAGE5
1199 *
1200 * @param PDMx instance
1201 * @retval None
1202 */
1203 __STATIC_INLINE void ll_pdm_enable_left_stage5(pdm_regs_t *PDMx)
1204 {
1205 MODIFY_REG(PDMx->EN_L, PDM_EN_L_EN_STAGE5, LL_PDM_LEFT_STAGE5_ENABLE);
1206 }
1207
1208 /**
1209 * @brief Disable PDM Module Left stage5.
1210 * @note This function is used to set PDM Left stage5 enable
1211
1212 * Register|BitsName
1213 * --------|--------
1214 * EN_L | EN_STAGE5
1215 *
1216 * @param PDMx instance
1217 * @retval None
1218 */
1219 __STATIC_INLINE void ll_pdm_disable_left_stage5(pdm_regs_t *PDMx)
1220 {
1221 MODIFY_REG(PDMx->EN_L, PDM_EN_L_EN_STAGE5, LL_PDM_LEFT_STAGE5_DISABLE);
1222 }
1223
1224 /**
1225 * @brief is PDM enables left stage5
1226 * @note This function is used to check the PDM Module left stage5 is enabled.
1227 *
1228 * Register|BitsName
1229 * --------|--------
1230 * EN_L | EN_STAGE5
1231 *
1232 * @param PDMx instance.
1233 * @retval None
1234 */
1235 __STATIC_INLINE uint32_t ll_pdm_is_enable_left_stage5(pdm_regs_t *PDMx)
1236 {
1237 return (READ_BITS(PDMx->EN_L, PDM_EN_L_EN_STAGE5) == LL_PDM_LEFT_STAGE5_ENABLE);
1238 }
1239
1240 /**
1241 * @brief Enable PDM Module right stage5
1242 * @note This function is used to set PDM right stage5 enable
1243 *
1244 * Register|BitsName
1245 * --------|--------
1246 * EN_R | EN_STAGE5
1247 *
1248 * @param PDMx instance
1249 * @retval None
1250 */
1251 __STATIC_INLINE void ll_pdm_enable_right_stage5(pdm_regs_t *PDMx)
1252 {
1253 MODIFY_REG(PDMx->EN_R, PDM_EN_R_EN_STAGE5, LL_PDM_RIGHT_STAGE5_ENABLE);
1254 }
1255
1256 /**
1257 * @brief Disable PDM Module right stage5
1258 * @note This function is used to set PDM right stage5 enable
1259
1260 * Register|BitsName
1261 * --------|--------
1262 * EN_R | EN_STAGE5
1263 *
1264 * @param PDMx instance
1265 * @retval None
1266 */
1267 __STATIC_INLINE void ll_pdm_disable_right_stage5(pdm_regs_t *PDMx)
1268 {
1269 MODIFY_REG(PDMx->EN_R, PDM_EN_R_EN_STAGE5, LL_PDM_RIGHT_STAGE5_DISABLE);
1270 }
1271
1272 /**
1273 * @brief is PDM enables right stage5
1274 * @note This function is used to check the PDM Module right stage5 is enabled.
1275 *
1276 * Register|BitsName
1277 * --------|--------
1278 * EN_R | EN_STAGE5
1279 *
1280 * @param PDMx instance.
1281 * @retval None
1282 */
1283 __STATIC_INLINE uint32_t ll_pdm_is_enable_right_stage5(pdm_regs_t *PDMx)
1284 {
1285 return (READ_BITS(PDMx->EN_R, PDM_EN_R_EN_STAGE5) == LL_PDM_RIGHT_STAGE5_ENABLE);
1286 }
1287
1288 /**
1289 * @brief Enable PDM Module Left stage6.
1290 * @note This function is used to set PDM Left stage6 enable
1291 *
1292 * Register|BitsName
1293 * --------|--------
1294 * EN_L | EN_STAGE6
1295 *
1296 * @param PDMx instance
1297 * @retval None
1298 */
1299 __STATIC_INLINE void ll_pdm_enable_left_stage6(pdm_regs_t *PDMx)
1300 {
1301 MODIFY_REG(PDMx->EN_L, PDM_EN_L_EN_STAGE6, LL_PDM_LEFT_STAGE6_ENABLE);
1302 }
1303
1304 /**
1305 * @brief Disable PDM Module Left stage6.
1306 * @note This function is used to set PDM Left stage6 enable
1307
1308 * Register|BitsName
1309 * --------|--------
1310 * EN_L | EN_STAGE6
1311 *
1312 * @param PDMx instance
1313 * @retval None
1314 */
1315 __STATIC_INLINE void ll_pdm_disable_left_stage6(pdm_regs_t *PDMx)
1316 {
1317 MODIFY_REG(PDMx->EN_L, PDM_EN_L_EN_STAGE6, LL_PDM_LEFT_STAGE6_DISABLE);
1318 }
1319
1320 /**
1321 * @brief is PDM enables left stage6
1322 * @note This function is used to check the PDM Module left stage6 is enabled.
1323 *
1324 * Register|BitsName
1325 * --------|--------
1326 * EN_L | EN_STAGE6
1327 *
1328 * @param PDMx instance.
1329 * @retval None
1330 */
1331 __STATIC_INLINE uint32_t ll_pdm_is_enable_left_stage6(pdm_regs_t *PDMx)
1332 {
1333 return (READ_BITS(PDMx->EN_L, PDM_EN_L_EN_STAGE6) == LL_PDM_LEFT_STAGE6_ENABLE);
1334 }
1335
1336 /**
1337 * @brief Enable PDM Module right stage6
1338 * @note This function is used to set PDM right stage6 enable
1339 *
1340 * Register|BitsName
1341 * --------|--------
1342 * EN_R | EN_STAGE6
1343 *
1344 * @param PDMx instance
1345 * @retval None
1346 */
1347 __STATIC_INLINE void ll_pdm_enable_right_stage6(pdm_regs_t *PDMx)
1348 {
1349 MODIFY_REG(PDMx->EN_R, PDM_EN_R_EN_STAGE6, LL_PDM_RIGHT_STAGE6_ENABLE);
1350 }
1351
1352 /**
1353 * @brief Disable PDM Module right stage6
1354 * @note This function is used to set PDM right stage6 enable
1355
1356 * Register|BitsName
1357 * --------|--------
1358 * EN_R | EN_STAGE6
1359 *
1360 * @param PDMx instance
1361 * @retval None
1362 */
1363 __STATIC_INLINE void ll_pdm_disable_right_stage6(pdm_regs_t *PDMx)
1364 {
1365 MODIFY_REG(PDMx->EN_R, PDM_EN_R_EN_STAGE6, LL_PDM_RIGHT_STAGE6_DISABLE);
1366 }
1367
1368 /**
1369 * @brief is PDM enables right stage6
1370 * @note This function is used to check the PDM Module right stage6 is enabled.
1371 *
1372 * Register|BitsName
1373 * --------|--------
1374 * EN_R | EN_STAGE6
1375 *
1376 * @param PDMx instance.
1377 * @retval None
1378 */
1379 __STATIC_INLINE uint32_t ll_pdm_is_enable_right_stage6(pdm_regs_t *PDMx)
1380 {
1381 return (READ_BITS(PDMx->EN_R, PDM_EN_R_EN_STAGE6) == LL_PDM_RIGHT_STAGE6_ENABLE);
1382 }
1383
1384 /**
1385 * @brief Enable PDM Module Left stage7.
1386 * @note This function is used to set PDM Left stage7 enable
1387 *
1388 * Register|BitsName
1389 * --------|--------
1390 * EN_L | EN_STAGE7
1391 *
1392 * @param PDMx instance
1393 * @retval None
1394 */
1395 __STATIC_INLINE void ll_pdm_enable_left_stage7(pdm_regs_t *PDMx)
1396 {
1397 MODIFY_REG(PDMx->EN_L, PDM_EN_L_EN_STAGE7, LL_PDM_LEFT_STAGE7_ENABLE);
1398 }
1399
1400 /**
1401 * @brief Disable PDM Module Left stage7.
1402 * @note This function is used to set PDM Left stage7 enable
1403
1404 * Register|BitsName
1405 * --------|--------
1406 * EN_L | EN_STAGE7
1407 *
1408 * @param PDMx instance
1409 * @retval None
1410 */
1411 __STATIC_INLINE void ll_pdm_disable_left_stage7(pdm_regs_t *PDMx)
1412 {
1413 MODIFY_REG(PDMx->EN_L, PDM_EN_L_EN_STAGE7, LL_PDM_LEFT_STAGE7_DISABLE);
1414 }
1415
1416 /**
1417 * @brief is PDM enables left stage7
1418 * @note This function is used to check the PDM Module left stage7 is enabled.
1419 *
1420 * Register|BitsName
1421 * --------|--------
1422 * EN_L | EN_STAGE7
1423 *
1424 * @param PDMx instance.
1425 * @retval None
1426 */
1427 __STATIC_INLINE uint32_t ll_pdm_is_enable_left_stage7(pdm_regs_t *PDMx)
1428 {
1429 return (READ_BITS(PDMx->EN_L, PDM_EN_L_EN_STAGE7) == LL_PDM_LEFT_STAGE7_ENABLE);
1430 }
1431
1432 /**
1433 * @brief Enable PDM Module right stage7
1434 * @note This function is used to set PDM right stage7 enable
1435 *
1436 * Register|BitsName
1437 * --------|--------
1438 * EN_R | EN_STAGE7
1439 *
1440 * @param PDMx instance
1441 * @retval None
1442 */
1443 __STATIC_INLINE void ll_pdm_enable_right_stage7(pdm_regs_t *PDMx)
1444 {
1445 MODIFY_REG(PDMx->EN_R, PDM_EN_R_EN_STAGE7, LL_PDM_RIGHT_STAGE7_ENABLE);
1446 }
1447
1448 /**
1449 * @brief Disable PDM Module right stage7
1450 * @note This function is used to set PDM right stage7 enable
1451
1452 * Register|BitsName
1453 * --------|--------
1454 * EN_R | EN_STAGE7
1455 *
1456 * @param PDMx instance
1457 * @retval None
1458 */
1459 __STATIC_INLINE void ll_pdm_disable_right_stage7(pdm_regs_t *PDMx)
1460 {
1461 MODIFY_REG(PDMx->EN_R, PDM_EN_R_EN_STAGE7, LL_PDM_RIGHT_STAGE7_DISABLE);
1462 }
1463
1464 /**
1465 * @brief is PDM enables right stage7
1466 * @note This function is used to check the PDM Module right stage7 is enabled.
1467 *
1468 * Register|BitsName
1469 * --------|--------
1470 * EN_R | EN_STAGE7
1471 *
1472 * @param PDMx instance.
1473 * @retval None
1474 */
1475 __STATIC_INLINE uint32_t ll_pdm_is_enable_right_stage7(pdm_regs_t *PDMx)
1476 {
1477 return (READ_BITS(PDMx->EN_R, PDM_EN_R_EN_STAGE7) == LL_PDM_RIGHT_STAGE7_ENABLE);
1478 }
1479
1480 /**
1481 * @brief Enable PDM Module Left hpf
1482 * @note This function is used to set PDM Left hpf enable
1483 *
1484 * Register|BitsName
1485 * --------|--------
1486 * EN_L | EN_HPF
1487 *
1488 * @param PDMx instance
1489 * @retval None
1490 */
1491 __STATIC_INLINE void ll_pdm_enable_left_hpf(pdm_regs_t *PDMx)
1492 {
1493 MODIFY_REG(PDMx->EN_L, PDM_EN_L_EN_HPF, LL_PDM_LEFT_HPF_ENABLE);
1494 }
1495
1496 /**
1497 * @brief Disable PDM Module Left hpf.
1498 * @note This function is used to set PDM Left hpf enable
1499
1500 * Register|BitsName
1501 * --------|--------
1502 * EN_L | EN_HPF
1503 *
1504 * @param PDMx instance
1505 * @retval None
1506 */
1507 __STATIC_INLINE void ll_pdm_disable_left_hpf(pdm_regs_t *PDMx)
1508 {
1509 MODIFY_REG(PDMx->EN_L, PDM_EN_L_EN_HPF, LL_PDM_LEFT_HPF_DISABLE);
1510 }
1511
1512 /**
1513 * @brief is PDM enables left hpf
1514 * @note This function is used to check the PDM Module left hpf is enabled.
1515 *
1516 * Register|BitsName
1517 * --------|--------
1518 * EN_L | EN_HPF
1519 *
1520 * @param PDMx instance.
1521 * @retval None
1522 */
1523 __STATIC_INLINE uint32_t ll_pdm_is_enable_left_hpf(pdm_regs_t *PDMx)
1524 {
1525 return (READ_BITS(PDMx->EN_L, PDM_EN_L_EN_HPF) == LL_PDM_LEFT_HPF_ENABLE);
1526 }
1527
1528 /**
1529 * @brief Enable PDM Module right hpf
1530 * @note This function is used to set PDM right hpf enable
1531 *
1532 * Register|BitsName
1533 * --------|--------
1534 * EN_R | EN_HPF
1535 *
1536 * @param PDMx instance
1537 * @retval None
1538 */
1539 __STATIC_INLINE void ll_pdm_enable_right_hpf(pdm_regs_t *PDMx)
1540 {
1541 MODIFY_REG(PDMx->EN_R, PDM_EN_R_EN_HPF, LL_PDM_RIGHT_HPF_ENABLE);
1542 }
1543
1544 /**
1545 * @brief Disable PDM Module right hpf.
1546 * @note This function is used to set PDM right hpf enable
1547
1548 * Register|BitsName
1549 * --------|--------
1550 * EN_R | EN_HPF
1551 *
1552 * @param PDMx instance
1553 * @retval None
1554 */
1555 __STATIC_INLINE void ll_pdm_disable_right_hpf(pdm_regs_t *PDMx)
1556 {
1557 MODIFY_REG(PDMx->EN_R, PDM_EN_R_EN_HPF, LL_PDM_RIGHT_HPF_DISABLE);
1558 }
1559
1560 /**
1561 * @brief is PDM enables right hpf
1562 * @note This function is used to check the PDM Module right hpf is enabled.
1563 *
1564 * Register|BitsName
1565 * --------|--------
1566 * EN_R | EN_HPF
1567 *
1568 * @param PDMx instance.
1569 * @retval None
1570 */
1571 __STATIC_INLINE uint32_t ll_pdm_is_enable_right_hpf(pdm_regs_t *PDMx)
1572 {
1573 return (READ_BITS(PDMx->EN_R, PDM_EN_R_EN_HPF) == LL_PDM_RIGHT_HPF_ENABLE);
1574 }
1575
1576 /**
1577 * @brief Set PDM left rxd upsample
1578 * @note This function is used to set PDM left rxd upsample
1579 *
1580 * Register|BitsName
1581 * --------|--------
1582 * INPUT_CFG_L | RXD_UPSAMPLE
1583 *
1584 * @param PDMx instance
1585 * @param rxd_upsample This parameter can be one of the following values:
1586 * Min_Data = 0 and Max_Data = 0x1
1587 * @retval None
1588 */
1589 __STATIC_INLINE void ll_pdm_set_left_rxd_upsample(pdm_regs_t *PDMx, uint32_t rxd_upsample)
1590 {
1591 MODIFY_REG(PDMx->IN_CFG_L, PDM_IN_CFG_L_RX_UPSMP, rxd_upsample << PDM_IN_CFG_L_RX_UPSMP_POS);
1592 }
1593
1594 /**
1595 * @brief Get PDM left rxd upsample.
1596 * @note This function is used to get PDM left rxd upsample
1597 *
1598 * Register|BitsName
1599 * --------|--------
1600 * INPUT_CFG_L | RXD_UPSAMPLE
1601 *
1602 * @param PDMx instance
1603 * @retval can be one of the following values:
1604 * 0x0 or 0x1
1605 */
1606 __STATIC_INLINE uint32_t ll_pdm_get_left_rxd_upsample(pdm_regs_t *PDMx)
1607 {
1608 return READ_BITS(PDMx->IN_CFG_L, PDM_IN_CFG_L_RX_UPSMP >> PDM_IN_CFG_L_RX_UPSMP_POS);
1609 }
1610
1611 /**
1612 * @brief Set PDM right rxd upsample
1613 * @note This function is used to set PDM right rxd upsample
1614 *
1615 * Register|BitsName
1616 * --------|--------
1617 * INPUT_CFG_R | RXD_UPSAMPLE
1618 *
1619 * @param PDMx instance
1620 * @param rxd_upsample This parameter can be one of the following values:
1621 * Min_Data = 0 and Max_Data = 0x1
1622 * @retval None
1623 */
1624 __STATIC_INLINE void ll_pdm_set_right_rxd_upsample(pdm_regs_t *PDMx, uint32_t rxd_upsample)
1625 {
1626 MODIFY_REG(PDMx->IN_CFG_R, PDM_IN_CFG_R_RX_UPSMP, rxd_upsample << PDM_IN_CFG_R_RX_UPSMP_POS);
1627 }
1628
1629 /**
1630 * @brief Get PDM right rxd upsample.
1631 * @note This function is used to get PDM right rxd upsample
1632 *
1633 * Register|BitsName
1634 * --------|--------
1635 * INPUT_CFG_L | RXD_UPSAMPLE
1636 *
1637 * @param PDMx instance
1638 * @retval can be one of the following values:
1639 * 0x0 or 0x1
1640 */
1641 __STATIC_INLINE uint32_t ll_pdm_get_right_rxd_upsample(pdm_regs_t *PDMx)
1642 {
1643 return READ_BITS(PDMx->IN_CFG_R, PDM_IN_CFG_R_RX_UPSMP >> PDM_IN_CFG_R_RX_UPSMP_POS);
1644 }
1645
1646 /**
1647 * @brief Set PDM left statge init
1648 * @note This function is used to set PDM left statge init
1649 *
1650 * Register|BitsName
1651 * --------|--------
1652 * INPUT_CFG_L | STAGE_INIT
1653 *
1654 * @param PDMx instance
1655 * @param stage_init This parameter can be one of the following values:
1656 * Min_Data = 0 and Max_Data = 0x2
1657 * @retval None
1658 */
1659 __STATIC_INLINE void ll_pdm_set_left_stage_init(pdm_regs_t *PDMx, uint32_t stage_init)
1660 {
1661 MODIFY_REG(PDMx->IN_CFG_L, PDM_IN_CFG_L_STAGE_INIT, stage_init << PDM_IN_CFG_L_STAGE_INIT_POS);
1662 }
1663
1664 /**
1665 * @brief Get PDM left statge init
1666 * @note This function is used to get PDM left statge init
1667 *
1668 * Register|BitsName
1669 * --------|--------
1670 * INPUT_CFG_L | STAGE_INIT
1671 *
1672 * @param PDMx instance
1673 * @retval can be one of the following values:
1674 * 0x0 or 0x2
1675 */
1676 __STATIC_INLINE uint32_t ll_pdm_get_left_stage_init(pdm_regs_t *PDMx)
1677 {
1678 return (READ_BITS(PDMx->IN_CFG_L, PDM_IN_CFG_L_STAGE_INIT) >> PDM_IN_CFG_L_STAGE_INIT_POS) ;
1679 }
1680
1681 /**
1682 * @brief Set PDM right statge init
1683 * @note This function is used to set PDM right statge init
1684 *
1685 * Register|BitsName
1686 * --------|--------
1687 * INPUT_CFG_R | STAGE_INIT
1688 *
1689 * @param PDMx instance
1690 * @param stage_init This parameter can be one of the following values:
1691 * Min_Data = 0 and Max_Data = 0x2
1692 * @retval None
1693 */
1694 __STATIC_INLINE void ll_pdm_set_right_stage_init(pdm_regs_t *PDMx, uint32_t stage_init)
1695 {
1696 MODIFY_REG(PDMx->IN_CFG_R, PDM_IN_CFG_R_STAGE_INIT, stage_init << PDM_IN_CFG_R_STAGE_INIT_POS);
1697 }
1698
1699 /**
1700 * @brief Get PDM right statge init
1701 * @note This function is used to get PDM right statge init
1702 *
1703 * Register|BitsName
1704 * --------|--------
1705 * INPUT_CFG_R | STAGE_INIT
1706 *
1707 * @param PDMx instance
1708 * @retval can be one of the following values:
1709 * 0x0 or 0x2
1710 */
1711 __STATIC_INLINE uint32_t ll_pdm_get_right_stage_init(pdm_regs_t *PDMx)
1712 {
1713 return (READ_BITS(PDMx->IN_CFG_R, PDM_IN_CFG_R_STAGE_INIT) >> PDM_IN_CFG_R_STAGE_INIT_POS) ;
1714 }
1715
1716 /**
1717 * @brief Set PDM left upsample factor
1718 * @note This function is used to set PDM left upsample factor
1719 *
1720 * Register|BitsName
1721 * --------|--------
1722 * LPF_CFG_L | UPSAMPLE_FACTOR
1723 *
1724 * @param PDMx instance
1725 * @param upsample_factor This parameter can be one of the following values:
1726 * Min_Data = 0 and Max_Data = 0x2
1727 * @retval None
1728 */
1729 __STATIC_INLINE void ll_pdm_set_left_upsample_factor(pdm_regs_t *PDMx, uint32_t upsample_factor)
1730 {
1731 MODIFY_REG(PDMx->LPF_CFG_L, PDM_LPF_CFG_L_UPSMP_FACTOR, upsample_factor << PDM_LPF_CFG_L_UPSMP_FACTOR_POS);
1732 }
1733
1734 /**
1735 * @brief Get PDM left upsample factor
1736 * @note This function is used to get PDM left upsample factor
1737 *
1738 * Register|BitsName
1739 * --------|--------
1740 * LPF_CFG_L | UPSAMPLE_FACTOR
1741 *
1742 * @param PDMx instance
1743 * @retval can be one of the following values:
1744 * 0x0 or 0x2
1745 */
1746 __STATIC_INLINE uint32_t ll_pdm_get_left_upsample_factor(pdm_regs_t *PDMx)
1747 {
1748 return (READ_BITS(PDMx->LPF_CFG_L, PDM_LPF_CFG_L_UPSMP_FACTOR) >> PDM_LPF_CFG_L_UPSMP_FACTOR_POS) ;
1749 }
1750
1751 /**
1752 * @brief Set PDM right upsample factor
1753 * @note This function is used to set PDM right upsample factor
1754 *
1755 * Register|BitsName
1756 * --------|--------
1757 * LPF_CFG_R | UPSAMPLE_FACTOR
1758 *
1759 * @param PDMx instance
1760 * @param upsample_factor This parameter can be one of the following values:
1761 * Min_Data = 0 and Max_Data = 0x2
1762 * @retval None
1763 */
1764 __STATIC_INLINE void ll_pdm_set_right_upsample_factor(pdm_regs_t *PDMx, uint32_t upsample_factor)
1765 {
1766 MODIFY_REG(PDMx->LPF_CFG_R, PDM_LPF_CFG_R_UPSMP_FACTOR, upsample_factor << PDM_LPF_CFG_R_UPSMP_FACTOR_POS);
1767 }
1768
1769 /**
1770 * @brief Get PDM right upsample factor
1771 * @note This function is used to get PDM right upsample factor
1772 *
1773 * Register|BitsName
1774 * --------|--------
1775 * LPF_CFG_R | UPSAMPLE_FACTOR
1776 *
1777 * @param PDMx instance
1778 * @retval can be one of the following values:
1779 * 0x0 or 0x2
1780 */
1781 __STATIC_INLINE uint32_t ll_pdm_get_right_upsample_factor(pdm_regs_t *PDMx)
1782 {
1783 return (READ_BITS(PDMx->LPF_CFG_R, PDM_LPF_CFG_R_UPSMP_FACTOR) >> PDM_LPF_CFG_R_UPSMP_FACTOR_POS) ;
1784 }
1785
1786 /**
1787 * @brief Enable PDM left hpf_bypass
1788 * @note This function is used to set PDM left hpf_bypass
1789 *
1790 * Register|BitsName
1791 * --------|--------
1792 * HPF_CFG_L | HPY_BYPASS
1793 *
1794 * @param PDMx instance
1795 * @retval None
1796 */
1797 __STATIC_INLINE void ll_pdm_enable_left_hpy_bypass(pdm_regs_t *PDMx)
1798 {
1799 MODIFY_REG(PDMx->HPF_CFG_L, PDM_HPF_CFG_L_BYPASS, LL_PDM_LEFT_HPF_BYPASS_ENABLE);
1800 }
1801
1802 /**
1803 * @brief Disable PDM left hpf_bypass
1804 * @note This function is used to disable PDM left hpf_bypass
1805 *
1806 * Register|BitsName
1807 * --------|--------
1808 * HPF_CFG_L | HPY_BYPASS
1809 *
1810 * @param PDMx instance
1811 */
1812 __STATIC_INLINE void ll_pdm_disable_left_hpy_bypass(pdm_regs_t *PDMx)
1813 {
1814 MODIFY_REG(PDMx->HPF_CFG_L, PDM_HPF_CFG_L_BYPASS, LL_PDM_LEFT_HPF_BYPASS_DISABLE);
1815 }
1816
1817 /**
1818 * @brief is PDM enables right stage7
1819 * @note This function is used to check the PDM Module right stage7 is enabled.
1820 *
1821 * Register|BitsName
1822 * --------|--------
1823 * EN_R | EN_STAGE7
1824 *
1825 * @param PDMx instance.
1826 * @retval None
1827 */
1828 __STATIC_INLINE uint32_t ll_pdm_is_enable_left_hpy_bypass(pdm_regs_t *PDMx)
1829 {
1830 return (READ_BITS(PDMx->HPF_CFG_L, PDM_HPF_CFG_L_BYPASS) == LL_PDM_LEFT_HPF_BYPASS_ENABLE);
1831 }
1832
1833 /**
1834 * @brief Enable PDM right hpf_bypass
1835 * @note This function is used to set PDM right hpf_bypass
1836 *
1837 * Register|BitsName
1838 * --------|--------
1839 * HPF_CFG_R | HPY_BYPASS
1840 *
1841 * @param PDMx instance
1842 * @retval None
1843 */
1844 __STATIC_INLINE void ll_pdm_enable_right_hpy_bypass(pdm_regs_t *PDMx)
1845 {
1846 MODIFY_REG(PDMx->HPF_CFG_R, PDM_HPF_CFG_R_BYPASS, LL_PDM_RIGHT_HPF_BYPASS_ENABLE);
1847 }
1848
1849 /**
1850 * @brief Disable PDM right hpf_bypass
1851 * @note This function is used to disable PDM right hpf_bypass
1852 *
1853 * Register|BitsName
1854 * --------|--------
1855 * HPF_CFG_R | HPY_BYPASS
1856 *
1857 * @param PDMx instance
1858 */
1859 __STATIC_INLINE void ll_pdm_disable_right_hpy_bypass(pdm_regs_t *PDMx)
1860 {
1861 MODIFY_REG(PDMx->HPF_CFG_R, PDM_HPF_CFG_R_BYPASS, LL_PDM_RIGHT_HPF_BYPASS_DISABLE);
1862 }
1863
1864 /**
1865 * @brief is PDM enables right hpf_bypass
1866 * @note This function is used to check the PDM Module right hpf_bypass is enabled.
1867 *
1868 * Register|BitsName
1869 * --------|--------
1870 * HPF_CFG_R | HPY_BYPASS
1871 *
1872 * @param PDMx instance.
1873 * @retval None
1874 */
1875 __STATIC_INLINE uint32_t ll_pdm_is_enable_right_hpy_bypass(pdm_regs_t *PDMx)
1876 {
1877 return (READ_BITS(PDMx->HPF_CFG_R, PDM_HPF_CFG_R_BYPASS) == LL_PDM_RIGHT_HPF_BYPASS_ENABLE);
1878 }
1879
1880 /**
1881 * @brief Set PDM left hpf corner
1882 * @note This function is used to set PDM left hpf corner
1883 *
1884 * Register|BitsName
1885 * --------|--------
1886 * HPF_CFG_L | HPF_CORNER
1887 *
1888 * @param PDMx instance
1889 * @param hpf_corner This parameter can be one of the following values:
1890 * @arg @ref LL_PDM_LEFT_HPF_CORNER_0_25
1891 * @arg @ref LL_PDM_LEFT_HPF_CORNER_1
1892 * @arg @ref LL_PDM_LEFT_HPF_CORNER_4
1893 * @arg @ref LL_PDM_LEFT_HPF_CORNER_16
1894 * @retval None
1895 */
1896 __STATIC_INLINE void ll_pdm_set_left_hpf_corner(pdm_regs_t *PDMx, uint32_t hpf_corner)
1897 {
1898 MODIFY_REG(PDMx->HPF_CFG_L, PDM_HPF_CFG_L_CORNER, hpf_corner);
1899 }
1900
1901 /**
1902 * @brief Get PDM left hpf corner
1903 * @note This function is used to get PDM left hpf corner
1904 *
1905 * Register|BitsName
1906 * --------|--------
1907 * HPF_CFG_L | HPF_CORNER
1908 *
1909 * @param PDMx instance
1910 * @retval can be one of the following values:
1911 * @arg @ref LL_PDM_LEFT_HPF_CORNER_0_25
1912 * @arg @ref LL_PDM_LEFT_HPF_CORNER_1
1913 * @arg @ref LL_PDM_LEFT_HPF_CORNER_4
1914 * @arg @ref LL_PDM_LEFT_HPF_CORNER_16
1915 */
1916 __STATIC_INLINE uint32_t ll_pdm_get_left_hpf_corner(pdm_regs_t *PDMx)
1917 {
1918 return READ_BITS(PDMx->HPF_CFG_L, PDM_HPF_CFG_L_CORNER);
1919 }
1920
1921 /**
1922 * @brief Set PDM right hpf corner
1923 * @note This function is used to set PDM right hpf corner
1924 *
1925 * Register|BitsName
1926 * --------|--------
1927 * HPF_CFG_R | HPF_CORNER
1928 *
1929 * @param PDMx instance
1930 * @param hpf_corner This parameter can be one of the following values:
1931 * @arg @ref LL_PDM_LEFT_HPF_CORNER_0_25
1932 * @arg @ref LL_PDM_LEFT_HPF_CORNER_1
1933 * @arg @ref LL_PDM_LEFT_HPF_CORNER_4
1934 * @arg @ref LL_PDM_LEFT_HPF_CORNER_16
1935 * @retval None
1936 */
1937 __STATIC_INLINE void ll_pdm_set_right_hpf_corner(pdm_regs_t *PDMx, uint32_t hpf_corner)
1938 {
1939 MODIFY_REG(PDMx->HPF_CFG_R, PDM_HPF_CFG_R_CORNER, hpf_corner);
1940 }
1941
1942 /**
1943 * @brief Get PDM right hpf corner
1944 * @note This function is used to get PDM right hpf corner
1945 *
1946 * Register|BitsName
1947 * --------|--------
1948 * HPF_CFG_R | HPF_CORNER
1949 *
1950 * @param PDMx instance
1951 * @retval can be one of the following values:
1952 * @arg @ref LL_PDM_LEFT_HPF_CORNER_0_25
1953 * @arg @ref LL_PDM_LEFT_HPF_CORNER_1
1954 * @arg @ref LL_PDM_LEFT_HPF_CORNER_4
1955 * @arg @ref LL_PDM_LEFT_HPF_CORNER_16
1956 */
1957 __STATIC_INLINE uint32_t ll_pdm_get_right_hpf_corner(pdm_regs_t *PDMx)
1958 {
1959 return READ_BITS(PDMx->HPF_CFG_R, PDM_HPF_CFG_R_CORNER);
1960 }
1961
1962 /**
1963 * @brief Enable PDM left hpf_freeze_en
1964 * @note This function is used to set PDM left hpf_freeze_en
1965 *
1966 * Register|BitsName
1967 * --------|--------
1968 * HPF_CFG_L | HPY_FREEZE_EN
1969 *
1970 * @param PDMx instance
1971 * @retval None
1972 */
1973 __STATIC_INLINE void ll_pdm_enable_left_hpf_freeze_en(pdm_regs_t *PDMx)
1974 {
1975 MODIFY_REG(PDMx->HPF_CFG_L, PDM_HPF_CFG_L_FREEZE_EN, LL_PDM_LEFT_HPF_FREEZE_ENABLE);
1976 }
1977
1978 /**
1979 * @brief Disable PDM left hpf_freeze_en
1980 * @note This function is used to disable PDM left hpf_freeze_en
1981 *
1982 * Register|BitsName
1983 * --------|--------
1984 * HPF_CFG_L | HPY_FREEZE_EN
1985 *
1986 * @param PDMx instance
1987 */
1988 __STATIC_INLINE void ll_pdm_disable_left_hpf_freeze_en(pdm_regs_t *PDMx)
1989 {
1990 MODIFY_REG(PDMx->HPF_CFG_L, PDM_HPF_CFG_L_FREEZE_EN, LL_PDM_LEFT_HPF_FREEZE_DISABLE);
1991 }
1992
1993 /**
1994 * @brief is PDM enables left hpf_freeze_en
1995 * @note This function is used to check the PDM Module left hpf_freeze_en is enabled.
1996 *
1997 * Register|BitsName
1998 * --------|--------
1999 * HPF_CFG_L | HPY_FREEZE_EN
2000 *
2001 * @param PDMx instance.
2002 * @retval None
2003 */
2004 __STATIC_INLINE uint32_t ll_pdm_is_enable_left_hpf_freeze_en(pdm_regs_t *PDMx)
2005 {
2006 return (READ_BITS(PDMx->HPF_CFG_L, PDM_HPF_CFG_L_FREEZE_EN) == LL_PDM_LEFT_HPF_FREEZE_ENABLE);
2007 }
2008
2009 /**
2010 * @brief Enable PDM right hpf_freeze_en
2011 * @note This function is used to set PDM right hpf_freeze_en
2012 *
2013 * Register|BitsName
2014 * --------|--------
2015 * HPF_CFG_R | HPY_FREEZE_EN
2016 *
2017 * @param PDMx instance
2018 * @retval None
2019 */
2020 __STATIC_INLINE void ll_pdm_enable_right_hpf_freeze_en(pdm_regs_t *PDMx)
2021 {
2022 MODIFY_REG(PDMx->HPF_CFG_R, PDM_HPF_CFG_R_FREEZE_EN, LL_PDM_RIGHT_HPF_FREEZE_ENABLE);
2023 }
2024
2025 /**
2026 * @brief Disable PDM right hpf_freeze_en
2027 * @note This function is used to disable PDM righthpf_freeze_en
2028 *
2029 * Register|BitsName
2030 * --------|--------
2031 * HPF_CFG_R | HPY_FREEZE_EN
2032 *
2033 * @param PDMx instance
2034 */
2035 __STATIC_INLINE void ll_pdm_disable_right_hpf_freeze_en(pdm_regs_t *PDMx)
2036 {
2037 MODIFY_REG(PDMx->HPF_CFG_R, PDM_HPF_CFG_R_FREEZE_EN, LL_PDM_RIGHT_HPF_FREEZE_DISABLE);
2038 }
2039
2040 /**
2041 * @brief is PDM enables right hpf_freeze_en
2042 * @note This function is used to check the PDM Module right hpf_freeze_en is enabled.
2043 *
2044 * Register|BitsName
2045 * --------|--------
2046 * HPF_CFG_R | HPY_FREEZE_EN
2047 *
2048 * @param PDMx instance.
2049 * @retval None
2050 */
2051 __STATIC_INLINE uint32_t ll_pdm_is_enable_right_hpf_freeze_en(pdm_regs_t *PDMx)
2052 {
2053 return (READ_BITS(PDMx->HPF_CFG_R, PDM_HPF_CFG_R_FREEZE_EN) == LL_PDM_RIGHT_HPF_FREEZE_ENABLE);
2054 }
2055
2056 /**
2057 * @brief Set PDM left pga_value
2058 * @note This function is used to set PDM left pga_value
2059 *
2060 * Register|BitsName
2061 * --------|--------
2062 * PGA_CFG_L | PGA_VAL
2063 *
2064 * @param PDMx instance
2065 * @param pga_val This parameter can be one of the following values:
2066 * Min 0x0 Max 0x3FFF
2067 * @retval None
2068 */
2069 __STATIC_INLINE void ll_pdm_set_left_pga_val(pdm_regs_t *PDMx, uint32_t pga_val)
2070 {
2071 MODIFY_REG(PDMx->PGA_CFG_L, PDM_PGA_CFG_L_VAL, pga_val << PDM_PGA_CFG_L_VAL_POS);
2072 }
2073
2074 /**
2075 * @brief Get PDM left pga_value
2076 * @note This function is used to get PDM left pga_value
2077 *
2078 * Register|BitsName
2079 * --------|--------
2080 * PGA_CFG_L | PGA_VAL
2081 *
2082 * @param PDMx instance
2083 * @retval can be one of the following values:
2084 * Min 0x0 Max 0x3FFF
2085 */
2086 __STATIC_INLINE uint32_t ll_pdm_get_left_pga_val(pdm_regs_t *PDMx)
2087 {
2088 return (READ_BITS(PDMx->PGA_CFG_L, PDM_PGA_CFG_L_VAL) >> PDM_PGA_CFG_L_VAL_POS);
2089 }
2090
2091 /**
2092 * @brief Set PDM right pga_value
2093 * @note This function is used to set PDM right pga_value
2094 *
2095 * Register|BitsName
2096 * --------|--------
2097 * PGA_CFG_R | PGA_VAL
2098 *
2099 * @param PDMx instance
2100 * @param pga_val This parameter can be one of the following values:
2101 * Min 0x0 Max 0x3FFF
2102 * @retval None
2103 */
2104 __STATIC_INLINE void ll_pdm_set_right_pga_val(pdm_regs_t *PDMx, uint32_t pga_val)
2105 {
2106 MODIFY_REG(PDMx->PGA_CFG_R, PDM_PGA_CFG_R_VAL, pga_val << PDM_PGA_CFG_R_VAL_POS);
2107 }
2108
2109 /**
2110 * @brief Get PDM right pga_value
2111 * @note This function is used to get PDM right pga_value
2112 *
2113 * Register|BitsName
2114 * --------|--------
2115 * PGA_CFG_R | PGA_VAL
2116 *
2117 * @param PDMx instance
2118 * @retval can be one of the following values:
2119 * Min 0x0 Max 0x3FFF
2120 */
2121 __STATIC_INLINE uint32_t ll_pdm_get_right_pga_val(pdm_regs_t *PDMx)
2122 {
2123 return (READ_BITS(PDMx->PGA_CFG_R, PDM_PGA_CFG_R_VAL) >> PDM_PGA_CFG_R_VAL_POS);
2124 }
2125
2126 /**
2127 * @brief Get PDM left data
2128 * @note This function is used to get PDM left data
2129 *
2130 * Register|BitsName
2131 * --------|--------
2132 * DATA_L | DATA
2133 *
2134 * @param PDMx instance
2135 * @retval can be one of the following values:
2136 * Min 0x0 Max 0xFFFF
2137 */
2138 __STATIC_INLINE uint32_t ll_pdm_get_left_data(pdm_regs_t *PDMx)
2139 {
2140 return (READ_BITS(PDMx->DATA_L, PDM_DATA_L_DATA) >> PDM_DATA_L_DATA_POS);
2141 }
2142
2143 /**
2144 * @brief Get PDM right data
2145 * @note This function is used to get PDM right data
2146 *
2147 * Register|BitsName
2148 * --------|--------
2149 * DATA_R | DATA
2150 *
2151 * @param PDMx instance
2152 * @retval can be one of the following values:
2153 * Min 0x0 Max 0xFFFF
2154 */
2155 __STATIC_INLINE uint32_t ll_pdm_get_right_data(pdm_regs_t *PDMx)
2156 {
2157 return (READ_BITS(PDMx->DATA_R, PDM_DATA_R_DATA) >> PDM_DATA_R_DATA_POS);
2158 }
2159
2160 /**
2161 * @brief Clean PDM left valid
2162 * @note This function is used to get PDM right overflow
2163 *
2164 * Register|BitsName
2165 * --------|--------
2166 * DATA_R | OVERFLOW
2167 *
2168 * @param PDMx instance
2169 * @retval can be one of the following values:
2170 * LL_PDM_LEFT_DATA_OVERFLOW
2171 * LL_PDM_LEFGT_DATA_NO_OVERFLOW
2172 */
2173 __STATIC_INLINE void ll_pdm_left_clear_flag_valid(pdm_regs_t *PDMx)
2174 {
2175 MODIFY_REG(PDMx->DATA_L, PDM_DATA_L_VALID, (1 << PDM_DATA_L_VALID_POS));
2176 }
2177
2178 /**
2179 * @brief Get PDM left valid
2180 * @note This function is used to get PDM left valid
2181 *
2182 * Register|BitsName
2183 * --------|--------
2184 * DATA_L | VALID
2185 *
2186 * @param PDMx instance
2187 * @retval can be one of the following values:
2188 * LL_PDM_LEFT_DATA_VALID
2189 * LL_PDM_LEFT_DATA_INVALID
2190 */
2191 __STATIC_INLINE uint32_t ll_pdm_left_is_active_flag_valid(pdm_regs_t *PDMx)
2192 {
2193 return ((READ_BITS(PDMx->DATA_L, PDM_DATA_L_VALID) >> PDM_DATA_L_VALID_POS) == 1);
2194 }
2195
2196 /**
2197 * @brief Clean PDM right valid
2198 * @note This function is used to get PDM right overflow
2199 *
2200 * Register|BitsName
2201 * --------|--------
2202 * DATA_R | OVERFLOW
2203 *
2204 * @param PDMx instance
2205 * @retval can be one of the following values:
2206 * LL_PDM_LEFT_DATA_OVERFLOW
2207 * LL_PDM_LEFGT_DATA_NO_OVERFLOW
2208 */
2209 __STATIC_INLINE void ll_pdm_right_clear_flag_valid(pdm_regs_t *PDMx)
2210 {
2211 MODIFY_REG(PDMx->DATA_R, PDM_DATA_R_VALID, (1 << PDM_DATA_R_VALID_POS));
2212 }
2213
2214 /**
2215 * @brief Get PDM right valid
2216 * @note This function is used to get PDM right valid
2217 *
2218 * Register|BitsName
2219 * --------|--------
2220 * DATA_R | VALID
2221 *
2222 * @param PDMx instance
2223 * @retval can be one of the following values:
2224 * LL_PDM_RIGHT_DATA_VALID
2225 * LL_PDM_RIGHT_DATA_INVALID
2226 */
2227 __STATIC_INLINE uint32_t ll_pdm_right_is_active_flag_valid(pdm_regs_t *PDMx)
2228 {
2229 return ((READ_BITS(PDMx->DATA_R, PDM_DATA_R_VALID) >> PDM_DATA_R_VALID_POS) == 1);
2230 }
2231
2232 /**
2233 * @brief Set PDM left overflow
2234 * @note This function is used to get PDM right overflow
2235 *
2236 * Register|BitsName
2237 * --------|--------
2238 * DATA_R | OVERFLOW
2239 *
2240 * @param PDMx instance
2241 * @retval can be one of the following values:
2242 * LL_PDM_LEFT_DATA_OVERFLOW
2243 * LL_PDM_LEFGT_DATA_NO_OVERFLOW
2244 */
2245 __STATIC_INLINE void ll_pdm_left_clear_flag_overflow(pdm_regs_t *PDMx)
2246 {
2247 MODIFY_REG(PDMx->DATA_L, PDM_DATA_L_OVER, (1 << PDM_DATA_L_OVER_POS));
2248 }
2249
2250 /**
2251 * @brief Get PDM left overflow
2252 * @note This function is used to get PDM left overflow
2253 *
2254 * Register|BitsName
2255 * --------|--------
2256 * DATA_L | OVERFLOW
2257 *
2258 * @param PDMx instance
2259 * @retval can be one of the following values:
2260 * LL_PDM_LEFT_DATA_OVERFLOW
2261 * LL_PDM_LEFT_DATA_NO_OVERFLOW
2262 */
2263 __STATIC_INLINE uint32_t ll_pdm_left_is_active_flag_overflow(pdm_regs_t *PDMx)
2264 {
2265 return ((READ_BITS(PDMx->DATA_L, PDM_DATA_L_OVER) >> PDM_DATA_L_OVER_POS) == 1);
2266 }
2267
2268 /**
2269 * @brief Set PDM right overflow
2270 * @note This function is used to get PDM right overflow
2271 *
2272 * Register|BitsName
2273 * --------|--------
2274 * DATA_R | OVERFLOW
2275 *
2276 * @param PDMx instance
2277 * @retval can be one of the following values:
2278 * LL_PDM_RIGHT_DATA_OVERFLOW
2279 * LL_PDM_RIGHT_DATA_NO_OVERFLOW
2280 */
2281 __STATIC_INLINE void ll_pdm_right_clear_flag_overflow(pdm_regs_t *PDMx)
2282 {
2283 MODIFY_REG(PDMx->DATA_R, PDM_DATA_R_OVER, (1 << PDM_DATA_R_OVER_POS));
2284 }
2285
2286 /**
2287 * @brief Get PDM right overflow
2288 * @note This function is used to get PDM right overflow
2289 *
2290 * Register|BitsName
2291 * --------|--------
2292 * DATA_R | OVERFLOW
2293 *
2294 * @param PDMx instance
2295 * @retval can be one of the following values:
2296 * LL_PDM_RIGHT_DATA_OVERFLOW
2297 * LL_PDM_RIGHT_DATA_NO_OVERFLOW
2298 */
2299 __STATIC_INLINE uint32_t ll_pdm_right_is_active_flag_overflow(pdm_regs_t *PDMx)
2300 {
2301 return ((READ_BITS(PDMx->DATA_R, PDM_DATA_R_OVER) >> PDM_DATA_R_OVER_POS) == 1);
2302 }
2303
2304 /**
2305 * @brief enable .valid inter
2306 *
2307 * Register|BitsName
2308 * --------|--------
2309 * INTR_L | VALID_INT_MASK
2310 *
2311 * @param PDMx PDMx instance
2312 * @retval State of bit (1 or 0).
2313 */
2314 __STATIC_INLINE void ll_pdm_left_enable_it_valid(pdm_regs_t *PDMx)
2315 {
2316 MODIFY_REG(PDMx->INT_L, PDM_INT_L_VALID_MASK,(0 << PDM_INT_L_VALID_MASK_POS));
2317 }
2318
2319 /**
2320 * @brief disable .valid inter
2321 *
2322 * Register|BitsName
2323 * --------|--------
2324 * INTR_L | VALID_INT_MASK
2325 *
2326 * @param PDMx PDMx instance
2327 * @retval None.
2328 */
2329 __STATIC_INLINE void ll_pdm_left_disable_it_valid(pdm_regs_t *PDMx)
2330 {
2331 MODIFY_REG(PDMx->INT_L, PDM_INT_L_VALID_MASK,(1 << PDM_INT_L_VALID_MASK_POS));
2332 }
2333
2334 /**
2335 * @brief Get .valid inter status
2336 *
2337 * Register|BitsName
2338 * --------|--------
2339 * INTR_L | VALID_INT_MASK
2340 *
2341 * @param PDMx PDMx instance
2342 * @retval None.
2343 */
2344 __STATIC_INLINE uint32_t ll_pdm_left_is_enable_it_valid(pdm_regs_t *PDMx)
2345 {
2346 return ((READ_BITS(PDMx->INT_L, PDM_INT_L_VALID_MASK) >> PDM_INT_L_VALID_MASK_POS) == 0);
2347 }
2348
2349 /**
2350 * @brief enable .valid inter
2351 *
2352 * Register|BitsName
2353 * --------|--------
2354 * INTR_R | VALID_INT_MASK
2355 *
2356 * @param PDMx PDMx instance
2357 * @retval State of bit (1 or 0).
2358 */
2359 __STATIC_INLINE void ll_pdm_right_enable_it_valid(pdm_regs_t *PDMx)
2360 {
2361 MODIFY_REG(PDMx->INT_R, PDM_INT_R_VALID_MASK,(0 << PDM_INT_R_VALID_MASK_POS));
2362 }
2363
2364 /**
2365 * @brief Clean the status of .valid inter status
2366 *
2367 * Register|BitsName
2368 * --------|--------
2369 * INTR_R | VALID_INT_MASK
2370 *
2371 * @param PDMx PDMx instance
2372 * @retval None.
2373 */
2374 __STATIC_INLINE void ll_pdm_right_disable_it_valid(pdm_regs_t *PDMx)
2375 {
2376 MODIFY_REG(PDMx->INT_R, PDM_INT_R_VALID_MASK,(1 << PDM_INT_R_VALID_MASK_POS));
2377 }
2378
2379 /**
2380 * @brief Get .valid inter status
2381 *
2382 * Register|BitsName
2383 * --------|--------
2384 * INTR_R | VALID_INT_MASK
2385 *
2386 * @param PDMx PDMx instance
2387 * @retval None.
2388 */
2389 __STATIC_INLINE uint32_t ll_pdm_right_is_enable_it_valid(pdm_regs_t *PDMx)
2390 {
2391 return ((READ_BITS(PDMx->INT_R, PDM_INT_R_VALID_MASK) >> PDM_INT_R_VALID_MASK_POS) == 0);
2392 }
2393
2394 /**
2395 * @brief enable .overflow inter
2396 *
2397 * Register|BitsName
2398 * --------|--------
2399 * INTR_L | OVERFLOW_INT_MASK
2400 *
2401 * @param PDMx PDMx instance
2402 * @retval State of bit (1 or 0).
2403 */
2404 __STATIC_INLINE void ll_pdm_left_enable_it_overflow(pdm_regs_t *PDMx)
2405 {
2406 MODIFY_REG(PDMx->INT_L, PDM_INT_L_OVER_MASK,(0 << PDM_INT_L_OVER_MASK_POS));
2407 }
2408
2409 /**
2410 * @brief disable .overflow inter
2411 *
2412 * Register|BitsName
2413 * --------|--------
2414 * INTR_L | OVERFLOW_INT_MASK
2415 *
2416 * @param PDMx PDMx instance
2417 * @retval None.
2418 */
2419 __STATIC_INLINE void ll_pdm_left_disable_it_overflow(pdm_regs_t *PDMx)
2420 {
2421 MODIFY_REG(PDMx->INT_L, PDM_INT_L_OVER_MASK,(1 << PDM_INT_L_OVER_MASK_POS));
2422 }
2423
2424 /**
2425 * @brief Get .overflow inter status
2426 *
2427 * Register|BitsName
2428 * --------|--------
2429 * INTR_L | OVERFLOW_INT_MASK
2430 *
2431 * @param PDMx PDMx instance
2432 * @retval None.
2433 */
2434 __STATIC_INLINE uint32_t ll_pdm_left_is_enable_it_overflow(pdm_regs_t *PDMx)
2435 {
2436 return ((READ_BITS(PDMx->INT_L, PDM_INT_L_OVER_MASK) >> PDM_INT_L_OVER_MASK_POS) == 0);
2437 }
2438
2439 /**
2440 * @brief enable .overflow inter
2441 *
2442 * Register|BitsName
2443 * --------|--------
2444 * INTR_R | OVERFLOW_INT_MASK
2445 *
2446 * @param PDMx PDMx instance
2447 * @retval State of bit (1 or 0).
2448 */
2449 __STATIC_INLINE void ll_pdm_right_enable_it_overflow(pdm_regs_t *PDMx)
2450 {
2451 MODIFY_REG(PDMx->INT_R, PDM_INT_R_OVER_MASK,(0 << PDM_INT_R_OVER_MASK_POS));
2452 }
2453
2454 /**
2455 * @brief disable .overflow inter
2456 *
2457 * Register|BitsName
2458 * --------|--------
2459 * INTR_R | OVERFLOW_INT_MASK
2460 *
2461 * @param PDMx PDMx instance
2462 * @retval None.
2463 */
2464 __STATIC_INLINE void ll_pdm_right_disable_it_overflow(pdm_regs_t *PDMx)
2465 {
2466 MODIFY_REG(PDMx->INT_R, PDM_INT_R_OVER_MASK,(1 << PDM_INT_R_OVER_MASK_POS));
2467 }
2468
2469 /**
2470 * @brief Get .overflow inter status
2471 *
2472 * Register|BitsName
2473 * --------|--------
2474 * INTR_R | OVERFLOW_INT_MASK
2475 *
2476 * @param PDMx PDMx instance
2477 * @retval None.
2478 */
2479 __STATIC_INLINE uint32_t ll_pdm_right_is_enable_it_overflow(pdm_regs_t *PDMx)
2480 {
2481 return ((READ_BITS(PDMx->INT_R, PDM_INT_R_OVER_MASK) >> PDM_INT_R_OVER_MASK_POS) == 0);
2482 }
2483
2484 /**
2485 * @brief set valid dma mask enable
2486 *
2487 * Register|BitsName
2488 * --------|--------
2489 * DATA_L | VALID_DMA_MASK
2490 *
2491 * @param PDMx PDMx instance
2492 * @retval None.
2493 */
2494 __STATIC_INLINE void ll_pdm_left_enable_dma_mask(pdm_regs_t *PDMx)
2495 {
2496 MODIFY_REG(PDMx->DATA_L, PDM_DATA_L_VALID_DMA_MASK,PDM_DATA_L_VALID_DMA_MASK_ENABLE);
2497 }
2498
2499 /**
2500 * @brief set valid dma mask disable
2501 *
2502 * Register|BitsName
2503 * --------|--------
2504 * DATA_L | VALID_DMA_MASK
2505 *
2506 * @param PDMx PDMx instance
2507 * @retval None.
2508 */
2509 __STATIC_INLINE void ll_pdm_left_disable_dma_mask(pdm_regs_t *PDMx)
2510 {
2511 MODIFY_REG(PDMx->DATA_L, PDM_DATA_L_VALID_DMA_MASK,PDM_DATA_L_VALID_DMA_MASK_DISABLE);
2512 }
2513
2514 /**
2515 * @brief set valid dma mask enable
2516 *
2517 * Register|BitsName
2518 * --------|--------
2519 * DATA_R | VALID_DMA_MASK
2520 *
2521 * @param PDMx PDMx instance
2522 * @retval None.
2523 */
2524 __STATIC_INLINE void ll_pdm_right_enable_dma_mask(pdm_regs_t *PDMx)
2525 {
2526 MODIFY_REG(PDMx->DATA_R, PDM_DATA_R_VALID_DMA_MASK,PDM_DATA_R_VALID_DMA_MASK_ENABLE);
2527 }
2528
2529 /**
2530 * @brief set valid dma mask disable
2531 *
2532 * Register|BitsName
2533 * --------|--------
2534 * DATA_R | VALID_DMA_MASK
2535 *
2536 * @param PDMx PDMx instance
2537 * @retval None.
2538 */
2539 __STATIC_INLINE void ll_pdm_right_disable_dma_mask(pdm_regs_t *PDMx)
2540 {
2541 MODIFY_REG(PDMx->DATA_R, PDM_DATA_R_VALID_DMA_MASK,PDM_DATA_R_VALID_DMA_MASK_DISABLE);
2542 }
2543
2544 /** @} */
2545
2546 /** @defgroup PDM_LL_EF_Init Initialization and de-initialization functions
2547 * @{
2548 */
2549
2550 /**
2551 * @brief De-initialize the PDM registers to their default reset values.
2552 * @param PDMx instance
2553 * @retval An error_status_t enumeration value:
2554 * - SUCCESS: PDM registers are de-initialized
2555 * - ERROR: PDM registers are not de-initialized
2556 */
2557 error_status_t ll_pdm_deinit(pdm_regs_t *PDMx);
2558
2559 /**
2560 * @brief Initialize the PDM registers according to the specified parameters in p_pdm_init.
2561 * @param PDMx instance
2562 * @param p_pdm_init pointer to a @ref ll_pdm_init_t structure.
2563 * @retval An error_status_t enumeration value:
2564 * - SUCCESS: PDM registers are initialized
2565 * - ERROR: Not applicable
2566 */
2567 error_status_t ll_pdm_init(pdm_regs_t *PDMx, ll_pdm_init_t *p_pdm_init);
2568
2569 /**
2570 * @brief Set each field of a @ref ll_pdm_init_t type structure to default value.
2571 * @param p_pdm_init Pointer to a @ref ll_pdm_init_t structure
2572 * whose fields will be set to default values.
2573 * @retval None
2574 */
2575 void ll_pdm_struct_init(ll_pdm_init_t *p_pdm_init);
2576
2577 /** @} */
2578
2579 /** @} */
2580
2581 #endif /* PDM */
2582
2583 #ifdef __cplusplus
2584 }
2585 #endif
2586
2587 #endif /* __GR55xx_LL_PDM_H__ */
2588
2589 /** @} */
2590
2591 /** @} */
2592
2593 /** @} */