Subversion Repositories ScreenTimer

Rev

Blame | Last modification | View Log | Download | RSS feed

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