STM32L486xx HAL User Manual
|
00001 /** 00002 ****************************************************************************** 00003 * @file stm32l4xx_ll_crc.h 00004 * @author MCD Application Team 00005 * @brief Header file of CRC LL module. 00006 ****************************************************************************** 00007 * @attention 00008 * 00009 * <h2><center>© COPYRIGHT(c) 2017 STMicroelectronics</center></h2> 00010 * 00011 * Redistribution and use in source and binary forms, with or without modification, 00012 * are permitted provided that the following conditions are met: 00013 * 1. Redistributions of source code must retain the above copyright notice, 00014 * this list of conditions and the following disclaimer. 00015 * 2. Redistributions in binary form must reproduce the above copyright notice, 00016 * this list of conditions and the following disclaimer in the documentation 00017 * and/or other materials provided with the distribution. 00018 * 3. Neither the name of STMicroelectronics nor the names of its contributors 00019 * may be used to endorse or promote products derived from this software 00020 * without specific prior written permission. 00021 * 00022 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 00023 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 00024 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 00025 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE 00026 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 00027 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 00028 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 00029 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 00030 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 00031 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 00032 * 00033 ****************************************************************************** 00034 */ 00035 00036 /* Define to prevent recursive inclusion -------------------------------------*/ 00037 #ifndef __STM32L4xx_LL_CRC_H 00038 #define __STM32L4xx_LL_CRC_H 00039 00040 #ifdef __cplusplus 00041 extern "C" { 00042 #endif 00043 00044 /* Includes ------------------------------------------------------------------*/ 00045 #include "stm32l4xx.h" 00046 00047 /** @addtogroup STM32L4xx_LL_Driver 00048 * @{ 00049 */ 00050 00051 #if defined(CRC) 00052 00053 /** @defgroup CRC_LL CRC 00054 * @{ 00055 */ 00056 00057 /* Private types -------------------------------------------------------------*/ 00058 /* Private variables ---------------------------------------------------------*/ 00059 /* Private constants ---------------------------------------------------------*/ 00060 /* Private macros ------------------------------------------------------------*/ 00061 00062 /* Exported types ------------------------------------------------------------*/ 00063 /* Exported constants --------------------------------------------------------*/ 00064 /** @defgroup CRC_LL_Exported_Constants CRC Exported Constants 00065 * @{ 00066 */ 00067 00068 /** @defgroup CRC_LL_EC_POLYLENGTH Polynomial length 00069 * @{ 00070 */ 00071 #define LL_CRC_POLYLENGTH_32B 0x00000000U /*!< 32 bits Polynomial size */ 00072 #define LL_CRC_POLYLENGTH_16B CRC_CR_POLYSIZE_0 /*!< 16 bits Polynomial size */ 00073 #define LL_CRC_POLYLENGTH_8B CRC_CR_POLYSIZE_1 /*!< 8 bits Polynomial size */ 00074 #define LL_CRC_POLYLENGTH_7B (CRC_CR_POLYSIZE_1 | CRC_CR_POLYSIZE_0) /*!< 7 bits Polynomial size */ 00075 /** 00076 * @} 00077 */ 00078 00079 /** @defgroup CRC_LL_EC_INDATA_REVERSE Input Data Reverse 00080 * @{ 00081 */ 00082 #define LL_CRC_INDATA_REVERSE_NONE 0x00000000U /*!< Input Data bit order not affected */ 00083 #define LL_CRC_INDATA_REVERSE_BYTE CRC_CR_REV_IN_0 /*!< Input Data bit reversal done by byte */ 00084 #define LL_CRC_INDATA_REVERSE_HALFWORD CRC_CR_REV_IN_1 /*!< Input Data bit reversal done by half-word */ 00085 #define LL_CRC_INDATA_REVERSE_WORD (CRC_CR_REV_IN_1 | CRC_CR_REV_IN_0) /*!< Input Data bit reversal done by word */ 00086 /** 00087 * @} 00088 */ 00089 00090 /** @defgroup CRC_LL_EC_OUTDATA_REVERSE Output Data Reverse 00091 * @{ 00092 */ 00093 #define LL_CRC_OUTDATA_REVERSE_NONE 0x00000000U /*!< Output Data bit order not affected */ 00094 #define LL_CRC_OUTDATA_REVERSE_BIT CRC_CR_REV_OUT /*!< Output Data bit reversal done by bit */ 00095 /** 00096 * @} 00097 */ 00098 00099 /** @defgroup CRC_LL_EC_Default_Polynomial_Value Default CRC generating polynomial value 00100 * @brief Normal representation of this polynomial value is 00101 * 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 . 00102 * @{ 00103 */ 00104 #define LL_CRC_DEFAULT_CRC32_POLY 0x04C11DB7U /*!< Default CRC generating polynomial value */ 00105 /** 00106 * @} 00107 */ 00108 00109 /** @defgroup CRC_LL_EC_Default_InitValue Default CRC computation initialization value 00110 * @{ 00111 */ 00112 #define LL_CRC_DEFAULT_CRC_INITVALUE 0xFFFFFFFFU /*!< Default CRC computation initialization value */ 00113 /** 00114 * @} 00115 */ 00116 00117 /** 00118 * @} 00119 */ 00120 00121 /* Exported macro ------------------------------------------------------------*/ 00122 /** @defgroup CRC_LL_Exported_Macros CRC Exported Macros 00123 * @{ 00124 */ 00125 00126 /** @defgroup CRC_LL_EM_WRITE_READ Common Write and read registers Macros 00127 * @{ 00128 */ 00129 00130 /** 00131 * @brief Write a value in CRC register 00132 * @param __INSTANCE__ CRC Instance 00133 * @param __REG__ Register to be written 00134 * @param __VALUE__ Value to be written in the register 00135 * @retval None 00136 */ 00137 #define LL_CRC_WriteReg(__INSTANCE__, __REG__, __VALUE__) WRITE_REG(__INSTANCE__->__REG__, __VALUE__) 00138 00139 /** 00140 * @brief Read a value in CRC register 00141 * @param __INSTANCE__ CRC Instance 00142 * @param __REG__ Register to be read 00143 * @retval Register value 00144 */ 00145 #define LL_CRC_ReadReg(__INSTANCE__, __REG__) READ_REG(__INSTANCE__->__REG__) 00146 /** 00147 * @} 00148 */ 00149 00150 /** 00151 * @} 00152 */ 00153 00154 00155 /* Exported functions --------------------------------------------------------*/ 00156 /** @defgroup CRC_LL_Exported_Functions CRC Exported Functions 00157 * @{ 00158 */ 00159 00160 /** @defgroup CRC_LL_EF_Configuration CRC Configuration functions 00161 * @{ 00162 */ 00163 00164 /** 00165 * @brief Reset the CRC calculation unit. 00166 * @note If Programmable Initial CRC value feature 00167 * is available, also set the Data Register to the value stored in the 00168 * CRC_INIT register, otherwise, reset Data Register to its default value. 00169 * @rmtoll CR RESET LL_CRC_ResetCRCCalculationUnit 00170 * @param CRCx CRC Instance 00171 * @retval None 00172 */ 00173 __STATIC_INLINE void LL_CRC_ResetCRCCalculationUnit(CRC_TypeDef *CRCx) 00174 { 00175 SET_BIT(CRCx->CR, CRC_CR_RESET); 00176 } 00177 00178 /** 00179 * @brief Configure size of the polynomial. 00180 * @rmtoll CR POLYSIZE LL_CRC_SetPolynomialSize 00181 * @param CRCx CRC Instance 00182 * @param PolySize This parameter can be one of the following values: 00183 * @arg @ref LL_CRC_POLYLENGTH_32B 00184 * @arg @ref LL_CRC_POLYLENGTH_16B 00185 * @arg @ref LL_CRC_POLYLENGTH_8B 00186 * @arg @ref LL_CRC_POLYLENGTH_7B 00187 * @retval None 00188 */ 00189 __STATIC_INLINE void LL_CRC_SetPolynomialSize(CRC_TypeDef *CRCx, uint32_t PolySize) 00190 { 00191 MODIFY_REG(CRCx->CR, CRC_CR_POLYSIZE, PolySize); 00192 } 00193 00194 /** 00195 * @brief Return size of the polynomial. 00196 * @rmtoll CR POLYSIZE LL_CRC_GetPolynomialSize 00197 * @param CRCx CRC Instance 00198 * @retval Returned value can be one of the following values: 00199 * @arg @ref LL_CRC_POLYLENGTH_32B 00200 * @arg @ref LL_CRC_POLYLENGTH_16B 00201 * @arg @ref LL_CRC_POLYLENGTH_8B 00202 * @arg @ref LL_CRC_POLYLENGTH_7B 00203 */ 00204 __STATIC_INLINE uint32_t LL_CRC_GetPolynomialSize(CRC_TypeDef *CRCx) 00205 { 00206 return (uint32_t)(READ_BIT(CRCx->CR, CRC_CR_POLYSIZE)); 00207 } 00208 00209 /** 00210 * @brief Configure the reversal of the bit order of the input data 00211 * @rmtoll CR REV_IN LL_CRC_SetInputDataReverseMode 00212 * @param CRCx CRC Instance 00213 * @param ReverseMode This parameter can be one of the following values: 00214 * @arg @ref LL_CRC_INDATA_REVERSE_NONE 00215 * @arg @ref LL_CRC_INDATA_REVERSE_BYTE 00216 * @arg @ref LL_CRC_INDATA_REVERSE_HALFWORD 00217 * @arg @ref LL_CRC_INDATA_REVERSE_WORD 00218 * @retval None 00219 */ 00220 __STATIC_INLINE void LL_CRC_SetInputDataReverseMode(CRC_TypeDef *CRCx, uint32_t ReverseMode) 00221 { 00222 MODIFY_REG(CRCx->CR, CRC_CR_REV_IN, ReverseMode); 00223 } 00224 00225 /** 00226 * @brief Return type of reversal for input data bit order 00227 * @rmtoll CR REV_IN LL_CRC_GetInputDataReverseMode 00228 * @param CRCx CRC Instance 00229 * @retval Returned value can be one of the following values: 00230 * @arg @ref LL_CRC_INDATA_REVERSE_NONE 00231 * @arg @ref LL_CRC_INDATA_REVERSE_BYTE 00232 * @arg @ref LL_CRC_INDATA_REVERSE_HALFWORD 00233 * @arg @ref LL_CRC_INDATA_REVERSE_WORD 00234 */ 00235 __STATIC_INLINE uint32_t LL_CRC_GetInputDataReverseMode(CRC_TypeDef *CRCx) 00236 { 00237 return (uint32_t)(READ_BIT(CRCx->CR, CRC_CR_REV_IN)); 00238 } 00239 00240 /** 00241 * @brief Configure the reversal of the bit order of the Output data 00242 * @rmtoll CR REV_OUT LL_CRC_SetOutputDataReverseMode 00243 * @param CRCx CRC Instance 00244 * @param ReverseMode This parameter can be one of the following values: 00245 * @arg @ref LL_CRC_OUTDATA_REVERSE_NONE 00246 * @arg @ref LL_CRC_OUTDATA_REVERSE_BIT 00247 * @retval None 00248 */ 00249 __STATIC_INLINE void LL_CRC_SetOutputDataReverseMode(CRC_TypeDef *CRCx, uint32_t ReverseMode) 00250 { 00251 MODIFY_REG(CRCx->CR, CRC_CR_REV_OUT, ReverseMode); 00252 } 00253 00254 /** 00255 * @brief Configure the reversal of the bit order of the Output data 00256 * @rmtoll CR REV_OUT LL_CRC_GetOutputDataReverseMode 00257 * @param CRCx CRC Instance 00258 * @retval Returned value can be one of the following values: 00259 * @arg @ref LL_CRC_OUTDATA_REVERSE_NONE 00260 * @arg @ref LL_CRC_OUTDATA_REVERSE_BIT 00261 */ 00262 __STATIC_INLINE uint32_t LL_CRC_GetOutputDataReverseMode(CRC_TypeDef *CRCx) 00263 { 00264 return (uint32_t)(READ_BIT(CRCx->CR, CRC_CR_REV_OUT)); 00265 } 00266 00267 /** 00268 * @brief Initialize the Programmable initial CRC value. 00269 * @note If the CRC size is less than 32 bits, the least significant bits 00270 * are used to write the correct value 00271 * @note LL_CRC_DEFAULT_CRC_INITVALUE could be used as value for InitCrc parameter. 00272 * @rmtoll INIT INIT LL_CRC_SetInitialData 00273 * @param CRCx CRC Instance 00274 * @param InitCrc Value to be programmed in Programmable initial CRC value register 00275 * @retval None 00276 */ 00277 __STATIC_INLINE void LL_CRC_SetInitialData(CRC_TypeDef *CRCx, uint32_t InitCrc) 00278 { 00279 WRITE_REG(CRCx->INIT, InitCrc); 00280 } 00281 00282 /** 00283 * @brief Return current Initial CRC value. 00284 * @note If the CRC size is less than 32 bits, the least significant bits 00285 * are used to read the correct value 00286 * @rmtoll INIT INIT LL_CRC_GetInitialData 00287 * @param CRCx CRC Instance 00288 * @retval Value programmed in Programmable initial CRC value register 00289 */ 00290 __STATIC_INLINE uint32_t LL_CRC_GetInitialData(CRC_TypeDef *CRCx) 00291 { 00292 return (uint32_t)(READ_REG(CRCx->INIT)); 00293 } 00294 00295 /** 00296 * @brief Initialize the Programmable polynomial value 00297 * (coefficients of the polynomial to be used for CRC calculation). 00298 * @note LL_CRC_DEFAULT_CRC32_POLY could be used as value for PolynomCoef parameter. 00299 * @note Please check Reference Manual and existing Errata Sheets, 00300 * regarding possible limitations for Polynomial values usage. 00301 * For example, for a polynomial of degree 7, X^7 + X^6 + X^5 + X^2 + 1 is written 0x65 00302 * @rmtoll POL POL LL_CRC_SetPolynomialCoef 00303 * @param CRCx CRC Instance 00304 * @param PolynomCoef Value to be programmed in Programmable Polynomial value register 00305 * @retval None 00306 */ 00307 __STATIC_INLINE void LL_CRC_SetPolynomialCoef(CRC_TypeDef *CRCx, uint32_t PolynomCoef) 00308 { 00309 WRITE_REG(CRCx->POL, PolynomCoef); 00310 } 00311 00312 /** 00313 * @brief Return current Programmable polynomial value 00314 * @note Please check Reference Manual and existing Errata Sheets, 00315 * regarding possible limitations for Polynomial values usage. 00316 * For example, for a polynomial of degree 7, X^7 + X^6 + X^5 + X^2 + 1 is written 0x65 00317 * @rmtoll POL POL LL_CRC_GetPolynomialCoef 00318 * @param CRCx CRC Instance 00319 * @retval Value programmed in Programmable Polynomial value register 00320 */ 00321 __STATIC_INLINE uint32_t LL_CRC_GetPolynomialCoef(CRC_TypeDef *CRCx) 00322 { 00323 return (uint32_t)(READ_REG(CRCx->POL)); 00324 } 00325 00326 /** 00327 * @} 00328 */ 00329 00330 /** @defgroup CRC_LL_EF_Data_Management Data_Management 00331 * @{ 00332 */ 00333 00334 /** 00335 * @brief Write given 32-bit data to the CRC calculator 00336 * @rmtoll DR DR LL_CRC_FeedData32 00337 * @param CRCx CRC Instance 00338 * @param InData value to be provided to CRC calculator between between Min_Data=0 and Max_Data=0xFFFFFFFF 00339 * @retval None 00340 */ 00341 __STATIC_INLINE void LL_CRC_FeedData32(CRC_TypeDef *CRCx, uint32_t InData) 00342 { 00343 WRITE_REG(CRCx->DR, InData); 00344 } 00345 00346 /** 00347 * @brief Write given 16-bit data to the CRC calculator 00348 * @rmtoll DR DR LL_CRC_FeedData16 00349 * @param CRCx CRC Instance 00350 * @param InData 16 bit value to be provided to CRC calculator between between Min_Data=0 and Max_Data=0xFFFF 00351 * @retval None 00352 */ 00353 __STATIC_INLINE void LL_CRC_FeedData16(CRC_TypeDef *CRCx, uint16_t InData) 00354 { 00355 __IO uint16_t *pReg; 00356 00357 pReg = (__IO uint16_t *)(__IO void *)(&CRCx->DR); 00358 *pReg = InData; 00359 } 00360 00361 /** 00362 * @brief Write given 8-bit data to the CRC calculator 00363 * @rmtoll DR DR LL_CRC_FeedData8 00364 * @param CRCx CRC Instance 00365 * @param InData 8 bit value to be provided to CRC calculator between between Min_Data=0 and Max_Data=0xFF 00366 * @retval None 00367 */ 00368 __STATIC_INLINE void LL_CRC_FeedData8(CRC_TypeDef *CRCx, uint8_t InData) 00369 { 00370 *(uint8_t __IO *)(&CRCx->DR) = (uint8_t) InData; 00371 } 00372 00373 /** 00374 * @brief Return current CRC calculation result. 32 bits value is returned. 00375 * @rmtoll DR DR LL_CRC_ReadData32 00376 * @param CRCx CRC Instance 00377 * @retval Current CRC calculation result as stored in CRC_DR register (32 bits). 00378 */ 00379 __STATIC_INLINE uint32_t LL_CRC_ReadData32(CRC_TypeDef *CRCx) 00380 { 00381 return (uint32_t)(READ_REG(CRCx->DR)); 00382 } 00383 00384 /** 00385 * @brief Return current CRC calculation result. 16 bits value is returned. 00386 * @note This function is expected to be used in a 16 bits CRC polynomial size context. 00387 * @rmtoll DR DR LL_CRC_ReadData16 00388 * @param CRCx CRC Instance 00389 * @retval Current CRC calculation result as stored in CRC_DR register (16 bits). 00390 */ 00391 __STATIC_INLINE uint16_t LL_CRC_ReadData16(CRC_TypeDef *CRCx) 00392 { 00393 return (uint16_t)READ_REG(CRCx->DR); 00394 } 00395 00396 /** 00397 * @brief Return current CRC calculation result. 8 bits value is returned. 00398 * @note This function is expected to be used in a 8 bits CRC polynomial size context. 00399 * @rmtoll DR DR LL_CRC_ReadData8 00400 * @param CRCx CRC Instance 00401 * @retval Current CRC calculation result as stored in CRC_DR register (8 bits). 00402 */ 00403 __STATIC_INLINE uint8_t LL_CRC_ReadData8(CRC_TypeDef *CRCx) 00404 { 00405 return (uint8_t)READ_REG(CRCx->DR); 00406 } 00407 00408 /** 00409 * @brief Return current CRC calculation result. 7 bits value is returned. 00410 * @note This function is expected to be used in a 7 bits CRC polynomial size context. 00411 * @rmtoll DR DR LL_CRC_ReadData7 00412 * @param CRCx CRC Instance 00413 * @retval Current CRC calculation result as stored in CRC_DR register (7 bits). 00414 */ 00415 __STATIC_INLINE uint8_t LL_CRC_ReadData7(CRC_TypeDef *CRCx) 00416 { 00417 return (uint8_t)(READ_REG(CRCx->DR) & 0x7FU); 00418 } 00419 00420 /** 00421 * @brief Return data stored in the Independent Data(IDR) register. 00422 * @note This register can be used as a temporary storage location. 00423 * @note Refer to the Reference Manual to get the authorized data length in bits. 00424 * @rmtoll IDR IDR LL_CRC_Read_IDR 00425 * @param CRCx CRC Instance 00426 * @retval Value stored in CRC_IDR register 00427 */ 00428 __STATIC_INLINE uint32_t LL_CRC_Read_IDR(CRC_TypeDef *CRCx) 00429 { 00430 return (uint32_t)(READ_REG(CRCx->IDR)); 00431 } 00432 00433 /** 00434 * @brief Store data in the Independent Data(IDR) register. 00435 * @note This register can be used as a temporary storage location. 00436 * @note Refer to the Reference Manual to get the authorized data length in bits. 00437 * @rmtoll IDR IDR LL_CRC_Write_IDR 00438 * @param CRCx CRC Instance 00439 * @param InData value to be stored in CRC_IDR register 00440 * @retval None 00441 */ 00442 __STATIC_INLINE void LL_CRC_Write_IDR(CRC_TypeDef *CRCx, uint32_t InData) 00443 { 00444 #if (CRC_IDR_IDR == 0x0FFU) 00445 *((uint8_t __IO *)(&CRCx->IDR)) = (uint8_t) InData; 00446 #else 00447 WRITE_REG(CRCx->IDR, InData); 00448 #endif 00449 } 00450 /** 00451 * @} 00452 */ 00453 00454 #if defined(USE_FULL_LL_DRIVER) 00455 /** @defgroup CRC_LL_EF_Init Initialization and de-initialization functions 00456 * @{ 00457 */ 00458 00459 ErrorStatus LL_CRC_DeInit(CRC_TypeDef *CRCx); 00460 00461 /** 00462 * @} 00463 */ 00464 #endif /* USE_FULL_LL_DRIVER */ 00465 00466 /** 00467 * @} 00468 */ 00469 00470 /** 00471 * @} 00472 */ 00473 00474 #endif /* defined(CRC) */ 00475 00476 /** 00477 * @} 00478 */ 00479 00480 #ifdef __cplusplus 00481 } 00482 #endif 00483 00484 #endif /* __STM32L4xx_LL_CRC_H */ 00485 00486 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/