mbed official / mbed-dev

mbed library sources. Supersedes mbed-src.

Dependents:   Nucleo_Hello_Encoder BLE_iBeaconScan AM1805_DEMO DISCO-F429ZI_ExportTemplate1 ... more

targets/TARGET_STM/TARGET_STM32L0/device/stm32l0xx_hal_crc.c@149:156823d33999, 2016-10-28 (annotated)

Committer:
<>
Date:
Fri Oct 28 11:17:30 2016 +0100
Revision:
149:156823d33999
Parent:
targets/cmsis/TARGET_STM/TARGET_STM32L0/stm32l0xx_hal_crc.c@144:ef7eb2e8f9f7
Child:
151:5eaa88a5bcc7
This updates the lib to the mbed lib v128



NOTE: This release includes a restructuring of the file and directory locations and thus some

include paths in your code may need updating accordingly.

Who changed what in which revision?

UserRevisionLine numberNew contents of line
<> 144:ef7eb2e8f9f7 1 /**
<> 144:ef7eb2e8f9f7 2 ******************************************************************************
<> 144:ef7eb2e8f9f7 3 * @file stm32l0xx_hal_crc.c
<> 144:ef7eb2e8f9f7 4 * @author MCD Application Team
<> 144:ef7eb2e8f9f7 5 * @version V1.5.0
<> 144:ef7eb2e8f9f7 6 * @date 8-January-2016
<> 144:ef7eb2e8f9f7 7 * @brief CRC HAL module driver.
<> 144:ef7eb2e8f9f7 8 *
<> 144:ef7eb2e8f9f7 9 * This file provides firmware functions to manage the following
<> 144:ef7eb2e8f9f7 10 * functionalities of the CRC peripheral:
<> 144:ef7eb2e8f9f7 11 * + Initialization and de-initialization functions
<> 144:ef7eb2e8f9f7 12 * + Peripheral Control functions
<> 144:ef7eb2e8f9f7 13 * + Peripheral State functions
<> 144:ef7eb2e8f9f7 14 *
<> 144:ef7eb2e8f9f7 15 @verbatim
<> 144:ef7eb2e8f9f7 16 ===============================================================================
<> 144:ef7eb2e8f9f7 17 ##### CRC How to use this driver #####
<> 144:ef7eb2e8f9f7 18 ===============================================================================
<> 144:ef7eb2e8f9f7 19 [..]
<> 144:ef7eb2e8f9f7 20
<> 144:ef7eb2e8f9f7 21 (#) Enable CRC AHB clock using __HAL_RCC_CRC_CLK_ENABLE();
<> 144:ef7eb2e8f9f7 22
<> 144:ef7eb2e8f9f7 23 (#) Initialize CRC calculator
<> 144:ef7eb2e8f9f7 24 (++) specify generating polynomial (IP default or non-default one)
<> 144:ef7eb2e8f9f7 25 (++) specify initialization value (IP default or non-default one)
<> 144:ef7eb2e8f9f7 26 (++) specify input data format
<> 144:ef7eb2e8f9f7 27 (++) specify input or output data inversion mode if any
<> 144:ef7eb2e8f9f7 28
<> 144:ef7eb2e8f9f7 29 (#) Use HAL_CRC_Accumulate() function to compute the CRC value of the
<> 144:ef7eb2e8f9f7 30 input data buffer starting with the previously computed CRC as
<> 144:ef7eb2e8f9f7 31 initialization value
<> 144:ef7eb2e8f9f7 32
<> 144:ef7eb2e8f9f7 33 (#) Use HAL_CRC_Calculate() function to compute the CRC value of the
<> 144:ef7eb2e8f9f7 34 input data buffer starting with the defined initialization value
<> 144:ef7eb2e8f9f7 35 (default or non-default) to initiate CRC calculation
<> 144:ef7eb2e8f9f7 36
<> 144:ef7eb2e8f9f7 37 @endverbatim
<> 144:ef7eb2e8f9f7 38 ******************************************************************************
<> 144:ef7eb2e8f9f7 39 * @attention
<> 144:ef7eb2e8f9f7 40 *
<> 144:ef7eb2e8f9f7 41 * <h2><center>&copy; COPYRIGHT(c) 2016 STMicroelectronics</center></h2>
<> 144:ef7eb2e8f9f7 42 *
<> 144:ef7eb2e8f9f7 43 * Redistribution and use in source and binary forms, with or without modification,
<> 144:ef7eb2e8f9f7 44 * are permitted provided that the following conditions are met:
<> 144:ef7eb2e8f9f7 45 * 1. Redistributions of source code must retain the above copyright notice,
<> 144:ef7eb2e8f9f7 46 * this list of conditions and the following disclaimer.
<> 144:ef7eb2e8f9f7 47 * 2. Redistributions in binary form must reproduce the above copyright notice,
<> 144:ef7eb2e8f9f7 48 * this list of conditions and the following disclaimer in the documentation
<> 144:ef7eb2e8f9f7 49 * and/or other materials provided with the distribution.
<> 144:ef7eb2e8f9f7 50 * 3. Neither the name of STMicroelectronics nor the names of its contributors
<> 144:ef7eb2e8f9f7 51 * may be used to endorse or promote products derived from this software
<> 144:ef7eb2e8f9f7 52 * without specific prior written permission.
<> 144:ef7eb2e8f9f7 53 *
<> 144:ef7eb2e8f9f7 54 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
<> 144:ef7eb2e8f9f7 55 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
<> 144:ef7eb2e8f9f7 56 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
<> 144:ef7eb2e8f9f7 57 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
<> 144:ef7eb2e8f9f7 58 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
<> 144:ef7eb2e8f9f7 59 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
<> 144:ef7eb2e8f9f7 60 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
<> 144:ef7eb2e8f9f7 61 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
<> 144:ef7eb2e8f9f7 62 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
<> 144:ef7eb2e8f9f7 63 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
<> 144:ef7eb2e8f9f7 64 *
<> 144:ef7eb2e8f9f7 65 ******************************************************************************
<> 144:ef7eb2e8f9f7 66 */
<> 144:ef7eb2e8f9f7 67
<> 144:ef7eb2e8f9f7 68 /* Includes ------------------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 69 #include "stm32l0xx_hal.h"
<> 144:ef7eb2e8f9f7 70
<> 144:ef7eb2e8f9f7 71 /** @addtogroup STM32L0xx_HAL_Driver
<> 144:ef7eb2e8f9f7 72 * @{
<> 144:ef7eb2e8f9f7 73 */
<> 144:ef7eb2e8f9f7 74
<> 144:ef7eb2e8f9f7 75 #ifdef HAL_CRC_MODULE_ENABLED
<> 144:ef7eb2e8f9f7 76
<> 144:ef7eb2e8f9f7 77 /** @addtogroup CRC
<> 144:ef7eb2e8f9f7 78 * @brief CRC HAL module driver
<> 144:ef7eb2e8f9f7 79 * @{
<> 144:ef7eb2e8f9f7 80 */
<> 144:ef7eb2e8f9f7 81
<> 144:ef7eb2e8f9f7 82 /** @addtogroup CRC_Private
<> 144:ef7eb2e8f9f7 83 * @{
<> 144:ef7eb2e8f9f7 84 */
<> 144:ef7eb2e8f9f7 85 /* Private typedef -----------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 86 /* Private define ------------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 87 /* Private macro -------------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 88 /* Private variables ---------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 89 /* Private function prototypes -----------------------------------------------*/
<> 144:ef7eb2e8f9f7 90 static uint32_t CRC_Handle_8(CRC_HandleTypeDef *hcrc, uint8_t pBuffer[], uint32_t BufferLength);
<> 144:ef7eb2e8f9f7 91 static uint32_t CRC_Handle_16(CRC_HandleTypeDef *hcrc, uint16_t pBuffer[], uint32_t BufferLength);
<> 144:ef7eb2e8f9f7 92 /**
<> 144:ef7eb2e8f9f7 93 * @}
<> 144:ef7eb2e8f9f7 94 */
<> 144:ef7eb2e8f9f7 95
<> 144:ef7eb2e8f9f7 96 /* Exported functions --------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 97 /** @addtogroup CRC_Exported_Functions
<> 144:ef7eb2e8f9f7 98 * @{
<> 144:ef7eb2e8f9f7 99 */
<> 144:ef7eb2e8f9f7 100
<> 144:ef7eb2e8f9f7 101 /** @addtogroup CRC_Exported_Functions_Group1
<> 144:ef7eb2e8f9f7 102 * @brief Initialization and Configuration functions.
<> 144:ef7eb2e8f9f7 103 *
<> 144:ef7eb2e8f9f7 104 @verbatim
<> 144:ef7eb2e8f9f7 105 ===============================================================================
<> 144:ef7eb2e8f9f7 106 ##### Initialization and de-initialization functions #####
<> 144:ef7eb2e8f9f7 107 ===============================================================================
<> 144:ef7eb2e8f9f7 108 [..]
<> 144:ef7eb2e8f9f7 109 This section provides functions allowing to:
<> 144:ef7eb2e8f9f7 110
<> 144:ef7eb2e8f9f7 111 (#) Initialize the CRC according to the specified parameters
<> 144:ef7eb2e8f9f7 112 in the CRC_InitTypeDef and create the associated handle
<> 144:ef7eb2e8f9f7 113
<> 144:ef7eb2e8f9f7 114 (#) DeInitialize the CRC peripheral
<> 144:ef7eb2e8f9f7 115
<> 144:ef7eb2e8f9f7 116 (#) Initialize the CRC MSP
<> 144:ef7eb2e8f9f7 117
<> 144:ef7eb2e8f9f7 118 (#) DeInitialize CRC MSP
<> 144:ef7eb2e8f9f7 119
<> 144:ef7eb2e8f9f7 120 @endverbatim
<> 144:ef7eb2e8f9f7 121 * @{
<> 144:ef7eb2e8f9f7 122 */
<> 144:ef7eb2e8f9f7 123
<> 144:ef7eb2e8f9f7 124 /**
<> 144:ef7eb2e8f9f7 125 * @brief Initializes the CRC according to the specified
<> 144:ef7eb2e8f9f7 126 * parameters in the CRC_InitTypeDef and creates the associated handle.
<> 144:ef7eb2e8f9f7 127 * @param hcrc: CRC handle
<> 144:ef7eb2e8f9f7 128 * @retval HAL status
<> 144:ef7eb2e8f9f7 129 */
<> 144:ef7eb2e8f9f7 130 HAL_StatusTypeDef HAL_CRC_Init(CRC_HandleTypeDef *hcrc)
<> 144:ef7eb2e8f9f7 131 {
<> 144:ef7eb2e8f9f7 132 /* Check the CRC handle allocation */
<> 144:ef7eb2e8f9f7 133 if(hcrc == NULL)
<> 144:ef7eb2e8f9f7 134 {
<> 144:ef7eb2e8f9f7 135 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 136 }
<> 144:ef7eb2e8f9f7 137
<> 144:ef7eb2e8f9f7 138 /* Check the parameters */
<> 144:ef7eb2e8f9f7 139 assert_param(IS_CRC_ALL_INSTANCE(hcrc->Instance));
<> 144:ef7eb2e8f9f7 140
<> 144:ef7eb2e8f9f7 141 if(hcrc->State == HAL_CRC_STATE_RESET)
<> 144:ef7eb2e8f9f7 142 {
<> 144:ef7eb2e8f9f7 143 /* Allocate lock resource and initialize it */
<> 144:ef7eb2e8f9f7 144 hcrc->Lock = HAL_UNLOCKED;
<> 144:ef7eb2e8f9f7 145
<> 144:ef7eb2e8f9f7 146 /* Init the low level hardware */
<> 144:ef7eb2e8f9f7 147 HAL_CRC_MspInit(hcrc);
<> 144:ef7eb2e8f9f7 148 }
<> 144:ef7eb2e8f9f7 149
<> 144:ef7eb2e8f9f7 150 /* Change CRC peripheral state */
<> 144:ef7eb2e8f9f7 151 hcrc->State = HAL_CRC_STATE_BUSY;
<> 144:ef7eb2e8f9f7 152
<> 144:ef7eb2e8f9f7 153 /* check whether or not non-default generating polynomial has been
<> 144:ef7eb2e8f9f7 154 * picked up by user */
<> 144:ef7eb2e8f9f7 155 assert_param(IS_DEFAULT_POLYNOMIAL(hcrc->Init.DefaultPolynomialUse));
<> 144:ef7eb2e8f9f7 156 if (hcrc->Init.DefaultPolynomialUse == DEFAULT_POLYNOMIAL_ENABLE)
<> 144:ef7eb2e8f9f7 157 {
<> 144:ef7eb2e8f9f7 158 /* initialize IP with default generating polynomial */
<> 144:ef7eb2e8f9f7 159 WRITE_REG(hcrc->Instance->POL, DEFAULT_CRC32_POLY);
<> 144:ef7eb2e8f9f7 160 MODIFY_REG(hcrc->Instance->CR, CRC_CR_POLYSIZE, CRC_POLYLENGTH_32B);
<> 144:ef7eb2e8f9f7 161 }
<> 144:ef7eb2e8f9f7 162 else
<> 144:ef7eb2e8f9f7 163 {
<> 144:ef7eb2e8f9f7 164 /* initialize CRC IP with generating polynomial defined by user */
<> 144:ef7eb2e8f9f7 165 assert_param(IS_CRC_POL_LENGTH(hcrc->Init.CRCLength));
<> 144:ef7eb2e8f9f7 166 if (HAL_CRCEx_Polynomial_Set(hcrc, hcrc->Init.GeneratingPolynomial, hcrc->Init.CRCLength) != HAL_OK)
<> 144:ef7eb2e8f9f7 167 {
<> 144:ef7eb2e8f9f7 168 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 169 }
<> 144:ef7eb2e8f9f7 170 }
<> 144:ef7eb2e8f9f7 171
<> 144:ef7eb2e8f9f7 172 /* check whether or not non-default CRC initial value has been
<> 144:ef7eb2e8f9f7 173 * picked up by user */
<> 144:ef7eb2e8f9f7 174 assert_param(IS_DEFAULT_INIT_VALUE(hcrc->Init.DefaultInitValueUse));
<> 144:ef7eb2e8f9f7 175 if (hcrc->Init.DefaultInitValueUse == DEFAULT_INIT_VALUE_ENABLE)
<> 144:ef7eb2e8f9f7 176 {
<> 144:ef7eb2e8f9f7 177 WRITE_REG(hcrc->Instance->INIT, DEFAULT_CRC_INITVALUE);
<> 144:ef7eb2e8f9f7 178 }
<> 144:ef7eb2e8f9f7 179 else
<> 144:ef7eb2e8f9f7 180 {
<> 144:ef7eb2e8f9f7 181 WRITE_REG(hcrc->Instance->INIT, hcrc->Init.InitValue);
<> 144:ef7eb2e8f9f7 182 }
<> 144:ef7eb2e8f9f7 183
<> 144:ef7eb2e8f9f7 184
<> 144:ef7eb2e8f9f7 185 /* set input data inversion mode */
<> 144:ef7eb2e8f9f7 186 assert_param(IS_CRC_INPUTDATA_INVERSION_MODE(hcrc->Init.InputDataInversionMode));
<> 144:ef7eb2e8f9f7 187 MODIFY_REG(hcrc->Instance->CR, CRC_CR_REV_IN, hcrc->Init.InputDataInversionMode);
<> 144:ef7eb2e8f9f7 188
<> 144:ef7eb2e8f9f7 189 /* set output data inversion mode */
<> 144:ef7eb2e8f9f7 190 assert_param(IS_CRC_OUTPUTDATA_INVERSION_MODE(hcrc->Init.OutputDataInversionMode));
<> 144:ef7eb2e8f9f7 191 MODIFY_REG(hcrc->Instance->CR, CRC_CR_REV_OUT, hcrc->Init.OutputDataInversionMode);
<> 144:ef7eb2e8f9f7 192
<> 144:ef7eb2e8f9f7 193 /* makes sure the input data format (bytes, halfwords or words stream)
<> 144:ef7eb2e8f9f7 194 * is properly specified by user */
<> 144:ef7eb2e8f9f7 195 assert_param(IS_CRC_INPUTDATA_FORMAT(hcrc->InputDataFormat));
<> 144:ef7eb2e8f9f7 196
<> 144:ef7eb2e8f9f7 197 /* Change CRC peripheral state */
<> 144:ef7eb2e8f9f7 198 hcrc->State = HAL_CRC_STATE_READY;
<> 144:ef7eb2e8f9f7 199
<> 144:ef7eb2e8f9f7 200 /* Return function status */
<> 144:ef7eb2e8f9f7 201 return HAL_OK;
<> 144:ef7eb2e8f9f7 202 }
<> 144:ef7eb2e8f9f7 203
<> 144:ef7eb2e8f9f7 204 /**
<> 144:ef7eb2e8f9f7 205 * @brief DeInitializes the CRC peripheral.
<> 144:ef7eb2e8f9f7 206 * @param hcrc: CRC handle
<> 144:ef7eb2e8f9f7 207 * @retval HAL status
<> 144:ef7eb2e8f9f7 208 */
<> 144:ef7eb2e8f9f7 209 HAL_StatusTypeDef HAL_CRC_DeInit(CRC_HandleTypeDef *hcrc)
<> 144:ef7eb2e8f9f7 210 {
<> 144:ef7eb2e8f9f7 211 /* Check the CRC handle allocation */
<> 144:ef7eb2e8f9f7 212 if(hcrc == NULL)
<> 144:ef7eb2e8f9f7 213 {
<> 144:ef7eb2e8f9f7 214 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 215 }
<> 144:ef7eb2e8f9f7 216
<> 144:ef7eb2e8f9f7 217 /* Check the parameters */
<> 144:ef7eb2e8f9f7 218 assert_param(IS_CRC_ALL_INSTANCE(hcrc->Instance));
<> 144:ef7eb2e8f9f7 219
<> 144:ef7eb2e8f9f7 220 /* Check the CRC peripheral state */
<> 144:ef7eb2e8f9f7 221 if(hcrc->State == HAL_CRC_STATE_BUSY)
<> 144:ef7eb2e8f9f7 222 {
<> 144:ef7eb2e8f9f7 223 return HAL_BUSY;
<> 144:ef7eb2e8f9f7 224 }
<> 144:ef7eb2e8f9f7 225
<> 144:ef7eb2e8f9f7 226 /* Change CRC peripheral state */
<> 144:ef7eb2e8f9f7 227 hcrc->State = HAL_CRC_STATE_BUSY;
<> 144:ef7eb2e8f9f7 228
<> 144:ef7eb2e8f9f7 229 /* Reset CRC calculation unit */
<> 144:ef7eb2e8f9f7 230 __HAL_CRC_DR_RESET(hcrc);
<> 144:ef7eb2e8f9f7 231
<> 144:ef7eb2e8f9f7 232 /* DeInit the low level hardware */
<> 144:ef7eb2e8f9f7 233 HAL_CRC_MspDeInit(hcrc);
<> 144:ef7eb2e8f9f7 234
<> 144:ef7eb2e8f9f7 235 /* Change CRC peripheral state */
<> 144:ef7eb2e8f9f7 236 hcrc->State = HAL_CRC_STATE_RESET;
<> 144:ef7eb2e8f9f7 237
<> 144:ef7eb2e8f9f7 238 /* Process unlocked */
<> 144:ef7eb2e8f9f7 239 __HAL_UNLOCK(hcrc);
<> 144:ef7eb2e8f9f7 240
<> 144:ef7eb2e8f9f7 241 /* Return function status */
<> 144:ef7eb2e8f9f7 242 return HAL_OK;
<> 144:ef7eb2e8f9f7 243 }
<> 144:ef7eb2e8f9f7 244
<> 144:ef7eb2e8f9f7 245 /**
<> 144:ef7eb2e8f9f7 246 * @brief Initializes the CRC MSP.
<> 144:ef7eb2e8f9f7 247 * @param hcrc: CRC handle
<> 144:ef7eb2e8f9f7 248 * @retval None
<> 144:ef7eb2e8f9f7 249 */
<> 144:ef7eb2e8f9f7 250 __weak void HAL_CRC_MspInit(CRC_HandleTypeDef *hcrc)
<> 144:ef7eb2e8f9f7 251 {
<> 144:ef7eb2e8f9f7 252 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 253 UNUSED(hcrc);
<> 144:ef7eb2e8f9f7 254
<> 144:ef7eb2e8f9f7 255 /* NOTE : This function should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 256 the HAL_CRC_MspInit can be implemented in the user file
<> 144:ef7eb2e8f9f7 257 */
<> 144:ef7eb2e8f9f7 258 }
<> 144:ef7eb2e8f9f7 259
<> 144:ef7eb2e8f9f7 260 /**
<> 144:ef7eb2e8f9f7 261 * @brief DeInitializes the CRC MSP.
<> 144:ef7eb2e8f9f7 262 * @param hcrc: CRC handle
<> 144:ef7eb2e8f9f7 263 * @retval None
<> 144:ef7eb2e8f9f7 264 */
<> 144:ef7eb2e8f9f7 265 __weak void HAL_CRC_MspDeInit(CRC_HandleTypeDef *hcrc)
<> 144:ef7eb2e8f9f7 266 {
<> 144:ef7eb2e8f9f7 267 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 268 UNUSED(hcrc);
<> 144:ef7eb2e8f9f7 269
<> 144:ef7eb2e8f9f7 270 /* NOTE : This function should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 271 the HAL_CRC_MspDeInit can be implemented in the user file
<> 144:ef7eb2e8f9f7 272 */
<> 144:ef7eb2e8f9f7 273 }
<> 144:ef7eb2e8f9f7 274
<> 144:ef7eb2e8f9f7 275
<> 144:ef7eb2e8f9f7 276 /**
<> 144:ef7eb2e8f9f7 277 * @}
<> 144:ef7eb2e8f9f7 278 */
<> 144:ef7eb2e8f9f7 279
<> 144:ef7eb2e8f9f7 280 /** @addtogroup CRC_Exported_Functions_Group2
<> 144:ef7eb2e8f9f7 281 * @brief management functions.
<> 144:ef7eb2e8f9f7 282 *
<> 144:ef7eb2e8f9f7 283 @verbatim
<> 144:ef7eb2e8f9f7 284 ===============================================================================
<> 144:ef7eb2e8f9f7 285 ##### Peripheral Control functions #####
<> 144:ef7eb2e8f9f7 286 ===============================================================================
<> 144:ef7eb2e8f9f7 287 [..] This section provides functions allowing to:
<> 144:ef7eb2e8f9f7 288
<> 144:ef7eb2e8f9f7 289 (#) Compute the 7, 8, 16 or 32-bit CRC value of an 8, 16 or 32-bit data buffer
<> 144:ef7eb2e8f9f7 290 using combination of the previous CRC value and the new one.
<> 144:ef7eb2e8f9f7 291
<> 144:ef7eb2e8f9f7 292 or
<> 144:ef7eb2e8f9f7 293
<> 144:ef7eb2e8f9f7 294 (#) Compute the 7, 8, 16 or 32-bit CRC value of an 8, 16 or 32-bit data buffer
<> 144:ef7eb2e8f9f7 295 independently of the previous CRC value.
<> 144:ef7eb2e8f9f7 296
<> 144:ef7eb2e8f9f7 297 @endverbatim
<> 144:ef7eb2e8f9f7 298 * @{
<> 144:ef7eb2e8f9f7 299 */
<> 144:ef7eb2e8f9f7 300
<> 144:ef7eb2e8f9f7 301 /**
<> 144:ef7eb2e8f9f7 302 * @brief Compute the 7, 8, 16 or 32-bit CRC value of an 8, 16 or 32-bit data buffer
<> 144:ef7eb2e8f9f7 303 * starting with the previously computed CRC as initialization value.
<> 144:ef7eb2e8f9f7 304 * @param hcrc: CRC handle
<> 144:ef7eb2e8f9f7 305 * @param pBuffer: pointer to the input data buffer, exact input data format is
<> 144:ef7eb2e8f9f7 306 * provided by hcrc->InputDataFormat.
<> 144:ef7eb2e8f9f7 307 * @param BufferLength: input data buffer length (number of bytes if pBuffer
<> 144:ef7eb2e8f9f7 308 * type is * uint8_t, number of half-words if pBuffer type is * uint16_t,
<> 144:ef7eb2e8f9f7 309 * number of words if pBuffer type is * uint32_t).
<> 144:ef7eb2e8f9f7 310 * @note By default, the API expects a uint32_t pointer as input buffer parameter.
<> 144:ef7eb2e8f9f7 311 * Input buffer pointers with other types simply need to be cast in uint32_t
<> 144:ef7eb2e8f9f7 312 * and the API will internally adjust its input data processing based on the
<> 144:ef7eb2e8f9f7 313 * handle field hcrc->InputDataFormat.
<> 144:ef7eb2e8f9f7 314 * @retval uint32_t CRC (returned value LSBs for CRC shorter than 32 bits)
<> 144:ef7eb2e8f9f7 315 */
<> 144:ef7eb2e8f9f7 316 uint32_t HAL_CRC_Accumulate(CRC_HandleTypeDef *hcrc, uint32_t pBuffer[], uint32_t BufferLength)
<> 144:ef7eb2e8f9f7 317 {
<> 144:ef7eb2e8f9f7 318 uint32_t index = 0; /* CRC input data buffer index */
<> 144:ef7eb2e8f9f7 319 uint32_t temp = 0; /* CRC output (read from hcrc->Instance->DR register) */
<> 144:ef7eb2e8f9f7 320
<> 144:ef7eb2e8f9f7 321 /* Process locked */
<> 144:ef7eb2e8f9f7 322 __HAL_LOCK(hcrc);
<> 144:ef7eb2e8f9f7 323
<> 144:ef7eb2e8f9f7 324 /* Change CRC peripheral state */
<> 144:ef7eb2e8f9f7 325 hcrc->State = HAL_CRC_STATE_BUSY;
<> 144:ef7eb2e8f9f7 326
<> 144:ef7eb2e8f9f7 327 switch (hcrc->InputDataFormat)
<> 144:ef7eb2e8f9f7 328 {
<> 144:ef7eb2e8f9f7 329 case CRC_INPUTDATA_FORMAT_WORDS:
<> 144:ef7eb2e8f9f7 330 /* Enter Data to the CRC calculator */
<> 144:ef7eb2e8f9f7 331 for(index = 0; index < BufferLength; index++)
<> 144:ef7eb2e8f9f7 332 {
<> 144:ef7eb2e8f9f7 333 hcrc->Instance->DR = pBuffer[index];
<> 144:ef7eb2e8f9f7 334 }
<> 144:ef7eb2e8f9f7 335 temp = hcrc->Instance->DR;
<> 144:ef7eb2e8f9f7 336 break;
<> 144:ef7eb2e8f9f7 337
<> 144:ef7eb2e8f9f7 338 case CRC_INPUTDATA_FORMAT_BYTES:
<> 144:ef7eb2e8f9f7 339 temp = CRC_Handle_8(hcrc, (uint8_t*)pBuffer, BufferLength);
<> 144:ef7eb2e8f9f7 340 break;
<> 144:ef7eb2e8f9f7 341
<> 144:ef7eb2e8f9f7 342 case CRC_INPUTDATA_FORMAT_HALFWORDS:
<> 144:ef7eb2e8f9f7 343 temp = CRC_Handle_16(hcrc, (uint16_t*)pBuffer, BufferLength);
<> 144:ef7eb2e8f9f7 344 break;
<> 144:ef7eb2e8f9f7 345 default:
<> 144:ef7eb2e8f9f7 346 break;
<> 144:ef7eb2e8f9f7 347 }
<> 144:ef7eb2e8f9f7 348
<> 144:ef7eb2e8f9f7 349 /* Change CRC peripheral state */
<> 144:ef7eb2e8f9f7 350 hcrc->State = HAL_CRC_STATE_READY;
<> 144:ef7eb2e8f9f7 351
<> 144:ef7eb2e8f9f7 352 /* Process unlocked */
<> 144:ef7eb2e8f9f7 353 __HAL_UNLOCK(hcrc);
<> 144:ef7eb2e8f9f7 354
<> 144:ef7eb2e8f9f7 355 /* Return the CRC computed value */
<> 144:ef7eb2e8f9f7 356 return temp;
<> 144:ef7eb2e8f9f7 357 }
<> 144:ef7eb2e8f9f7 358
<> 144:ef7eb2e8f9f7 359
<> 144:ef7eb2e8f9f7 360 /**
<> 144:ef7eb2e8f9f7 361 * @brief Compute the 7, 8, 16 or 32-bit CRC value of an 8, 16 or 32-bit data buffer
<> 144:ef7eb2e8f9f7 362 * starting with hcrc->Instance->INIT as initialization value.
<> 144:ef7eb2e8f9f7 363 * @param hcrc: CRC handle
<> 144:ef7eb2e8f9f7 364 * @param pBuffer: pointer to the input data buffer, exact input data format is
<> 144:ef7eb2e8f9f7 365 * provided by hcrc->InputDataFormat.
<> 144:ef7eb2e8f9f7 366 * @param BufferLength: input data buffer length (number of bytes if pBuffer
<> 144:ef7eb2e8f9f7 367 * type is * uint8_t, number of half-words if pBuffer type is * uint16_t,
<> 144:ef7eb2e8f9f7 368 * number of words if pBuffer type is * uint32_t).
<> 144:ef7eb2e8f9f7 369 * @note By default, the API expects a uint32_t pointer as input buffer parameter.
<> 144:ef7eb2e8f9f7 370 * Input buffer pointers with other types simply need to be cast in uint32_t
<> 144:ef7eb2e8f9f7 371 * and the API will internally adjust its input data processing based on the
<> 144:ef7eb2e8f9f7 372 * handle field hcrc->InputDataFormat.
<> 144:ef7eb2e8f9f7 373 * @retval uint32_t CRC (returned value LSBs for CRC shorter than 32 bits)
<> 144:ef7eb2e8f9f7 374 */
<> 144:ef7eb2e8f9f7 375 uint32_t HAL_CRC_Calculate(CRC_HandleTypeDef *hcrc, uint32_t pBuffer[], uint32_t BufferLength)
<> 144:ef7eb2e8f9f7 376 {
<> 144:ef7eb2e8f9f7 377 uint32_t index = 0; /* CRC input data buffer index */
<> 144:ef7eb2e8f9f7 378 uint32_t temp = 0; /* CRC output (read from hcrc->Instance->DR register) */
<> 144:ef7eb2e8f9f7 379
<> 144:ef7eb2e8f9f7 380 /* Process locked */
<> 144:ef7eb2e8f9f7 381 __HAL_LOCK(hcrc);
<> 144:ef7eb2e8f9f7 382
<> 144:ef7eb2e8f9f7 383 /* Change CRC peripheral state */
<> 144:ef7eb2e8f9f7 384 hcrc->State = HAL_CRC_STATE_BUSY;
<> 144:ef7eb2e8f9f7 385
<> 144:ef7eb2e8f9f7 386 /* Reset CRC Calculation Unit (hcrc->Instance->INIT is
<> 144:ef7eb2e8f9f7 387 * written in hcrc->Instance->DR) */
<> 144:ef7eb2e8f9f7 388 __HAL_CRC_DR_RESET(hcrc);
<> 144:ef7eb2e8f9f7 389
<> 144:ef7eb2e8f9f7 390 switch (hcrc->InputDataFormat)
<> 144:ef7eb2e8f9f7 391 {
<> 144:ef7eb2e8f9f7 392 case CRC_INPUTDATA_FORMAT_WORDS:
<> 144:ef7eb2e8f9f7 393 /* Enter 32-bit input data to the CRC calculator */
<> 144:ef7eb2e8f9f7 394 for(index = 0; index < BufferLength; index++)
<> 144:ef7eb2e8f9f7 395 {
<> 144:ef7eb2e8f9f7 396 hcrc->Instance->DR = pBuffer[index];
<> 144:ef7eb2e8f9f7 397 }
<> 144:ef7eb2e8f9f7 398 temp = hcrc->Instance->DR;
<> 144:ef7eb2e8f9f7 399 break;
<> 144:ef7eb2e8f9f7 400
<> 144:ef7eb2e8f9f7 401 case CRC_INPUTDATA_FORMAT_BYTES:
<> 144:ef7eb2e8f9f7 402 /* Specific 8-bit input data handling */
<> 144:ef7eb2e8f9f7 403 temp = CRC_Handle_8(hcrc, (uint8_t*)pBuffer, BufferLength);
<> 144:ef7eb2e8f9f7 404 break;
<> 144:ef7eb2e8f9f7 405
<> 144:ef7eb2e8f9f7 406 case CRC_INPUTDATA_FORMAT_HALFWORDS:
<> 144:ef7eb2e8f9f7 407 /* Specific 16-bit input data handling */
<> 144:ef7eb2e8f9f7 408 temp = CRC_Handle_16(hcrc, (uint16_t*)pBuffer, BufferLength);
<> 144:ef7eb2e8f9f7 409 break;
<> 144:ef7eb2e8f9f7 410 default:
<> 144:ef7eb2e8f9f7 411 break;
<> 144:ef7eb2e8f9f7 412 }
<> 144:ef7eb2e8f9f7 413
<> 144:ef7eb2e8f9f7 414 /* Change CRC peripheral state */
<> 144:ef7eb2e8f9f7 415 hcrc->State = HAL_CRC_STATE_READY;
<> 144:ef7eb2e8f9f7 416
<> 144:ef7eb2e8f9f7 417 /* Process unlocked */
<> 144:ef7eb2e8f9f7 418 __HAL_UNLOCK(hcrc);
<> 144:ef7eb2e8f9f7 419
<> 144:ef7eb2e8f9f7 420 /* Return the CRC computed value */
<> 144:ef7eb2e8f9f7 421 return temp;
<> 144:ef7eb2e8f9f7 422 }
<> 144:ef7eb2e8f9f7 423
<> 144:ef7eb2e8f9f7 424
<> 144:ef7eb2e8f9f7 425
<> 144:ef7eb2e8f9f7 426 /**
<> 144:ef7eb2e8f9f7 427 * @}
<> 144:ef7eb2e8f9f7 428 */
<> 144:ef7eb2e8f9f7 429
<> 144:ef7eb2e8f9f7 430 /** @addtogroup CRC_Exported_Functions_Group3
<> 144:ef7eb2e8f9f7 431 * @brief Peripheral State functions.
<> 144:ef7eb2e8f9f7 432 *
<> 144:ef7eb2e8f9f7 433 @verbatim
<> 144:ef7eb2e8f9f7 434 ===============================================================================
<> 144:ef7eb2e8f9f7 435 ##### Peripheral State functions #####
<> 144:ef7eb2e8f9f7 436 ===============================================================================
<> 144:ef7eb2e8f9f7 437 [..]
<> 144:ef7eb2e8f9f7 438 This subsection permits to get in run-time the status of the peripheral.
<> 144:ef7eb2e8f9f7 439
<> 144:ef7eb2e8f9f7 440 @endverbatim
<> 144:ef7eb2e8f9f7 441 * @{
<> 144:ef7eb2e8f9f7 442 */
<> 144:ef7eb2e8f9f7 443
<> 144:ef7eb2e8f9f7 444 /**
<> 144:ef7eb2e8f9f7 445 * @brief Returns the CRC state.
<> 144:ef7eb2e8f9f7 446 * @param hcrc: CRC handle
<> 144:ef7eb2e8f9f7 447 * @retval HAL state
<> 144:ef7eb2e8f9f7 448 */
<> 144:ef7eb2e8f9f7 449 HAL_CRC_StateTypeDef HAL_CRC_GetState(CRC_HandleTypeDef *hcrc)
<> 144:ef7eb2e8f9f7 450 {
<> 144:ef7eb2e8f9f7 451 return hcrc->State;
<> 144:ef7eb2e8f9f7 452 }
<> 144:ef7eb2e8f9f7 453
<> 144:ef7eb2e8f9f7 454 /**
<> 144:ef7eb2e8f9f7 455 * @}
<> 144:ef7eb2e8f9f7 456 */
<> 144:ef7eb2e8f9f7 457
<> 144:ef7eb2e8f9f7 458 /**
<> 144:ef7eb2e8f9f7 459 * @}
<> 144:ef7eb2e8f9f7 460 */
<> 144:ef7eb2e8f9f7 461
<> 144:ef7eb2e8f9f7 462 /** @addtogroup CRC_Private
<> 144:ef7eb2e8f9f7 463 * @{
<> 144:ef7eb2e8f9f7 464 */
<> 144:ef7eb2e8f9f7 465 /**
<> 144:ef7eb2e8f9f7 466 * @brief Enter 8-bit input data to the CRC calculator.
<> 144:ef7eb2e8f9f7 467 * Specific data handling to optimize processing time.
<> 144:ef7eb2e8f9f7 468 * @param hcrc: CRC handle
<> 144:ef7eb2e8f9f7 469 * @param pBuffer: pointer to the input data buffer
<> 144:ef7eb2e8f9f7 470 * @param BufferLength: input data buffer length
<> 144:ef7eb2e8f9f7 471 * @retval uint32_t CRC (returned value LSBs for CRC shorter than 32 bits)
<> 144:ef7eb2e8f9f7 472 */
<> 144:ef7eb2e8f9f7 473 static uint32_t CRC_Handle_8(CRC_HandleTypeDef *hcrc, uint8_t pBuffer[], uint32_t BufferLength)
<> 144:ef7eb2e8f9f7 474 {
<> 144:ef7eb2e8f9f7 475 uint32_t i = 0; /* input data buffer index */
<> 144:ef7eb2e8f9f7 476
<> 144:ef7eb2e8f9f7 477 /* Processing time optimization: 4 bytes are entered in a row with a single word write,
<> 144:ef7eb2e8f9f7 478 * last bytes must be carefully fed to the CRC calculator to ensure a correct type
<> 144:ef7eb2e8f9f7 479 * handling by the IP */
<> 144:ef7eb2e8f9f7 480 for(i = 0; i < (BufferLength/4); i++)
<> 144:ef7eb2e8f9f7 481 {
<> 144:ef7eb2e8f9f7 482 hcrc->Instance->DR = ((uint32_t)pBuffer[4*i]<<24) | ((uint32_t)pBuffer[4*i+1]<<16) | ((uint32_t)pBuffer[4*i+2]<<8) | (uint32_t)pBuffer[4*i+3];
<> 144:ef7eb2e8f9f7 483 }
<> 144:ef7eb2e8f9f7 484 /* last bytes specific handling */
<> 144:ef7eb2e8f9f7 485 if ((BufferLength%4) != 0)
<> 144:ef7eb2e8f9f7 486 {
<> 144:ef7eb2e8f9f7 487 if (BufferLength%4 == 1)
<> 144:ef7eb2e8f9f7 488 {
<> 144:ef7eb2e8f9f7 489 *(uint8_t volatile*) (&hcrc->Instance->DR) = pBuffer[4*i];
<> 144:ef7eb2e8f9f7 490 }
<> 144:ef7eb2e8f9f7 491 if (BufferLength%4 == 2)
<> 144:ef7eb2e8f9f7 492 {
<> 144:ef7eb2e8f9f7 493 *(uint16_t volatile*) (&hcrc->Instance->DR) = ((uint32_t)pBuffer[4*i]<<8) | (uint32_t)pBuffer[4*i+1];
<> 144:ef7eb2e8f9f7 494 }
<> 144:ef7eb2e8f9f7 495 if (BufferLength%4 == 3)
<> 144:ef7eb2e8f9f7 496 {
<> 144:ef7eb2e8f9f7 497 *(uint16_t volatile*) (&hcrc->Instance->DR) = ((uint32_t)pBuffer[4*i]<<8) | (uint32_t)pBuffer[4*i+1];
<> 144:ef7eb2e8f9f7 498 *(uint8_t volatile*) (&hcrc->Instance->DR) = pBuffer[4*i+2];
<> 144:ef7eb2e8f9f7 499 }
<> 144:ef7eb2e8f9f7 500 }
<> 144:ef7eb2e8f9f7 501
<> 144:ef7eb2e8f9f7 502 /* Return the CRC computed value */
<> 144:ef7eb2e8f9f7 503 return hcrc->Instance->DR;
<> 144:ef7eb2e8f9f7 504 }
<> 144:ef7eb2e8f9f7 505
<> 144:ef7eb2e8f9f7 506 /**
<> 144:ef7eb2e8f9f7 507 * @brief Enter 16-bit input data to the CRC calculator.
<> 144:ef7eb2e8f9f7 508 * Specific data handling to optimize processing time.
<> 144:ef7eb2e8f9f7 509 * @param hcrc: CRC handle
<> 144:ef7eb2e8f9f7 510 * @param pBuffer: pointer to the input data buffer
<> 144:ef7eb2e8f9f7 511 * @param BufferLength: input data buffer length
<> 144:ef7eb2e8f9f7 512 * @retval uint32_t CRC (returned value LSBs for CRC shorter than 32 bits)
<> 144:ef7eb2e8f9f7 513 */
<> 144:ef7eb2e8f9f7 514 static uint32_t CRC_Handle_16(CRC_HandleTypeDef *hcrc, uint16_t pBuffer[], uint32_t BufferLength)
<> 144:ef7eb2e8f9f7 515 {
<> 144:ef7eb2e8f9f7 516 uint32_t i = 0; /* input data buffer index */
<> 144:ef7eb2e8f9f7 517
<> 144:ef7eb2e8f9f7 518 /* Processing time optimization: 2 HalfWords are entered in a row with a single word write,
<> 144:ef7eb2e8f9f7 519 * in case of odd length, last HalfWord must be carefully fed to the CRC calculator to ensure
<> 144:ef7eb2e8f9f7 520 * a correct type handling by the IP */
<> 144:ef7eb2e8f9f7 521 for(i = 0; i < (BufferLength/2); i++)
<> 144:ef7eb2e8f9f7 522 {
<> 144:ef7eb2e8f9f7 523 hcrc->Instance->DR = ((uint32_t)pBuffer[2*i]<<16) | (uint32_t)pBuffer[2*i+1];
<> 144:ef7eb2e8f9f7 524 }
<> 144:ef7eb2e8f9f7 525 if ((BufferLength%2) != 0)
<> 144:ef7eb2e8f9f7 526 {
<> 144:ef7eb2e8f9f7 527 *(uint16_t volatile*) (&hcrc->Instance->DR) = pBuffer[2*i];
<> 144:ef7eb2e8f9f7 528 }
<> 144:ef7eb2e8f9f7 529
<> 144:ef7eb2e8f9f7 530 /* Return the CRC computed value */
<> 144:ef7eb2e8f9f7 531 return hcrc->Instance->DR;
<> 144:ef7eb2e8f9f7 532 }
<> 144:ef7eb2e8f9f7 533
<> 144:ef7eb2e8f9f7 534 /**
<> 144:ef7eb2e8f9f7 535 * @}
<> 144:ef7eb2e8f9f7 536 */
<> 144:ef7eb2e8f9f7 537
<> 144:ef7eb2e8f9f7 538 /**
<> 144:ef7eb2e8f9f7 539 * @}
<> 144:ef7eb2e8f9f7 540 */
<> 144:ef7eb2e8f9f7 541
<> 144:ef7eb2e8f9f7 542 #endif /* HAL_CRC_MODULE_ENABLED */
<> 144:ef7eb2e8f9f7 543
<> 144:ef7eb2e8f9f7 544 /**
<> 144:ef7eb2e8f9f7 545 * @}
<> 144:ef7eb2e8f9f7 546 */
<> 144:ef7eb2e8f9f7 547
<> 144:ef7eb2e8f9f7 548 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
<> 144:ef7eb2e8f9f7 549