git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/CORTEX_M7_STM32F7_STM32756G-EVAL_IAR_Keil/ST_Library/stm32f7xx_hal_spi.c

   1 /**\r
   2   ******************************************************************************\r
   3   * @file    stm32f7xx_hal_spi.c\r
   4   * @author  MCD Application Team\r
   5   * @version V1.0.0RC1\r
   6   * @date    24-March-2015\r
   7   * @brief   SPI HAL module driver.\r
   8   *    \r
   9   *          This file provides firmware functions to manage the following \r
  10   *          functionalities of the Serial Peripheral Interface (SPI) peripheral:\r
  11   *           + Initialization and de-initialization functions\r
  12   *           + IO operation functions\r
  13   *           + Peripheral Control functions \r
  14   *           + Peripheral State functions\r
  15   @verbatim\r
  16   ==============================================================================\r
  17                         ##### How to use this driver #####\r
  18   ==============================================================================\r
  19     [..]\r
  20       The SPI HAL driver can be used as follows:\r
  21 \r
  22       (#) Declare a SPI_HandleTypeDef handle structure, for example:\r
  23           SPI_HandleTypeDef  hspi;\r
  24 \r
  25       (#)Initialize the SPI low level resources by implementing the HAL_SPI_MspInit ()API:\r
  26           (##) Enable the SPIx interface clock\r
  27           (##) SPI pins configuration\r
  28               (+++) Enable the clock for the SPI GPIOs\r
  29               (+++) Configure these SPI pins as alternate function push-pull\r
  30           (##) NVIC configuration if you need to use interrupt process\r
  31               (+++) Configure the SPIx interrupt priority\r
  32               (+++) Enable the NVIC SPI IRQ handle\r
  33           (##) DMA Configuration if you need to use DMA process\r
  34               (+++) Declare a DMA_HandleTypeDef handle structure for the transmit or receive channel\r
  35               (+++) Enable the DMAx clock\r
  36               (+++) Configure the DMA handle parameters\r
  37               (+++) Configure the DMA Tx or Rx channel\r
  38               (+++) Associate the initialized hdma_tx handle to the hspi DMA Tx or Rx handle\r
  39               (+++) Configure the priority and enable the NVIC for the transfer complete interrupt on the DMA Tx or Rx channel\r
  40 \r
  41       (#) Program the Mode, BidirectionalMode , Data size, Baudrate Prescaler, NSS\r
  42           management, Clock polarity and phase, FirstBit and CRC configuration in the hspi Init structure.\r
  43 \r
  44       (#) Initialize the SPI registers by calling the HAL_SPI_Init() API:\r
  45           (++) This API configures also the low level Hardware GPIO, CLOCK, CORTEX...etc)\r
  46               by calling the customed HAL_SPI_MspInit() API.\r
  47      [..]\r
  48        Circular mode restriction:\r
  49       (#) The DMA circular mode cannot be used when the SPI is configured in these modes:\r
  50           (##) Master 2Lines RxOnly\r
  51           (##) Master 1Line Rx\r
  52       (#) The CRC feature is not managed when the DMA circular mode is enabled\r
  53       (#) When the SPI DMA Pause/Stop features are used, we must use the following APIs\r
  54           the HAL_SPI_DMAPause()/ HAL_SPI_DMAStop() only under the SPI callbacks\r
  55 \r
  56   @endverbatim\r
  57   ******************************************************************************\r
  58   * @attention\r
  59   *\r
  60   * <h2><center>&copy; COPYRIGHT(c) 2015 STMicroelectronics</center></h2>\r
  61   *\r
  62   * Redistribution and use in source and binary forms, with or without modification,\r
  63   * are permitted provided that the following conditions are met:\r
  64   *   1. Redistributions of source code must retain the above copyright notice,\r
  65   *      this list of conditions and the following disclaimer.\r
  66   *   2. Redistributions in binary form must reproduce the above copyright notice,\r
  67   *      this list of conditions and the following disclaimer in the documentation\r
  68   *      and/or other materials provided with the distribution.\r
  69   *   3. Neither the name of STMicroelectronics nor the names of its contributors\r
  70   *      may be used to endorse or promote products derived from this software\r
  71   *      without specific prior written permission.\r
  72   *\r
  73   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"\r
  74   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
  75   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\r
  76   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\r
  77   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\r
  78   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\r
  79   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\r
  80   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\r
  81   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\r
  82   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
  83   *\r
  84   ******************************************************************************\r
  85   */\r
  86     \r
  87 /* Includes ------------------------------------------------------------------*/\r
  88 #include "stm32f7xx_hal.h"\r
  89    \r
  90 /** @addtogroup STM32F7xx_HAL_Driver\r
  91   * @{\r
  92   */\r
  93 \r
  94 /** @defgroup SPI SPI \r
  95   * @brief SPI HAL module driver\r
  96   * @{\r
  97   */\r
  98 #ifdef HAL_SPI_MODULE_ENABLED\r
  99 \r
 100 /* Private typedef -----------------------------------------------------------*/\r
 101 /* Private defines -----------------------------------------------------------*/\r
 102 /** @defgroup SPI_Private_Constants SPI Private Constants\r
 103   * @{\r
 104   */\r
 105 #define SPI_DEFAULT_TIMEOUT 50\r
 106 /**\r
 107   * @}\r
 108   */\r
 109 \r
 110 /* Private macro -------------------------------------------------------------*/\r
 111 /* Private variables ---------------------------------------------------------*/\r
 112 /* Private function prototypes -----------------------------------------------*/\r
 113 /** @defgroup SPI_Private_Functions SPI Private Functions\r
 114   * @{\r
 115   */\r
 116 static void SPI_DMATransmitCplt(DMA_HandleTypeDef *hdma);\r
 117 static void SPI_DMAReceiveCplt(DMA_HandleTypeDef *hdma);\r
 118 static void SPI_DMATransmitReceiveCplt(DMA_HandleTypeDef *hdma);\r
 119 static void SPI_DMAHalfTransmitCplt(DMA_HandleTypeDef *hdma);\r
 120 static void SPI_DMAHalfReceiveCplt(DMA_HandleTypeDef *hdma);\r
 121 static void SPI_DMAHalfTransmitReceiveCplt(DMA_HandleTypeDef *hdma);\r
 122 static void SPI_DMAError(DMA_HandleTypeDef *hdma);\r
 123 static HAL_StatusTypeDef SPI_WaitFlagStateUntilTimeout(SPI_HandleTypeDef *hspi, uint32_t Flag, uint32_t State, uint32_t Timeout);\r
 124 static HAL_StatusTypeDef SPI_WaitFifoStateUntilTimeout(SPI_HandleTypeDef *hspi, uint32_t Fifo, uint32_t State, uint32_t Timeout);\r
 125 static void SPI_TxISR_8BIT(struct __SPI_HandleTypeDef *hspi);\r
 126 static void SPI_TxISR_16BIT(struct __SPI_HandleTypeDef *hspi);\r
 127 static void SPI_RxISR_8BIT(struct __SPI_HandleTypeDef *hspi);\r
 128 static void SPI_RxISR_8BITCRC(struct __SPI_HandleTypeDef *hspi);\r
 129 static void SPI_RxISR_16BIT(struct __SPI_HandleTypeDef *hspi);\r
 130 static void SPI_RxISR_16BITCRC(struct __SPI_HandleTypeDef *hspi);\r
 131 static void SPI_2linesRxISR_8BIT(struct __SPI_HandleTypeDef *hspi);\r
 132 static void SPI_2linesRxISR_8BITCRC(struct __SPI_HandleTypeDef *hspi);\r
 133 static void SPI_2linesTxISR_8BIT(struct __SPI_HandleTypeDef *hspi);\r
 134 static void SPI_2linesTxISR_16BIT(struct __SPI_HandleTypeDef *hspi);\r
 135 static void SPI_2linesRxISR_16BIT(struct __SPI_HandleTypeDef *hspi);\r
 136 static void SPI_2linesRxISR_16BITCRC(struct __SPI_HandleTypeDef *hspi);\r
 137 static void SPI_CloseRxTx_ISR(SPI_HandleTypeDef *hspi);\r
 138 static void SPI_CloseRx_ISR(SPI_HandleTypeDef *hspi);\r
 139 static void SPI_CloseTx_ISR(SPI_HandleTypeDef *hspi);\r
 140 static HAL_StatusTypeDef SPI_EndRxTransaction(SPI_HandleTypeDef *hspi, uint32_t Timeout);\r
 141 static HAL_StatusTypeDef SPI_EndRxTxTransaction(SPI_HandleTypeDef *hspi, uint32_t Timeout);\r
 142 /**\r
 143   * @}\r
 144   */\r
 145 \r
 146 /* Exported functions ---------------------------------------------------------*/\r
 147 \r
 148 /** @defgroup SPI_Exported_Functions SPI Exported Functions\r
 149   * @{\r
 150   */\r
 151 \r
 152 /** @defgroup SPI_Exported_Functions_Group1 Initialization and de-initialization functions\r
 153  *  @brief    Initialization and Configuration functions\r
 154  *\r
 155 @verbatim\r
 156  ===============================================================================\r
 157               ##### Initialization and de-initialization functions #####\r
 158  ===============================================================================\r
 159     [..]  This subsection provides a set of functions allowing to initialize and\r
 160           de-initialize the SPIx peripheral:\r
 161 \r
 162       (+) User must implement HAL_SPI_MspInit() function in which he configures\r
 163           all related peripherals resources (CLOCK, GPIO, DMA, IT and NVIC ).\r
 164 \r
 165       (+) Call the function HAL_SPI_Init() to configure the selected device with\r
 166           the selected configuration:\r
 167         (++) Mode\r
 168         (++) Direction\r
 169         (++) Data Size\r
 170         (++) Clock Polarity and Phase\r
 171         (++) NSS Management\r
 172         (++) BaudRate Prescaler\r
 173         (++) FirstBit\r
 174         (++) TIMode\r
 175         (++) CRC Calculation\r
 176         (++) CRC Polynomial if CRC enabled\r
 177         (++) CRC Length, used only with Data8 and Data16\r
 178         (++) FIFO reception threshold\r
 179 \r
 180       (+) Call the function HAL_SPI_DeInit() to restore the default configuration\r
 181           of the selected SPIx peripheral.\r
 182 \r
 183 @endverbatim\r
 184   * @{\r
 185   */\r
 186 \r
 187 /**\r
 188   * @brief  Initializes the SPI according to the specified parameters\r
 189   *         in the SPI_InitTypeDef and create the associated handle.\r
 190   * @param  hspi: pointer to a SPI_HandleTypeDef structure that contains\r
 191   *               the configuration information for SPI module.\r
 192   * @retval HAL status\r
 193   */\r
 194 HAL_StatusTypeDef HAL_SPI_Init(SPI_HandleTypeDef *hspi)\r
 195 {\r
 196   uint32_t frxth;\r
 197 \r
 198   /* Check the SPI handle allocation */\r
 199   if(hspi == NULL)\r
 200   {\r
 201     return HAL_ERROR;\r
 202   }\r
 203 \r
 204   /* Check the parameters */\r
 205   assert_param(IS_SPI_ALL_INSTANCE(hspi->Instance));\r
 206   assert_param(IS_SPI_MODE(hspi->Init.Mode));\r
 207   assert_param(IS_SPI_DIRECTION(hspi->Init.Direction));\r
 208   assert_param(IS_SPI_DATASIZE(hspi->Init.DataSize));\r
 209   assert_param(IS_SPI_CPOL(hspi->Init.CLKPolarity));\r
 210   assert_param(IS_SPI_CPHA(hspi->Init.CLKPhase));\r
 211   assert_param(IS_SPI_NSS(hspi->Init.NSS));\r
 212   assert_param(IS_SPI_NSSP(hspi->Init.NSSPMode));\r
 213   assert_param(IS_SPI_BAUDRATE_PRESCALER(hspi->Init.BaudRatePrescaler));\r
 214   assert_param(IS_SPI_FIRST_BIT(hspi->Init.FirstBit));\r
 215   assert_param(IS_SPI_TIMODE(hspi->Init.TIMode));\r
 216   assert_param(IS_SPI_CRC_CALCULATION(hspi->Init.CRCCalculation));\r
 217   assert_param(IS_SPI_CRC_POLYNOMIAL(hspi->Init.CRCPolynomial));\r
 218   assert_param(IS_SPI_CRC_LENGTH(hspi->Init.CRCLength));\r
 219 \r
 220   if(hspi->State == HAL_SPI_STATE_RESET)\r
 221   {\r
 222     /* Allocate lock resource and initialize it */\r
 223     hspi->Lock = HAL_UNLOCKED;\r
 224 \r
 225     /* Init the low level hardware : GPIO, CLOCK, NVIC... */\r
 226     HAL_SPI_MspInit(hspi);\r
 227   }\r
 228 \r
 229   hspi->State = HAL_SPI_STATE_BUSY;\r
 230 \r
 231   /* Disable the selected SPI peripheral */\r
 232   __HAL_SPI_DISABLE(hspi);\r
 233 \r
 234   /* Align by default the rs fifo threshold on the data size */\r
 235   if(hspi->Init.DataSize > SPI_DATASIZE_8BIT)\r
 236   {\r
 237     frxth = SPI_RXFIFO_THRESHOLD_HF;\r
 238   }\r
 239   else\r
 240   {\r
 241     frxth = SPI_RXFIFO_THRESHOLD_QF;\r
 242   }\r
 243 \r
 244   /* CRC calculation is valid only for 16Bit and 8 Bit */\r
 245   if(( hspi->Init.DataSize != SPI_DATASIZE_16BIT ) && ( hspi->Init.DataSize != SPI_DATASIZE_8BIT ))\r
 246   {\r
 247     /* CRC must be disabled */\r
 248     hspi->Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;\r
 249   }\r
 250 \r
 251   /* Align the CRC Length on the data size */\r
 252   if( hspi->Init.CRCLength == SPI_CRC_LENGTH_DATASIZE)\r
 253   {\r
 254     /* CRC Length aligned on the data size : value set by default */\r
 255     if(hspi->Init.DataSize > SPI_DATASIZE_8BIT)\r
 256     {\r
 257       hspi->Init.CRCLength = SPI_CRC_LENGTH_16BIT;\r
 258     }\r
 259     else\r
 260     {\r
 261       hspi->Init.CRCLength = SPI_CRC_LENGTH_8BIT;\r
 262     }\r
 263   }\r
 264 \r
 265   /*---------------------------- SPIx CR1 & CR2 Configuration ------------------------*/\r
 266   /* Configure : SPI Mode, Communication Mode, Clock polarity and phase, NSS management,\r
 267   Communication speed, First bit, CRC calculation state, CRC Length */\r
 268   hspi->Instance->CR1 = (hspi->Init.Mode | hspi->Init.Direction |\r
 269                          hspi->Init.CLKPolarity | hspi->Init.CLKPhase | (hspi->Init.NSS & SPI_CR1_SSM) |\r
 270                          hspi->Init.BaudRatePrescaler | hspi->Init.FirstBit  | hspi->Init.CRCCalculation);\r
 271 \r
 272   if( hspi->Init.CRCLength == SPI_CRC_LENGTH_16BIT)\r
 273   {\r
 274     hspi->Instance->CR1|= SPI_CR1_CRCL;\r
 275   }\r
 276 \r
 277   /* Configure : NSS management */\r
 278   /* Configure : Rx Fifo Threshold */\r
 279   hspi->Instance->CR2 = (((hspi->Init.NSS >> 16) & SPI_CR2_SSOE) | hspi->Init.TIMode | hspi->Init.NSSPMode |\r
 280                          hspi->Init.DataSize ) | frxth;\r
 281 \r
 282   /*---------------------------- SPIx CRCPOLY Configuration --------------------*/\r
 283   /* Configure : CRC Polynomial */\r
 284   hspi->Instance->CRCPR = hspi->Init.CRCPolynomial;\r
 285 \r
 286   hspi->ErrorCode = HAL_SPI_ERROR_NONE;\r
 287   hspi->State= HAL_SPI_STATE_READY;\r
 288 \r
 289   return HAL_OK;\r
 290 }\r
 291 \r
 292 /**\r
 293   * @brief  DeInitializes the SPI peripheral\r
 294   * @param  hspi: pointer to a SPI_HandleTypeDef structure that contains\r
 295   *               the configuration information for SPI module.\r
 296   * @retval HAL status\r
 297   */\r
 298 HAL_StatusTypeDef HAL_SPI_DeInit(SPI_HandleTypeDef *hspi)\r
 299 {\r
 300   /* Check the SPI handle allocation */\r
 301   if(hspi == NULL)\r
 302   {\r
 303     return HAL_ERROR;\r
 304   }\r
 305 \r
 306   /* Check the parameters */\r
 307   assert_param(IS_SPI_ALL_INSTANCE(hspi->Instance));\r
 308 \r
 309   hspi->State = HAL_SPI_STATE_BUSY;\r
 310 \r
 311   /* check flag before the SPI disable */\r
 312   SPI_WaitFifoStateUntilTimeout(hspi, SPI_FLAG_FTLVL, SPI_FTLVL_EMPTY, SPI_DEFAULT_TIMEOUT);\r
 313   SPI_WaitFlagStateUntilTimeout(hspi, SPI_FLAG_BSY, RESET, SPI_DEFAULT_TIMEOUT);\r
 314   SPI_WaitFifoStateUntilTimeout(hspi, SPI_FLAG_FRLVL, SPI_FRLVL_EMPTY, SPI_DEFAULT_TIMEOUT);\r
 315 \r
 316   /* Disable the SPI Peripheral Clock */\r
 317   __HAL_SPI_DISABLE(hspi);\r
 318 \r
 319   /* DeInit the low level hardware: GPIO, CLOCK, NVIC... */\r
 320   HAL_SPI_MspDeInit(hspi);\r
 321 \r
 322   hspi->ErrorCode = HAL_SPI_ERROR_NONE;\r
 323   hspi->State = HAL_SPI_STATE_RESET;\r
 324 \r
 325   __HAL_UNLOCK(hspi);\r
 326 \r
 327   return HAL_OK;\r
 328 }\r
 329 \r
 330 /**\r
 331   * @brief SPI MSP Init\r
 332   * @param  hspi: pointer to a SPI_HandleTypeDef structure that contains\r
 333   *               the configuration information for SPI module.\r
 334   * @retval None\r
 335   */\r
 336  __weak void HAL_SPI_MspInit(SPI_HandleTypeDef *hspi)\r
 337  {\r
 338    /* NOTE : This function should not be modified, when the callback is needed,\r
 339             the HAL_SPI_MspInit should be implemented in the user file\r
 340    */\r
 341 }\r
 342 \r
 343 /**\r
 344   * @brief SPI MSP DeInit\r
 345   * @param  hspi: pointer to a SPI_HandleTypeDef structure that contains\r
 346   *               the configuration information for SPI module.\r
 347   * @retval None\r
 348   */\r
 349  __weak void HAL_SPI_MspDeInit(SPI_HandleTypeDef *hspi)\r
 350 {\r
 351   /* NOTE : This function should not be modified, when the callback is needed,\r
 352             the HAL_SPI_MspDeInit should be implemented in the user file\r
 353    */\r
 354 }\r
 355 \r
 356 /**\r
 357   * @}\r
 358   */\r
 359 \r
 360 /** @defgroup SPI_Exported_Functions_Group2 IO operation functions\r
 361  *  @brief   Data transfers functions\r
 362  *\r
 363 @verbatim\r
 364   ==============================================================================\r
 365                       ##### IO operation functions #####\r
 366  ===============================================================================\r
 367     This subsection provides a set of functions allowing to manage the SPI\r
 368     data transfers.\r
 369 \r
 370     [..] The SPI supports master and slave mode :\r
 371 \r
 372     (#) There are two modes of transfer:\r
 373        (++) Blocking mode: The communication is performed in polling mode.\r
 374             The HAL status of all data processing is returned by the same function\r
 375             after finishing transfer.\r
 376        (++) No-Blocking mode: The communication is performed using Interrupts\r
 377            or DMA, These APIs return the HAL status.\r
 378            The end of the data processing will be indicated through the\r
 379            dedicated SPI IRQ when using Interrupt mode or the DMA IRQ when\r
 380            using DMA mode.\r
 381            The HAL_SPI_TxCpltCallback(), HAL_SPI_RxCpltCallback() and HAL_SPI_TxRxCpltCallback() user callbacks\r
 382            will be executed respectively at the end of the transmit or Receive process\r
 383            The HAL_SPI_ErrorCallback()user callback will be executed when a communication error is detected\r
 384 \r
 385     (#) APIs provided for these 2 transfer modes (Blocking mode or Non blocking mode using either Interrupt or DMA)\r
 386         exist for 1Line (simplex) and 2Lines (full duplex) modes.\r
 387 \r
 388 @endverbatim\r
 389   * @{\r
 390   */\r
 391 \r
 392 /**\r
 393   * @brief  Transmit an amount of data in blocking mode\r
 394   * @param  hspi: pointer to a SPI_HandleTypeDef structure that contains\r
 395   *               the configuration information for SPI module.\r
 396   * @param  pData: pointer to data buffer\r
 397   * @param  Size: amount of data to be sent\r
 398   * @param  Timeout: Timeout duration\r
 399   * @retval HAL status\r
 400   */\r
 401 HAL_StatusTypeDef HAL_SPI_Transmit(SPI_HandleTypeDef *hspi, uint8_t *pData, uint16_t Size, uint32_t Timeout)\r
 402 {\r
 403   assert_param(IS_SPI_DIRECTION_2LINES_OR_1LINE(hspi->Init.Direction));\r
 404 \r
 405   /* Process Locked */\r
 406   __HAL_LOCK(hspi);\r
 407 \r
 408   if(hspi->State != HAL_SPI_STATE_READY)\r
 409   {\r
 410     hspi->State = HAL_SPI_STATE_READY;\r
 411    /* Process Unlocked */\r
 412    __HAL_UNLOCK(hspi);\r
 413    return HAL_BUSY;\r
 414   }\r
 415   \r
 416   if((pData == NULL ) || (Size == 0))\r
 417   {\r
 418     hspi->State = HAL_SPI_STATE_READY;\r
 419    /* Process Unlocked */\r
 420    __HAL_UNLOCK(hspi);\r
 421     return HAL_ERROR;\r
 422   }\r
 423 \r
 424   /* Set the transaction information */\r
 425   hspi->State       = HAL_SPI_STATE_BUSY_TX;\r
 426   hspi->ErrorCode   = HAL_SPI_ERROR_NONE;\r
 427   hspi->pTxBuffPtr  = pData;\r
 428   hspi->TxXferSize  = Size;\r
 429   hspi->TxXferCount = Size;\r
 430   hspi->pRxBuffPtr  = (uint8_t *)NULL;\r
 431   hspi->RxXferSize  = 0;\r
 432   hspi->RxXferCount = 0;\r
 433 \r
 434   /* Configure communication direction : 1Line */\r
 435   if(hspi->Init.Direction == SPI_DIRECTION_1LINE)\r
 436   {\r
 437     SPI_1LINE_TX(hspi);\r
 438   }\r
 439 \r
 440   /* Reset CRC Calculation */\r
 441   if(hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)\r
 442   {\r
 443     SPI_RESET_CRC(hspi);\r
 444   }\r
 445 \r
 446   /* Check if the SPI is already enabled */\r
 447   if((hspi->Instance->CR1 & SPI_CR1_SPE) != SPI_CR1_SPE)\r
 448   {\r
 449     /* Enable SPI peripheral */\r
 450     __HAL_SPI_ENABLE(hspi);\r
 451   }\r
 452 \r
 453   /* Transmit data in 16 Bit mode */\r
 454   if(hspi->Init.DataSize > SPI_DATASIZE_8BIT)\r
 455   {\r
 456     /* Transmit data in 16 Bit mode */\r
 457     while (hspi->TxXferCount > 0)\r
 458     {\r
 459       /* Wait until TXE flag is set to send data */\r
 460       if(SPI_WaitFlagStateUntilTimeout(hspi,SPI_FLAG_TXE,SPI_FLAG_TXE,Timeout) != HAL_OK)\r
 461       {\r
 462         hspi->State = HAL_SPI_STATE_READY;\r
 463         /* Process Unlocked */\r
 464        __HAL_UNLOCK(hspi);\r
 465         return HAL_TIMEOUT;\r
 466       }\r
 467       hspi->Instance->DR = *((uint16_t *)hspi->pTxBuffPtr);\r
 468       hspi->pTxBuffPtr += sizeof(uint16_t);\r
 469       hspi->TxXferCount--;\r
 470     }\r
 471   }\r
 472   /* Transmit data in 8 Bit mode */\r
 473   else\r
 474   {\r
 475     while (hspi->TxXferCount > 0)\r
 476     {\r
 477       if(hspi->TxXferCount != 0x1)\r
 478       {\r
 479         /* Wait until TXE flag is set to send data */\r
 480         if(SPI_WaitFlagStateUntilTimeout(hspi,SPI_FLAG_TXE,SPI_FLAG_TXE,Timeout) != HAL_OK)\r
 481         {\r
 482           hspi->State = HAL_SPI_STATE_READY;\r
 483           /* Process Unlocked */\r
 484           __HAL_UNLOCK(hspi);\r
 485           return HAL_TIMEOUT;\r
 486         }\r
 487         hspi->Instance->DR = *((uint16_t*)hspi->pTxBuffPtr);\r
 488         hspi->pTxBuffPtr += sizeof(uint16_t);\r
 489         hspi->TxXferCount -= 2;\r
 490       }\r
 491       else\r
 492       {\r
 493         /* Wait until TXE flag is set to send data */\r
 494         if(SPI_WaitFlagStateUntilTimeout(hspi,SPI_FLAG_TXE,SPI_FLAG_TXE,Timeout) != HAL_OK)  \r
 495         {\r
 496           return HAL_TIMEOUT;\r
 497         }\r
 498         *((__IO uint8_t*)&hspi->Instance->DR) = (*hspi->pTxBuffPtr++);\r
 499         hspi->TxXferCount--;    \r
 500       }\r
 501     }\r
 502   }\r
 503 \r
 504   /* Enable CRC Transmission */\r
 505   if(hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)\r
 506   {\r
 507      hspi->Instance->CR1|= SPI_CR1_CRCNEXT;\r
 508   }\r
 509 \r
 510   /* Check the end of the transaction */\r
 511   if(SPI_EndRxTxTransaction(hspi,Timeout) != HAL_OK)\r
 512   {\r
 513     return HAL_TIMEOUT;\r
 514   }\r
 515   \r
 516   /* Clear OVERUN flag in 2 Lines communication mode because received is not read */\r
 517   if(hspi->Init.Direction == SPI_DIRECTION_2LINES)\r
 518   {\r
 519     __HAL_SPI_CLEAR_OVRFLAG(hspi);\r
 520   }\r
 521     \r
 522   hspi->State = HAL_SPI_STATE_READY; \r
 523 \r
 524   /* Process Unlocked */\r
 525   __HAL_UNLOCK(hspi);\r
 526   \r
 527   if(hspi->ErrorCode != HAL_SPI_ERROR_NONE)\r
 528   {   \r
 529     return HAL_ERROR;\r
 530   }\r
 531   else\r
 532   {\r
 533     return HAL_OK;\r
 534   }\r
 535 }\r
 536 \r
 537 /**\r
 538   * @brief  Receive an amount of data in blocking mode\r
 539   * @param  hspi: pointer to a SPI_HandleTypeDef structure that contains\r
 540   *               the configuration information for SPI module.\r
 541   * @param  pData: pointer to data buffer\r
 542   * @param  Size: amount of data to be received\r
 543   * @param  Timeout: Timeout duration\r
 544   * @retval HAL status\r
 545   */\r
 546 HAL_StatusTypeDef HAL_SPI_Receive(SPI_HandleTypeDef *hspi, uint8_t *pData, uint16_t Size, uint32_t Timeout)\r
 547 {\r
 548   __IO uint16_t tmpreg;\r
 549   \r
 550   if(hspi->State != HAL_SPI_STATE_READY)\r
 551   {\r
 552     return HAL_BUSY;\r
 553   }\r
 554   \r
 555   if((pData == NULL ) || (Size == 0))\r
 556   {\r
 557     return HAL_ERROR;\r
 558   }\r
 559 \r
 560   if((hspi->Init.Mode == SPI_MODE_MASTER) && (hspi->Init.Direction == SPI_DIRECTION_2LINES))\r
 561   {\r
 562     /* the receive process is not supported in 2Lines direction master mode */\r
 563     /* in this case we call the transmitReceive process                     */\r
 564     return HAL_SPI_TransmitReceive(hspi,pData,pData,Size,Timeout);\r
 565   }\r
 566   \r
 567   /* Process Locked */\r
 568   __HAL_LOCK(hspi);\r
 569     \r
 570   hspi->State       = HAL_SPI_STATE_BUSY_RX;\r
 571   hspi->ErrorCode   = HAL_SPI_ERROR_NONE;\r
 572   hspi->pRxBuffPtr  = pData;\r
 573   hspi->RxXferSize  = Size;\r
 574   hspi->RxXferCount = Size;\r
 575   hspi->pTxBuffPtr  = (uint8_t *)NULL;\r
 576   hspi->TxXferSize  = 0;\r
 577   hspi->TxXferCount = 0;\r
 578 \r
 579   /* Reset CRC Calculation */\r
 580   if(hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)\r
 581   {\r
 582     SPI_RESET_CRC(hspi);\r
 583     /* this is done to handle the CRCNEXT before the latest data */\r
 584     hspi->RxXferCount--;\r
 585   }\r
 586 \r
 587   /* Set the Rx Fido thresold */\r
 588   if(hspi->Init.DataSize > SPI_DATASIZE_8BIT)\r
 589   {\r
 590     /* set fiforxthresold according the reception data length: 16bit */\r
 591     CLEAR_BIT(hspi->Instance->CR2, SPI_RXFIFO_THRESHOLD);\r
 592   }\r
 593   else\r
 594   {\r
 595     /* set fiforxthresold according the reception data length: 8bit */\r
 596     SET_BIT(hspi->Instance->CR2, SPI_RXFIFO_THRESHOLD);\r
 597   }\r
 598 \r
 599   /* Configure communication direction 1Line and enabled SPI if needed */\r
 600   if(hspi->Init.Direction == SPI_DIRECTION_1LINE)\r
 601   {\r
 602     SPI_1LINE_RX(hspi);\r
 603   }\r
 604 \r
 605   /* Check if the SPI is already enabled */\r
 606   if((hspi->Instance->CR1 & SPI_CR1_SPE) != SPI_CR1_SPE)\r
 607   {\r
 608     /* Enable SPI peripheral */\r
 609     __HAL_SPI_ENABLE(hspi);\r
 610   }\r
 611 \r
 612   /* Receive data in 8 Bit mode */\r
 613   if(hspi->Init.DataSize <= SPI_DATASIZE_8BIT)\r
 614   {\r
 615     while(hspi->RxXferCount > 1)\r
 616     {\r
 617       /* Wait until the RXNE flag */\r
 618       if(SPI_WaitFlagStateUntilTimeout(hspi, SPI_FLAG_RXNE, SPI_FLAG_RXNE, Timeout) != HAL_OK)\r
 619       {\r
 620         return HAL_TIMEOUT;\r
 621       }\r
 622       (*hspi->pRxBuffPtr++)= *(__IO uint8_t *)&hspi->Instance->DR;\r
 623       hspi->RxXferCount--;  \r
 624     }\r
 625   }\r
 626   else /* Receive data in 16 Bit mode */\r
 627   {   \r
 628     while(hspi->RxXferCount > 1 )\r
 629     {\r
 630       /* Wait until RXNE flag is reset to read data */\r
 631       if(SPI_WaitFlagStateUntilTimeout(hspi, SPI_FLAG_RXNE, SPI_FLAG_RXNE, Timeout) != HAL_OK)\r
 632       {\r
 633         return HAL_TIMEOUT;\r
 634       }\r
 635       *((uint16_t*)hspi->pRxBuffPtr) = hspi->Instance->DR;\r
 636       hspi->pRxBuffPtr += sizeof(uint16_t);\r
 637       hspi->RxXferCount--;\r
 638     } \r
 639   }\r
 640   \r
 641   /* Enable CRC Transmission */\r
 642   if(hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE) \r
 643   {\r
 644     hspi->Instance->CR1 |= SPI_CR1_CRCNEXT;\r
 645   }  \r
 646 \r
 647   /* Wait until RXNE flag is set */\r
 648   if(SPI_WaitFlagStateUntilTimeout(hspi, SPI_FLAG_RXNE, SPI_FLAG_RXNE, Timeout) != HAL_OK)\r
 649   {\r
 650     return HAL_TIMEOUT;\r
 651   }\r
 652   \r
 653   /* Receive last data in 16 Bit mode */\r
 654   if(hspi->Init.DataSize > SPI_DATASIZE_8BIT)\r
 655   {        \r
 656     *((uint16_t*)hspi->pRxBuffPtr) = hspi->Instance->DR;\r
 657     hspi->pRxBuffPtr += sizeof(uint16_t);\r
 658   }\r
 659   /* Receive last data in 8 Bit mode */\r
 660   else \r
 661   {\r
 662     (*hspi->pRxBuffPtr++) = *(__IO uint8_t *)&hspi->Instance->DR;\r
 663   }\r
 664   hspi->RxXferCount--;\r
 665   \r
 666   /* Read CRC from DR to close CRC calculation process */\r
 667   if(hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)\r
 668   {\r
 669     /* Wait until TXE flag */\r
 670     if(SPI_WaitFlagStateUntilTimeout(hspi, SPI_FLAG_RXNE, SPI_FLAG_RXNE, Timeout) != HAL_OK) \r
 671     {\r
 672       /* Erreur on the CRC reception */\r
 673       hspi->ErrorCode|= HAL_SPI_ERROR_CRC;\r
 674     }\r
 675     if(hspi->Init.DataSize > SPI_DATASIZE_8BIT)\r
 676     {        \r
 677       tmpreg = hspi->Instance->DR;\r
 678       UNUSED(tmpreg); /* To avoid GCC warning */\r
 679     }\r
 680     else\r
 681     {\r
 682       tmpreg = *(__IO uint8_t *)&hspi->Instance->DR;\r
 683       UNUSED(tmpreg); /* To avoid GCC warning */\r
 684 \r
 685       if((hspi->Init.DataSize == SPI_DATASIZE_8BIT) && (hspi->Init.CRCLength == SPI_CRC_LENGTH_16BIT))\r
 686       {\r
 687         if(SPI_WaitFlagStateUntilTimeout(hspi, SPI_FLAG_RXNE, SPI_FLAG_RXNE, Timeout) != HAL_OK)\r
 688         {\r
 689           /* Erreur on the CRC reception */\r
 690           hspi->ErrorCode|= HAL_SPI_ERROR_FLAG;\r
 691         }\r
 692         tmpreg = *(__IO uint8_t *)&hspi->Instance->DR;\r
 693         UNUSED(tmpreg); /* To avoid GCC warning */\r
 694       }\r
 695     }\r
 696   }\r
 697   \r
 698   /* Check the end of the transaction */\r
 699   if(SPI_EndRxTransaction(hspi,Timeout) != HAL_OK)\r
 700   {\r
 701     return HAL_TIMEOUT;\r
 702   }\r
 703 \r
 704   hspi->State = HAL_SPI_STATE_READY; \r
 705     \r
 706   /* Check if CRC error occurred */\r
 707   if(__HAL_SPI_GET_FLAG(hspi, SPI_FLAG_CRCERR) != RESET)\r
 708   {\r
 709     hspi->ErrorCode|= HAL_SPI_ERROR_CRC;\r
 710     __HAL_SPI_CLEAR_CRCERRFLAG(hspi);\r
 711                   \r
 712     /* Process Unlocked */\r
 713     __HAL_UNLOCK(hspi);\r
 714     return HAL_ERROR;\r
 715   }\r
 716     \r
 717   /* Process Unlocked */\r
 718   __HAL_UNLOCK(hspi);\r
 719   \r
 720   if(hspi->ErrorCode != HAL_SPI_ERROR_NONE)\r
 721   {   \r
 722     return HAL_ERROR;\r
 723   }\r
 724   else\r
 725   {\r
 726     return HAL_OK;\r
 727   }\r
 728 }\r
 729 \r
 730 /**\r
 731   * @brief  Transmit and Receive an amount of data in blocking mode\r
 732   * @param  hspi: pointer to a SPI_HandleTypeDef structure that contains\r
 733   *               the configuration information for SPI module.\r
 734   * @param  pTxData: pointer to transmission data buffer\r
 735   * @param  pRxData: pointer to reception data buffer\r
 736   * @param  Size: amount of data to be sent and received\r
 737   * @param  Timeout: Timeout duration\r
 738   * @retval HAL status\r
 739   */\r
 740 HAL_StatusTypeDef HAL_SPI_TransmitReceive(SPI_HandleTypeDef *hspi, uint8_t *pTxData, uint8_t *pRxData, uint16_t Size, uint32_t Timeout)\r
 741 {\r
 742   __IO uint16_t tmpreg = 0;\r
 743   uint32_t tickstart = HAL_GetTick();\r
 744   \r
 745   assert_param(IS_SPI_DIRECTION_2LINES(hspi->Init.Direction));\r
 746   \r
 747   if(hspi->State != HAL_SPI_STATE_READY) \r
 748   {\r
 749     return HAL_BUSY;\r
 750   }\r
 751   \r
 752   if((pTxData == NULL) || (pRxData == NULL) || (Size == 0))\r
 753   {\r
 754     return HAL_ERROR;\r
 755   }\r
 756 \r
 757   \r
 758   /* Process Locked */\r
 759   __HAL_LOCK(hspi); \r
 760   \r
 761   hspi->State       = HAL_SPI_STATE_BUSY_TX_RX;\r
 762   hspi->ErrorCode   = HAL_SPI_ERROR_NONE;\r
 763   hspi->pRxBuffPtr  = pRxData;\r
 764   hspi->RxXferCount = Size;\r
 765   hspi->RxXferSize  = Size;\r
 766   hspi->pTxBuffPtr  = pTxData;\r
 767   hspi->TxXferCount = Size;\r
 768   hspi->TxXferSize  = Size;\r
 769 \r
 770   /* Reset CRC Calculation */\r
 771   if(hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)\r
 772   {\r
 773     SPI_RESET_CRC(hspi);\r
 774   }\r
 775 \r
 776   /* Set the Rx Fido threshold */\r
 777   if((hspi->Init.DataSize > SPI_DATASIZE_8BIT) || (hspi->RxXferCount > 1))\r
 778   {\r
 779     /* set fiforxthreshold according the reception data length: 16bit */\r
 780     CLEAR_BIT(hspi->Instance->CR2, SPI_RXFIFO_THRESHOLD);\r
 781   }\r
 782   else\r
 783   {\r
 784     /* set fiforxthreshold according the reception data length: 8bit */\r
 785     SET_BIT(hspi->Instance->CR2, SPI_RXFIFO_THRESHOLD);\r
 786   }\r
 787 \r
 788   /* Check if the SPI is already enabled */\r
 789   if((hspi->Instance->CR1 &SPI_CR1_SPE) != SPI_CR1_SPE)\r
 790   {\r
 791     /* Enable SPI peripheral */\r
 792     __HAL_SPI_ENABLE(hspi);\r
 793   }\r
 794 \r
 795   /* Transmit and Receive data in 16 Bit mode */\r
 796   if(hspi->Init.DataSize > SPI_DATASIZE_8BIT)\r
 797   {\r
 798     while ((hspi->TxXferCount > 0 ) || (hspi->RxXferCount > 0))\r
 799     {\r
 800       /* Check TXE flag */\r
 801       if((hspi->TxXferCount > 0) && ((hspi->Instance->SR & SPI_FLAG_TXE) == SPI_FLAG_TXE))\r
 802       {\r
 803         hspi->Instance->DR = *((uint16_t *)hspi->pTxBuffPtr);\r
 804         hspi->pTxBuffPtr += sizeof(uint16_t);\r
 805         hspi->TxXferCount--;\r
 806 \r
 807         /* Enable CRC Transmission */\r
 808         if((hspi->TxXferCount == 0) && (hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE))\r
 809         {\r
 810           SET_BIT(hspi->Instance->CR1, SPI_CR1_CRCNEXT);\r
 811         } \r
 812       }\r
 813 \r
 814       /* Check RXNE flag */\r
 815       if((hspi->RxXferCount > 0) && ((hspi->Instance->SR & SPI_FLAG_RXNE) == SPI_FLAG_RXNE))\r
 816       {\r
 817         *((uint16_t *)hspi->pRxBuffPtr) = hspi->Instance->DR;\r
 818         hspi->pRxBuffPtr += sizeof(uint16_t);\r
 819         hspi->RxXferCount--;\r
 820       }\r
 821       if(Timeout != HAL_MAX_DELAY)\r
 822       {\r
 823         if((Timeout == 0) || ((HAL_GetTick()-tickstart) > Timeout)) \r
 824         {\r
 825           hspi->State = HAL_SPI_STATE_READY;\r
 826           __HAL_UNLOCK(hspi);\r
 827           return HAL_TIMEOUT;\r
 828         }\r
 829       }\r
 830     }\r
 831   }\r
 832   /* Transmit and Receive data in 8 Bit mode */\r
 833   else\r
 834   {\r
 835     while((hspi->TxXferCount > 0) || (hspi->RxXferCount > 0))\r
 836     {\r
 837       /* check TXE flag */\r
 838       if((hspi->TxXferCount > 0) && ((hspi->Instance->SR & SPI_FLAG_TXE) == SPI_FLAG_TXE))\r
 839       {\r
 840         if(hspi->TxXferCount > 1)\r
 841         {\r
 842           hspi->Instance->DR = *((uint16_t*)hspi->pTxBuffPtr);\r
 843           hspi->pTxBuffPtr += sizeof(uint16_t);\r
 844           hspi->TxXferCount -= 2;\r
 845         }\r
 846         else\r
 847         {\r
 848           *(__IO uint8_t *)&hspi->Instance->DR = (*hspi->pTxBuffPtr++);\r
 849           hspi->TxXferCount--;\r
 850         }\r
 851 \r
 852         /* Enable CRC Transmission */\r
 853         if((hspi->TxXferCount == 0) && (hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE))\r
 854         {\r
 855           SET_BIT(hspi->Instance->CR1, SPI_CR1_CRCNEXT);\r
 856         }\r
 857       }\r
 858 \r
 859       /* Wait until RXNE flag is reset */\r
 860       if((hspi->RxXferCount > 0) && ((hspi->Instance->SR & SPI_FLAG_RXNE) == SPI_FLAG_RXNE))\r
 861       {\r
 862         if(hspi->RxXferCount > 1)\r
 863         {\r
 864           *((uint16_t*)hspi->pRxBuffPtr) = hspi->Instance->DR;\r
 865           hspi->pRxBuffPtr += sizeof(uint16_t);\r
 866           hspi->RxXferCount -= 2;\r
 867           if(hspi->RxXferCount <= 1)\r
 868           {\r
 869             /* set fiforxthresold before to switch on 8 bit data size */\r
 870             SET_BIT(hspi->Instance->CR2, SPI_RXFIFO_THRESHOLD);\r
 871           }\r
 872         }\r
 873         else\r
 874         {\r
 875           (*hspi->pRxBuffPtr++) =  *(__IO uint8_t *)&hspi->Instance->DR;\r
 876           hspi->RxXferCount--;\r
 877         }\r
 878       }\r
 879       if(Timeout != HAL_MAX_DELAY)\r
 880       {\r
 881         if((Timeout == 0) || ((HAL_GetTick()-tickstart) > Timeout))\r
 882         {\r
 883           hspi->State = HAL_SPI_STATE_READY;\r
 884           __HAL_UNLOCK(hspi);\r
 885           return HAL_TIMEOUT;\r
 886         }\r
 887       }\r
 888     }\r
 889   }\r
 890 \r
 891   /* Read CRC from DR to close CRC calculation process */\r
 892   if(hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)\r
 893   {\r
 894     /* Wait until TXE flag */\r
 895     if(SPI_WaitFlagStateUntilTimeout(hspi, SPI_FLAG_RXNE, SPI_FLAG_RXNE, Timeout) != HAL_OK)\r
 896     {\r
 897       /* Erreur on the CRC reception */\r
 898       hspi->ErrorCode|= HAL_SPI_ERROR_CRC;\r
 899     }\r
 900 \r
 901     if(hspi->Init.DataSize == SPI_DATASIZE_16BIT)\r
 902     {\r
 903       tmpreg = hspi->Instance->DR;\r
 904       UNUSED(tmpreg); /* To avoid GCC warning */\r
 905     }\r
 906     else\r
 907     {\r
 908       tmpreg = *(__IO uint8_t *)&hspi->Instance->DR;\r
 909       UNUSED(tmpreg); /* To avoid GCC warning */\r
 910 \r
 911       if(hspi->Init.CRCLength == SPI_CRC_LENGTH_16BIT)\r
 912       {\r
 913         if(SPI_WaitFlagStateUntilTimeout(hspi, SPI_FLAG_RXNE, SPI_FLAG_RXNE, Timeout) != HAL_OK)\r
 914         {\r
 915           /* Erreur on the CRC reception */\r
 916           hspi->ErrorCode|= HAL_SPI_ERROR_CRC;\r
 917         }\r
 918         tmpreg = *(__IO uint8_t *)&hspi->Instance->DR;\r
 919         UNUSED(tmpreg); /* To avoid GCC warning */\r
 920       }\r
 921     }\r
 922   }\r
 923 \r
 924   /* Check the end of the transaction */\r
 925   if(SPI_EndRxTxTransaction(hspi,Timeout) != HAL_OK)\r
 926   {\r
 927     return HAL_TIMEOUT;\r
 928   }\r
 929 \r
 930   hspi->State = HAL_SPI_STATE_READY;\r
 931   \r
 932   /* Check if CRC error occurred */\r
 933   if(__HAL_SPI_GET_FLAG(hspi, SPI_FLAG_CRCERR) != RESET)\r
 934   {\r
 935     hspi->ErrorCode|= HAL_SPI_ERROR_CRC;\r
 936     /* Clear CRC Flag */\r
 937     __HAL_SPI_CLEAR_CRCERRFLAG(hspi);\r
 938     \r
 939     /* Process Unlocked */\r
 940     __HAL_UNLOCK(hspi);\r
 941     \r
 942     return HAL_ERROR;\r
 943   }\r
 944   \r
 945   /* Process Unlocked */\r
 946   __HAL_UNLOCK(hspi);\r
 947   \r
 948   if(hspi->ErrorCode != HAL_SPI_ERROR_NONE)\r
 949   {   \r
 950     return HAL_ERROR;\r
 951   }\r
 952   else\r
 953   {\r
 954     return HAL_OK;\r
 955   }\r
 956 }\r
 957 \r
 958 /**\r
 959   * @brief  Transmit an amount of data in no-blocking mode with Interrupt\r
 960   * @param  hspi: pointer to a SPI_HandleTypeDef structure that contains\r
 961   *               the configuration information for SPI module.\r
 962   * @param  pData: pointer to data buffer\r
 963   * @param  Size: amount of data to be sent\r
 964   * @retval HAL status\r
 965   */\r
 966 HAL_StatusTypeDef HAL_SPI_Transmit_IT(SPI_HandleTypeDef *hspi, uint8_t *pData, uint16_t Size)\r
 967 {\r
 968   assert_param(IS_SPI_DIRECTION_2LINES_OR_1LINE(hspi->Init.Direction));\r
 969   \r
 970   if(hspi->State == HAL_SPI_STATE_READY)\r
 971   {\r
 972     if((pData == NULL) || (Size == 0)) \r
 973     {\r
 974       return  HAL_ERROR;                                    \r
 975     }\r
 976     \r
 977     /* Process Locked */\r
 978     __HAL_LOCK(hspi);\r
 979     \r
 980     hspi->State       = HAL_SPI_STATE_BUSY_TX;\r
 981     hspi->ErrorCode   = HAL_SPI_ERROR_NONE;\r
 982     hspi->pTxBuffPtr  = pData;\r
 983     hspi->TxXferSize  = Size;\r
 984     hspi->TxXferCount = Size;\r
 985     hspi->pRxBuffPtr  = NULL;\r
 986     hspi->RxXferSize  = 0;\r
 987     hspi->RxXferCount = 0;\r
 988 \r
 989     /* Set the function for IT treatement */\r
 990     if(hspi->Init.DataSize > SPI_DATASIZE_8BIT )\r
 991     {\r
 992       hspi->RxISR = NULL;\r
 993       hspi->TxISR = SPI_TxISR_16BIT;\r
 994     }\r
 995     else\r
 996     {\r
 997       hspi->RxISR = NULL;\r
 998       hspi->TxISR = SPI_TxISR_8BIT;\r
 999     }\r
1000     \r
1001     /* Configure communication direction : 1Line */\r
1002     if(hspi->Init.Direction == SPI_DIRECTION_1LINE)\r
1003     {\r
1004       SPI_1LINE_TX(hspi);\r
1005     }\r
1006     \r
1007     /* Reset CRC Calculation */\r
1008     if(hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)\r
1009     {\r
1010       SPI_RESET_CRC(hspi);    \r
1011     }\r
1012     \r
1013     /* Enable TXE and ERR interrupt */\r
1014     __HAL_SPI_ENABLE_IT(hspi,(SPI_IT_TXE));\r
1015 \r
1016     /* Process Unlocked */\r
1017     __HAL_UNLOCK(hspi);\r
1018 \r
1019     /* Note : The SPI must be enabled after unlocking current process \r
1020               to avoid the risk of SPI interrupt handle execution before current\r
1021               process unlock */\r
1022         \r
1023     /* Check if the SPI is already enabled */ \r
1024     if((hspi->Instance->CR1 &SPI_CR1_SPE) != SPI_CR1_SPE)\r
1025     {\r
1026       /* Enable SPI peripheral */    \r
1027       __HAL_SPI_ENABLE(hspi);\r
1028     }\r
1029         \r
1030     return HAL_OK;\r
1031   }\r
1032   else\r
1033   {\r
1034     return HAL_BUSY;\r
1035   }\r
1036 }\r
1037 \r
1038 /**\r
1039   * @brief  Receive an amount of data in no-blocking mode with Interrupt\r
1040   * @param  hspi: pointer to a SPI_HandleTypeDef structure that contains\r
1041   *               the configuration information for SPI module.\r
1042   * @param  pData: pointer to data buffer\r
1043   * @param  Size: amount of data to be sent\r
1044   * @retval HAL status\r
1045   */\r
1046 HAL_StatusTypeDef HAL_SPI_Receive_IT(SPI_HandleTypeDef *hspi, uint8_t *pData, uint16_t Size)\r
1047 {\r
1048   if(hspi->State == HAL_SPI_STATE_READY)\r
1049   {\r
1050     if((pData == NULL) || (Size == 0))\r
1051     { \r
1052       return  HAL_ERROR;                      \r
1053     }\r
1054 \r
1055     /* Process Locked */\r
1056     __HAL_LOCK(hspi);\r
1057     \r
1058     /* Configure communication */\r
1059     hspi->State       = HAL_SPI_STATE_BUSY_RX;\r
1060     hspi->ErrorCode   = HAL_SPI_ERROR_NONE;\r
1061     hspi->pRxBuffPtr  = pData;\r
1062     hspi->RxXferSize  = Size;\r
1063     hspi->RxXferCount = Size;\r
1064     hspi->pTxBuffPtr  = NULL;\r
1065     hspi->TxXferSize  = 0;\r
1066     hspi->TxXferCount = 0;\r
1067 \r
1068     if((hspi->Init.Mode == SPI_MODE_MASTER) && (hspi->Init.Direction == SPI_DIRECTION_2LINES))\r
1069     {\r
1070       /* Process Unlocked */\r
1071       __HAL_UNLOCK(hspi);\r
1072       /* the receive process is not supported in 2Lines direction master mode */\r
1073       /* in this we call the transmitReceive process          */\r
1074       return HAL_SPI_TransmitReceive_IT(hspi,pData,pData,Size);\r
1075     }\r
1076         \r
1077     if(hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)\r
1078     {\r
1079       hspi->CRCSize = 1;\r
1080       if((hspi->Init.DataSize <= SPI_DATASIZE_8BIT) && (hspi->Init.CRCLength == SPI_CRC_LENGTH_16BIT))\r
1081       {\r
1082         hspi->CRCSize = 2;\r
1083       }\r
1084     }\r
1085     else\r
1086     {\r
1087       hspi->CRCSize = 0;\r
1088     }\r
1089         \r
1090     /* check the data size to adapt Rx threshold and the set the function for IT treatment */\r
1091     if(hspi->Init.DataSize > SPI_DATASIZE_8BIT )\r
1092     {\r
1093       /* set fiforxthresold according the reception data length: 16 bit */\r
1094       CLEAR_BIT(hspi->Instance->CR2, SPI_RXFIFO_THRESHOLD);\r
1095       hspi->RxISR = SPI_RxISR_16BIT;\r
1096       hspi->TxISR = NULL;\r
1097     }\r
1098     else\r
1099     {\r
1100       /* set fiforxthresold according the reception data length: 8 bit */\r
1101       SET_BIT(hspi->Instance->CR2, SPI_RXFIFO_THRESHOLD);\r
1102       hspi->RxISR = SPI_RxISR_8BIT;\r
1103       hspi->TxISR = NULL;\r
1104     }\r
1105     \r
1106     /* Configure communication direction : 1Line */\r
1107     if(hspi->Init.Direction == SPI_DIRECTION_1LINE)\r
1108     {\r
1109       SPI_1LINE_RX(hspi);\r
1110     }\r
1111     \r
1112     /* Reset CRC Calculation */\r
1113     if(hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)\r
1114     {\r
1115       SPI_RESET_CRC(hspi);\r
1116     }\r
1117     \r
1118     /* Enable TXE and ERR interrupt */\r
1119     __HAL_SPI_ENABLE_IT(hspi, (SPI_IT_RXNE | SPI_IT_ERR));\r
1120     \r
1121     /* Process Unlocked */\r
1122     __HAL_UNLOCK(hspi);\r
1123     \r
1124     /* Note : The SPI must be enabled after unlocking current process \r
1125     to avoid the risk of SPI interrupt handle execution before current\r
1126     process unlock */\r
1127     \r
1128     /* Check if the SPI is already enabled */ \r
1129     if((hspi->Instance->CR1 & SPI_CR1_SPE) != SPI_CR1_SPE)\r
1130     {\r
1131       /* Enable SPI peripheral */    \r
1132       __HAL_SPI_ENABLE(hspi);\r
1133     }\r
1134     \r
1135     return HAL_OK;\r
1136   }\r
1137   else\r
1138   {\r
1139     return HAL_BUSY; \r
1140   }\r
1141 }\r
1142 \r
1143 /**\r
1144   * @brief  Transmit and Receive an amount of data in no-blocking mode with Interrupt\r
1145   * @param  hspi: pointer to a SPI_HandleTypeDef structure that contains\r
1146   *               the configuration information for SPI module.\r
1147   * @param  pTxData: pointer to transmission data buffer\r
1148   * @param  pRxData: pointer to reception data buffer\r
1149   * @param  Size: amount of data to be sent and received\r
1150   * @retval HAL status\r
1151   */\r
1152 HAL_StatusTypeDef HAL_SPI_TransmitReceive_IT(SPI_HandleTypeDef *hspi, uint8_t *pTxData, uint8_t *pRxData, uint16_t Size)\r
1153 {\r
1154   assert_param(IS_SPI_DIRECTION_2LINES(hspi->Init.Direction));\r
1155   \r
1156   if((hspi->State == HAL_SPI_STATE_READY) || \\r
1157      ((hspi->Init.Mode == SPI_MODE_MASTER) && (hspi->Init.Direction == SPI_DIRECTION_2LINES) && (hspi->State == HAL_SPI_STATE_BUSY_RX)))\r
1158   {\r
1159     if((pTxData == NULL ) || (pRxData == NULL ) || (Size == 0)) \r
1160     {\r
1161       return  HAL_ERROR;                                    \r
1162     }\r
1163     \r
1164     /* Process locked */\r
1165     __HAL_LOCK(hspi);\r
1166     \r
1167     hspi->CRCSize = 0;\r
1168     if(hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)\r
1169     {\r
1170       hspi->CRCSize = 1;\r
1171       if((hspi->Init.DataSize <= SPI_DATASIZE_8BIT) && (hspi->Init.CRCLength == SPI_CRC_LENGTH_16BIT))\r
1172       {\r
1173         hspi->CRCSize = 2;\r
1174       }\r
1175     }\r
1176     \r
1177     if(hspi->State != HAL_SPI_STATE_BUSY_RX)\r
1178     {\r
1179       hspi->State = HAL_SPI_STATE_BUSY_TX_RX;\r
1180     }\r
1181     \r
1182     hspi->ErrorCode   = HAL_SPI_ERROR_NONE;\r
1183     hspi->pTxBuffPtr  = pTxData;\r
1184     hspi->TxXferSize  = Size;\r
1185     hspi->TxXferCount = Size;\r
1186     hspi->pRxBuffPtr  = pRxData;\r
1187     hspi->RxXferSize  = Size;\r
1188     hspi->RxXferCount = Size;\r
1189     \r
1190     /* Set the function for IT treatement */\r
1191     if(hspi->Init.DataSize > SPI_DATASIZE_8BIT )\r
1192     {\r
1193       hspi->RxISR = SPI_2linesRxISR_16BIT;\r
1194       hspi->TxISR = SPI_2linesTxISR_16BIT;       \r
1195     }\r
1196     else\r
1197     {\r
1198       hspi->RxISR = SPI_2linesRxISR_8BIT;\r
1199       hspi->TxISR = SPI_2linesTxISR_8BIT;\r
1200     }\r
1201     \r
1202     /* Reset CRC Calculation */\r
1203     if(hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)\r
1204     {\r
1205       SPI_RESET_CRC(hspi);\r
1206     }\r
1207     \r
1208     /* check if packing mode is enabled and if there is more than 2 data to receive */\r
1209     if((hspi->Init.DataSize > SPI_DATASIZE_8BIT) || (hspi->RxXferCount >= 2))\r
1210     {\r
1211       /* set fiforxthresold according the reception data length: 16 bit */\r
1212       CLEAR_BIT(hspi->Instance->CR2, SPI_RXFIFO_THRESHOLD);\r
1213     }\r
1214     else\r
1215     {\r
1216       /* set fiforxthresold according the reception data length: 8 bit */\r
1217       SET_BIT(hspi->Instance->CR2, SPI_RXFIFO_THRESHOLD);\r
1218     }\r
1219     \r
1220     /* Enable TXE, RXNE and ERR interrupt */\r
1221     __HAL_SPI_ENABLE_IT(hspi, (SPI_IT_TXE | SPI_IT_RXNE | SPI_IT_ERR));\r
1222     \r
1223     /* Process Unlocked */\r
1224     __HAL_UNLOCK(hspi);\r
1225     \r
1226     /* Check if the SPI is already enabled */ \r
1227     if((hspi->Instance->CR1 & SPI_CR1_SPE) != SPI_CR1_SPE)\r
1228     {\r
1229       /* Enable SPI peripheral */    \r
1230       __HAL_SPI_ENABLE(hspi);\r
1231     }\r
1232     \r
1233     return HAL_OK;\r
1234   }\r
1235   else\r
1236   {\r
1237     return HAL_BUSY;\r
1238   }\r
1239 }\r
1240 \r
1241 /**\r
1242   * @brief  Transmit an amount of data in no-blocking mode with DMA\r
1243   * @param  hspi: pointer to a SPI_HandleTypeDef structure that contains\r
1244   *               the configuration information for SPI module.\r
1245   * @param  pData: pointer to data buffer\r
1246   * @param  Size: amount of data to be sent\r
1247   * @retval HAL status\r
1248   */\r
1249 HAL_StatusTypeDef HAL_SPI_Transmit_DMA(SPI_HandleTypeDef *hspi, uint8_t *pData, uint16_t Size)\r
1250 {    \r
1251   assert_param(IS_SPI_DIRECTION_2LINES_OR_1LINE(hspi->Init.Direction));\r
1252 \r
1253   if(hspi->State != HAL_SPI_STATE_READY) \r
1254   {\r
1255     return HAL_BUSY;\r
1256   }\r
1257   \r
1258   if((pData == NULL) || (Size == 0))\r
1259   {\r
1260     return HAL_ERROR;\r
1261   }\r
1262   \r
1263   /* Process Locked */\r
1264   __HAL_LOCK(hspi);\r
1265   \r
1266   hspi->State       = HAL_SPI_STATE_BUSY_TX;\r
1267   hspi->ErrorCode   = HAL_SPI_ERROR_NONE;\r
1268   hspi->pTxBuffPtr  = pData;\r
1269   hspi->TxXferSize  = Size;\r
1270   hspi->TxXferCount = Size;\r
1271   hspi->pRxBuffPtr  = (uint8_t *)NULL;\r
1272   hspi->RxXferSize  = 0;\r
1273   hspi->RxXferCount = 0;\r
1274   \r
1275   /* Configure communication direction : 1Line */\r
1276   if(hspi->Init.Direction == SPI_DIRECTION_1LINE)\r
1277   {\r
1278     SPI_1LINE_TX(hspi);\r
1279   }\r
1280   \r
1281   /* Reset CRC Calculation */\r
1282   if(hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)\r
1283   {\r
1284     SPI_RESET_CRC(hspi);\r
1285   }\r
1286   \r
1287   /* Set the SPI TxDMA Half transfer complete callback */\r
1288   hspi->hdmatx->XferHalfCpltCallback = SPI_DMAHalfTransmitCplt;\r
1289   \r
1290   /* Set the SPI TxDMA transfer complete callback */\r
1291   hspi->hdmatx->XferCpltCallback = SPI_DMATransmitCplt;\r
1292   \r
1293   /* Set the DMA error callback */\r
1294   hspi->hdmatx->XferErrorCallback = SPI_DMAError;\r
1295   \r
1296   CLEAR_BIT(hspi->Instance->CR2, SPI_CR2_LDMATX);\r
1297   /* packing mode is enabled only if the DMA setting is HALWORD */\r
1298   if((hspi->Init.DataSize <= SPI_DATASIZE_8BIT) && (hspi->hdmatx->Init.MemDataAlignment == DMA_MDATAALIGN_HALFWORD))\r
1299   {\r
1300     /* Check the even/odd of the data size + crc if enabled */\r
1301     if((hspi->TxXferCount & 0x1) == 0)\r
1302     {\r
1303       CLEAR_BIT(hspi->Instance->CR2, SPI_CR2_LDMATX);\r
1304       hspi->TxXferCount = (hspi->TxXferCount >> 1);\r
1305     }\r
1306     else\r
1307     {\r
1308       SET_BIT(hspi->Instance->CR2, SPI_CR2_LDMATX);\r
1309       hspi->TxXferCount = (hspi->TxXferCount >> 1) + 1;\r
1310     }\r
1311   }\r
1312   \r
1313   /* Enable the Tx DMA channel */\r
1314   HAL_DMA_Start_IT(hspi->hdmatx, (uint32_t)hspi->pTxBuffPtr, (uint32_t)&hspi->Instance->DR, hspi->TxXferCount);\r
1315   \r
1316   /* Check if the SPI is already enabled */ \r
1317   if((hspi->Instance->CR1 &SPI_CR1_SPE) != SPI_CR1_SPE)\r
1318   {\r
1319     /* Enable SPI peripheral */    \r
1320     __HAL_SPI_ENABLE(hspi);\r
1321   }\r
1322 \r
1323   /* Enable Tx DMA Request */\r
1324   hspi->Instance->CR2 |= SPI_CR2_TXDMAEN;\r
1325   \r
1326   /* Process Unlocked */\r
1327   __HAL_UNLOCK(hspi);\r
1328   \r
1329   return HAL_OK;\r
1330 }\r
1331 \r
1332 /**\r
1333 * @brief  Receive an amount of data in no-blocking mode with DMA \r
1334 * @param  hspi: SPI handle\r
1335 * @param  pData: pointer to data buffer\r
1336 * @param  Size: amount of data to be sent\r
1337 * @retval HAL status\r
1338 */\r
1339 HAL_StatusTypeDef HAL_SPI_Receive_DMA(SPI_HandleTypeDef *hspi, uint8_t *pData, uint16_t Size)\r
1340 {\r
1341   if(hspi->State != HAL_SPI_STATE_READY)\r
1342   {\r
1343     return HAL_BUSY;\r
1344   }\r
1345   \r
1346   if((pData == NULL) || (Size == 0))\r
1347   {\r
1348     return HAL_ERROR;\r
1349   }\r
1350   \r
1351   /* Process Locked */\r
1352   __HAL_LOCK(hspi);\r
1353 \r
1354   hspi->State       = HAL_SPI_STATE_BUSY_RX;\r
1355   hspi->ErrorCode   = HAL_SPI_ERROR_NONE;\r
1356   hspi->pRxBuffPtr  = pData;\r
1357   hspi->RxXferSize  = Size;\r
1358   hspi->RxXferCount = Size;\r
1359   hspi->pTxBuffPtr  = (uint8_t *)NULL;\r
1360   hspi->TxXferSize  = 0;\r
1361   hspi->TxXferCount = 0;\r
1362 \r
1363   if((hspi->Init.Mode == SPI_MODE_MASTER) && (hspi->Init.Direction == SPI_DIRECTION_2LINES))\r
1364   {\r
1365     /* Process Unlocked */\r
1366     __HAL_UNLOCK(hspi);\r
1367     /* the receive process is not supported in 2Lines direction master mode */\r
1368     /* in this case we call the transmitReceive process                     */\r
1369     return HAL_SPI_TransmitReceive_DMA(hspi,pData,pData,Size);\r
1370   }\r
1371   \r
1372   /* Configure communication direction : 1Line */\r
1373   if(hspi->Init.Direction == SPI_DIRECTION_1LINE)\r
1374   {\r
1375     SPI_1LINE_RX(hspi);\r
1376   }\r
1377   \r
1378   /* Reset CRC Calculation */\r
1379   if(hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)\r
1380   {\r
1381     SPI_RESET_CRC(hspi);\r
1382   }\r
1383   \r
1384   /* packing mode management is enabled by the DMA settings */\r
1385   if((hspi->Init.DataSize <= SPI_DATASIZE_8BIT) && (hspi->hdmarx->Init.MemDataAlignment == DMA_MDATAALIGN_HALFWORD))\r
1386   {\r
1387     /* Process Locked */\r
1388     __HAL_UNLOCK(hspi);\r
1389     /* Restriction the DMA data received is not allowed in this mode */\r
1390     return HAL_ERROR;\r
1391   }\r
1392   \r
1393   CLEAR_BIT(hspi->Instance->CR2, SPI_CR2_LDMARX);\r
1394   if( hspi->Init.DataSize > SPI_DATASIZE_8BIT)\r
1395   {\r
1396     /* set fiforxthresold according the reception data length: 16bit */\r
1397     CLEAR_BIT(hspi->Instance->CR2, SPI_RXFIFO_THRESHOLD);\r
1398   }\r
1399   else\r
1400   {\r
1401     /* set fiforxthresold according the reception data length: 8bit */\r
1402     SET_BIT(hspi->Instance->CR2, SPI_RXFIFO_THRESHOLD);\r
1403   }\r
1404   \r
1405   /* Set the SPI RxDMA Half transfer complete callback */\r
1406   hspi->hdmarx->XferHalfCpltCallback = SPI_DMAHalfReceiveCplt;\r
1407 \r
1408   /* Set the SPI Rx DMA transfer complete callback */\r
1409   hspi->hdmarx->XferCpltCallback = SPI_DMAReceiveCplt;\r
1410   \r
1411   /* Set the DMA error callback */\r
1412   hspi->hdmarx->XferErrorCallback = SPI_DMAError;\r
1413   \r
1414   /* Enable Rx DMA Request */  \r
1415   hspi->Instance->CR2 |= SPI_CR2_RXDMAEN;\r
1416   \r
1417   /* Enable the Rx DMA channel */\r
1418   HAL_DMA_Start_IT(hspi->hdmarx, (uint32_t)&hspi->Instance->DR, (uint32_t)hspi->pRxBuffPtr, hspi->RxXferCount);\r
1419   \r
1420   /* Process Unlocked */\r
1421   __HAL_UNLOCK(hspi);\r
1422   \r
1423   /* Check if the SPI is already enabled */ \r
1424   if((hspi->Instance->CR1 & SPI_CR1_SPE) != SPI_CR1_SPE)\r
1425   {\r
1426     /* Enable SPI peripheral */    \r
1427     __HAL_SPI_ENABLE(hspi);\r
1428   }\r
1429   \r
1430   return HAL_OK;\r
1431 }\r
1432 \r
1433 /**\r
1434   * @brief  Transmit and Receive an amount of data in no-blocking mode with DMA\r
1435   * @param  hspi: pointer to a SPI_HandleTypeDef structure that contains\r
1436   *               the configuration information for SPI module.\r
1437   * @param  pTxData: pointer to transmission data buffer\r
1438   * @param  pRxData: pointer to reception data buffer\r
1439   * @note  When the CRC feature is enabled the pRxData Length must be Size + 1\r
1440   * @param  Size: amount of data to be sent\r
1441   * @retval HAL status\r
1442   */\r
1443 HAL_StatusTypeDef HAL_SPI_TransmitReceive_DMA(SPI_HandleTypeDef *hspi, uint8_t *pTxData, uint8_t *pRxData, uint16_t Size)\r
1444 {\r
1445   assert_param(IS_SPI_DIRECTION_2LINES(hspi->Init.Direction));\r
1446   \r
1447   if((hspi->State == HAL_SPI_STATE_READY) ||\r
1448      ((hspi->Init.Mode == SPI_MODE_MASTER) && (hspi->Init.Direction == SPI_DIRECTION_2LINES) && (hspi->State == HAL_SPI_STATE_BUSY_RX)))\r
1449   {\r
1450     if((pTxData == NULL ) || (pRxData == NULL ) || (Size == 0)) \r
1451     {\r
1452       return  HAL_ERROR;                                    \r
1453     }\r
1454     \r
1455     /* Process locked */\r
1456     __HAL_LOCK(hspi);\r
1457     \r
1458     /* check if the transmit Receive function is not called by a receive master */\r
1459     if(hspi->State != HAL_SPI_STATE_BUSY_RX)\r
1460     {  \r
1461       hspi->State = HAL_SPI_STATE_BUSY_TX_RX;\r
1462     }\r
1463     \r
1464     hspi->ErrorCode   = HAL_SPI_ERROR_NONE;\r
1465     hspi->pTxBuffPtr  = (uint8_t *)pTxData;\r
1466     hspi->TxXferSize  = Size;\r
1467     hspi->TxXferCount = Size;\r
1468     hspi->pRxBuffPtr  = (uint8_t *)pRxData;\r
1469     hspi->RxXferSize  = Size;\r
1470     hspi->RxXferCount = Size;\r
1471     \r
1472     /* Reset CRC Calculation + increase the rxsize */\r
1473     if(hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)\r
1474     {\r
1475       SPI_RESET_CRC(hspi);\r
1476     }\r
1477     \r
1478     /* Reset the threshold bit */\r
1479     CLEAR_BIT(hspi->Instance->CR2, SPI_CR2_LDMATX);\r
1480     CLEAR_BIT(hspi->Instance->CR2, SPI_CR2_LDMARX);\r
1481     \r
1482     /* the packing mode management is enabled by the DMA settings according the spi data size */\r
1483     if(hspi->Init.DataSize > SPI_DATASIZE_8BIT)\r
1484     {\r
1485       /* set fiforxthreshold according the reception data length: 16bit */\r
1486       CLEAR_BIT(hspi->Instance->CR2, SPI_RXFIFO_THRESHOLD);\r
1487     }\r
1488     else\r
1489     {\r
1490       /* set fiforxthresold according the reception data length: 8bit */\r
1491       SET_BIT(hspi->Instance->CR2, SPI_RXFIFO_THRESHOLD);\r
1492       \r
1493       if(hspi->hdmatx->Init.MemDataAlignment == DMA_MDATAALIGN_HALFWORD)\r
1494       {\r
1495         if((hspi->TxXferSize & 0x1) == 0x0 )\r
1496         {\r
1497           CLEAR_BIT(hspi->Instance->CR2, SPI_CR2_LDMATX);\r
1498           hspi->TxXferCount = hspi->TxXferCount >> 1;\r
1499         }\r
1500         else\r
1501         {\r
1502           SET_BIT(hspi->Instance->CR2, SPI_CR2_LDMATX);\r
1503           hspi->TxXferCount = (hspi->TxXferCount >> 1) + 1;\r
1504         }      \r
1505       }\r
1506       \r
1507       if(hspi->hdmarx->Init.MemDataAlignment == DMA_MDATAALIGN_HALFWORD)\r
1508       {\r
1509         /* set fiforxthresold according the reception data length: 16bit */\r
1510         CLEAR_BIT(hspi->Instance->CR2, SPI_RXFIFO_THRESHOLD);\r
1511         \r
1512         /* Size must include the CRC length */\r
1513         if((hspi->RxXferCount & 0x1) == 0x0 )\r
1514         {\r
1515           CLEAR_BIT(hspi->Instance->CR2, SPI_CR2_LDMARX);\r
1516           hspi->RxXferCount = hspi->RxXferCount >> 1;\r
1517         }\r
1518         else\r
1519         {\r
1520           SET_BIT(hspi->Instance->CR2, SPI_CR2_LDMARX);\r
1521           hspi->RxXferCount = (hspi->RxXferCount >> 1) + 1; \r
1522         } \r
1523       }\r
1524     }   \r
1525     \r
1526     /* Set the SPI Rx DMA transfer complete callback because the last generated transfer request is \r
1527     the reception request (RXNE) */\r
1528     if(hspi->State == HAL_SPI_STATE_BUSY_RX)\r
1529     {                   \r
1530       hspi->hdmarx->XferHalfCpltCallback = SPI_DMAHalfReceiveCplt;\r
1531       hspi->hdmarx->XferCpltCallback = SPI_DMAReceiveCplt;\r
1532     }\r
1533     else\r
1534     {   \r
1535        hspi->hdmarx->XferHalfCpltCallback = SPI_DMAHalfTransmitReceiveCplt;\r
1536       hspi->hdmarx->XferCpltCallback = SPI_DMATransmitReceiveCplt;\r
1537     }\r
1538     /* Set the DMA error callback */\r
1539     hspi->hdmarx->XferErrorCallback = SPI_DMAError;\r
1540     \r
1541     /* Enable Rx DMA Request */  \r
1542     hspi->Instance->CR2 |= SPI_CR2_RXDMAEN;\r
1543     \r
1544     /* Enable the Rx DMA channel */\r
1545     HAL_DMA_Start_IT(hspi->hdmarx, (uint32_t)&hspi->Instance->DR, (uint32_t) hspi->pRxBuffPtr, hspi->RxXferCount);\r
1546     \r
1547     /* Set the SPI Tx DMA transfer complete callback as NULL because the communication closing\r
1548     is performed in DMA reception complete callback  */\r
1549     hspi->hdmatx->XferHalfCpltCallback = NULL;\r
1550     hspi->hdmatx->XferCpltCallback = NULL;\r
1551     \r
1552     /* Set the DMA error callback */\r
1553     hspi->hdmatx->XferErrorCallback = SPI_DMAError;\r
1554     \r
1555     /* Enable the Tx DMA channel */\r
1556     HAL_DMA_Start_IT(hspi->hdmatx, (uint32_t)hspi->pTxBuffPtr, (uint32_t)&hspi->Instance->DR, hspi->TxXferCount);\r
1557     \r
1558     /* Check if the SPI is already enabled */ \r
1559     if((hspi->Instance->CR1 &SPI_CR1_SPE) != SPI_CR1_SPE)\r
1560     {\r
1561       /* Enable SPI peripheral */    \r
1562       __HAL_SPI_ENABLE(hspi);\r
1563     }\r
1564     \r
1565     /* Enable Tx DMA Request */  \r
1566     hspi->Instance->CR2 |= SPI_CR2_TXDMAEN;\r
1567     \r
1568     /* Process Unlocked */\r
1569     __HAL_UNLOCK(hspi);\r
1570     \r
1571     return HAL_OK;\r
1572   }\r
1573   else\r
1574   {\r
1575     return HAL_BUSY;\r
1576   }\r
1577 }\r
1578 \r
1579 /**\r
1580   * @brief Pauses the DMA Transfer.\r
1581   * @param  hspi: pointer to a SPI_HandleTypeDef structure that contains\r
1582   *               the configuration information for the specified SPI module.\r
1583   * @retval HAL status\r
1584   */\r
1585 HAL_StatusTypeDef HAL_SPI_DMAPause(SPI_HandleTypeDef *hspi)\r
1586 {\r
1587   /* Process Locked */\r
1588   __HAL_LOCK(hspi);\r
1589 \r
1590   /* Disable the SPI DMA Tx & Rx requests */\r
1591   CLEAR_BIT(hspi->Instance->CR2, SPI_CR2_TXDMAEN | SPI_CR2_RXDMAEN);\r
1592 \r
1593   /* Process Unlocked */\r
1594   __HAL_UNLOCK(hspi);\r
1595 \r
1596   return HAL_OK;\r
1597 }\r
1598 \r
1599 /**\r
1600   * @brief Resumes the DMA Transfer.\r
1601   * @param  hspi: pointer to a SPI_HandleTypeDef structure that contains\r
1602   *               the configuration information for the specified SPI module.\r
1603   * @retval HAL status\r
1604   */\r
1605 HAL_StatusTypeDef HAL_SPI_DMAResume(SPI_HandleTypeDef *hspi)\r
1606 {\r
1607   /* Process Locked */\r
1608   __HAL_LOCK(hspi);\r
1609 \r
1610   /* Enable the SPI DMA Tx & Rx requests */\r
1611   SET_BIT(hspi->Instance->CR2, SPI_CR2_TXDMAEN | SPI_CR2_RXDMAEN);\r
1612 \r
1613   /* Process Unlocked */\r
1614   __HAL_UNLOCK(hspi);\r
1615 \r
1616   return HAL_OK;\r
1617 }\r
1618 \r
1619 /**\r
1620   * @brief Stops the DMA Transfer.\r
1621   * @param  hspi: pointer to a SPI_HandleTypeDef structure that contains\r
1622   *               the configuration information for the specified SPI module.\r
1623   * @retval HAL status\r
1624   */\r
1625 HAL_StatusTypeDef HAL_SPI_DMAStop(SPI_HandleTypeDef *hspi)\r
1626 {\r
1627   /* The Lock is not implemented on this API to allow the user application\r
1628      to call the HAL SPI API under callbacks HAL_SPI_TxCpltCallback() or HAL_SPI_RxCpltCallback() or HAL_SPI_TxRxCpltCallback():\r
1629      when calling HAL_DMA_Abort() API the DMA TX/RX Transfer complete interrupt is generated\r
1630      and the correspond call back is executed HAL_SPI_TxCpltCallback() or HAL_SPI_RxCpltCallback() or HAL_SPI_TxRxCpltCallback()\r
1631      */\r
1632   \r
1633   /* Abort the SPI DMA tx Stream */\r
1634   if(hspi->hdmatx != NULL)\r
1635   {\r
1636     HAL_DMA_Abort(hspi->hdmatx);\r
1637   }\r
1638   /* Abort the SPI DMA rx Stream */\r
1639   if(hspi->hdmarx != NULL)\r
1640   {\r
1641     HAL_DMA_Abort(hspi->hdmarx);\r
1642   }\r
1643 \r
1644   /* Disable the SPI DMA Tx & Rx requests */\r
1645   CLEAR_BIT(hspi->Instance->CR2, SPI_CR2_TXDMAEN | SPI_CR2_RXDMAEN);\r
1646   hspi->State = HAL_SPI_STATE_READY;\r
1647   return HAL_OK;\r
1648 }\r
1649 \r
1650 /**\r
1651   * @brief  This function handles SPI interrupt request.\r
1652   * @param  hspi: pointer to a SPI_HandleTypeDef structure that contains\r
1653   *               the configuration information for the specified SPI module.\r
1654   * @retval None\r
1655   */\r
1656 void HAL_SPI_IRQHandler(SPI_HandleTypeDef *hspi)\r
1657 {\r
1658   /* SPI in mode Receiver ----------------------------------------------------*/\r
1659   if((__HAL_SPI_GET_FLAG(hspi, SPI_FLAG_OVR) == RESET) &&\r
1660      (__HAL_SPI_GET_FLAG(hspi, SPI_FLAG_RXNE) != RESET) && (__HAL_SPI_GET_IT_SOURCE(hspi, SPI_IT_RXNE) != RESET))\r
1661   {\r
1662     hspi->RxISR(hspi);\r
1663     return;\r
1664   }\r
1665   \r
1666   /* SPI in mode Tramitter ---------------------------------------------------*/\r
1667   if((__HAL_SPI_GET_FLAG(hspi, SPI_FLAG_TXE) != RESET) && (__HAL_SPI_GET_IT_SOURCE(hspi, SPI_IT_TXE) != RESET))\r
1668   {   \r
1669     hspi->TxISR(hspi);\r
1670     return;\r
1671   }\r
1672   \r
1673   /* SPI in Erreur Treatment ---------------------------------------------------*/\r
1674   if((hspi->Instance->SR & (SPI_FLAG_MODF | SPI_FLAG_OVR | SPI_FLAG_FRE)) != RESET)  \r
1675   {\r
1676     /* SPI Overrun error interrupt occured -------------------------------------*/\r
1677     if(__HAL_SPI_GET_FLAG(hspi, SPI_FLAG_OVR) != RESET) \r
1678     {\r
1679       if(hspi->State != HAL_SPI_STATE_BUSY_TX)\r
1680       {\r
1681         hspi->ErrorCode |= HAL_SPI_ERROR_OVR;\r
1682         __HAL_SPI_CLEAR_OVRFLAG(hspi);\r
1683       }\r
1684       else\r
1685       {\r
1686         return;\r
1687       }\r
1688     }\r
1689     \r
1690     /* SPI Mode Fault error interrupt occured -------------------------------------*/\r
1691     if(__HAL_SPI_GET_FLAG(hspi, SPI_FLAG_MODF) != RESET)\r
1692     { \r
1693       hspi->ErrorCode |= HAL_SPI_ERROR_MODF;\r
1694       __HAL_SPI_CLEAR_MODFFLAG(hspi);\r
1695     }\r
1696     \r
1697     /* SPI Frame error interrupt occured ----------------------------------------*/\r
1698     if(__HAL_SPI_GET_FLAG(hspi, SPI_FLAG_FRE) != RESET)\r
1699     { \r
1700       hspi->ErrorCode |= HAL_SPI_ERROR_FRE;\r
1701       __HAL_SPI_CLEAR_FREFLAG(hspi);\r
1702     }\r
1703     \r
1704     __HAL_SPI_DISABLE_IT(hspi, SPI_IT_RXNE | SPI_IT_TXE | SPI_IT_ERR);\r
1705     hspi->State = HAL_SPI_STATE_READY;\r
1706     HAL_SPI_ErrorCallback(hspi);\r
1707     \r
1708     return;\r
1709   }\r
1710 }\r
1711 \r
1712 /**\r
1713   * @brief Tx Transfer completed callback\r
1714   * @param  hspi: pointer to a SPI_HandleTypeDef structure that contains\r
1715   *               the configuration information for SPI module.\r
1716   * @retval None\r
1717   */\r
1718 __weak void HAL_SPI_TxCpltCallback(SPI_HandleTypeDef *hspi)\r
1719 {\r
1720   /* NOTE : This function should not be modified, when the callback is needed,\r
1721             the HAL_SPI_TxCpltCallback should be implemented in the user file\r
1722    */\r
1723 }\r
1724 \r
1725 /**\r
1726   * @brief Rx Transfer completed callbacks\r
1727   * @param  hspi: pointer to a SPI_HandleTypeDef structure that contains\r
1728   *               the configuration information for SPI module.\r
1729   * @retval None\r
1730   */\r
1731 __weak void HAL_SPI_RxCpltCallback(SPI_HandleTypeDef *hspi)\r
1732 {\r
1733   /* NOTE : This function should not be modified, when the callback is needed,\r
1734             the HAL_SPI_RxCpltCallback should be implemented in the user file\r
1735    */\r
1736 }\r
1737 \r
1738 /**\r
1739   * @brief Tx and Rx Transfer completed callback\r
1740   * @param  hspi: pointer to a SPI_HandleTypeDef structure that contains\r
1741   *               the configuration information for SPI module.\r
1742   * @retval None\r
1743   */\r
1744 __weak void HAL_SPI_TxRxCpltCallback(SPI_HandleTypeDef *hspi)\r
1745 {\r
1746   /* NOTE : This function should not be modified, when the callback is needed,\r
1747             the HAL_SPI_TxRxCpltCallback should be implemented in the user file\r
1748    */\r
1749 }\r
1750 \r
1751 /**\r
1752   * @brief Tx Half Transfer completed callback\r
1753   * @param  hspi: pointer to a SPI_HandleTypeDef structure that contains\r
1754   *               the configuration information for SPI module.\r
1755   * @retval None\r
1756   */\r
1757 __weak void HAL_SPI_TxHalfCpltCallback(SPI_HandleTypeDef *hspi)\r
1758 {\r
1759   /* NOTE : This function should not be modified, when the callback is needed,\r
1760             the HAL_SPI_TxHalfCpltCallback should be implemented in the user file\r
1761    */\r
1762 }\r
1763 \r
1764 /**\r
1765   * @brief Rx Half Transfer completed callback\r
1766   * @param  hspi: pointer to a SPI_HandleTypeDef structure that contains\r
1767   *               the configuration information for SPI module.\r
1768   * @retval None\r
1769   */\r
1770 __weak void HAL_SPI_RxHalfCpltCallback(SPI_HandleTypeDef *hspi)\r
1771 {\r
1772   /* NOTE : This function should not be modified, when the callback is needed,\r
1773             the HAL_SPI_RxHalfCpltCallback() should be implemented in the user file\r
1774    */\r
1775 }\r
1776 \r
1777 /**\r
1778   * @brief Tx and Rx Half Transfer callback\r
1779   * @param  hspi: pointer to a SPI_HandleTypeDef structure that contains\r
1780   *               the configuration information for SPI module.\r
1781   * @retval None\r
1782   */\r
1783 __weak void HAL_SPI_TxRxHalfCpltCallback(SPI_HandleTypeDef *hspi)\r
1784 {\r
1785   /* NOTE : This function should not be modified, when the callback is needed,\r
1786             the HAL_SPI_TxRxHalfCpltCallback() should be implemented in the user file\r
1787    */\r
1788 }\r
1789 \r
1790 /**\r
1791   * @brief SPI error callback\r
1792   * @param  hspi: pointer to a SPI_HandleTypeDef structure that contains\r
1793   *               the configuration information for SPI module.\r
1794   * @retval None\r
1795   */\r
1796  __weak void HAL_SPI_ErrorCallback(SPI_HandleTypeDef *hspi)\r
1797 {\r
1798   /* NOTE : This function should not be modified, when the callback is needed,\r
1799             the HAL_SPI_ErrorCallback should be implemented in the user file\r
1800    */\r
1801   /* NOTE : The ErrorCode parameter in the hspi handle is updated by the SPI processes\r
1802             and user can use HAL_SPI_GetError() API to check the latest error occurred\r
1803    */\r
1804 }\r
1805 \r
1806 /**\r
1807   * @}\r
1808   */\r
1809 \r
1810 \r
1811 \r
1812 \r
1813 \r
1814 \r
1815       \r
1816 \r
1817 \r
1818 /**\r
1819   * @}\r
1820   */\r
1821 \r
1822 /** @defgroup SPI_Exported_Functions_Group3 Peripheral State and Errors functions\r
1823   *  @brief   SPI control functions\r
1824   *\r
1825 @verbatim\r
1826  ===============================================================================\r
1827                       ##### Peripheral State and Errors functions #####\r
1828  ===============================================================================\r
1829     [..]\r
1830     This subsection provides a set of functions allowing to control the SPI.\r
1831      (+) HAL_SPI_GetState() API can be helpful to check in run-time the state of the SPI peripheral\r
1832      (+) HAL_SPI_GetError() check in run-time Errors occurring during communication\r
1833 @endverbatim\r
1834   * @{\r
1835   */\r
1836 \r
1837 /**\r
1838   * @brief  Return the SPI state\r
1839   * @param  hspi: pointer to a SPI_HandleTypeDef structure that contains\r
1840   *               the configuration information for SPI module.\r
1841   * @retval SPI state\r
1842   */\r
1843 HAL_SPI_StateTypeDef HAL_SPI_GetState(SPI_HandleTypeDef *hspi)\r
1844 {\r
1845   return hspi->State;\r
1846 }\r
1847 \r
1848 /**\r
1849   * @brief  Return the SPI error code\r
1850   * @param  hspi: pointer to a SPI_HandleTypeDef structure that contains\r
1851   *               the configuration information for SPI module.\r
1852   * @retval SPI error code in bitmap format\r
1853   */\r
1854 uint32_t HAL_SPI_GetError(SPI_HandleTypeDef *hspi)\r
1855 {\r
1856   return hspi->ErrorCode;\r
1857 }\r
1858 \r
1859 /**\r
1860   * @}\r
1861   */\r
1862 \r
1863 /**\r
1864   * @}\r
1865   */\r
1866 \r
1867 /** @addtogroup SPI_Private_Functions\r
1868  *  @brief   Private functions\r
1869   * @{\r
1870   */\r
1871 /**\r
1872   * @brief DMA SPI transmit process complete callback\r
1873   * @param  hdma: pointer to a DMA_HandleTypeDef structure that contains\r
1874   *               the configuration information for the specified DMA module.\r
1875   * @retval None\r
1876   */\r
1877 static void SPI_DMATransmitCplt(DMA_HandleTypeDef *hdma)\r
1878 {\r
1879   SPI_HandleTypeDef* hspi = ( SPI_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;\r
1880 \r
1881   /* DMA Normal Mode */\r
1882   if((hdma->Instance->CR & DMA_SxCR_CIRC) == 0)\r
1883   {\r
1884     /* Disable Tx DMA Request */\r
1885     CLEAR_BIT(hspi->Instance->CR2, SPI_CR2_TXDMAEN);\r
1886 \r
1887     /* Clear OVERUN flag in 2 Lines communication mode because received data is not read */\r
1888     if(hspi->Init.Direction == SPI_DIRECTION_2LINES)\r
1889     {\r
1890       __HAL_SPI_CLEAR_OVRFLAG(hspi);\r
1891     }\r
1892 \r
1893     hspi->TxXferCount = 0;\r
1894     hspi->State = HAL_SPI_STATE_READY;\r
1895 \r
1896     if(hspi->ErrorCode != HAL_SPI_ERROR_NONE)\r
1897     {\r
1898       HAL_SPI_ErrorCallback(hspi);\r
1899       return;\r
1900     }\r
1901   }\r
1902   HAL_SPI_TxCpltCallback(hspi);\r
1903 }\r
1904 \r
1905 /**\r
1906   * @brief DMA SPI receive process complete callback\r
1907   * @param  hdma: pointer to a DMA_HandleTypeDef structure that contains\r
1908   *               the configuration information for the specified DMA module.\r
1909   * @retval None\r
1910   */\r
1911 static void SPI_DMAReceiveCplt(DMA_HandleTypeDef *hdma)\r
1912 {\r
1913   __IO uint16_t tmpreg;\r
1914   SPI_HandleTypeDef* hspi = ( SPI_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;\r
1915   \r
1916   /* CRC handling */\r
1917   if(hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)\r
1918   {\r
1919     /* Wait until TXE flag */\r
1920     if(SPI_WaitFlagStateUntilTimeout(hspi, SPI_FLAG_RXNE, SPI_FLAG_RXNE, SPI_DEFAULT_TIMEOUT) != HAL_OK)\r
1921     {\r
1922       /* Erreur on the CRC reception */\r
1923       hspi->ErrorCode|= HAL_SPI_ERROR_CRC;      \r
1924     }\r
1925     if(hspi->Init.DataSize > SPI_DATASIZE_8BIT)\r
1926     {        \r
1927       tmpreg = hspi->Instance->DR;\r
1928       UNUSED(tmpreg); /* To avoid GCC warning */\r
1929     }\r
1930     else\r
1931     {\r
1932       tmpreg = *(__IO uint8_t *)&hspi->Instance->DR;\r
1933       UNUSED(tmpreg); /* To avoid GCC warning */\r
1934 \r
1935       if(hspi->Init.CRCLength == SPI_CRC_LENGTH_16BIT)\r
1936       {\r
1937         if(SPI_WaitFlagStateUntilTimeout(hspi, SPI_FLAG_RXNE, SPI_FLAG_RXNE, SPI_DEFAULT_TIMEOUT) != HAL_OK)\r
1938         {\r
1939           /* Erreur on the CRC reception */\r
1940           hspi->ErrorCode|= HAL_SPI_ERROR_CRC;      \r
1941         }\r
1942         tmpreg = *(__IO uint8_t *)&hspi->Instance->DR;\r
1943         UNUSED(tmpreg); /* To avoid GCC warning */\r
1944       }\r
1945     }  \r
1946   }\r
1947 \r
1948   /* Disable Rx DMA Request */\r
1949   hspi->Instance->CR2 &= (uint32_t)(~SPI_CR2_RXDMAEN);\r
1950   /* Disable Tx DMA Request (done by default to handle the case master rx direction 2 lines) */\r
1951   hspi->Instance->CR2 &= (uint32_t)(~SPI_CR2_TXDMAEN);\r
1952 \r
1953   /* Check the end of the transaction */\r
1954   SPI_EndRxTransaction(hspi,SPI_DEFAULT_TIMEOUT);\r
1955   \r
1956   hspi->RxXferCount = 0;\r
1957   hspi->State = HAL_SPI_STATE_READY;\r
1958   \r
1959   /* Check if CRC error occurred */\r
1960   if(__HAL_SPI_GET_FLAG(hspi, SPI_FLAG_CRCERR) != RESET)\r
1961   {\r
1962     hspi->ErrorCode|= HAL_SPI_ERROR_CRC;\r
1963     __HAL_SPI_CLEAR_CRCERRFLAG(hspi);\r
1964     HAL_SPI_RxCpltCallback(hspi);\r
1965   }\r
1966   else\r
1967   {\r
1968     if(hspi->ErrorCode == HAL_SPI_ERROR_NONE)\r
1969     {\r
1970       HAL_SPI_RxCpltCallback(hspi);\r
1971     }\r
1972     else\r
1973     {\r
1974       HAL_SPI_ErrorCallback(hspi); \r
1975     }\r
1976   }\r
1977 }\r
1978 \r
1979 /**\r
1980   * @brief DMA SPI transmit receive process complete callback\r
1981   * @param  hdma : pointer to a DMA_HandleTypeDef structure that contains\r
1982   *               the configuration information for the specified DMA module.\r
1983   * @retval None\r
1984   */\r
1985 static void SPI_DMATransmitReceiveCplt(DMA_HandleTypeDef *hdma)\r
1986 {\r
1987   __IO int16_t tmpreg;\r
1988   SPI_HandleTypeDef* hspi = ( SPI_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;\r
1989   \r
1990   /* CRC handling */\r
1991   if(hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)\r
1992   {\r
1993     if((hspi->Init.DataSize == SPI_DATASIZE_8BIT) && (hspi->Init.CRCLength == SPI_CRC_LENGTH_8BIT))\r
1994     {        \r
1995       if(SPI_WaitFifoStateUntilTimeout(hspi, SPI_FLAG_FRLVL, SPI_FRLVL_QUARTER_FULL, SPI_DEFAULT_TIMEOUT) != HAL_OK)\r
1996       {\r
1997         /* Error on the CRC reception */\r
1998         hspi->ErrorCode|= HAL_SPI_ERROR_CRC;      \r
1999       }\r
2000       tmpreg = *(__IO uint8_t *)&hspi->Instance->DR;\r
2001       UNUSED(tmpreg); /* To avoid GCC warning */\r
2002     }\r
2003     else\r
2004     {\r
2005       if(SPI_WaitFifoStateUntilTimeout(hspi, SPI_FLAG_FRLVL, SPI_FRLVL_HALF_FULL, SPI_DEFAULT_TIMEOUT) != HAL_OK)\r
2006       {\r
2007         /* Erreur on the CRC reception */\r
2008         hspi->ErrorCode|= HAL_SPI_ERROR_CRC;      \r
2009       }\r
2010       tmpreg = hspi->Instance->DR;\r
2011       UNUSED(tmpreg); /* To avoid GCC warning */\r
2012     }\r
2013   }  \r
2014   \r
2015   /* Check the end of the transaction */\r
2016   SPI_EndRxTxTransaction(hspi,SPI_DEFAULT_TIMEOUT);\r
2017   \r
2018   /* Disable Tx DMA Request */\r
2019   CLEAR_BIT(hspi->Instance->CR2, SPI_CR2_TXDMAEN);\r
2020   \r
2021   /* Disable Rx DMA Request */\r
2022   CLEAR_BIT(hspi->Instance->CR2, SPI_CR2_RXDMAEN);\r
2023    \r
2024   hspi->TxXferCount = 0;\r
2025   hspi->RxXferCount = 0;\r
2026   hspi->State = HAL_SPI_STATE_READY;\r
2027   \r
2028   /* Check if CRC error occurred */\r
2029   if(__HAL_SPI_GET_FLAG(hspi, SPI_FLAG_CRCERR) != RESET)\r
2030   {\r
2031     hspi->ErrorCode = HAL_SPI_ERROR_CRC;\r
2032     __HAL_SPI_CLEAR_CRCERRFLAG(hspi);\r
2033     HAL_SPI_ErrorCallback(hspi);\r
2034   }\r
2035   else\r
2036   {     \r
2037     if(hspi->ErrorCode == HAL_SPI_ERROR_NONE)\r
2038     {\r
2039       HAL_SPI_TxRxCpltCallback(hspi);\r
2040     }\r
2041     else\r
2042     {\r
2043       HAL_SPI_ErrorCallback(hspi);\r
2044     }\r
2045   }\r
2046 }\r
2047 \r
2048 /**\r
2049   * @brief DMA SPI half transmit process complete callback\r
2050   * @param  hdma : pointer to a DMA_HandleTypeDef structure that contains\r
2051   *               the configuration information for the specified DMA module.\r
2052   * @retval None\r
2053   */\r
2054 static void SPI_DMAHalfTransmitCplt(DMA_HandleTypeDef *hdma)\r
2055 {\r
2056   SPI_HandleTypeDef* hspi = ( SPI_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;\r
2057 \r
2058   HAL_SPI_TxHalfCpltCallback(hspi);\r
2059 }\r
2060 \r
2061 /**\r
2062   * @brief DMA SPI half receive process complete callback\r
2063   * @param  hdma: pointer to a DMA_HandleTypeDef structure that contains\r
2064   *               the configuration information for the specified DMA module.\r
2065   * @retval None\r
2066   */\r
2067 static void SPI_DMAHalfReceiveCplt(DMA_HandleTypeDef *hdma)\r
2068 {\r
2069   SPI_HandleTypeDef* hspi = ( SPI_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;\r
2070 \r
2071   HAL_SPI_RxHalfCpltCallback(hspi);\r
2072 }\r
2073 \r
2074 /**\r
2075   * @brief DMA SPI Half transmit receive process complete callback\r
2076   * @param  hdma : pointer to a DMA_HandleTypeDef structure that contains\r
2077   *               the configuration information for the specified DMA module.\r
2078   * @retval None\r
2079   */\r
2080 static void SPI_DMAHalfTransmitReceiveCplt(DMA_HandleTypeDef *hdma)\r
2081 {\r
2082   SPI_HandleTypeDef* hspi = ( SPI_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;\r
2083 \r
2084   HAL_SPI_TxRxHalfCpltCallback(hspi);\r
2085 }\r
2086 \r
2087 /**\r
2088   * @brief DMA SPI communication error callback\r
2089   * @param  hdma : pointer to a DMA_HandleTypeDef structure that contains\r
2090   *               the configuration information for the specified DMA module.\r
2091   * @retval None\r
2092   */\r
2093 static void SPI_DMAError(DMA_HandleTypeDef *hdma)\r
2094 {\r
2095   SPI_HandleTypeDef* hspi = ( SPI_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;\r
2096 \r
2097   /* Stop the disable DMA transfer on SPI side */\r
2098   CLEAR_BIT(hspi->Instance->CR2, SPI_CR2_TXDMAEN | SPI_CR2_RXDMAEN);\r
2099 \r
2100   hspi->ErrorCode|= HAL_SPI_ERROR_DMA;\r
2101   hspi->State = HAL_SPI_STATE_READY;\r
2102   HAL_SPI_ErrorCallback(hspi);\r
2103 }\r
2104 \r
2105 /**\r
2106   * @brief  Rx Handler for Transmit and Receive in Interrupt mode\r
2107   * @param  hspi: pointer to a SPI_HandleTypeDef structure that contains\r
2108   *               the configuration information for SPI module.\r
2109   * @retval None\r
2110   */\r
2111 static void SPI_2linesRxISR_8BIT(struct __SPI_HandleTypeDef *hspi)\r
2112 {\r
2113   /* Receive data in packing mode */\r
2114   if(hspi->RxXferCount > 1)\r
2115   {\r
2116     *((uint16_t*)hspi->pRxBuffPtr) = hspi->Instance->DR;\r
2117     hspi->pRxBuffPtr += sizeof(uint16_t);\r
2118     hspi->RxXferCount -= 2;\r
2119     if(hspi->RxXferCount == 1)\r
2120     {\r
2121       /* set fiforxthresold according the reception data length: 8bit */\r
2122       SET_BIT(hspi->Instance->CR2, SPI_RXFIFO_THRESHOLD);\r
2123     }\r
2124   }\r
2125   /* Receive data in 8 Bit mode */\r
2126   else\r
2127   {\r
2128     *hspi->pRxBuffPtr++ = *((__IO uint8_t *)&hspi->Instance->DR);\r
2129     hspi->RxXferCount--;\r
2130   }\r
2131   \r
2132   /* check end of the reception */\r
2133   if(hspi->RxXferCount == 0)\r
2134   {\r
2135     if(hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)\r
2136     {\r
2137       hspi->RxISR =  SPI_2linesRxISR_8BITCRC;\r
2138       return;\r
2139     }\r
2140         \r
2141     /* Disable RXNE interrupt */\r
2142     __HAL_SPI_DISABLE_IT(hspi, SPI_IT_RXNE);\r
2143 \r
2144     if(hspi->TxXferCount == 0)\r
2145     {\r
2146       SPI_CloseRxTx_ISR(hspi);\r
2147     }\r
2148   }\r
2149 }\r
2150 \r
2151 /**\r
2152   * @brief  Rx Handler for Transmit and Receive in Interrupt mode\r
2153   * @param  hspi: pointer to a SPI_HandleTypeDef structure that contains\r
2154   *               the configuration information for SPI module.\r
2155   * @retval None\r
2156   */\r
2157 static void SPI_2linesRxISR_8BITCRC(struct __SPI_HandleTypeDef *hspi)\r
2158 {\r
2159   __IO uint8_t tmpreg;\r
2160   \r
2161   tmpreg = *((__IO uint8_t *)&hspi->Instance->DR);\r
2162   UNUSED(tmpreg); /* To avoid GCC warning */\r
2163 \r
2164   hspi->CRCSize--;\r
2165   \r
2166   /* check end of the reception */\r
2167   if(hspi->CRCSize == 0)\r
2168   {\r
2169     /* Disable RXNE interrupt */\r
2170     __HAL_SPI_DISABLE_IT(hspi, SPI_IT_RXNE);\r
2171 \r
2172     if(hspi->TxXferCount == 0)\r
2173     {\r
2174       SPI_CloseRxTx_ISR(hspi);\r
2175     }\r
2176   }\r
2177 }\r
2178 \r
2179 /**\r
2180   * @brief  Tx Handler for Transmit and Receive in Interrupt mode\r
2181   * @param  hspi: pointer to a SPI_HandleTypeDef structure that contains\r
2182   *               the configuration information for SPI module.\r
2183   * @retval None\r
2184   */\r
2185 static void SPI_2linesTxISR_8BIT(struct __SPI_HandleTypeDef *hspi)\r
2186 {\r
2187   /* Transmit data in packing Bit mode */\r
2188   if(hspi->TxXferCount >= 2)\r
2189   {\r
2190     hspi->Instance->DR = *((uint16_t *)hspi->pTxBuffPtr);\r
2191     hspi->pTxBuffPtr += sizeof(uint16_t);\r
2192     hspi->TxXferCount -= 2;\r
2193   }\r
2194   /* Transmit data in 8 Bit mode */\r
2195   else\r
2196   {        \r
2197     *(__IO uint8_t *)&hspi->Instance->DR = (*hspi->pTxBuffPtr++);\r
2198     hspi->TxXferCount--;\r
2199   }\r
2200   \r
2201   /* check the end of the transmission */\r
2202   if(hspi->TxXferCount == 0)\r
2203   {\r
2204     if(hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)\r
2205     {\r
2206       hspi->Instance->CR1 |= SPI_CR1_CRCNEXT;\r
2207     }\r
2208     /* Disable TXE interrupt */\r
2209     __HAL_SPI_DISABLE_IT(hspi, SPI_IT_TXE);\r
2210     \r
2211     if(hspi->RxXferCount == 0)\r
2212     { \r
2213       SPI_CloseRxTx_ISR(hspi);\r
2214     }\r
2215   }\r
2216 }\r
2217 \r
2218 /**\r
2219   * @brief  Rx 16Bit Handler for Transmit and Receive in Interrupt mode\r
2220   * @param  hspi: pointer to a SPI_HandleTypeDef structure that contains\r
2221   *               the configuration information for SPI module.\r
2222   * @retval None\r
2223   */\r
2224 static void SPI_2linesRxISR_16BIT(struct __SPI_HandleTypeDef *hspi)\r
2225 {\r
2226   /* Receive data in 16 Bit mode */\r
2227   *((uint16_t*)hspi->pRxBuffPtr) = hspi->Instance->DR;\r
2228   hspi->pRxBuffPtr += sizeof(uint16_t);\r
2229   hspi->RxXferCount--;\r
2230 \r
2231   if(hspi->RxXferCount == 0)\r
2232   {\r
2233     if(hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)\r
2234     {\r
2235       hspi->RxISR =  SPI_2linesRxISR_16BITCRC;\r
2236       return;\r
2237     }\r
2238     \r
2239     /* Disable RXNE interrupt */\r
2240     __HAL_SPI_DISABLE_IT(hspi, SPI_IT_RXNE);\r
2241 \r
2242     if(hspi->TxXferCount == 0)\r
2243     {\r
2244       SPI_CloseRxTx_ISR(hspi);\r
2245     }\r
2246   }\r
2247 }\r
2248 \r
2249 /**\r
2250   * @brief  Manage the CRC 16bit receive for Transmit and Receive in Interrupt mode\r
2251   * @param  hspi: pointer to a SPI_HandleTypeDef structure that contains\r
2252   *               the configuration information for SPI module.\r
2253   * @retval None\r
2254   */\r
2255 static void SPI_2linesRxISR_16BITCRC(struct __SPI_HandleTypeDef *hspi)\r
2256 {\r
2257   /* Receive data in 16 Bit mode */\r
2258   __IO uint16_t tmpreg = hspi->Instance->DR;\r
2259   UNUSED(tmpreg); /* To avoid GCC warning */\r
2260 \r
2261   /* Disable RXNE interrupt */\r
2262   __HAL_SPI_DISABLE_IT(hspi, SPI_IT_RXNE);\r
2263 \r
2264   SPI_CloseRxTx_ISR(hspi);\r
2265 }\r
2266 \r
2267 /**\r
2268   * @brief  Tx Handler for Transmit and Receive in Interrupt mode\r
2269   * @param  hspi: pointer to a SPI_HandleTypeDef structure that contains\r
2270   *               the configuration information for SPI module.\r
2271   * @retval None\r
2272   */\r
2273 static void SPI_2linesTxISR_16BIT(struct __SPI_HandleTypeDef *hspi)\r
2274 {\r
2275   /* Transmit data in 16 Bit mode */\r
2276   hspi->Instance->DR = *((uint16_t *)hspi->pTxBuffPtr);\r
2277   hspi->pTxBuffPtr += sizeof(uint16_t);\r
2278   hspi->TxXferCount--;\r
2279   \r
2280   /* Enable CRC Transmission */\r
2281   if(hspi->TxXferCount == 0)\r
2282   {\r
2283     if(hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)\r
2284     {\r
2285       hspi->Instance->CR1 |= SPI_CR1_CRCNEXT;\r
2286     }\r
2287     /* Disable TXE interrupt */\r
2288     __HAL_SPI_DISABLE_IT(hspi, SPI_IT_TXE);\r
2289 \r
2290     if(hspi->RxXferCount == 0)\r
2291     {\r
2292       SPI_CloseRxTx_ISR(hspi);\r
2293     }\r
2294   }\r
2295 }\r
2296 \r
2297 /**\r
2298   * @brief  Manage the CRC receive in Interrupt context\r
2299   * @param  hspi: pointer to a SPI_HandleTypeDef structure that contains\r
2300   *               the configuration information for SPI module.\r
2301   * @retval None\r
2302   */\r
2303 static void SPI_RxISR_8BITCRC(struct __SPI_HandleTypeDef *hspi)\r
2304 {\r
2305   __IO uint8_t tmpreg;\r
2306   tmpreg = *((__IO uint8_t*)&hspi->Instance->DR);\r
2307   UNUSED(tmpreg); /* To avoid GCC warning */\r
2308 \r
2309   hspi->CRCSize--;\r
2310   \r
2311   if(hspi->CRCSize == 0)\r
2312   { \r
2313     SPI_CloseRx_ISR(hspi);\r
2314   }\r
2315 }\r
2316 \r
2317 /**\r
2318   * @brief  Manage the receive in Interrupt context\r
2319   * @param  hspi: pointer to a SPI_HandleTypeDef structure that contains\r
2320   *               the configuration information for SPI module.\r
2321   * @retval None\r
2322   */\r
2323 static void SPI_RxISR_8BIT(struct __SPI_HandleTypeDef *hspi)\r
2324 {\r
2325   *hspi->pRxBuffPtr++ = (*(__IO uint8_t *)&hspi->Instance->DR);\r
2326   hspi->RxXferCount--;\r
2327 \r
2328   /* Enable CRC Transmission */\r
2329   if((hspi->RxXferCount == 1) && (hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE))\r
2330   {\r
2331     hspi->Instance->CR1 |= SPI_CR1_CRCNEXT;\r
2332   }\r
2333 \r
2334   if(hspi->RxXferCount == 0)\r
2335   {\r
2336     if(hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)\r
2337     {\r
2338       hspi->RxISR =  SPI_RxISR_8BITCRC;\r
2339       return;\r
2340     }\r
2341     SPI_CloseRx_ISR(hspi);\r
2342   }\r
2343 }\r
2344 \r
2345 /**\r
2346   * @brief  Manage the CRC 16bit receive in Interrupt context\r
2347   * @param  hspi: pointer to a SPI_HandleTypeDef structure that contains\r
2348   *               the configuration information for SPI module.\r
2349   * @retval None\r
2350   */\r
2351 static void SPI_RxISR_16BITCRC(struct __SPI_HandleTypeDef *hspi)\r
2352 {\r
2353   __IO uint16_t tmpreg;\r
2354   \r
2355   tmpreg = hspi->Instance->DR;\r
2356   UNUSED(tmpreg); /* To avoid GCC warning */\r
2357 \r
2358   /* Disable RXNE and ERR interrupt */\r
2359   __HAL_SPI_DISABLE_IT(hspi, (SPI_IT_RXNE | SPI_IT_ERR));\r
2360   \r
2361   SPI_CloseRx_ISR(hspi);\r
2362 }\r
2363 \r
2364 /**\r
2365   * @brief  Manage the 16Bit receive in Interrupt context\r
2366   * @param  hspi: pointer to a SPI_HandleTypeDef structure that contains\r
2367   *               the configuration information for SPI module.\r
2368   * @retval None\r
2369   */\r
2370 static void SPI_RxISR_16BIT(struct __SPI_HandleTypeDef *hspi)\r
2371 {\r
2372   *((uint16_t *)hspi->pRxBuffPtr) = hspi->Instance->DR;\r
2373   hspi->pRxBuffPtr += sizeof(uint16_t);\r
2374   hspi->RxXferCount--;\r
2375   \r
2376   /* Enable CRC Transmission */\r
2377   if((hspi->RxXferCount == 1) && (hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE))\r
2378   {\r
2379     hspi->Instance->CR1 |= SPI_CR1_CRCNEXT;\r
2380   }\r
2381   \r
2382   if(hspi->RxXferCount == 0)\r
2383   {    \r
2384     if(hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)\r
2385     {\r
2386       hspi->RxISR = SPI_RxISR_16BITCRC;\r
2387       return;\r
2388     }\r
2389     SPI_CloseRx_ISR(hspi);\r
2390   }\r
2391 }\r
2392 \r
2393 /**\r
2394   * @brief  Handle the data 8Bit transmit in Interrupt mode\r
2395   * @param  hspi: pointer to a SPI_HandleTypeDef structure that contains\r
2396   *               the configuration information for SPI module.\r
2397   * @retval None\r
2398   */\r
2399 static void SPI_TxISR_8BIT(struct __SPI_HandleTypeDef *hspi)\r
2400 {\r
2401   *(__IO uint8_t *)&hspi->Instance->DR = (*hspi->pTxBuffPtr++);\r
2402   hspi->TxXferCount--;\r
2403   \r
2404   if(hspi->TxXferCount == 0)\r
2405   {\r
2406     if(hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)\r
2407     {\r
2408       /* Enable CRC Transmission */\r
2409       hspi->Instance->CR1 |= SPI_CR1_CRCNEXT;\r
2410     }\r
2411     SPI_CloseTx_ISR(hspi);\r
2412   }\r
2413 }\r
2414 \r
2415 /**\r
2416   * @brief  Handle the data 16Bit transmit in Interrupt mode\r
2417   * @param  hspi: pointer to a SPI_HandleTypeDef structure that contains\r
2418   *               the configuration information for SPI module.\r
2419   * @retval None\r
2420   */\r
2421 static void SPI_TxISR_16BIT(struct __SPI_HandleTypeDef *hspi)\r
2422 { \r
2423   /* Transmit data in 16 Bit mode */\r
2424   hspi->Instance->DR = *((uint16_t *)hspi->pTxBuffPtr);\r
2425   hspi->pTxBuffPtr += sizeof(uint16_t);\r
2426   hspi->TxXferCount--;\r
2427   \r
2428   if(hspi->TxXferCount == 0)\r
2429   {\r
2430     if(hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)\r
2431     {\r
2432       /* Enable CRC Transmission */\r
2433       hspi->Instance->CR1 |= SPI_CR1_CRCNEXT;\r
2434     }\r
2435     SPI_CloseTx_ISR(hspi);\r
2436   }\r
2437 }\r
2438 \r
2439 /**\r
2440   * @brief This function handles SPI Communication Timeout.\r
2441   * @param  hspi: pointer to a SPI_HandleTypeDef structure that contains\r
2442   *               the configuration information for SPI module.\r
2443   * @param Flag : SPI flag to check\r
2444   * @param State : flag state to check\r
2445   * @param Timeout : Timeout duration\r
2446   * @retval HAL status\r
2447   */\r
2448 static HAL_StatusTypeDef SPI_WaitFlagStateUntilTimeout(SPI_HandleTypeDef *hspi, uint32_t Flag, uint32_t State, uint32_t Timeout)\r
2449 {\r
2450   uint32_t tickstart = HAL_GetTick();\r
2451 \r
2452   while((hspi->Instance->SR & Flag) != State)\r
2453   {\r
2454     if(Timeout != HAL_MAX_DELAY)\r
2455     {\r
2456       if((Timeout == 0) || ((HAL_GetTick()-tickstart) >= Timeout))\r
2457       {\r
2458         /* Disable the SPI and reset the CRC: the CRC value should be cleared\r
2459         on both master and slave sides in order to resynchronize the master\r
2460         and slave for their respective CRC calculation */\r
2461 \r
2462         /* Disable TXE, RXNE and ERR interrupts for the interrupt process */\r
2463         __HAL_SPI_DISABLE_IT(hspi, (SPI_IT_TXE | SPI_IT_RXNE | SPI_IT_ERR));\r
2464 \r
2465         if((hspi->Init.Mode == SPI_MODE_MASTER)&&((hspi->Init.Direction == SPI_DIRECTION_1LINE)||(hspi->Init.Direction == SPI_DIRECTION_2LINES_RXONLY)))\r
2466         {\r
2467           /* Disable SPI peripheral */\r
2468           __HAL_SPI_DISABLE(hspi);\r
2469         }\r
2470 \r
2471         /* Reset CRC Calculation */\r
2472         if(hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)\r
2473         {\r
2474           SPI_RESET_CRC(hspi);\r
2475         }\r
2476         \r
2477         hspi->State= HAL_SPI_STATE_READY;\r
2478         \r
2479         /* Process Unlocked */\r
2480         __HAL_UNLOCK(hspi);\r
2481         \r
2482         return HAL_TIMEOUT;\r
2483       }\r
2484     }\r
2485   }\r
2486   \r
2487   return HAL_OK;      \r
2488 }\r
2489 \r
2490 /**\r
2491   * @brief This function handles SPI Communication Timeout.\r
2492   * @param  hspi: pointer to a SPI_HandleTypeDef structure that contains\r
2493   *               the configuration information for SPI module.\r
2494   * @param Fifo : Fifo to check\r
2495   * @param State : Fifo state to check\r
2496   * @param Timeout : Timeout duration\r
2497   * @retval HAL status\r
2498   */\r
2499 static HAL_StatusTypeDef SPI_WaitFifoStateUntilTimeout(SPI_HandleTypeDef *hspi, uint32_t Fifo, uint32_t State, uint32_t Timeout)\r
2500 {\r
2501   __IO uint8_t tmpreg;\r
2502   uint32_t tickstart = HAL_GetTick();\r
2503 \r
2504   while((hspi->Instance->SR & Fifo) != State)\r
2505   {\r
2506     if((Fifo == SPI_SR_FRLVL) && (State == SPI_FRLVL_EMPTY))\r
2507     {\r
2508       tmpreg = *((__IO uint8_t*)&hspi->Instance->DR);\r
2509       UNUSED(tmpreg); /* To avoid GCC warning */\r
2510     }\r
2511 \r
2512     if(Timeout != HAL_MAX_DELAY)\r
2513     {\r
2514       if((Timeout == 0) || ((HAL_GetTick()-tickstart) >= Timeout))\r
2515       {\r
2516         /* Disable the SPI and reset the CRC: the CRC value should be cleared\r
2517                   on both master and slave sides in order to resynchronize the master\r
2518                  and slave for their respective CRC calculation */\r
2519 \r
2520         /* Disable TXE, RXNE and ERR interrupts for the interrupt process */\r
2521         __HAL_SPI_DISABLE_IT(hspi, (SPI_IT_TXE | SPI_IT_RXNE | SPI_IT_ERR));\r
2522 \r
2523         if((hspi->Init.Mode == SPI_MODE_MASTER)&&((hspi->Init.Direction == SPI_DIRECTION_1LINE)||(hspi->Init.Direction == SPI_DIRECTION_2LINES_RXONLY)))\r
2524         {\r
2525           /* Disable SPI peripheral */\r
2526           __HAL_SPI_DISABLE(hspi);\r
2527         }\r
2528 \r
2529         /* Reset CRC Calculation */\r
2530         if(hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)\r
2531         {\r
2532           SPI_RESET_CRC(hspi);\r
2533         }\r
2534 \r
2535         hspi->State = HAL_SPI_STATE_READY;\r
2536 \r
2537         /* Process Unlocked */\r
2538         __HAL_UNLOCK(hspi);\r
2539 \r
2540         return HAL_TIMEOUT;\r
2541       }\r
2542     }\r
2543   }\r
2544 \r
2545   return HAL_OK;\r
2546 }\r
2547 \r
2548 /**\r
2549   * @brief This function handles the check of the RX transaction complete.\r
2550   * @param  hspi: pointer to a SPI_HandleTypeDef structure that contains\r
2551   *               the configuration information for SPI module.\r
2552   * @param Timeout : Timeout duration\r
2553   * @retval None\r
2554   */\r
2555 static HAL_StatusTypeDef SPI_EndRxTransaction(SPI_HandleTypeDef *hspi,  uint32_t Timeout)\r
2556 {\r
2557   if((hspi->Init.Mode == SPI_MODE_MASTER)&&((hspi->Init.Direction == SPI_DIRECTION_1LINE)||(hspi->Init.Direction == SPI_DIRECTION_2LINES_RXONLY)))\r
2558   {\r
2559     /* Disable SPI peripheral */\r
2560     __HAL_SPI_DISABLE(hspi);\r
2561   }\r
2562   if(SPI_WaitFlagStateUntilTimeout(hspi, SPI_FLAG_BSY, RESET, Timeout) != HAL_OK)\r
2563   {  \r
2564     hspi->ErrorCode |= HAL_SPI_ERROR_FLAG;\r
2565     return HAL_TIMEOUT;\r
2566   }\r
2567   if(SPI_WaitFifoStateUntilTimeout(hspi, SPI_FLAG_FRLVL, SPI_FRLVL_EMPTY, Timeout) != HAL_OK) \r
2568   {\r
2569     hspi->ErrorCode |= HAL_SPI_ERROR_FLAG;\r
2570     return HAL_TIMEOUT;\r
2571   }\r
2572   \r
2573   return HAL_OK;\r
2574 }\r
2575   \r
2576 /**\r
2577   * @brief This function handles the check of the RXTX or TX transaction complete.\r
2578   * @param hspi: SPI handle\r
2579   * @param Timeout : Timeout duration\r
2580   */\r
2581 static HAL_StatusTypeDef SPI_EndRxTxTransaction(SPI_HandleTypeDef *hspi, uint32_t Timeout)\r
2582 {\r
2583   /* Procedure to check the transaction complete */\r
2584   if(SPI_WaitFifoStateUntilTimeout(hspi, SPI_FLAG_FTLVL, SPI_FTLVL_EMPTY, Timeout) != HAL_OK)\r
2585   {\r
2586     hspi->ErrorCode |= HAL_SPI_ERROR_FLAG;\r
2587     return HAL_TIMEOUT;\r
2588   }\r
2589   if(SPI_WaitFlagStateUntilTimeout(hspi, SPI_FLAG_BSY, RESET, Timeout) != HAL_OK)\r
2590   {\r
2591     hspi->ErrorCode |= HAL_SPI_ERROR_FLAG;\r
2592     return HAL_TIMEOUT;\r
2593   }\r
2594   if(SPI_WaitFifoStateUntilTimeout(hspi, SPI_FLAG_FRLVL, SPI_FRLVL_EMPTY, Timeout) != HAL_OK)\r
2595   {\r
2596     hspi->ErrorCode |= HAL_SPI_ERROR_FLAG;\r
2597     return HAL_TIMEOUT;\r
2598   }\r
2599   return HAL_OK;\r
2600 }\r
2601 \r
2602 /**\r
2603   * @brief This function handles the close of the RXTX transaction.\r
2604   * @param  hspi: pointer to a SPI_HandleTypeDef structure that contains\r
2605   *               the configuration information for SPI module.\r
2606   * @retval None\r
2607   */\r
2608 static void SPI_CloseRxTx_ISR(SPI_HandleTypeDef *hspi)\r
2609 {\r
2610   /* Disable ERR interrupt */\r
2611   __HAL_SPI_DISABLE_IT(hspi, SPI_IT_ERR);\r
2612 \r
2613   /* Check if CRC error occurred */\r
2614   if(__HAL_SPI_GET_FLAG(hspi, SPI_FLAG_CRCERR) != RESET)\r
2615   {\r
2616     hspi->State = HAL_SPI_STATE_READY;\r
2617     hspi->ErrorCode|= HAL_SPI_ERROR_CRC;\r
2618     __HAL_SPI_CLEAR_CRCERRFLAG(hspi);\r
2619     HAL_SPI_ErrorCallback(hspi);\r
2620   }\r
2621   else\r
2622   {\r
2623     if(hspi->ErrorCode == HAL_SPI_ERROR_NONE)\r
2624     {\r
2625       if(hspi->State == HAL_SPI_STATE_BUSY_RX)\r
2626       {\r
2627         hspi->State = HAL_SPI_STATE_READY;\r
2628         HAL_SPI_RxCpltCallback(hspi);\r
2629       }\r
2630       else\r
2631       {\r
2632         hspi->State = HAL_SPI_STATE_READY;\r
2633         HAL_SPI_TxRxCpltCallback(hspi);\r
2634       }      \r
2635     }\r
2636     else\r
2637     {\r
2638       hspi->State = HAL_SPI_STATE_READY;\r
2639       HAL_SPI_ErrorCallback(hspi);\r
2640     }\r
2641   }\r
2642 }\r
2643 \r
2644 /**\r
2645   * @brief This function handles the close of the RX transaction.\r
2646   * @param  hspi: pointer to a SPI_HandleTypeDef structure that contains\r
2647   *               the configuration information for SPI module.\r
2648   * @retval None\r
2649   */\r
2650 static void SPI_CloseRx_ISR(SPI_HandleTypeDef *hspi)\r
2651 {\r
2652     /* Disable RXNE and ERR interrupt */\r
2653     __HAL_SPI_DISABLE_IT(hspi, (SPI_IT_RXNE | SPI_IT_ERR));\r
2654     \r
2655     /* Check the end of the transaction */\r
2656     SPI_EndRxTransaction(hspi,SPI_DEFAULT_TIMEOUT);\r
2657 \r
2658     hspi->State = HAL_SPI_STATE_READY;\r
2659 \r
2660     /* Check if CRC error occurred */\r
2661     if(__HAL_SPI_GET_FLAG(hspi, SPI_FLAG_CRCERR) != RESET)\r
2662     {\r
2663       hspi->ErrorCode|= HAL_SPI_ERROR_CRC;\r
2664       __HAL_SPI_CLEAR_CRCERRFLAG(hspi);\r
2665       HAL_SPI_ErrorCallback(hspi);\r
2666     }\r
2667     else\r
2668     {\r
2669       if(hspi->ErrorCode == HAL_SPI_ERROR_NONE)\r
2670       {\r
2671         HAL_SPI_RxCpltCallback(hspi);\r
2672       }\r
2673       else\r
2674       {\r
2675         HAL_SPI_ErrorCallback(hspi);\r
2676       }\r
2677     }\r
2678 }\r
2679 \r
2680 /**\r
2681   * @brief This function handles the close of the TX transaction.\r
2682   * @param  hspi: pointer to a SPI_HandleTypeDef structure that contains\r
2683   *               the configuration information for SPI module.\r
2684   * @retval None\r
2685   */\r
2686 static void SPI_CloseTx_ISR(SPI_HandleTypeDef *hspi)\r
2687 {\r
2688   /* Disable TXE and ERR interrupt */\r
2689   __HAL_SPI_DISABLE_IT(hspi, (SPI_IT_TXE | SPI_IT_ERR));\r
2690 \r
2691   /* Clear OVERUN flag in 2 Lines communication mode because received is not read */\r
2692   if(hspi->Init.Direction == SPI_DIRECTION_2LINES)\r
2693   {\r
2694     __HAL_SPI_CLEAR_OVRFLAG(hspi);\r
2695   }\r
2696 \r
2697   hspi->State = HAL_SPI_STATE_READY;\r
2698   if(hspi->ErrorCode != HAL_SPI_ERROR_NONE)\r
2699   {\r
2700     HAL_SPI_ErrorCallback(hspi);\r
2701   }\r
2702   else\r
2703   {\r
2704     HAL_SPI_TxCpltCallback(hspi);\r
2705   }\r
2706 }\r
2707 \r
2708 /**\r
2709   * @}\r
2710   */\r
2711 \r
2712 #endif /* HAL_SPI_MODULE_ENABLED */\r
2713 /**\r
2714   * @}\r
2715   */\r
2716 \r
2717 /**\r
2718   * @}\r
2719   */\r
2720 \r
2721 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/\r