1 /**
2 ******************************************************************************
3 * @file stm32u0xx_ll_crc.h
4 * @author MCD Application Team
5 * @brief Header file of CRC LL module.
6 ******************************************************************************
7 * @attention
8 *
9 * Copyright (c) 2023 STMicroelectronics.
10 * All rights reserved.
11 *
12 * This software is licensed under terms that can be found in the LICENSE file
13 * in the root directory of this software component.
14 * If no LICENSE file comes with this software, it is provided AS-IS.
15 *
16 ******************************************************************************
17 */
18
19 /* Define to prevent recursive inclusion -------------------------------------*/
20 #ifndef STM32U0xx_LL_CRC_H
21 #define STM32U0xx_LL_CRC_H
22
23 #ifdef __cplusplus
24 extern "C" {
25 #endif
26
27 /* Includes ------------------------------------------------------------------*/
28 #include "stm32u0xx.h"
29
30 /** @addtogroup STM32U0xx_LL_Driver
31 * @{
32 */
33
34 #if defined(CRC)
35
36 /** @defgroup CRC_LL CRC
37 * @{
38 */
39
40 /* Private types -------------------------------------------------------------*/
41 /* Private variables ---------------------------------------------------------*/
42 /* Private constants ---------------------------------------------------------*/
43 /* Private macros ------------------------------------------------------------*/
44
45 /* Exported types ------------------------------------------------------------*/
46 /* Exported constants --------------------------------------------------------*/
47 /** @defgroup CRC_LL_Exported_Constants CRC Exported Constants
48 * @{
49 */
50
51 /** @defgroup CRC_LL_EC_POLYLENGTH Polynomial length
52 * @{
53 */
54 #define LL_CRC_POLYLENGTH_32B 0x00000000U /*!< 32 bits Polynomial size */
55 #define LL_CRC_POLYLENGTH_16B CRC_CR_POLYSIZE_0 /*!< 16 bits Polynomial size */
56 #define LL_CRC_POLYLENGTH_8B CRC_CR_POLYSIZE_1 /*!< 8 bits Polynomial size */
57 #define LL_CRC_POLYLENGTH_7B (CRC_CR_POLYSIZE_1 | CRC_CR_POLYSIZE_0) /*!< 7 bits Polynomial size */
58 /**
59 * @}
60 */
61
62 /** @defgroup CRC_LL_EC_INPUT_REVERSE_TYPE Input Reverse Type
63 * @{
64 */
65 #define LL_CRC_INDATA_REVERSETYPE_BIT 0x00000000U /*!< Input Data reverse type at bit level granularity */
66 #define LL_CRC_INDATA_REVERSETYPE_BYTE_HALFWORD CRC_CR_RTYPE_IN /*!< Input Data reverse type at byte or half-word level granularity */
67 /**
68 * @}
69 */
70
71 /** @defgroup CRC_LL_EC_OUTPUT_REVERSE_TYPE Output Reverse Type
72 * @{
73 */
74 #define LL_CRC_OUTDATA_REVERSETYPE_BIT 0x00000000U /*!< Output Data reverse type at bit level granularity */
75 #define LL_CRC_OUTDATA_REVERSETYPE_BYTE_HALFWORD CRC_CR_RTYPE_OUT /*!< Output Data reverse type at byte or half-word level granularity */
76 /**
77 * @}
78 */
79
80 /** @defgroup CRC_LL_EC_INDATA_REVERSE Input Data Reverse
81 * @{
82 */
83 #define LL_CRC_INDATA_REVERSE_NONE 0x00000000U /*!< Input Data bit order not affected */
84 #define LL_CRC_INDATA_REVERSE_BIT_BYBYTE CRC_CR_REV_IN_0 /*!< Input Data bit reversal done by byte */
85 #define LL_CRC_INDATA_REVERSE_BYTE LL_CRC_INDATA_REVERSE_BIT_BYBYTE /*!< Definition for compatibility with legacy code */
86 #define LL_CRC_INDATA_REVERSE_HALFWORD_BYWORD (CRC_CR_RTYPE_IN | CRC_CR_REV_IN_0) /*!< Input Data half-word reversal done by word */
87 #define LL_CRC_INDATA_REVERSE_BIT_BYHALFWORD CRC_CR_REV_IN_1 /*!< Input Data bit reversal done by half-word */
88 #define LL_CRC_INDATA_REVERSE_HALFWORD LL_CRC_INDATA_REVERSE_BIT_BYHALFWORD /*!< Definition for compatibility with legacy code */
89 #define LL_CRC_INDATA_REVERSE_BYTE_BYWORD (CRC_CR_RTYPE_IN | CRC_CR_REV_IN_1) /*!< Input Data byte reversal done by word */
90 #define LL_CRC_INDATA_REVERSE_BIT_BYWORD (CRC_CR_REV_IN_1 | CRC_CR_REV_IN_0) /*!< Input Data bit reversal done by word */
91 #define LL_CRC_INDATA_REVERSE_WORD LL_CRC_INDATA_REVERSE_BIT_BYWORD /*!< Definition for compatibility with legacy code */
92 /**
93 * @}
94 */
95
96 /** @defgroup CRC_LL_EC_OUTDATA_REVERSE Output Data Reverse
97 * @{
98 */
99 #define LL_CRC_OUTDATA_REVERSE_NONE 0x00000000U /*!< Output Data bit order not affected */
100 #define LL_CRC_OUTDATA_REVERSE_BIT CRC_CR_REV_OUT_0 /*!< Output Data bit reversal done by bit */
101 #define LL_CRC_OUTDATA_REVERSE_HALFWORD (CRC_CR_RTYPE_OUT | CRC_CR_REV_OUT_0) /*!< Output Data half-word reversal done by word */
102 #define LL_CRC_OUTDATA_REVERSE_BYTE (CRC_CR_RTYPE_OUT | CRC_CR_REV_OUT_1) /*!< Output Data byte reversal done by word */
103 /**
104 * @}
105 */
106
107 /** @defgroup CRC_LL_EC_Default_Polynomial_Value Default CRC generating polynomial value
108 * @brief Normal representation of this polynomial value is
109 * X^32 + X^26 + X^23 + X^22 + X^16 + X^12 + X^11 + X^10 +X^8 + X^7 + X^5 + X^4 + X^2 + X + 1 .
110 * @{
111 */
112 #define LL_CRC_DEFAULT_CRC32_POLY 0x04C11DB7U /*!< Default CRC generating polynomial value */
113 /**
114 * @}
115 */
116
117 /** @defgroup CRC_LL_EC_Default_InitValue Default CRC computation initialization value
118 * @{
119 */
120 #define LL_CRC_DEFAULT_CRC_INITVALUE 0xFFFFFFFFU /*!< Default CRC computation initialization value */
121 /**
122 * @}
123 */
124
125 /**
126 * @}
127 */
128
129 /* Exported macro ------------------------------------------------------------*/
130 /** @defgroup CRC_LL_Exported_Macros CRC Exported Macros
131 * @{
132 */
133
134 /** @defgroup CRC_LL_EM_WRITE_READ Common Write and read registers Macros
135 * @{
136 */
137
138 /**
139 * @brief Write a value in CRC register
140 * @param __INSTANCE__ CRC Instance
141 * @param __REG__ Register to be written
142 * @param __VALUE__ Value to be written in the register
143 * @retval None
144 */
145 #define LL_CRC_WriteReg(__INSTANCE__, __REG__, __VALUE__) WRITE_REG(__INSTANCE__->__REG__, __VALUE__)
146
147 /**
148 * @brief Read a value in CRC register
149 * @param __INSTANCE__ CRC Instance
150 * @param __REG__ Register to be read
151 * @retval Register value
152 */
153 #define LL_CRC_ReadReg(__INSTANCE__, __REG__) READ_REG(__INSTANCE__->__REG__)
154 /**
155 * @}
156 */
157
158 /**
159 * @}
160 */
161
162
163 /* Exported functions --------------------------------------------------------*/
164 /** @defgroup CRC_LL_Exported_Functions CRC Exported Functions
165 * @{
166 */
167
168 /** @defgroup CRC_LL_EF_Configuration CRC Configuration functions
169 * @{
170 */
171
172 /**
173 * @brief Reset the CRC calculation unit.
174 * @note If Programmable Initial CRC value feature
175 * is available, also set the Data Register to the value stored in the
176 * CRC_INIT register, otherwise, reset Data Register to its default value.
177 * @rmtoll CR RESET LL_CRC_ResetCRCCalculationUnit
178 * @param CRCx CRC Instance
179 * @retval None
180 */
LL_CRC_ResetCRCCalculationUnit(CRC_TypeDef * CRCx)181 __STATIC_INLINE void LL_CRC_ResetCRCCalculationUnit(CRC_TypeDef *CRCx)
182 {
183 SET_BIT(CRCx->CR, CRC_CR_RESET);
184 }
185
186 /**
187 * @brief Configure size of the polynomial.
188 * @rmtoll CR POLYSIZE LL_CRC_SetPolynomialSize
189 * @param CRCx CRC Instance
190 * @param PolySize This parameter can be one of the following values:
191 * @arg @ref LL_CRC_POLYLENGTH_32B
192 * @arg @ref LL_CRC_POLYLENGTH_16B
193 * @arg @ref LL_CRC_POLYLENGTH_8B
194 * @arg @ref LL_CRC_POLYLENGTH_7B
195 * @retval None
196 */
LL_CRC_SetPolynomialSize(CRC_TypeDef * CRCx,uint32_t PolySize)197 __STATIC_INLINE void LL_CRC_SetPolynomialSize(CRC_TypeDef *CRCx, uint32_t PolySize)
198 {
199 MODIFY_REG(CRCx->CR, CRC_CR_POLYSIZE, PolySize);
200 }
201
202 /**
203 * @brief Return size of the polynomial.
204 * @rmtoll CR POLYSIZE LL_CRC_GetPolynomialSize
205 * @param CRCx CRC Instance
206 * @retval Returned value can be one of the following values:
207 * @arg @ref LL_CRC_POLYLENGTH_32B
208 * @arg @ref LL_CRC_POLYLENGTH_16B
209 * @arg @ref LL_CRC_POLYLENGTH_8B
210 * @arg @ref LL_CRC_POLYLENGTH_7B
211 */
LL_CRC_GetPolynomialSize(const CRC_TypeDef * CRCx)212 __STATIC_INLINE uint32_t LL_CRC_GetPolynomialSize(const CRC_TypeDef *CRCx)
213 {
214 return (uint32_t)(READ_BIT(CRCx->CR, CRC_CR_POLYSIZE));
215 }
216
217 /**
218 * @brief Configure the reversal type of the input data
219 * @rmtoll CR RTYPE_IN LL_CRC_SetInputDataReverseType
220 * @param CRCx CRC Instance
221 * @param ReverseType This parameter can be one of the following values:
222 * @arg @ref LL_CRC_INDATA_REVERSETYPE_BIT
223 * @arg @ref LL_CRC_INDATA_REVERSETYPE_BYTE_HALFWORD
224 * @retval None
225 */
LL_CRC_SetInputDataReverseType(CRC_TypeDef * CRCx,uint32_t ReverseType)226 __STATIC_INLINE void LL_CRC_SetInputDataReverseType(CRC_TypeDef *CRCx, uint32_t ReverseType)
227 {
228 MODIFY_REG(CRCx->CR, CRC_CR_RTYPE_IN, ReverseType);
229 }
230
231 /**
232 * @brief Return input data type of reversal
233 * @rmtoll CR RTYPE_IN LL_CRC_GetInputDataReverseType
234 * @param CRCx CRC Instance
235 * @retval Returned value can be one of the following values:
236 * @arg @ref LL_CRC_INDATA_REVERSETYPE_BIT
237 * @arg @ref LL_CRC_INDATA_REVERSETYPE_BYTE_HALFWORD
238 */
LL_CRC_GetInputDataReverseType(CRC_TypeDef * CRCx)239 __STATIC_INLINE uint32_t LL_CRC_GetInputDataReverseType(CRC_TypeDef *CRCx)
240 {
241 return (uint32_t)(READ_BIT(CRCx->CR, CRC_CR_RTYPE_IN));
242 }
243
244 /**
245 * @brief Configure the reversal type of the output data
246 * @rmtoll CR RTYPE_OUT LL_CRC_SetOutputDataReverseType
247 * @param CRCx CRC Instance
248 * @param ReverseType This parameter can be one of the following values:
249 * @arg @ref LL_CRC_OUTDATA_REVERSETYPE_BIT
250 * @arg @ref LL_CRC_OUTDATA_REVERSETYPE_BYTE_HALFWORD
251 * @retval None
252 */
LL_CRC_SetOutputDataReverseType(CRC_TypeDef * CRCx,uint32_t ReverseType)253 __STATIC_INLINE void LL_CRC_SetOutputDataReverseType(CRC_TypeDef *CRCx, uint32_t ReverseType)
254 {
255 MODIFY_REG(CRCx->CR, CRC_CR_RTYPE_OUT, ReverseType);
256 }
257
258 /**
259 * @brief Return output data type of reversal
260 * @rmtoll CR RTYPE_OUT LL_CRC_GetOutputDataReverseType
261 * @param CRCx CRC Instance
262 * @retval Returned value can be one of the following values:
263 * @arg @ref LL_CRC_OUTDATA_REVERSETYPE_BIT
264 * @arg @ref LL_CRC_OUTDATA_REVERSETYPE_BYTE_HALFWORD
265 */
LL_CRC_GetOutputDataReverseType(CRC_TypeDef * CRCx)266 __STATIC_INLINE uint32_t LL_CRC_GetOutputDataReverseType(CRC_TypeDef *CRCx)
267 {
268 return (uint32_t)(READ_BIT(CRCx->CR, CRC_CR_RTYPE_OUT));
269 }
270
271 /**
272 * @brief Configure the reversal of the bit order of the input data
273 * @rmtoll CR REV_IN LL_CRC_SetInputDataReverseMode
274 * @param CRCx CRC Instance
275 * @param ReverseMode This parameter can be one of the following values:
276 * @arg @ref LL_CRC_INDATA_REVERSE_NONE
277 * @arg @ref LL_CRC_INDATA_REVERSE_BIT_BYBYTE
278 * @arg @ref LL_CRC_INDATA_REVERSE_HALFWORD_BYWORD
279 * @arg @ref LL_CRC_INDATA_REVERSE_BIT_BYHALFWORD
280 * @arg @ref LL_CRC_INDATA_REVERSE_BYTE_BYWORD
281 * @arg @ref LL_CRC_INDATA_REVERSE_BIT_BYWORD
282 * @retval None
283 */
LL_CRC_SetInputDataReverseMode(CRC_TypeDef * CRCx,uint32_t ReverseMode)284 __STATIC_INLINE void LL_CRC_SetInputDataReverseMode(CRC_TypeDef *CRCx, uint32_t ReverseMode)
285 {
286 MODIFY_REG(CRCx->CR, (CRC_CR_RTYPE_IN | CRC_CR_REV_IN), ReverseMode);
287 }
288
289 /**
290 * @brief Return mode of reversal for input data bit order
291 * @rmtoll CR REV_IN LL_CRC_GetInputDataReverseMode
292 * @param CRCx CRC Instance
293 * @retval Returned value can be one of the following values:
294 * @arg @ref LL_CRC_INDATA_REVERSE_NONE
295 * @arg @ref LL_CRC_INDATA_REVERSE_BIT_BYBYTE
296 * @arg @ref LL_CRC_INDATA_REVERSE_HALFWORD_BYWORD
297 * @arg @ref LL_CRC_INDATA_REVERSE_BIT_BYHALFWORD
298 * @arg @ref LL_CRC_INDATA_REVERSE_BYTE_BYWORD
299 * @arg @ref LL_CRC_INDATA_REVERSE_BIT_BYWORD
300 */
LL_CRC_GetInputDataReverseMode(const CRC_TypeDef * CRCx)301 __STATIC_INLINE uint32_t LL_CRC_GetInputDataReverseMode(const CRC_TypeDef *CRCx)
302 {
303 return (uint32_t)(READ_BIT(CRCx->CR, (CRC_CR_RTYPE_IN | CRC_CR_REV_IN)));
304 }
305
306 /**
307 * @brief Configure the reversal of the bit order of the Output data
308 * @rmtoll CR REV_OUT LL_CRC_SetOutputDataReverseMode
309 * @param CRCx CRC Instance
310 * @param ReverseMode This parameter can be one of the following values:
311 * @arg @ref LL_CRC_OUTDATA_REVERSE_NONE
312 * @arg @ref LL_CRC_OUTDATA_REVERSE_BIT
313 * @arg @ref LL_CRC_OUTDATA_REVERSE_HALFWORD
314 * @arg @ref LL_CRC_OUTDATA_REVERSE_BYTE
315 * @retval None
316 */
LL_CRC_SetOutputDataReverseMode(CRC_TypeDef * CRCx,uint32_t ReverseMode)317 __STATIC_INLINE void LL_CRC_SetOutputDataReverseMode(CRC_TypeDef *CRCx, uint32_t ReverseMode)
318 {
319 MODIFY_REG(CRCx->CR, (CRC_CR_RTYPE_OUT | CRC_CR_REV_OUT), ReverseMode);
320 }
321
322 /**
323 * @brief Return mode of reversal of the bit order of the Output data
324 * @rmtoll CR REV_OUT LL_CRC_GetOutputDataReverseMode
325 * @param CRCx CRC Instance
326 * @retval Returned value can be one of the following values:
327 * @arg @ref LL_CRC_OUTDATA_REVERSE_NONE
328 * @arg @ref LL_CRC_OUTDATA_REVERSE_BIT
329 * @arg @ref LL_CRC_OUTDATA_REVERSE_HALFWORD
330 * @arg @ref LL_CRC_OUTDATA_REVERSE_BYTE
331 */
LL_CRC_GetOutputDataReverseMode(const CRC_TypeDef * CRCx)332 __STATIC_INLINE uint32_t LL_CRC_GetOutputDataReverseMode(const CRC_TypeDef *CRCx)
333 {
334 return (uint32_t)(READ_BIT(CRCx->CR, (CRC_CR_RTYPE_OUT | CRC_CR_REV_OUT)));
335 }
336
337 /**
338 * @brief Initialize the Programmable initial CRC value.
339 * @note If the CRC size is less than 32 bits, the least significant bits
340 * are used to write the correct value
341 * @note LL_CRC_DEFAULT_CRC_INITVALUE could be used as value for InitCrc parameter.
342 * @rmtoll INIT INIT LL_CRC_SetInitialData
343 * @param CRCx CRC Instance
344 * @param InitCrc Value to be programmed in Programmable initial CRC value register
345 * @retval None
346 */
LL_CRC_SetInitialData(CRC_TypeDef * CRCx,uint32_t InitCrc)347 __STATIC_INLINE void LL_CRC_SetInitialData(CRC_TypeDef *CRCx, uint32_t InitCrc)
348 {
349 WRITE_REG(CRCx->INIT, InitCrc);
350 }
351
352 /**
353 * @brief Return current Initial CRC value.
354 * @note If the CRC size is less than 32 bits, the least significant bits
355 * are used to read the correct value
356 * @rmtoll INIT INIT LL_CRC_GetInitialData
357 * @param CRCx CRC Instance
358 * @retval Value programmed in Programmable initial CRC value register
359 */
LL_CRC_GetInitialData(const CRC_TypeDef * CRCx)360 __STATIC_INLINE uint32_t LL_CRC_GetInitialData(const CRC_TypeDef *CRCx)
361 {
362 return (uint32_t)(READ_REG(CRCx->INIT));
363 }
364
365 /**
366 * @brief Initialize the Programmable polynomial value
367 * (coefficients of the polynomial to be used for CRC calculation).
368 * @note LL_CRC_DEFAULT_CRC32_POLY could be used as value for PolynomCoef parameter.
369 * @note Please check Reference Manual and existing Errata Sheets,
370 * regarding possible limitations for Polynomial values usage.
371 * For example, for a polynomial of degree 7, X^7 + X^6 + X^5 + X^2 + 1 is written 0x65
372 * @rmtoll POL POL LL_CRC_SetPolynomialCoef
373 * @param CRCx CRC Instance
374 * @param PolynomCoef Value to be programmed in Programmable Polynomial value register
375 * @retval None
376 */
LL_CRC_SetPolynomialCoef(CRC_TypeDef * CRCx,uint32_t PolynomCoef)377 __STATIC_INLINE void LL_CRC_SetPolynomialCoef(CRC_TypeDef *CRCx, uint32_t PolynomCoef)
378 {
379 WRITE_REG(CRCx->POL, PolynomCoef);
380 }
381
382 /**
383 * @brief Return current Programmable polynomial value
384 * @note Please check Reference Manual and existing Errata Sheets,
385 * regarding possible limitations for Polynomial values usage.
386 * For example, for a polynomial of degree 7, X^7 + X^6 + X^5 + X^2 + 1 is written 0x65
387 * @rmtoll POL POL LL_CRC_GetPolynomialCoef
388 * @param CRCx CRC Instance
389 * @retval Value programmed in Programmable Polynomial value register
390 */
LL_CRC_GetPolynomialCoef(const CRC_TypeDef * CRCx)391 __STATIC_INLINE uint32_t LL_CRC_GetPolynomialCoef(const CRC_TypeDef *CRCx)
392 {
393 return (uint32_t)(READ_REG(CRCx->POL));
394 }
395
396 /**
397 * @}
398 */
399
400 /** @defgroup CRC_LL_EF_Data_Management Data_Management
401 * @{
402 */
403
404 /**
405 * @brief Write given 32-bit data to the CRC calculator
406 * @rmtoll DR DR LL_CRC_FeedData32
407 * @param CRCx CRC Instance
408 * @param InData value to be provided to CRC calculator between between Min_Data=0 and Max_Data=0xFFFFFFFF
409 * @retval None
410 */
LL_CRC_FeedData32(CRC_TypeDef * CRCx,uint32_t InData)411 __STATIC_INLINE void LL_CRC_FeedData32(CRC_TypeDef *CRCx, uint32_t InData)
412 {
413 WRITE_REG(CRCx->DR, InData);
414 }
415
416 /**
417 * @brief Write given 16-bit data to the CRC calculator
418 * @rmtoll DR DR LL_CRC_FeedData16
419 * @param CRCx CRC Instance
420 * @param InData 16 bit value to be provided to CRC calculator between between Min_Data=0 and Max_Data=0xFFFF
421 * @retval None
422 */
LL_CRC_FeedData16(CRC_TypeDef * CRCx,uint16_t InData)423 __STATIC_INLINE void LL_CRC_FeedData16(CRC_TypeDef *CRCx, uint16_t InData)
424 {
425 __IO uint16_t *pReg;
426
427 pReg = (__IO uint16_t *)(__IO void *)(&CRCx->DR); /* Derogation MisraC2012 R.11.5 */
428 *pReg = InData;
429 }
430
431 /**
432 * @brief Write given 8-bit data to the CRC calculator
433 * @rmtoll DR DR LL_CRC_FeedData8
434 * @param CRCx CRC Instance
435 * @param InData 8 bit value to be provided to CRC calculator between between Min_Data=0 and Max_Data=0xFF
436 * @retval None
437 */
LL_CRC_FeedData8(CRC_TypeDef * CRCx,uint8_t InData)438 __STATIC_INLINE void LL_CRC_FeedData8(CRC_TypeDef *CRCx, uint8_t InData)
439 {
440 *(uint8_t __IO *)(&CRCx->DR) = (uint8_t) InData;
441 }
442
443 /**
444 * @brief Return current CRC calculation result. 32 bits value is returned.
445 * @rmtoll DR DR LL_CRC_ReadData32
446 * @param CRCx CRC Instance
447 * @retval Current CRC calculation result as stored in CRC_DR register (32 bits).
448 */
LL_CRC_ReadData32(const CRC_TypeDef * CRCx)449 __STATIC_INLINE uint32_t LL_CRC_ReadData32(const CRC_TypeDef *CRCx)
450 {
451 return (uint32_t)(READ_REG(CRCx->DR));
452 }
453
454 /**
455 * @brief Return current CRC calculation result. 16 bits value is returned.
456 * @note This function is expected to be used in a 16 bits CRC polynomial size context.
457 * @rmtoll DR DR LL_CRC_ReadData16
458 * @param CRCx CRC Instance
459 * @retval Current CRC calculation result as stored in CRC_DR register (16 bits).
460 */
LL_CRC_ReadData16(const CRC_TypeDef * CRCx)461 __STATIC_INLINE uint16_t LL_CRC_ReadData16(const CRC_TypeDef *CRCx)
462 {
463 return (uint16_t)READ_REG(CRCx->DR);
464 }
465
466 /**
467 * @brief Return current CRC calculation result. 8 bits value is returned.
468 * @note This function is expected to be used in a 8 bits CRC polynomial size context.
469 * @rmtoll DR DR LL_CRC_ReadData8
470 * @param CRCx CRC Instance
471 * @retval Current CRC calculation result as stored in CRC_DR register (8 bits).
472 */
LL_CRC_ReadData8(const CRC_TypeDef * CRCx)473 __STATIC_INLINE uint8_t LL_CRC_ReadData8(const CRC_TypeDef *CRCx)
474 {
475 return (uint8_t)READ_REG(CRCx->DR);
476 }
477
478 /**
479 * @brief Return current CRC calculation result. 7 bits value is returned.
480 * @note This function is expected to be used in a 7 bits CRC polynomial size context.
481 * @rmtoll DR DR LL_CRC_ReadData7
482 * @param CRCx CRC Instance
483 * @retval Current CRC calculation result as stored in CRC_DR register (7 bits).
484 */
LL_CRC_ReadData7(const CRC_TypeDef * CRCx)485 __STATIC_INLINE uint8_t LL_CRC_ReadData7(const CRC_TypeDef *CRCx)
486 {
487 return (uint8_t)(READ_REG(CRCx->DR) & 0x7FU);
488 }
489
490 /**
491 * @brief Return data stored in the Independent Data(IDR) register.
492 * @note This register can be used as a temporary storage location for one 32-bit long data.
493 * @rmtoll IDR IDR LL_CRC_Read_IDR
494 * @param CRCx CRC Instance
495 * @retval Value stored in CRC_IDR register (General-purpose 32-bit data register).
496 */
LL_CRC_Read_IDR(const CRC_TypeDef * CRCx)497 __STATIC_INLINE uint32_t LL_CRC_Read_IDR(const CRC_TypeDef *CRCx)
498 {
499 return (uint32_t)(READ_REG(CRCx->IDR));
500 }
501
502 /**
503 * @brief Store data in the Independent Data(IDR) register.
504 * @note This register can be used as a temporary storage location for one 32-bit long data.
505 * @rmtoll IDR IDR LL_CRC_Write_IDR
506 * @param CRCx CRC Instance
507 * @param InData value to be stored in CRC_IDR register (32-bit) between Min_Data=0 and Max_Data=0xFFFFFFFF
508 * @retval None
509 */
LL_CRC_Write_IDR(CRC_TypeDef * CRCx,uint32_t InData)510 __STATIC_INLINE void LL_CRC_Write_IDR(CRC_TypeDef *CRCx, uint32_t InData)
511 {
512 *((uint32_t __IO *)(&CRCx->IDR)) = (uint32_t) InData;
513 }
514 /**
515 * @}
516 */
517
518 #if defined(USE_FULL_LL_DRIVER)
519 /** @defgroup CRC_LL_EF_Init Initialization and de-initialization functions
520 * @{
521 */
522
523 ErrorStatus LL_CRC_DeInit(const CRC_TypeDef *CRCx);
524
525 /**
526 * @}
527 */
528 #endif /* USE_FULL_LL_DRIVER */
529
530 /**
531 * @}
532 */
533
534 /**
535 * @}
536 */
537
538 #endif /* defined(CRC) */
539
540 /**
541 * @}
542 */
543
544 #ifdef __cplusplus
545 }
546 #endif
547
548 #endif /* STM32U0xx_LL_CRC_H */
549
