git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/CORTEX_MPU_STM32L4_Discovery_GCC_IAR_Keil/ST_Code/Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_spi.c

   1 /**\r
   2   ******************************************************************************\r
   3   * @file    stm32l4xx_hal_spi.c\r
   4   * @author  MCD Application Team\r
   5   * @brief   SPI HAL module driver.\r
   6   *          This file provides firmware functions to manage the following\r
   7   *          functionalities of the Serial Peripheral Interface (SPI) peripheral:\r
   8   *           + Initialization and de-initialization functions\r
   9   *           + IO operation functions\r
  10   *           + Peripheral Control functions\r
  11   *           + Peripheral State functions\r
  12   *\r
  13   @verbatim\r
  14   ==============================================================================\r
  15                         ##### How to use this driver #####\r
  16   ==============================================================================\r
  17     [..]\r
  18       The SPI HAL driver can be used as follows:\r
  19 \r
  20       (#) Declare a SPI_HandleTypeDef handle structure, for example:\r
  21           SPI_HandleTypeDef  hspi;\r
  22 \r
  23       (#)Initialize the SPI low level resources by implementing the HAL_SPI_MspInit() API:\r
  24           (##) Enable the SPIx interface clock\r
  25           (##) SPI pins configuration\r
  26               (+++) Enable the clock for the SPI GPIOs\r
  27               (+++) Configure these SPI pins as alternate function push-pull\r
  28           (##) NVIC configuration if you need to use interrupt process\r
  29               (+++) Configure the SPIx interrupt priority\r
  30               (+++) Enable the NVIC SPI IRQ handle\r
  31           (##) DMA Configuration if you need to use DMA process\r
  32               (+++) Declare a DMA_HandleTypeDef handle structure for the transmit or receive Stream/Channel\r
  33               (+++) Enable the DMAx clock\r
  34               (+++) Configure the DMA handle parameters\r
  35               (+++) Configure the DMA Tx or Rx Stream/Channel\r
  36               (+++) Associate the initialized hdma_tx(or _rx)  handle to the hspi DMA Tx or Rx handle\r
  37               (+++) Configure the priority and enable the NVIC for the transfer complete interrupt on the DMA Tx or Rx Stream/Channel\r
  38 \r
  39       (#) Program the Mode, BidirectionalMode , Data size, Baudrate Prescaler, NSS\r
  40           management, Clock polarity and phase, FirstBit and CRC configuration in the hspi Init structure.\r
  41 \r
  42       (#) Initialize the SPI registers by calling the HAL_SPI_Init() API:\r
  43           (++) This API configures also the low level Hardware GPIO, CLOCK, CORTEX...etc)\r
  44               by calling the customized HAL_SPI_MspInit() API.\r
  45      [..]\r
  46        Circular mode restriction:\r
  47       (#) The DMA circular mode cannot be used when the SPI is configured in these modes:\r
  48           (##) Master 2Lines RxOnly\r
  49           (##) Master 1Line Rx\r
  50       (#) The CRC feature is not managed when the DMA circular mode is enabled\r
  51       (#) When the SPI DMA Pause/Stop features are used, we must use the following APIs\r
  52           the HAL_SPI_DMAPause()/ HAL_SPI_DMAStop() only under the SPI callbacks\r
  53      [..]\r
  54        Master Receive mode restriction:\r
  55       (#) In Master unidirectional receive-only mode (MSTR =1, BIDIMODE=0, RXONLY=1) or\r
  56           bidirectional receive mode (MSTR=1, BIDIMODE=1, BIDIOE=0), to ensure that the SPI\r
  57           does not initiate a new transfer the following procedure has to be respected:\r
  58           (##) HAL_SPI_DeInit()\r
  59           (##) HAL_SPI_Init()\r
  60      [..]\r
  61        Callback registration:\r
  62 \r
  63       (#) The compilation flag USE_HAL_SPI_REGISTER_CALLBACKS when set to 1U\r
  64           allows the user to configure dynamically the driver callbacks.\r
  65           Use Functions HAL_SPI_RegisterCallback() to register an interrupt callback.\r
  66 \r
  67           Function HAL_SPI_RegisterCallback() allows to register following callbacks:\r
  68             (+) TxCpltCallback        : SPI Tx Completed callback\r
  69             (+) RxCpltCallback        : SPI Rx Completed callback\r
  70             (+) TxRxCpltCallback      : SPI TxRx Completed callback\r
  71             (+) TxHalfCpltCallback    : SPI Tx Half Completed callback\r
  72             (+) RxHalfCpltCallback    : SPI Rx Half Completed callback\r
  73             (+) TxRxHalfCpltCallback  : SPI TxRx Half Completed callback\r
  74             (+) ErrorCallback         : SPI Error callback\r
  75             (+) AbortCpltCallback     : SPI Abort callback\r
  76             (+) MspInitCallback       : SPI Msp Init callback\r
  77             (+) MspDeInitCallback     : SPI Msp DeInit callback\r
  78           This function takes as parameters the HAL peripheral handle, the Callback ID\r
  79           and a pointer to the user callback function.\r
  80 \r
  81 \r
  82       (#) Use function HAL_SPI_UnRegisterCallback to reset a callback to the default\r
  83           weak function.\r
  84           HAL_SPI_UnRegisterCallback takes as parameters the HAL peripheral handle,\r
  85           and the Callback ID.\r
  86           This function allows to reset following callbacks:\r
  87             (+) TxCpltCallback        : SPI Tx Completed callback\r
  88             (+) RxCpltCallback        : SPI Rx Completed callback\r
  89             (+) TxRxCpltCallback      : SPI TxRx Completed callback\r
  90             (+) TxHalfCpltCallback    : SPI Tx Half Completed callback\r
  91             (+) RxHalfCpltCallback    : SPI Rx Half Completed callback\r
  92             (+) TxRxHalfCpltCallback  : SPI TxRx Half Completed callback\r
  93             (+) ErrorCallback         : SPI Error callback\r
  94             (+) AbortCpltCallback     : SPI Abort callback\r
  95             (+) MspInitCallback       : SPI Msp Init callback\r
  96             (+) MspDeInitCallback     : SPI Msp DeInit callback\r
  97 \r
  98        By default, after the HAL_SPI_Init() and when the state is HAL_SPI_STATE_RESET\r
  99        all callbacks are set to the corresponding weak functions:\r
 100        examples HAL_SPI_MasterTxCpltCallback(), HAL_SPI_MasterRxCpltCallback().\r
 101        Exception done for MspInit and MspDeInit functions that are\r
 102        reset to the legacy weak functions in the HAL_SPI_Init()/ HAL_SPI_DeInit() only when\r
 103        these callbacks are null (not registered beforehand).\r
 104        If MspInit or MspDeInit are not null, the HAL_SPI_Init()/ HAL_SPI_DeInit()\r
 105        keep and use the user MspInit/MspDeInit callbacks (registered beforehand) whatever the state.\r
 106 \r
 107        Callbacks can be registered/unregistered in HAL_SPI_STATE_READY state only.\r
 108        Exception done MspInit/MspDeInit functions that can be registered/unregistered\r
 109        in HAL_SPI_STATE_READY or HAL_SPI_STATE_RESET state,\r
 110        thus registered (user) MspInit/DeInit callbacks can be used during the Init/DeInit.\r
 111        Then, the user first registers the MspInit/MspDeInit user callbacks\r
 112        using HAL_SPI_RegisterCallback() before calling HAL_SPI_DeInit()\r
 113        or HAL_SPI_Init() function.\r
 114 \r
 115        When The compilation define USE_HAL_PPP_REGISTER_CALLBACKS is set to 0 or\r
 116        not defined, the callback registering feature is not available\r
 117        and weak (surcharged) callbacks are used.\r
 118 \r
 119      [..]\r
 120        Using the HAL it is not possible to reach all supported SPI frequency with the different SPI Modes,\r
 121        the following table resume the max SPI frequency reached with data size 8bits/16bits,\r
 122          according to frequency of the APBx Peripheral Clock (fPCLK) used by the SPI instance.\r
 123 \r
 124   @endverbatim\r
 125 \r
 126   Additional table :\r
 127 \r
 128        DataSize = SPI_DATASIZE_8BIT:\r
 129        +----------------------------------------------------------------------------------------------+\r
 130        |         |                | 2Lines Fullduplex   |     2Lines RxOnly    |         1Line        |\r
 131        | Process | Tranfert mode  |---------------------|----------------------|----------------------|\r
 132        |         |                |  Master  |  Slave   |  Master   |  Slave   |  Master   |  Slave   |\r
 133        |==============================================================================================|\r
 134        |    T    |     Polling    | Fpclk/4  | Fpclk/8  |    NA     |    NA    |    NA     |   NA     |\r
 135        |    X    |----------------|----------|----------|-----------|----------|-----------|----------|\r
 136        |    /    |     Interrupt  | Fpclk/4  | Fpclk/16 |    NA     |    NA    |    NA     |   NA     |\r
 137        |    R    |----------------|----------|----------|-----------|----------|-----------|----------|\r
 138        |    X    |       DMA      | Fpclk/2  | Fpclk/2  |    NA     |    NA    |    NA     |   NA     |\r
 139        |=========|================|==========|==========|===========|==========|===========|==========|\r
 140        |         |     Polling    | Fpclk/4  | Fpclk/8  | Fpclk/16  | Fpclk/8  | Fpclk/8   | Fpclk/8  |\r
 141        |         |----------------|----------|----------|-----------|----------|-----------|----------|\r
 142        |    R    |     Interrupt  | Fpclk/8  | Fpclk/16 | Fpclk/8   | Fpclk/8  | Fpclk/8   | Fpclk/4  |\r
 143        |    X    |----------------|----------|----------|-----------|----------|-----------|----------|\r
 144        |         |       DMA      | Fpclk/4  | Fpclk/2  | Fpclk/2   | Fpclk/16 | Fpclk/2   | Fpclk/16 |\r
 145        |=========|================|==========|==========|===========|==========|===========|==========|\r
 146        |         |     Polling    | Fpclk/8  | Fpclk/2  |     NA    |    NA    | Fpclk/8   | Fpclk/8  |\r
 147        |         |----------------|----------|----------|-----------|----------|-----------|----------|\r
 148        |    T    |     Interrupt  | Fpclk/2  | Fpclk/4  |     NA    |    NA    | Fpclk/16  | Fpclk/8  |\r
 149        |    X    |----------------|----------|----------|-----------|----------|-----------|----------|\r
 150        |         |       DMA      | Fpclk/2  | Fpclk/2  |     NA    |    NA    | Fpclk/8   | Fpclk/16 |\r
 151        +----------------------------------------------------------------------------------------------+\r
 152 \r
 153        DataSize = SPI_DATASIZE_16BIT:\r
 154        +----------------------------------------------------------------------------------------------+\r
 155        |         |                | 2Lines Fullduplex   |     2Lines RxOnly    |         1Line        |\r
 156        | Process | Tranfert mode  |---------------------|----------------------|----------------------|\r
 157        |         |                |  Master  |  Slave   |  Master   |  Slave   |  Master   |  Slave   |\r
 158        |==============================================================================================|\r
 159        |    T    |     Polling    | Fpclk/4  | Fpclk/8  |    NA     |    NA    |    NA     |   NA     |\r
 160        |    X    |----------------|----------|----------|-----------|----------|-----------|----------|\r
 161        |    /    |     Interrupt  | Fpclk/4  | Fpclk/16 |    NA     |    NA    |    NA     |   NA     |\r
 162        |    R    |----------------|----------|----------|-----------|----------|-----------|----------|\r
 163        |    X    |       DMA      | Fpclk/2  | Fpclk/2  |    NA     |    NA    |    NA     |   NA     |\r
 164        |=========|================|==========|==========|===========|==========|===========|==========|\r
 165        |         |     Polling    | Fpclk/4  | Fpclk/8  | Fpclk/16  | Fpclk/8  | Fpclk/8   | Fpclk/8  |\r
 166        |         |----------------|----------|----------|-----------|----------|-----------|----------|\r
 167        |    R    |     Interrupt  | Fpclk/8  | Fpclk/16 | Fpclk/8   | Fpclk/8  | Fpclk/8   | Fpclk/4  |\r
 168        |    X    |----------------|----------|----------|-----------|----------|-----------|----------|\r
 169        |         |       DMA      | Fpclk/4  | Fpclk/2  | Fpclk/2   | Fpclk/16 | Fpclk/2   | Fpclk/16 |\r
 170        |=========|================|==========|==========|===========|==========|===========|==========|\r
 171        |         |     Polling    | Fpclk/8  | Fpclk/2  |     NA    |    NA    | Fpclk/8   | Fpclk/8  |\r
 172        |         |----------------|----------|----------|-----------|----------|-----------|----------|\r
 173        |    T    |     Interrupt  | Fpclk/2  | Fpclk/4  |     NA    |    NA    | Fpclk/16  | Fpclk/8  |\r
 174        |    X    |----------------|----------|----------|-----------|----------|-----------|----------|\r
 175        |         |       DMA      | Fpclk/2  | Fpclk/2  |     NA    |    NA    | Fpclk/8   | Fpclk/16 |\r
 176        +----------------------------------------------------------------------------------------------+\r
 177        @note The max SPI frequency depend on SPI data size (4bits, 5bits,..., 8bits,...15bits, 16bits),\r
 178              SPI mode(2 Lines fullduplex, 2 lines RxOnly, 1 line TX/RX) and Process mode (Polling, IT, DMA).\r
 179        @note\r
 180             (#) TX/RX processes are HAL_SPI_TransmitReceive(), HAL_SPI_TransmitReceive_IT() and HAL_SPI_TransmitReceive_DMA()\r
 181             (#) RX processes are HAL_SPI_Receive(), HAL_SPI_Receive_IT() and HAL_SPI_Receive_DMA()\r
 182             (#) TX processes are HAL_SPI_Transmit(), HAL_SPI_Transmit_IT() and HAL_SPI_Transmit_DMA()\r
 183 \r
 184   ******************************************************************************\r
 185   * @attention\r
 186   *\r
 187   * <h2><center>&copy; Copyright (c) 2017 STMicroelectronics.\r
 188   * All rights reserved.</center></h2>\r
 189   *\r
 190   * This software component is licensed by ST under BSD 3-Clause license,\r
 191   * the "License"; You may not use this file except in compliance with the\r
 192   * License. You may obtain a copy of the License at:\r
 193   *                        opensource.org/licenses/BSD-3-Clause\r
 194   *\r
 195   ******************************************************************************\r
 196   */\r
 197 \r
 198 /* Includes ------------------------------------------------------------------*/\r
 199 #include "stm32l4xx_hal.h"\r
 200 \r
 201 /** @addtogroup STM32L4xx_HAL_Driver\r
 202   * @{\r
 203   */\r
 204 \r
 205 /** @defgroup SPI SPI\r
 206   * @brief SPI HAL module driver\r
 207   * @{\r
 208   */\r
 209 #ifdef HAL_SPI_MODULE_ENABLED\r
 210 \r
 211 /* Private typedef -----------------------------------------------------------*/\r
 212 /* Private defines -----------------------------------------------------------*/\r
 213 /** @defgroup SPI_Private_Constants SPI Private Constants\r
 214   * @{\r
 215   */\r
 216 #define SPI_DEFAULT_TIMEOUT 100U\r
 217 /**\r
 218   * @}\r
 219   */\r
 220 \r
 221 /* Private macros ------------------------------------------------------------*/\r
 222 /* Private variables ---------------------------------------------------------*/\r
 223 /* Private function prototypes -----------------------------------------------*/\r
 224 /** @defgroup SPI_Private_Functions SPI Private Functions\r
 225   * @{\r
 226   */\r
 227 static void SPI_DMATransmitCplt(DMA_HandleTypeDef *hdma);\r
 228 static void SPI_DMAReceiveCplt(DMA_HandleTypeDef *hdma);\r
 229 static void SPI_DMATransmitReceiveCplt(DMA_HandleTypeDef *hdma);\r
 230 static void SPI_DMAHalfTransmitCplt(DMA_HandleTypeDef *hdma);\r
 231 static void SPI_DMAHalfReceiveCplt(DMA_HandleTypeDef *hdma);\r
 232 static void SPI_DMAHalfTransmitReceiveCplt(DMA_HandleTypeDef *hdma);\r
 233 static void SPI_DMAError(DMA_HandleTypeDef *hdma);\r
 234 static void SPI_DMAAbortOnError(DMA_HandleTypeDef *hdma);\r
 235 static void SPI_DMATxAbortCallback(DMA_HandleTypeDef *hdma);\r
 236 static void SPI_DMARxAbortCallback(DMA_HandleTypeDef *hdma);\r
 237 static HAL_StatusTypeDef SPI_WaitFlagStateUntilTimeout(SPI_HandleTypeDef *hspi, uint32_t Flag, FlagStatus State,\r
 238                                                        uint32_t Timeout, uint32_t Tickstart);\r
 239 static HAL_StatusTypeDef SPI_WaitFifoStateUntilTimeout(SPI_HandleTypeDef *hspi, uint32_t Fifo, uint32_t State,\r
 240                                                        uint32_t Timeout, uint32_t Tickstart);\r
 241 static void SPI_TxISR_8BIT(struct __SPI_HandleTypeDef *hspi);\r
 242 static void SPI_TxISR_16BIT(struct __SPI_HandleTypeDef *hspi);\r
 243 static void SPI_RxISR_8BIT(struct __SPI_HandleTypeDef *hspi);\r
 244 static void SPI_RxISR_16BIT(struct __SPI_HandleTypeDef *hspi);\r
 245 static void SPI_2linesRxISR_8BIT(struct __SPI_HandleTypeDef *hspi);\r
 246 static void SPI_2linesTxISR_8BIT(struct __SPI_HandleTypeDef *hspi);\r
 247 static void SPI_2linesTxISR_16BIT(struct __SPI_HandleTypeDef *hspi);\r
 248 static void SPI_2linesRxISR_16BIT(struct __SPI_HandleTypeDef *hspi);\r
 249 #if (USE_SPI_CRC != 0U)\r
 250 static void SPI_RxISR_8BITCRC(struct __SPI_HandleTypeDef *hspi);\r
 251 static void SPI_RxISR_16BITCRC(struct __SPI_HandleTypeDef *hspi);\r
 252 static void SPI_2linesRxISR_8BITCRC(struct __SPI_HandleTypeDef *hspi);\r
 253 static void SPI_2linesRxISR_16BITCRC(struct __SPI_HandleTypeDef *hspi);\r
 254 #endif /* USE_SPI_CRC */\r
 255 static void SPI_AbortRx_ISR(SPI_HandleTypeDef *hspi);\r
 256 static void SPI_AbortTx_ISR(SPI_HandleTypeDef *hspi);\r
 257 static void SPI_CloseRxTx_ISR(SPI_HandleTypeDef *hspi);\r
 258 static void SPI_CloseRx_ISR(SPI_HandleTypeDef *hspi);\r
 259 static void SPI_CloseTx_ISR(SPI_HandleTypeDef *hspi);\r
 260 static HAL_StatusTypeDef SPI_EndRxTransaction(SPI_HandleTypeDef *hspi, uint32_t Timeout, uint32_t Tickstart);\r
 261 static HAL_StatusTypeDef SPI_EndRxTxTransaction(SPI_HandleTypeDef *hspi, uint32_t Timeout, uint32_t Tickstart);\r
 262 /**\r
 263   * @}\r
 264   */\r
 265 \r
 266 /* Exported functions --------------------------------------------------------*/\r
 267 /** @defgroup SPI_Exported_Functions SPI Exported Functions\r
 268   * @{\r
 269   */\r
 270 \r
 271 /** @defgroup SPI_Exported_Functions_Group1 Initialization and de-initialization functions\r
 272  *  @brief    Initialization and Configuration functions\r
 273  *\r
 274 @verbatim\r
 275  ===============================================================================\r
 276               ##### Initialization and de-initialization functions #####\r
 277  ===============================================================================\r
 278     [..]  This subsection provides a set of functions allowing to initialize and\r
 279           de-initialize the SPIx peripheral:\r
 280 \r
 281       (+) User must implement HAL_SPI_MspInit() function in which he configures\r
 282           all related peripherals resources (CLOCK, GPIO, DMA, IT and NVIC ).\r
 283 \r
 284       (+) Call the function HAL_SPI_Init() to configure the selected device with\r
 285           the selected configuration:\r
 286         (++) Mode\r
 287         (++) Direction\r
 288         (++) Data Size\r
 289         (++) Clock Polarity and Phase\r
 290         (++) NSS Management\r
 291         (++) BaudRate Prescaler\r
 292         (++) FirstBit\r
 293         (++) TIMode\r
 294         (++) CRC Calculation\r
 295         (++) CRC Polynomial if CRC enabled\r
 296         (++) CRC Length, used only with Data8 and Data16\r
 297         (++) FIFO reception threshold\r
 298 \r
 299       (+) Call the function HAL_SPI_DeInit() to restore the default configuration\r
 300           of the selected SPIx peripheral.\r
 301 \r
 302 @endverbatim\r
 303   * @{\r
 304   */\r
 305 \r
 306 /**\r
 307   * @brief  Initialize the SPI according to the specified parameters\r
 308   *         in the SPI_InitTypeDef and initialize the associated handle.\r
 309   * @param  hspi pointer to a SPI_HandleTypeDef structure that contains\r
 310   *               the configuration information for SPI module.\r
 311   * @retval HAL status\r
 312   */\r
 313 HAL_StatusTypeDef HAL_SPI_Init(SPI_HandleTypeDef *hspi)\r
 314 {\r
 315   uint32_t frxth;\r
 316 \r
 317   /* Check the SPI handle allocation */\r
 318   if (hspi == NULL)\r
 319   {\r
 320     return HAL_ERROR;\r
 321   }\r
 322 \r
 323   /* Check the parameters */\r
 324   assert_param(IS_SPI_ALL_INSTANCE(hspi->Instance));\r
 325   assert_param(IS_SPI_MODE(hspi->Init.Mode));\r
 326   assert_param(IS_SPI_DIRECTION(hspi->Init.Direction));\r
 327   assert_param(IS_SPI_DATASIZE(hspi->Init.DataSize));\r
 328   assert_param(IS_SPI_NSS(hspi->Init.NSS));\r
 329   assert_param(IS_SPI_NSSP(hspi->Init.NSSPMode));\r
 330   assert_param(IS_SPI_BAUDRATE_PRESCALER(hspi->Init.BaudRatePrescaler));\r
 331   assert_param(IS_SPI_FIRST_BIT(hspi->Init.FirstBit));\r
 332   assert_param(IS_SPI_TIMODE(hspi->Init.TIMode));\r
 333   if (hspi->Init.TIMode == SPI_TIMODE_DISABLE)\r
 334   {\r
 335     assert_param(IS_SPI_CPOL(hspi->Init.CLKPolarity));\r
 336     assert_param(IS_SPI_CPHA(hspi->Init.CLKPhase));\r
 337   }\r
 338 #if (USE_SPI_CRC != 0U)\r
 339   assert_param(IS_SPI_CRC_CALCULATION(hspi->Init.CRCCalculation));\r
 340   if (hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)\r
 341   {\r
 342     assert_param(IS_SPI_CRC_POLYNOMIAL(hspi->Init.CRCPolynomial));\r
 343     assert_param(IS_SPI_CRC_LENGTH(hspi->Init.CRCLength));\r
 344   }\r
 345 #else\r
 346   hspi->Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;\r
 347 #endif /* USE_SPI_CRC */\r
 348 \r
 349   if (hspi->State == HAL_SPI_STATE_RESET)\r
 350   {\r
 351     /* Allocate lock resource and initialize it */\r
 352     hspi->Lock = HAL_UNLOCKED;\r
 353 \r
 354 #if (USE_HAL_SPI_REGISTER_CALLBACKS == 1U)\r
 355     /* Init the SPI Callback settings */\r
 356     hspi->TxCpltCallback       = HAL_SPI_TxCpltCallback;       /* Legacy weak TxCpltCallback       */\r
 357     hspi->RxCpltCallback       = HAL_SPI_RxCpltCallback;       /* Legacy weak RxCpltCallback       */\r
 358     hspi->TxRxCpltCallback     = HAL_SPI_TxRxCpltCallback;     /* Legacy weak TxRxCpltCallback     */\r
 359     hspi->TxHalfCpltCallback   = HAL_SPI_TxHalfCpltCallback;   /* Legacy weak TxHalfCpltCallback   */\r
 360     hspi->RxHalfCpltCallback   = HAL_SPI_RxHalfCpltCallback;   /* Legacy weak RxHalfCpltCallback   */\r
 361     hspi->TxRxHalfCpltCallback = HAL_SPI_TxRxHalfCpltCallback; /* Legacy weak TxRxHalfCpltCallback */\r
 362     hspi->ErrorCallback        = HAL_SPI_ErrorCallback;        /* Legacy weak ErrorCallback        */\r
 363     hspi->AbortCpltCallback    = HAL_SPI_AbortCpltCallback;    /* Legacy weak AbortCpltCallback    */\r
 364 \r
 365     if (hspi->MspInitCallback == NULL)\r
 366     {\r
 367       hspi->MspInitCallback = HAL_SPI_MspInit; /* Legacy weak MspInit  */\r
 368     }\r
 369 \r
 370     /* Init the low level hardware : GPIO, CLOCK, NVIC... */\r
 371     hspi->MspInitCallback(hspi);\r
 372 #else\r
 373     /* Init the low level hardware : GPIO, CLOCK, NVIC... */\r
 374     HAL_SPI_MspInit(hspi);\r
 375 #endif /* USE_HAL_SPI_REGISTER_CALLBACKS */\r
 376   }\r
 377 \r
 378   hspi->State = HAL_SPI_STATE_BUSY;\r
 379 \r
 380   /* Disable the selected SPI peripheral */\r
 381   __HAL_SPI_DISABLE(hspi);\r
 382 \r
 383   /* Align by default the rs fifo threshold on the data size */\r
 384   if (hspi->Init.DataSize > SPI_DATASIZE_8BIT)\r
 385   {\r
 386     frxth = SPI_RXFIFO_THRESHOLD_HF;\r
 387   }\r
 388   else\r
 389   {\r
 390     frxth = SPI_RXFIFO_THRESHOLD_QF;\r
 391   }\r
 392 \r
 393   /* CRC calculation is valid only for 16Bit and 8 Bit */\r
 394   if ((hspi->Init.DataSize != SPI_DATASIZE_16BIT) && (hspi->Init.DataSize != SPI_DATASIZE_8BIT))\r
 395   {\r
 396     /* CRC must be disabled */\r
 397     hspi->Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;\r
 398   }\r
 399 \r
 400   /* Align the CRC Length on the data size */\r
 401   if (hspi->Init.CRCLength == SPI_CRC_LENGTH_DATASIZE)\r
 402   {\r
 403     /* CRC Length aligned on the data size : value set by default */\r
 404     if (hspi->Init.DataSize > SPI_DATASIZE_8BIT)\r
 405     {\r
 406       hspi->Init.CRCLength = SPI_CRC_LENGTH_16BIT;\r
 407     }\r
 408     else\r
 409     {\r
 410       hspi->Init.CRCLength = SPI_CRC_LENGTH_8BIT;\r
 411     }\r
 412   }\r
 413 \r
 414   /*----------------------- SPIx CR1 & CR2 Configuration ---------------------*/\r
 415   /* Configure : SPI Mode, Communication Mode, Clock polarity and phase, NSS management,\r
 416   Communication speed, First bit and CRC calculation state */\r
 417   WRITE_REG(hspi->Instance->CR1, (hspi->Init.Mode | hspi->Init.Direction |\r
 418                                   hspi->Init.CLKPolarity | hspi->Init.CLKPhase | (hspi->Init.NSS & SPI_CR1_SSM) |\r
 419                                   hspi->Init.BaudRatePrescaler | hspi->Init.FirstBit  | hspi->Init.CRCCalculation));\r
 420 #if (USE_SPI_CRC != 0U)\r
 421   /* Configure : CRC Length */\r
 422   if (hspi->Init.CRCLength == SPI_CRC_LENGTH_16BIT)\r
 423   {\r
 424     hspi->Instance->CR1 |= SPI_CR1_CRCL;\r
 425   }\r
 426 #endif /* USE_SPI_CRC */\r
 427 \r
 428   /* Configure : NSS management, TI Mode, NSS Pulse, Data size and Rx Fifo threshold */\r
 429   WRITE_REG(hspi->Instance->CR2, (((hspi->Init.NSS >> 16U) & SPI_CR2_SSOE) | hspi->Init.TIMode |\r
 430                                   hspi->Init.NSSPMode | hspi->Init.DataSize) | frxth);\r
 431 \r
 432 #if (USE_SPI_CRC != 0U)\r
 433   /*---------------------------- SPIx CRCPOLY Configuration ------------------*/\r
 434   /* Configure : CRC Polynomial */\r
 435   if (hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)\r
 436   {\r
 437     WRITE_REG(hspi->Instance->CRCPR, hspi->Init.CRCPolynomial);\r
 438   }\r
 439 #endif /* USE_SPI_CRC */\r
 440 \r
 441 #if defined(SPI_I2SCFGR_I2SMOD)\r
 442   /* Activate the SPI mode (Make sure that I2SMOD bit in I2SCFGR register is reset) */\r
 443   CLEAR_BIT(hspi->Instance->I2SCFGR, SPI_I2SCFGR_I2SMOD);\r
 444 #endif /* SPI_I2SCFGR_I2SMOD */\r
 445 \r
 446   hspi->ErrorCode = HAL_SPI_ERROR_NONE;\r
 447   hspi->State     = HAL_SPI_STATE_READY;\r
 448 \r
 449   return HAL_OK;\r
 450 }\r
 451 \r
 452 /**\r
 453   * @brief  De-Initialize the SPI peripheral.\r
 454   * @param  hspi pointer to a SPI_HandleTypeDef structure that contains\r
 455   *               the configuration information for SPI module.\r
 456   * @retval HAL status\r
 457   */\r
 458 HAL_StatusTypeDef HAL_SPI_DeInit(SPI_HandleTypeDef *hspi)\r
 459 {\r
 460   /* Check the SPI handle allocation */\r
 461   if (hspi == NULL)\r
 462   {\r
 463     return HAL_ERROR;\r
 464   }\r
 465 \r
 466   /* Check SPI Instance parameter */\r
 467   assert_param(IS_SPI_ALL_INSTANCE(hspi->Instance));\r
 468 \r
 469   hspi->State = HAL_SPI_STATE_BUSY;\r
 470 \r
 471   /* Disable the SPI Peripheral Clock */\r
 472   __HAL_SPI_DISABLE(hspi);\r
 473 \r
 474 #if (USE_HAL_SPI_REGISTER_CALLBACKS == 1U)\r
 475   if (hspi->MspDeInitCallback == NULL)\r
 476   {\r
 477     hspi->MspDeInitCallback = HAL_SPI_MspDeInit; /* Legacy weak MspDeInit  */\r
 478   }\r
 479 \r
 480   /* DeInit the low level hardware: GPIO, CLOCK, NVIC... */\r
 481   hspi->MspDeInitCallback(hspi);\r
 482 #else\r
 483   /* DeInit the low level hardware: GPIO, CLOCK, NVIC... */\r
 484   HAL_SPI_MspDeInit(hspi);\r
 485 #endif /* USE_HAL_SPI_REGISTER_CALLBACKS */\r
 486 \r
 487   hspi->ErrorCode = HAL_SPI_ERROR_NONE;\r
 488   hspi->State = HAL_SPI_STATE_RESET;\r
 489 \r
 490   /* Release Lock */\r
 491   __HAL_UNLOCK(hspi);\r
 492 \r
 493   return HAL_OK;\r
 494 }\r
 495 \r
 496 /**\r
 497   * @brief  Initialize the SPI MSP.\r
 498   * @param  hspi pointer to a SPI_HandleTypeDef structure that contains\r
 499   *               the configuration information for SPI module.\r
 500   * @retval None\r
 501   */\r
 502 __weak void HAL_SPI_MspInit(SPI_HandleTypeDef *hspi)\r
 503 {\r
 504   /* Prevent unused argument(s) compilation warning */\r
 505   UNUSED(hspi);\r
 506 \r
 507   /* NOTE : This function should not be modified, when the callback is needed,\r
 508             the HAL_SPI_MspInit should be implemented in the user file\r
 509    */\r
 510 }\r
 511 \r
 512 /**\r
 513   * @brief  De-Initialize the SPI MSP.\r
 514   * @param  hspi pointer to a SPI_HandleTypeDef structure that contains\r
 515   *               the configuration information for SPI module.\r
 516   * @retval None\r
 517   */\r
 518 __weak void HAL_SPI_MspDeInit(SPI_HandleTypeDef *hspi)\r
 519 {\r
 520   /* Prevent unused argument(s) compilation warning */\r
 521   UNUSED(hspi);\r
 522 \r
 523   /* NOTE : This function should not be modified, when the callback is needed,\r
 524             the HAL_SPI_MspDeInit should be implemented in the user file\r
 525    */\r
 526 }\r
 527 \r
 528 #if (USE_HAL_SPI_REGISTER_CALLBACKS == 1U)\r
 529 /**\r
 530   * @brief  Register a User SPI Callback\r
 531   *         To be used instead of the weak predefined callback\r
 532   * @param  hspi Pointer to a SPI_HandleTypeDef structure that contains\r
 533   *                the configuration information for the specified SPI.\r
 534   * @param  CallbackID ID of the callback to be registered\r
 535   * @param  pCallback pointer to the Callback function\r
 536   * @retval HAL status\r
 537   */\r
 538 HAL_StatusTypeDef HAL_SPI_RegisterCallback(SPI_HandleTypeDef *hspi, HAL_SPI_CallbackIDTypeDef CallbackID, pSPI_CallbackTypeDef pCallback)\r
 539 {\r
 540   HAL_StatusTypeDef status = HAL_OK;\r
 541 \r
 542   if (pCallback == NULL)\r
 543   {\r
 544     /* Update the error code */\r
 545     hspi->ErrorCode |= HAL_SPI_ERROR_INVALID_CALLBACK;\r
 546 \r
 547     return HAL_ERROR;\r
 548   }\r
 549   /* Process locked */\r
 550   __HAL_LOCK(hspi);\r
 551 \r
 552   if (HAL_SPI_STATE_READY == hspi->State)\r
 553   {\r
 554     switch (CallbackID)\r
 555     {\r
 556       case HAL_SPI_TX_COMPLETE_CB_ID :\r
 557         hspi->TxCpltCallback = pCallback;\r
 558         break;\r
 559 \r
 560       case HAL_SPI_RX_COMPLETE_CB_ID :\r
 561         hspi->RxCpltCallback = pCallback;\r
 562         break;\r
 563 \r
 564       case HAL_SPI_TX_RX_COMPLETE_CB_ID :\r
 565         hspi->TxRxCpltCallback = pCallback;\r
 566         break;\r
 567 \r
 568       case HAL_SPI_TX_HALF_COMPLETE_CB_ID :\r
 569         hspi->TxHalfCpltCallback = pCallback;\r
 570         break;\r
 571 \r
 572       case HAL_SPI_RX_HALF_COMPLETE_CB_ID :\r
 573         hspi->RxHalfCpltCallback = pCallback;\r
 574         break;\r
 575 \r
 576       case HAL_SPI_TX_RX_HALF_COMPLETE_CB_ID :\r
 577         hspi->TxRxHalfCpltCallback = pCallback;\r
 578         break;\r
 579 \r
 580       case HAL_SPI_ERROR_CB_ID :\r
 581         hspi->ErrorCallback = pCallback;\r
 582         break;\r
 583 \r
 584       case HAL_SPI_ABORT_CB_ID :\r
 585         hspi->AbortCpltCallback = pCallback;\r
 586         break;\r
 587 \r
 588       case HAL_SPI_MSPINIT_CB_ID :\r
 589         hspi->MspInitCallback = pCallback;\r
 590         break;\r
 591 \r
 592       case HAL_SPI_MSPDEINIT_CB_ID :\r
 593         hspi->MspDeInitCallback = pCallback;\r
 594         break;\r
 595 \r
 596       default :\r
 597         /* Update the error code */\r
 598         SET_BIT(hspi->ErrorCode, HAL_SPI_ERROR_INVALID_CALLBACK);\r
 599 \r
 600         /* Return error status */\r
 601         status =  HAL_ERROR;\r
 602         break;\r
 603     }\r
 604   }\r
 605   else if (HAL_SPI_STATE_RESET == hspi->State)\r
 606   {\r
 607     switch (CallbackID)\r
 608     {\r
 609       case HAL_SPI_MSPINIT_CB_ID :\r
 610         hspi->MspInitCallback = pCallback;\r
 611         break;\r
 612 \r
 613       case HAL_SPI_MSPDEINIT_CB_ID :\r
 614         hspi->MspDeInitCallback = pCallback;\r
 615         break;\r
 616 \r
 617       default :\r
 618         /* Update the error code */\r
 619         SET_BIT(hspi->ErrorCode, HAL_SPI_ERROR_INVALID_CALLBACK);\r
 620 \r
 621         /* Return error status */\r
 622         status =  HAL_ERROR;\r
 623         break;\r
 624     }\r
 625   }\r
 626   else\r
 627   {\r
 628     /* Update the error code */\r
 629     SET_BIT(hspi->ErrorCode, HAL_SPI_ERROR_INVALID_CALLBACK);\r
 630 \r
 631     /* Return error status */\r
 632     status =  HAL_ERROR;\r
 633   }\r
 634 \r
 635   /* Release Lock */\r
 636   __HAL_UNLOCK(hspi);\r
 637   return status;\r
 638 }\r
 639 \r
 640 /**\r
 641   * @brief  Unregister an SPI Callback\r
 642   *         SPI callback is redirected to the weak predefined callback\r
 643   * @param  hspi Pointer to a SPI_HandleTypeDef structure that contains\r
 644   *                the configuration information for the specified SPI.\r
 645   * @param  CallbackID ID of the callback to be unregistered\r
 646   * @retval HAL status\r
 647   */\r
 648 HAL_StatusTypeDef HAL_SPI_UnRegisterCallback(SPI_HandleTypeDef *hspi, HAL_SPI_CallbackIDTypeDef CallbackID)\r
 649 {\r
 650   HAL_StatusTypeDef status = HAL_OK;\r
 651 \r
 652   /* Process locked */\r
 653   __HAL_LOCK(hspi);\r
 654 \r
 655   if (HAL_SPI_STATE_READY == hspi->State)\r
 656   {\r
 657     switch (CallbackID)\r
 658     {\r
 659       case HAL_SPI_TX_COMPLETE_CB_ID :\r
 660         hspi->TxCpltCallback = HAL_SPI_TxCpltCallback;             /* Legacy weak TxCpltCallback       */\r
 661         break;\r
 662 \r
 663       case HAL_SPI_RX_COMPLETE_CB_ID :\r
 664         hspi->RxCpltCallback = HAL_SPI_RxCpltCallback;             /* Legacy weak RxCpltCallback       */\r
 665         break;\r
 666 \r
 667       case HAL_SPI_TX_RX_COMPLETE_CB_ID :\r
 668         hspi->TxRxCpltCallback = HAL_SPI_TxRxCpltCallback;         /* Legacy weak TxRxCpltCallback     */\r
 669         break;\r
 670 \r
 671       case HAL_SPI_TX_HALF_COMPLETE_CB_ID :\r
 672         hspi->TxHalfCpltCallback = HAL_SPI_TxHalfCpltCallback;     /* Legacy weak TxHalfCpltCallback   */\r
 673         break;\r
 674 \r
 675       case HAL_SPI_RX_HALF_COMPLETE_CB_ID :\r
 676         hspi->RxHalfCpltCallback = HAL_SPI_RxHalfCpltCallback;     /* Legacy weak RxHalfCpltCallback   */\r
 677         break;\r
 678 \r
 679       case HAL_SPI_TX_RX_HALF_COMPLETE_CB_ID :\r
 680         hspi->TxRxHalfCpltCallback = HAL_SPI_TxRxHalfCpltCallback; /* Legacy weak TxRxHalfCpltCallback */\r
 681         break;\r
 682 \r
 683       case HAL_SPI_ERROR_CB_ID :\r
 684         hspi->ErrorCallback = HAL_SPI_ErrorCallback;               /* Legacy weak ErrorCallback        */\r
 685         break;\r
 686 \r
 687       case HAL_SPI_ABORT_CB_ID :\r
 688         hspi->AbortCpltCallback = HAL_SPI_AbortCpltCallback;       /* Legacy weak AbortCpltCallback    */\r
 689         break;\r
 690 \r
 691       case HAL_SPI_MSPINIT_CB_ID :\r
 692         hspi->MspInitCallback = HAL_SPI_MspInit;                   /* Legacy weak MspInit              */\r
 693         break;\r
 694 \r
 695       case HAL_SPI_MSPDEINIT_CB_ID :\r
 696         hspi->MspDeInitCallback = HAL_SPI_MspDeInit;               /* Legacy weak MspDeInit            */\r
 697         break;\r
 698 \r
 699       default :\r
 700         /* Update the error code */\r
 701         SET_BIT(hspi->ErrorCode, HAL_SPI_ERROR_INVALID_CALLBACK);\r
 702 \r
 703         /* Return error status */\r
 704         status =  HAL_ERROR;\r
 705         break;\r
 706     }\r
 707   }\r
 708   else if (HAL_SPI_STATE_RESET == hspi->State)\r
 709   {\r
 710     switch (CallbackID)\r
 711     {\r
 712       case HAL_SPI_MSPINIT_CB_ID :\r
 713         hspi->MspInitCallback = HAL_SPI_MspInit;                   /* Legacy weak MspInit              */\r
 714         break;\r
 715 \r
 716       case HAL_SPI_MSPDEINIT_CB_ID :\r
 717         hspi->MspDeInitCallback = HAL_SPI_MspDeInit;               /* Legacy weak MspDeInit            */\r
 718         break;\r
 719 \r
 720       default :\r
 721         /* Update the error code */\r
 722         SET_BIT(hspi->ErrorCode, HAL_SPI_ERROR_INVALID_CALLBACK);\r
 723 \r
 724         /* Return error status */\r
 725         status =  HAL_ERROR;\r
 726         break;\r
 727     }\r
 728   }\r
 729   else\r
 730   {\r
 731     /* Update the error code */\r
 732     SET_BIT(hspi->ErrorCode, HAL_SPI_ERROR_INVALID_CALLBACK);\r
 733 \r
 734     /* Return error status */\r
 735     status =  HAL_ERROR;\r
 736   }\r
 737 \r
 738   /* Release Lock */\r
 739   __HAL_UNLOCK(hspi);\r
 740   return status;\r
 741 }\r
 742 #endif /* USE_HAL_SPI_REGISTER_CALLBACKS */\r
 743 /**\r
 744   * @}\r
 745   */\r
 746 \r
 747 /** @defgroup SPI_Exported_Functions_Group2 IO operation functions\r
 748  *  @brief   Data transfers functions\r
 749  *\r
 750 @verbatim\r
 751   ==============================================================================\r
 752                       ##### IO operation functions #####\r
 753  ===============================================================================\r
 754  [..]\r
 755     This subsection provides a set of functions allowing to manage the SPI\r
 756     data transfers.\r
 757 \r
 758     [..] The SPI supports master and slave mode :\r
 759 \r
 760     (#) There are two modes of transfer:\r
 761        (++) Blocking mode: The communication is performed in polling mode.\r
 762             The HAL status of all data processing is returned by the same function\r
 763             after finishing transfer.\r
 764        (++) No-Blocking mode: The communication is performed using Interrupts\r
 765             or DMA, These APIs return the HAL status.\r
 766             The end of the data processing will be indicated through the\r
 767             dedicated SPI IRQ when using Interrupt mode or the DMA IRQ when\r
 768             using DMA mode.\r
 769             The HAL_SPI_TxCpltCallback(), HAL_SPI_RxCpltCallback() and HAL_SPI_TxRxCpltCallback() user callbacks\r
 770             will be executed respectively at the end of the transmit or Receive process\r
 771             The HAL_SPI_ErrorCallback()user callback will be executed when a communication error is detected\r
 772 \r
 773     (#) APIs provided for these 2 transfer modes (Blocking mode or Non blocking mode using either Interrupt or DMA)\r
 774         exist for 1Line (simplex) and 2Lines (full duplex) modes.\r
 775 \r
 776 @endverbatim\r
 777   * @{\r
 778   */\r
 779 \r
 780 /**\r
 781   * @brief  Transmit an amount of data in blocking mode.\r
 782   * @param  hspi pointer to a SPI_HandleTypeDef structure that contains\r
 783   *               the configuration information for SPI module.\r
 784   * @param  pData pointer to data buffer\r
 785   * @param  Size amount of data to be sent\r
 786   * @param  Timeout Timeout duration\r
 787   * @retval HAL status\r
 788   */\r
 789 HAL_StatusTypeDef HAL_SPI_Transmit(SPI_HandleTypeDef *hspi, uint8_t *pData, uint16_t Size, uint32_t Timeout)\r
 790 {\r
 791   uint32_t tickstart;\r
 792   HAL_StatusTypeDef errorcode = HAL_OK;\r
 793   uint16_t initial_TxXferCount;\r
 794 \r
 795   /* Check Direction parameter */\r
 796   assert_param(IS_SPI_DIRECTION_2LINES_OR_1LINE(hspi->Init.Direction));\r
 797 \r
 798   /* Process Locked */\r
 799   __HAL_LOCK(hspi);\r
 800 \r
 801   /* Init tickstart for timeout management*/\r
 802   tickstart = HAL_GetTick();\r
 803   initial_TxXferCount = Size;\r
 804 \r
 805   if (hspi->State != HAL_SPI_STATE_READY)\r
 806   {\r
 807     errorcode = HAL_BUSY;\r
 808     goto error;\r
 809   }\r
 810 \r
 811   if ((pData == NULL) || (Size == 0U))\r
 812   {\r
 813     errorcode = HAL_ERROR;\r
 814     goto error;\r
 815   }\r
 816 \r
 817   /* Set the transaction information */\r
 818   hspi->State       = HAL_SPI_STATE_BUSY_TX;\r
 819   hspi->ErrorCode   = HAL_SPI_ERROR_NONE;\r
 820   hspi->pTxBuffPtr  = (uint8_t *)pData;\r
 821   hspi->TxXferSize  = Size;\r
 822   hspi->TxXferCount = Size;\r
 823 \r
 824   /*Init field not used in handle to zero */\r
 825   hspi->pRxBuffPtr  = (uint8_t *)NULL;\r
 826   hspi->RxXferSize  = 0U;\r
 827   hspi->RxXferCount = 0U;\r
 828   hspi->TxISR       = NULL;\r
 829   hspi->RxISR       = NULL;\r
 830 \r
 831   /* Configure communication direction : 1Line */\r
 832   if (hspi->Init.Direction == SPI_DIRECTION_1LINE)\r
 833   {\r
 834     SPI_1LINE_TX(hspi);\r
 835   }\r
 836 \r
 837 #if (USE_SPI_CRC != 0U)\r
 838   /* Reset CRC Calculation */\r
 839   if (hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)\r
 840   {\r
 841     SPI_RESET_CRC(hspi);\r
 842   }\r
 843 #endif /* USE_SPI_CRC */\r
 844 \r
 845   /* Check if the SPI is already enabled */\r
 846   if ((hspi->Instance->CR1 & SPI_CR1_SPE) != SPI_CR1_SPE)\r
 847   {\r
 848     /* Enable SPI peripheral */\r
 849     __HAL_SPI_ENABLE(hspi);\r
 850   }\r
 851 \r
 852   /* Transmit data in 16 Bit mode */\r
 853   if (hspi->Init.DataSize > SPI_DATASIZE_8BIT)\r
 854   {\r
 855     if ((hspi->Init.Mode == SPI_MODE_SLAVE) || (initial_TxXferCount == 0x01U))\r
 856     {\r
 857       hspi->Instance->DR = *((uint16_t *)hspi->pTxBuffPtr);\r
 858       hspi->pTxBuffPtr += sizeof(uint16_t);\r
 859       hspi->TxXferCount--;\r
 860     }\r
 861     /* Transmit data in 16 Bit mode */\r
 862     while (hspi->TxXferCount > 0U)\r
 863     {\r
 864       /* Wait until TXE flag is set to send data */\r
 865       if (__HAL_SPI_GET_FLAG(hspi, SPI_FLAG_TXE))\r
 866       {\r
 867         hspi->Instance->DR = *((uint16_t *)hspi->pTxBuffPtr);\r
 868         hspi->pTxBuffPtr += sizeof(uint16_t);\r
 869         hspi->TxXferCount--;\r
 870       }\r
 871       else\r
 872       {\r
 873         /* Timeout management */\r
 874         if ((((HAL_GetTick() - tickstart) >=  Timeout) && (Timeout != HAL_MAX_DELAY)) || (Timeout == 0U))\r
 875         {\r
 876           errorcode = HAL_TIMEOUT;\r
 877           goto error;\r
 878         }\r
 879       }\r
 880     }\r
 881   }\r
 882   /* Transmit data in 8 Bit mode */\r
 883   else\r
 884   {\r
 885     if ((hspi->Init.Mode == SPI_MODE_SLAVE) || (initial_TxXferCount == 0x01U))\r
 886     {\r
 887       if (hspi->TxXferCount > 1U)\r
 888       {\r
 889         /* write on the data register in packing mode */\r
 890         hspi->Instance->DR = *((uint16_t *)hspi->pTxBuffPtr);\r
 891         hspi->pTxBuffPtr += sizeof(uint16_t);\r
 892         hspi->TxXferCount -= 2U;\r
 893       }\r
 894       else\r
 895       {\r
 896         *((__IO uint8_t *)&hspi->Instance->DR) = (*hspi->pTxBuffPtr);\r
 897         hspi->pTxBuffPtr ++;\r
 898         hspi->TxXferCount--;\r
 899       }\r
 900     }\r
 901     while (hspi->TxXferCount > 0U)\r
 902     {\r
 903       /* Wait until TXE flag is set to send data */\r
 904       if (__HAL_SPI_GET_FLAG(hspi, SPI_FLAG_TXE))\r
 905       {\r
 906         if (hspi->TxXferCount > 1U)\r
 907         {\r
 908           /* write on the data register in packing mode */\r
 909           hspi->Instance->DR = *((uint16_t *)hspi->pTxBuffPtr);\r
 910           hspi->pTxBuffPtr += sizeof(uint16_t);\r
 911           hspi->TxXferCount -= 2U;\r
 912         }\r
 913         else\r
 914         {\r
 915           *((__IO uint8_t *)&hspi->Instance->DR) = (*hspi->pTxBuffPtr);\r
 916           hspi->pTxBuffPtr++;\r
 917           hspi->TxXferCount--;\r
 918         }\r
 919       }\r
 920       else\r
 921       {\r
 922         /* Timeout management */\r
 923         if ((((HAL_GetTick() - tickstart) >=  Timeout) && (Timeout != HAL_MAX_DELAY)) || (Timeout == 0U))\r
 924         {\r
 925           errorcode = HAL_TIMEOUT;\r
 926           goto error;\r
 927         }\r
 928       }\r
 929     }\r
 930   }\r
 931 #if (USE_SPI_CRC != 0U)\r
 932   /* Enable CRC Transmission */\r
 933   if (hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)\r
 934   {\r
 935     SET_BIT(hspi->Instance->CR1, SPI_CR1_CRCNEXT);\r
 936   }\r
 937 #endif /* USE_SPI_CRC */\r
 938 \r
 939   /* Check the end of the transaction */\r
 940   if (SPI_EndRxTxTransaction(hspi, Timeout, tickstart) != HAL_OK)\r
 941   {\r
 942     hspi->ErrorCode = HAL_SPI_ERROR_FLAG;\r
 943   }\r
 944 \r
 945   /* Clear overrun flag in 2 Lines communication mode because received is not read */\r
 946   if (hspi->Init.Direction == SPI_DIRECTION_2LINES)\r
 947   {\r
 948     __HAL_SPI_CLEAR_OVRFLAG(hspi);\r
 949   }\r
 950 \r
 951   if (hspi->ErrorCode != HAL_SPI_ERROR_NONE)\r
 952   {\r
 953     errorcode = HAL_ERROR;\r
 954   }\r
 955 \r
 956 error:\r
 957   hspi->State = HAL_SPI_STATE_READY;\r
 958   /* Process Unlocked */\r
 959   __HAL_UNLOCK(hspi);\r
 960   return errorcode;\r
 961 }\r
 962 \r
 963 /**\r
 964   * @brief  Receive an amount of data in blocking mode.\r
 965   * @param  hspi pointer to a SPI_HandleTypeDef structure that contains\r
 966   *               the configuration information for SPI module.\r
 967   * @param  pData pointer to data buffer\r
 968   * @param  Size amount of data to be received\r
 969   * @param  Timeout Timeout duration\r
 970   * @retval HAL status\r
 971   */\r
 972 HAL_StatusTypeDef HAL_SPI_Receive(SPI_HandleTypeDef *hspi, uint8_t *pData, uint16_t Size, uint32_t Timeout)\r
 973 {\r
 974   uint32_t tickstart;\r
 975   HAL_StatusTypeDef errorcode = HAL_OK;\r
 976 \r
 977   if ((hspi->Init.Mode == SPI_MODE_MASTER) && (hspi->Init.Direction == SPI_DIRECTION_2LINES))\r
 978   {\r
 979     hspi->State = HAL_SPI_STATE_BUSY_RX;\r
 980     /* Call transmit-receive function to send Dummy data on Tx line and generate clock on CLK line */\r
 981     return HAL_SPI_TransmitReceive(hspi, pData, pData, Size, Timeout);\r
 982   }\r
 983 \r
 984   /* Process Locked */\r
 985   __HAL_LOCK(hspi);\r
 986 \r
 987   /* Init tickstart for timeout management*/\r
 988   tickstart = HAL_GetTick();\r
 989 \r
 990   if (hspi->State != HAL_SPI_STATE_READY)\r
 991   {\r
 992     errorcode = HAL_BUSY;\r
 993     goto error;\r
 994   }\r
 995 \r
 996   if ((pData == NULL) || (Size == 0U))\r
 997   {\r
 998     errorcode = HAL_ERROR;\r
 999     goto error;\r
1000   }\r
1001 \r
1002   /* Set the transaction information */\r
1003   hspi->State       = HAL_SPI_STATE_BUSY_RX;\r
1004   hspi->ErrorCode   = HAL_SPI_ERROR_NONE;\r
1005   hspi->pRxBuffPtr  = (uint8_t *)pData;\r
1006   hspi->RxXferSize  = Size;\r
1007   hspi->RxXferCount = Size;\r
1008 \r
1009   /*Init field not used in handle to zero */\r
1010   hspi->pTxBuffPtr  = (uint8_t *)NULL;\r
1011   hspi->TxXferSize  = 0U;\r
1012   hspi->TxXferCount = 0U;\r
1013   hspi->RxISR       = NULL;\r
1014   hspi->TxISR       = NULL;\r
1015 \r
1016 #if (USE_SPI_CRC != 0U)\r
1017   /* Reset CRC Calculation */\r
1018   if (hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)\r
1019   {\r
1020     SPI_RESET_CRC(hspi);\r
1021     /* this is done to handle the CRCNEXT before the latest data */\r
1022     hspi->RxXferCount--;\r
1023   }\r
1024 #endif /* USE_SPI_CRC */\r
1025 \r
1026   /* Set the Rx Fifo threshold */\r
1027   if (hspi->Init.DataSize > SPI_DATASIZE_8BIT)\r
1028   {\r
1029     /* Set RX Fifo threshold according the reception data length: 16bit */\r
1030     CLEAR_BIT(hspi->Instance->CR2, SPI_RXFIFO_THRESHOLD);\r
1031   }\r
1032   else\r
1033   {\r
1034     /* Set RX Fifo threshold according the reception data length: 8bit */\r
1035     SET_BIT(hspi->Instance->CR2, SPI_RXFIFO_THRESHOLD);\r
1036   }\r
1037 \r
1038   /* Configure communication direction: 1Line */\r
1039   if (hspi->Init.Direction == SPI_DIRECTION_1LINE)\r
1040   {\r
1041     SPI_1LINE_RX(hspi);\r
1042   }\r
1043 \r
1044   /* Check if the SPI is already enabled */\r
1045   if ((hspi->Instance->CR1 & SPI_CR1_SPE) != SPI_CR1_SPE)\r
1046   {\r
1047     /* Enable SPI peripheral */\r
1048     __HAL_SPI_ENABLE(hspi);\r
1049   }\r
1050 \r
1051   /* Receive data in 8 Bit mode */\r
1052   if (hspi->Init.DataSize <= SPI_DATASIZE_8BIT)\r
1053   {\r
1054     /* Transfer loop */\r
1055     while (hspi->RxXferCount > 0U)\r
1056     {\r
1057       /* Check the RXNE flag */\r
1058       if (__HAL_SPI_GET_FLAG(hspi, SPI_FLAG_RXNE))\r
1059       {\r
1060         /* read the received data */\r
1061         (* (uint8_t *)hspi->pRxBuffPtr) = *(__IO uint8_t *)&hspi->Instance->DR;\r
1062         hspi->pRxBuffPtr += sizeof(uint8_t);\r
1063         hspi->RxXferCount--;\r
1064       }\r
1065       else\r
1066       {\r
1067         /* Timeout management */\r
1068         if ((((HAL_GetTick() - tickstart) >=  Timeout) && (Timeout != HAL_MAX_DELAY)) || (Timeout == 0U))\r
1069         {\r
1070           errorcode = HAL_TIMEOUT;\r
1071           goto error;\r
1072         }\r
1073       }\r
1074     }\r
1075   }\r
1076   else\r
1077   {\r
1078     /* Transfer loop */\r
1079     while (hspi->RxXferCount > 0U)\r
1080     {\r
1081       /* Check the RXNE flag */\r
1082       if (__HAL_SPI_GET_FLAG(hspi, SPI_FLAG_RXNE))\r
1083       {\r
1084         *((uint16_t *)hspi->pRxBuffPtr) = (uint16_t)hspi->Instance->DR;\r
1085         hspi->pRxBuffPtr += sizeof(uint16_t);\r
1086         hspi->RxXferCount--;\r
1087       }\r
1088       else\r
1089       {\r
1090         /* Timeout management */\r
1091         if ((((HAL_GetTick() - tickstart) >=  Timeout) && (Timeout != HAL_MAX_DELAY)) || (Timeout == 0U))\r
1092         {\r
1093           errorcode = HAL_TIMEOUT;\r
1094           goto error;\r
1095         }\r
1096       }\r
1097     }\r
1098   }\r
1099 \r
1100 #if (USE_SPI_CRC != 0U)\r
1101   /* Handle the CRC Transmission */\r
1102   if (hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)\r
1103   {\r
1104     /* freeze the CRC before the latest data */\r
1105     SET_BIT(hspi->Instance->CR1, SPI_CR1_CRCNEXT);\r
1106 \r
1107     /* Read the latest data */\r
1108     if (SPI_WaitFlagStateUntilTimeout(hspi, SPI_FLAG_RXNE, SET, Timeout, tickstart) != HAL_OK)\r
1109     {\r
1110       /* the latest data has not been received */\r
1111       errorcode = HAL_TIMEOUT;\r
1112       goto error;\r
1113     }\r
1114 \r
1115     /* Receive last data in 16 Bit mode */\r
1116     if (hspi->Init.DataSize > SPI_DATASIZE_8BIT)\r
1117     {\r
1118       *((uint16_t *)hspi->pRxBuffPtr) = (uint16_t)hspi->Instance->DR;\r
1119     }\r
1120     /* Receive last data in 8 Bit mode */\r
1121     else\r
1122     {\r
1123       (*(uint8_t *)hspi->pRxBuffPtr) = *(__IO uint8_t *)&hspi->Instance->DR;\r
1124     }\r
1125 \r
1126     /* Wait the CRC data */\r
1127     if (SPI_WaitFlagStateUntilTimeout(hspi, SPI_FLAG_RXNE, SET, Timeout, tickstart) != HAL_OK)\r
1128     {\r
1129       SET_BIT(hspi->ErrorCode, HAL_SPI_ERROR_CRC);\r
1130       errorcode = HAL_TIMEOUT;\r
1131       goto error;\r
1132     }\r
1133 \r
1134     /* Read CRC to Flush DR and RXNE flag */\r
1135     if (hspi->Init.DataSize == SPI_DATASIZE_16BIT)\r
1136     {\r
1137       /* Read 16bit CRC */\r
1138       READ_REG(hspi->Instance->DR);\r
1139     }\r
1140     else\r
1141     {\r
1142       /* Read 8bit CRC */\r
1143       READ_REG(*(__IO uint8_t *)&hspi->Instance->DR);\r
1144 \r
1145       if ((hspi->Init.DataSize == SPI_DATASIZE_8BIT) && (hspi->Init.CRCLength == SPI_CRC_LENGTH_16BIT))\r
1146       {\r
1147         if (SPI_WaitFlagStateUntilTimeout(hspi, SPI_FLAG_RXNE, SET, Timeout, tickstart) != HAL_OK)\r
1148         {\r
1149           /* Error on the CRC reception */\r
1150           SET_BIT(hspi->ErrorCode, HAL_SPI_ERROR_CRC);\r
1151           errorcode = HAL_TIMEOUT;\r
1152           goto error;\r
1153         }\r
1154         /* Read 8bit CRC again in case of 16bit CRC in 8bit Data mode */\r
1155         READ_REG(*(__IO uint8_t *)&hspi->Instance->DR);\r
1156       }\r
1157     }\r
1158   }\r
1159 #endif /* USE_SPI_CRC */\r
1160 \r
1161   /* Check the end of the transaction */\r
1162   if (SPI_EndRxTransaction(hspi, Timeout, tickstart) != HAL_OK)\r
1163   {\r
1164     hspi->ErrorCode = HAL_SPI_ERROR_FLAG;\r
1165   }\r
1166 \r
1167 #if (USE_SPI_CRC != 0U)\r
1168   /* Check if CRC error occurred */\r
1169   if (__HAL_SPI_GET_FLAG(hspi, SPI_FLAG_CRCERR))\r
1170   {\r
1171     SET_BIT(hspi->ErrorCode, HAL_SPI_ERROR_CRC);\r
1172     __HAL_SPI_CLEAR_CRCERRFLAG(hspi);\r
1173   }\r
1174 #endif /* USE_SPI_CRC */\r
1175 \r
1176   if (hspi->ErrorCode != HAL_SPI_ERROR_NONE)\r
1177   {\r
1178     errorcode = HAL_ERROR;\r
1179   }\r
1180 \r
1181 error :\r
1182   hspi->State = HAL_SPI_STATE_READY;\r
1183   __HAL_UNLOCK(hspi);\r
1184   return errorcode;\r
1185 }\r
1186 \r
1187 /**\r
1188   * @brief  Transmit and Receive an amount of data in blocking mode.\r
1189   * @param  hspi pointer to a SPI_HandleTypeDef structure that contains\r
1190   *               the configuration information for SPI module.\r
1191   * @param  pTxData pointer to transmission data buffer\r
1192   * @param  pRxData pointer to reception data buffer\r
1193   * @param  Size amount of data to be sent and received\r
1194   * @param  Timeout Timeout duration\r
1195   * @retval HAL status\r
1196   */\r
1197 HAL_StatusTypeDef HAL_SPI_TransmitReceive(SPI_HandleTypeDef *hspi, uint8_t *pTxData, uint8_t *pRxData, uint16_t Size,\r
1198                                           uint32_t Timeout)\r
1199 {\r
1200   uint16_t             initial_TxXferCount;\r
1201   uint16_t             initial_RxXferCount;\r
1202   uint32_t             tmp_mode;\r
1203   HAL_SPI_StateTypeDef tmp_state;\r
1204   uint32_t             tickstart;\r
1205 #if (USE_SPI_CRC != 0U)\r
1206   uint32_t             spi_cr1;\r
1207   uint32_t             spi_cr2;\r
1208 #endif /* USE_SPI_CRC */\r
1209 \r
1210   /* Variable used to alternate Rx and Tx during transfer */\r
1211   uint32_t             txallowed = 1U;\r
1212   HAL_StatusTypeDef    errorcode = HAL_OK;\r
1213 \r
1214   /* Check Direction parameter */\r
1215   assert_param(IS_SPI_DIRECTION_2LINES(hspi->Init.Direction));\r
1216 \r
1217   /* Process Locked */\r
1218   __HAL_LOCK(hspi);\r
1219 \r
1220   /* Init tickstart for timeout management*/\r
1221   tickstart = HAL_GetTick();\r
1222 \r
1223   /* Init temporary variables */\r
1224   tmp_state           = hspi->State;\r
1225   tmp_mode            = hspi->Init.Mode;\r
1226   initial_TxXferCount = Size;\r
1227   initial_RxXferCount = Size;\r
1228 #if (USE_SPI_CRC != 0U)\r
1229   spi_cr1             = READ_REG(hspi->Instance->CR1);\r
1230   spi_cr2             = READ_REG(hspi->Instance->CR2);\r
1231 #endif /* USE_SPI_CRC */\r
1232 \r
1233   if (!((tmp_state == HAL_SPI_STATE_READY) || \\r
1234         ((tmp_mode == SPI_MODE_MASTER) && (hspi->Init.Direction == SPI_DIRECTION_2LINES) && (tmp_state == HAL_SPI_STATE_BUSY_RX))))\r
1235   {\r
1236     errorcode = HAL_BUSY;\r
1237     goto error;\r
1238   }\r
1239 \r
1240   if ((pTxData == NULL) || (pRxData == NULL) || (Size == 0U))\r
1241   {\r
1242     errorcode = HAL_ERROR;\r
1243     goto error;\r
1244   }\r
1245 \r
1246   /* Don't overwrite in case of HAL_SPI_STATE_BUSY_RX */\r
1247   if (hspi->State != HAL_SPI_STATE_BUSY_RX)\r
1248   {\r
1249     hspi->State = HAL_SPI_STATE_BUSY_TX_RX;\r
1250   }\r
1251 \r
1252   /* Set the transaction information */\r
1253   hspi->ErrorCode   = HAL_SPI_ERROR_NONE;\r
1254   hspi->pRxBuffPtr  = (uint8_t *)pRxData;\r
1255   hspi->RxXferCount = Size;\r
1256   hspi->RxXferSize  = Size;\r
1257   hspi->pTxBuffPtr  = (uint8_t *)pTxData;\r
1258   hspi->TxXferCount = Size;\r
1259   hspi->TxXferSize  = Size;\r
1260 \r
1261   /*Init field not used in handle to zero */\r
1262   hspi->RxISR       = NULL;\r
1263   hspi->TxISR       = NULL;\r
1264 \r
1265 #if (USE_SPI_CRC != 0U)\r
1266   /* Reset CRC Calculation */\r
1267   if (hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)\r
1268   {\r
1269     SPI_RESET_CRC(hspi);\r
1270   }\r
1271 #endif /* USE_SPI_CRC */\r
1272 \r
1273   /* Set the Rx Fifo threshold */\r
1274   if ((hspi->Init.DataSize > SPI_DATASIZE_8BIT) || (initial_RxXferCount > 1U))\r
1275   {\r
1276     /* Set fiforxthreshold according the reception data length: 16bit */\r
1277     CLEAR_BIT(hspi->Instance->CR2, SPI_RXFIFO_THRESHOLD);\r
1278   }\r
1279   else\r
1280   {\r
1281     /* Set fiforxthreshold according the reception data length: 8bit */\r
1282     SET_BIT(hspi->Instance->CR2, SPI_RXFIFO_THRESHOLD);\r
1283   }\r
1284 \r
1285   /* Check if the SPI is already enabled */\r
1286   if ((hspi->Instance->CR1 & SPI_CR1_SPE) != SPI_CR1_SPE)\r
1287   {\r
1288     /* Enable SPI peripheral */\r
1289     __HAL_SPI_ENABLE(hspi);\r
1290   }\r
1291 \r
1292   /* Transmit and Receive data in 16 Bit mode */\r
1293   if (hspi->Init.DataSize > SPI_DATASIZE_8BIT)\r
1294   {\r
1295     if ((hspi->Init.Mode == SPI_MODE_SLAVE) || (initial_TxXferCount == 0x01U))\r
1296     {\r
1297       hspi->Instance->DR = *((uint16_t *)hspi->pTxBuffPtr);\r
1298       hspi->pTxBuffPtr += sizeof(uint16_t);\r
1299       hspi->TxXferCount--;\r
1300     }\r
1301     while ((hspi->TxXferCount > 0U) || (hspi->RxXferCount > 0U))\r
1302     {\r
1303       /* Check TXE flag */\r
1304       if ((__HAL_SPI_GET_FLAG(hspi, SPI_FLAG_TXE)) && (hspi->TxXferCount > 0U) && (txallowed == 1U))\r
1305       {\r
1306         hspi->Instance->DR = *((uint16_t *)hspi->pTxBuffPtr);\r
1307         hspi->pTxBuffPtr += sizeof(uint16_t);\r
1308         hspi->TxXferCount--;\r
1309         /* Next Data is a reception (Rx). Tx not allowed */\r
1310         txallowed = 0U;\r
1311 \r
1312 #if (USE_SPI_CRC != 0U)\r
1313         /* Enable CRC Transmission */\r
1314         if ((hspi->TxXferCount == 0U) && (hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE))\r
1315         {\r
1316           /* Set NSS Soft to received correctly the CRC on slave mode with NSS pulse activated */\r
1317           if ((READ_BIT(spi_cr1, SPI_CR1_MSTR) == 0U) && (READ_BIT(spi_cr2, SPI_CR2_NSSP) == SPI_CR2_NSSP))\r
1318           {\r
1319             SET_BIT(hspi->Instance->CR1, SPI_CR1_SSM);\r
1320           }\r
1321           SET_BIT(hspi->Instance->CR1, SPI_CR1_CRCNEXT);\r
1322         }\r
1323 #endif /* USE_SPI_CRC */\r
1324       }\r
1325 \r
1326       /* Check RXNE flag */\r
1327       if ((__HAL_SPI_GET_FLAG(hspi, SPI_FLAG_RXNE)) && (hspi->RxXferCount > 0U))\r
1328       {\r
1329         *((uint16_t *)hspi->pRxBuffPtr) = (uint16_t)hspi->Instance->DR;\r
1330         hspi->pRxBuffPtr += sizeof(uint16_t);\r
1331         hspi->RxXferCount--;\r
1332         /* Next Data is a Transmission (Tx). Tx is allowed */\r
1333         txallowed = 1U;\r
1334       }\r
1335       if (((HAL_GetTick() - tickstart) >=  Timeout) && (Timeout != HAL_MAX_DELAY))\r
1336       {\r
1337         errorcode = HAL_TIMEOUT;\r
1338         goto error;\r
1339       }\r
1340     }\r
1341   }\r
1342   /* Transmit and Receive data in 8 Bit mode */\r
1343   else\r
1344   {\r
1345     if ((hspi->Init.Mode == SPI_MODE_SLAVE) || (initial_TxXferCount == 0x01U))\r
1346     {\r
1347       if (hspi->TxXferCount > 1U)\r
1348       {\r
1349         hspi->Instance->DR = *((uint16_t *)hspi->pTxBuffPtr);\r
1350         hspi->pTxBuffPtr += sizeof(uint16_t);\r
1351         hspi->TxXferCount -= 2U;\r
1352       }\r
1353       else\r
1354       {\r
1355         *(__IO uint8_t *)&hspi->Instance->DR = (*hspi->pTxBuffPtr);\r
1356         hspi->pTxBuffPtr++;\r
1357         hspi->TxXferCount--;\r
1358       }\r
1359     }\r
1360     while ((hspi->TxXferCount > 0U) || (hspi->RxXferCount > 0U))\r
1361     {\r
1362       /* Check TXE flag */\r
1363       if ((__HAL_SPI_GET_FLAG(hspi, SPI_FLAG_TXE)) && (hspi->TxXferCount > 0U) && (txallowed == 1U))\r
1364       {\r
1365         if (hspi->TxXferCount > 1U)\r
1366         {\r
1367           hspi->Instance->DR = *((uint16_t *)hspi->pTxBuffPtr);\r
1368           hspi->pTxBuffPtr += sizeof(uint16_t);\r
1369           hspi->TxXferCount -= 2U;\r
1370         }\r
1371         else\r
1372         {\r
1373           *(__IO uint8_t *)&hspi->Instance->DR = (*hspi->pTxBuffPtr);\r
1374           hspi->pTxBuffPtr++;\r
1375           hspi->TxXferCount--;\r
1376         }\r
1377         /* Next Data is a reception (Rx). Tx not allowed */\r
1378         txallowed = 0U;\r
1379 \r
1380 #if (USE_SPI_CRC != 0U)\r
1381         /* Enable CRC Transmission */\r
1382         if ((hspi->TxXferCount == 0U) && (hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE))\r
1383         {\r
1384           /* Set NSS Soft to received correctly the CRC on slave mode with NSS pulse activated */\r
1385           if ((READ_BIT(spi_cr1, SPI_CR1_MSTR) == 0U) && (READ_BIT(spi_cr2, SPI_CR2_NSSP) == SPI_CR2_NSSP))\r
1386           {\r
1387             SET_BIT(hspi->Instance->CR1, SPI_CR1_SSM);\r
1388           }\r
1389           SET_BIT(hspi->Instance->CR1, SPI_CR1_CRCNEXT);\r
1390         }\r
1391 #endif /* USE_SPI_CRC */\r
1392       }\r
1393 \r
1394       /* Wait until RXNE flag is reset */\r
1395       if ((__HAL_SPI_GET_FLAG(hspi, SPI_FLAG_RXNE)) && (hspi->RxXferCount > 0U))\r
1396       {\r
1397         if (hspi->RxXferCount > 1U)\r
1398         {\r
1399           *((uint16_t *)hspi->pRxBuffPtr) = (uint16_t)hspi->Instance->DR;\r
1400           hspi->pRxBuffPtr += sizeof(uint16_t);\r
1401           hspi->RxXferCount -= 2U;\r
1402           if (hspi->RxXferCount <= 1U)\r
1403           {\r
1404             /* Set RX Fifo threshold before to switch on 8 bit data size */\r
1405             SET_BIT(hspi->Instance->CR2, SPI_RXFIFO_THRESHOLD);\r
1406           }\r
1407         }\r
1408         else\r
1409         {\r
1410           (*(uint8_t *)hspi->pRxBuffPtr) = *(__IO uint8_t *)&hspi->Instance->DR;\r
1411           hspi->pRxBuffPtr++;\r
1412           hspi->RxXferCount--;\r
1413         }\r
1414         /* Next Data is a Transmission (Tx). Tx is allowed */\r
1415         txallowed = 1U;\r
1416       }\r
1417       if ((((HAL_GetTick() - tickstart) >=  Timeout) && ((Timeout != HAL_MAX_DELAY))) || (Timeout == 0U))\r
1418       {\r
1419         errorcode = HAL_TIMEOUT;\r
1420         goto error;\r
1421       }\r
1422     }\r
1423   }\r
1424 \r
1425 #if (USE_SPI_CRC != 0U)\r
1426   /* Read CRC from DR to close CRC calculation process */\r
1427   if (hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)\r
1428   {\r
1429     /* Wait until TXE flag */\r
1430     if (SPI_WaitFlagStateUntilTimeout(hspi, SPI_FLAG_RXNE, SET, Timeout, tickstart) != HAL_OK)\r
1431     {\r
1432       /* Error on the CRC reception */\r
1433       SET_BIT(hspi->ErrorCode, HAL_SPI_ERROR_CRC);\r
1434       errorcode = HAL_TIMEOUT;\r
1435       goto error;\r
1436     }\r
1437     /* Read CRC */\r
1438     if (hspi->Init.DataSize == SPI_DATASIZE_16BIT)\r
1439     {\r
1440       /* Read 16bit CRC */\r
1441       READ_REG(hspi->Instance->DR);\r
1442     }\r
1443     else\r
1444     {\r
1445       /* Read 8bit CRC */\r
1446       READ_REG(*(__IO uint8_t *)&hspi->Instance->DR);\r
1447 \r
1448       if (hspi->Init.CRCLength == SPI_CRC_LENGTH_16BIT)\r
1449       {\r
1450         if (SPI_WaitFlagStateUntilTimeout(hspi, SPI_FLAG_RXNE, SET, Timeout, tickstart) != HAL_OK)\r
1451         {\r
1452           /* Error on the CRC reception */\r
1453           SET_BIT(hspi->ErrorCode, HAL_SPI_ERROR_CRC);\r
1454           errorcode = HAL_TIMEOUT;\r
1455           goto error;\r
1456         }\r
1457         /* Read 8bit CRC again in case of 16bit CRC in 8bit Data mode */\r
1458         READ_REG(*(__IO uint8_t *)&hspi->Instance->DR);\r
1459       }\r
1460     }\r
1461   }\r
1462 \r
1463   /* Check if CRC error occurred */\r
1464   if (__HAL_SPI_GET_FLAG(hspi, SPI_FLAG_CRCERR))\r
1465   {\r
1466     SET_BIT(hspi->ErrorCode, HAL_SPI_ERROR_CRC);\r
1467     /* Clear CRC Flag */\r
1468     __HAL_SPI_CLEAR_CRCERRFLAG(hspi);\r
1469 \r
1470     errorcode = HAL_ERROR;\r
1471   }\r
1472 #endif /* USE_SPI_CRC */\r
1473 \r
1474   /* Check the end of the transaction */\r
1475   if (SPI_EndRxTxTransaction(hspi, Timeout, tickstart) != HAL_OK)\r
1476   {\r
1477     errorcode = HAL_ERROR;\r
1478     hspi->ErrorCode = HAL_SPI_ERROR_FLAG;\r
1479   }\r
1480 \r
1481 error :\r
1482   hspi->State = HAL_SPI_STATE_READY;\r
1483   __HAL_UNLOCK(hspi);\r
1484   return errorcode;\r
1485 }\r
1486 \r
1487 /**\r
1488   * @brief  Transmit an amount of data in non-blocking mode with Interrupt.\r
1489   * @param  hspi pointer to a SPI_HandleTypeDef structure that contains\r
1490   *               the configuration information for SPI module.\r
1491   * @param  pData pointer to data buffer\r
1492   * @param  Size amount of data to be sent\r
1493   * @retval HAL status\r
1494   */\r
1495 HAL_StatusTypeDef HAL_SPI_Transmit_IT(SPI_HandleTypeDef *hspi, uint8_t *pData, uint16_t Size)\r
1496 {\r
1497   HAL_StatusTypeDef errorcode = HAL_OK;\r
1498 \r
1499   /* Check Direction parameter */\r
1500   assert_param(IS_SPI_DIRECTION_2LINES_OR_1LINE(hspi->Init.Direction));\r
1501 \r
1502   /* Process Locked */\r
1503   __HAL_LOCK(hspi);\r
1504 \r
1505   if ((pData == NULL) || (Size == 0U))\r
1506   {\r
1507     errorcode = HAL_ERROR;\r
1508     goto error;\r
1509   }\r
1510 \r
1511   if (hspi->State != HAL_SPI_STATE_READY)\r
1512   {\r
1513     errorcode = HAL_BUSY;\r
1514     goto error;\r
1515   }\r
1516 \r
1517   /* Set the transaction information */\r
1518   hspi->State       = HAL_SPI_STATE_BUSY_TX;\r
1519   hspi->ErrorCode   = HAL_SPI_ERROR_NONE;\r
1520   hspi->pTxBuffPtr  = (uint8_t *)pData;\r
1521   hspi->TxXferSize  = Size;\r
1522   hspi->TxXferCount = Size;\r
1523 \r
1524   /* Init field not used in handle to zero */\r
1525   hspi->pRxBuffPtr  = (uint8_t *)NULL;\r
1526   hspi->RxXferSize  = 0U;\r
1527   hspi->RxXferCount = 0U;\r
1528   hspi->RxISR       = NULL;\r
1529 \r
1530   /* Set the function for IT treatment */\r
1531   if (hspi->Init.DataSize > SPI_DATASIZE_8BIT)\r
1532   {\r
1533     hspi->TxISR = SPI_TxISR_16BIT;\r
1534   }\r
1535   else\r
1536   {\r
1537     hspi->TxISR = SPI_TxISR_8BIT;\r
1538   }\r
1539 \r
1540   /* Configure communication direction : 1Line */\r
1541   if (hspi->Init.Direction == SPI_DIRECTION_1LINE)\r
1542   {\r
1543     SPI_1LINE_TX(hspi);\r
1544   }\r
1545 \r
1546 #if (USE_SPI_CRC != 0U)\r
1547   /* Reset CRC Calculation */\r
1548   if (hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)\r
1549   {\r
1550     SPI_RESET_CRC(hspi);\r
1551   }\r
1552 #endif /* USE_SPI_CRC */\r
1553 \r
1554   /* Enable TXE and ERR interrupt */\r
1555   __HAL_SPI_ENABLE_IT(hspi, (SPI_IT_TXE | SPI_IT_ERR));\r
1556 \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 error :\r
1566   __HAL_UNLOCK(hspi);\r
1567   return errorcode;\r
1568 }\r
1569 \r
1570 /**\r
1571   * @brief  Receive an amount of data in non-blocking mode with Interrupt.\r
1572   * @param  hspi pointer to a SPI_HandleTypeDef structure that contains\r
1573   *               the configuration information for SPI module.\r
1574   * @param  pData pointer to data buffer\r
1575   * @param  Size amount of data to be sent\r
1576   * @retval HAL status\r
1577   */\r
1578 HAL_StatusTypeDef HAL_SPI_Receive_IT(SPI_HandleTypeDef *hspi, uint8_t *pData, uint16_t Size)\r
1579 {\r
1580   HAL_StatusTypeDef errorcode = HAL_OK;\r
1581 \r
1582   if ((hspi->Init.Direction == SPI_DIRECTION_2LINES) && (hspi->Init.Mode == SPI_MODE_MASTER))\r
1583   {\r
1584     hspi->State = HAL_SPI_STATE_BUSY_RX;\r
1585     /* Call transmit-receive function to send Dummy data on Tx line and generate clock on CLK line */\r
1586     return HAL_SPI_TransmitReceive_IT(hspi, pData, pData, Size);\r
1587   }\r
1588 \r
1589   /* Process Locked */\r
1590   __HAL_LOCK(hspi);\r
1591 \r
1592   if (hspi->State != HAL_SPI_STATE_READY)\r
1593   {\r
1594     errorcode = HAL_BUSY;\r
1595     goto error;\r
1596   }\r
1597 \r
1598   if ((pData == NULL) || (Size == 0U))\r
1599   {\r
1600     errorcode = HAL_ERROR;\r
1601     goto error;\r
1602   }\r
1603 \r
1604   /* Set the transaction information */\r
1605   hspi->State       = HAL_SPI_STATE_BUSY_RX;\r
1606   hspi->ErrorCode   = HAL_SPI_ERROR_NONE;\r
1607   hspi->pRxBuffPtr  = (uint8_t *)pData;\r
1608   hspi->RxXferSize  = Size;\r
1609   hspi->RxXferCount = Size;\r
1610 \r
1611   /* Init field not used in handle to zero */\r
1612   hspi->pTxBuffPtr  = (uint8_t *)NULL;\r
1613   hspi->TxXferSize  = 0U;\r
1614   hspi->TxXferCount = 0U;\r
1615   hspi->TxISR       = NULL;\r
1616 \r
1617   /* Check the data size to adapt Rx threshold and the set the function for IT treatment */\r
1618   if (hspi->Init.DataSize > SPI_DATASIZE_8BIT)\r
1619   {\r
1620     /* Set RX Fifo threshold according the reception data length: 16 bit */\r
1621     CLEAR_BIT(hspi->Instance->CR2, SPI_RXFIFO_THRESHOLD);\r
1622     hspi->RxISR = SPI_RxISR_16BIT;\r
1623   }\r
1624   else\r
1625   {\r
1626     /* Set RX Fifo threshold according the reception data length: 8 bit */\r
1627     SET_BIT(hspi->Instance->CR2, SPI_RXFIFO_THRESHOLD);\r
1628     hspi->RxISR = SPI_RxISR_8BIT;\r
1629   }\r
1630 \r
1631   /* Configure communication direction : 1Line */\r
1632   if (hspi->Init.Direction == SPI_DIRECTION_1LINE)\r
1633   {\r
1634     SPI_1LINE_RX(hspi);\r
1635   }\r
1636 \r
1637 #if (USE_SPI_CRC != 0U)\r
1638   /* Reset CRC Calculation */\r
1639   if (hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)\r
1640   {\r
1641     hspi->CRCSize = 1U;\r
1642     if ((hspi->Init.DataSize <= SPI_DATASIZE_8BIT) && (hspi->Init.CRCLength == SPI_CRC_LENGTH_16BIT))\r
1643     {\r
1644       hspi->CRCSize = 2U;\r
1645     }\r
1646     SPI_RESET_CRC(hspi);\r
1647   }\r
1648   else\r
1649   {\r
1650     hspi->CRCSize = 0U;\r
1651   }\r
1652 #endif /* USE_SPI_CRC */\r
1653 \r
1654   /* Enable TXE and ERR interrupt */\r
1655   __HAL_SPI_ENABLE_IT(hspi, (SPI_IT_RXNE | SPI_IT_ERR));\r
1656 \r
1657   /* Note : The SPI must be enabled after unlocking current process\r
1658             to avoid the risk of SPI interrupt handle execution before current\r
1659             process unlock */\r
1660 \r
1661   /* Check if the SPI is already enabled */\r
1662   if ((hspi->Instance->CR1 & SPI_CR1_SPE) != SPI_CR1_SPE)\r
1663   {\r
1664     /* Enable SPI peripheral */\r
1665     __HAL_SPI_ENABLE(hspi);\r
1666   }\r
1667 \r
1668 error :\r
1669   /* Process Unlocked */\r
1670   __HAL_UNLOCK(hspi);\r
1671   return errorcode;\r
1672 }\r
1673 \r
1674 /**\r
1675   * @brief  Transmit and Receive an amount of data in non-blocking mode with Interrupt.\r
1676   * @param  hspi pointer to a SPI_HandleTypeDef structure that contains\r
1677   *               the configuration information for SPI module.\r
1678   * @param  pTxData pointer to transmission data buffer\r
1679   * @param  pRxData pointer to reception data buffer\r
1680   * @param  Size amount of data to be sent and received\r
1681   * @retval HAL status\r
1682   */\r
1683 HAL_StatusTypeDef HAL_SPI_TransmitReceive_IT(SPI_HandleTypeDef *hspi, uint8_t *pTxData, uint8_t *pRxData, uint16_t Size)\r
1684 {\r
1685   uint32_t             tmp_mode;\r
1686   HAL_SPI_StateTypeDef tmp_state;\r
1687   HAL_StatusTypeDef    errorcode = HAL_OK;\r
1688 \r
1689   /* Check Direction parameter */\r
1690   assert_param(IS_SPI_DIRECTION_2LINES(hspi->Init.Direction));\r
1691 \r
1692   /* Process locked */\r
1693   __HAL_LOCK(hspi);\r
1694 \r
1695   /* Init temporary variables */\r
1696   tmp_state           = hspi->State;\r
1697   tmp_mode            = hspi->Init.Mode;\r
1698 \r
1699   if (!((tmp_state == HAL_SPI_STATE_READY) || \\r
1700         ((tmp_mode == SPI_MODE_MASTER) && (hspi->Init.Direction == SPI_DIRECTION_2LINES) && (tmp_state == HAL_SPI_STATE_BUSY_RX))))\r
1701   {\r
1702     errorcode = HAL_BUSY;\r
1703     goto error;\r
1704   }\r
1705 \r
1706   if ((pTxData == NULL) || (pRxData == NULL) || (Size == 0U))\r
1707   {\r
1708     errorcode = HAL_ERROR;\r
1709     goto error;\r
1710   }\r
1711 \r
1712   /* Don't overwrite in case of HAL_SPI_STATE_BUSY_RX */\r
1713   if (hspi->State != HAL_SPI_STATE_BUSY_RX)\r
1714   {\r
1715     hspi->State = HAL_SPI_STATE_BUSY_TX_RX;\r
1716   }\r
1717 \r
1718   /* Set the transaction information */\r
1719   hspi->ErrorCode   = HAL_SPI_ERROR_NONE;\r
1720   hspi->pTxBuffPtr  = (uint8_t *)pTxData;\r
1721   hspi->TxXferSize  = Size;\r
1722   hspi->TxXferCount = Size;\r
1723   hspi->pRxBuffPtr  = (uint8_t *)pRxData;\r
1724   hspi->RxXferSize  = Size;\r
1725   hspi->RxXferCount = Size;\r
1726 \r
1727   /* Set the function for IT treatment */\r
1728   if (hspi->Init.DataSize > SPI_DATASIZE_8BIT)\r
1729   {\r
1730     hspi->RxISR     = SPI_2linesRxISR_16BIT;\r
1731     hspi->TxISR     = SPI_2linesTxISR_16BIT;\r
1732   }\r
1733   else\r
1734   {\r
1735     hspi->RxISR     = SPI_2linesRxISR_8BIT;\r
1736     hspi->TxISR     = SPI_2linesTxISR_8BIT;\r
1737   }\r
1738 \r
1739 #if (USE_SPI_CRC != 0U)\r
1740   /* Reset CRC Calculation */\r
1741   if (hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)\r
1742   {\r
1743     hspi->CRCSize = 1U;\r
1744     if ((hspi->Init.DataSize <= SPI_DATASIZE_8BIT) && (hspi->Init.CRCLength == SPI_CRC_LENGTH_16BIT))\r
1745     {\r
1746       hspi->CRCSize = 2U;\r
1747     }\r
1748     SPI_RESET_CRC(hspi);\r
1749   }\r
1750   else\r
1751   {\r
1752     hspi->CRCSize = 0U;\r
1753   }\r
1754 #endif /* USE_SPI_CRC */\r
1755 \r
1756   /* Check if packing mode is enabled and if there is more than 2 data to receive */\r
1757   if ((hspi->Init.DataSize > SPI_DATASIZE_8BIT) || (Size >= 2U))\r
1758   {\r
1759     /* Set RX Fifo threshold according the reception data length: 16 bit */\r
1760     CLEAR_BIT(hspi->Instance->CR2, SPI_RXFIFO_THRESHOLD);\r
1761   }\r
1762   else\r
1763   {\r
1764     /* Set RX Fifo threshold according the reception data length: 8 bit */\r
1765     SET_BIT(hspi->Instance->CR2, SPI_RXFIFO_THRESHOLD);\r
1766   }\r
1767 \r
1768   /* Enable TXE, RXNE and ERR interrupt */\r
1769   __HAL_SPI_ENABLE_IT(hspi, (SPI_IT_TXE | SPI_IT_RXNE | SPI_IT_ERR));\r
1770 \r
1771   /* Check if the SPI is already enabled */\r
1772   if ((hspi->Instance->CR1 & SPI_CR1_SPE) != SPI_CR1_SPE)\r
1773   {\r
1774     /* Enable SPI peripheral */\r
1775     __HAL_SPI_ENABLE(hspi);\r
1776   }\r
1777 \r
1778 error :\r
1779   /* Process Unlocked */\r
1780   __HAL_UNLOCK(hspi);\r
1781   return errorcode;\r
1782 }\r
1783 \r
1784 /**\r
1785   * @brief  Transmit an amount of data in non-blocking mode with DMA.\r
1786   * @param  hspi pointer to a SPI_HandleTypeDef structure that contains\r
1787   *               the configuration information for SPI module.\r
1788   * @param  pData pointer to data buffer\r
1789   * @param  Size amount of data to be sent\r
1790   * @retval HAL status\r
1791   */\r
1792 HAL_StatusTypeDef HAL_SPI_Transmit_DMA(SPI_HandleTypeDef *hspi, uint8_t *pData, uint16_t Size)\r
1793 {\r
1794   HAL_StatusTypeDef errorcode = HAL_OK;\r
1795 \r
1796   /* Check tx dma handle */\r
1797   assert_param(IS_SPI_DMA_HANDLE(hspi->hdmatx));\r
1798 \r
1799   /* Check Direction parameter */\r
1800   assert_param(IS_SPI_DIRECTION_2LINES_OR_1LINE(hspi->Init.Direction));\r
1801 \r
1802   /* Process Locked */\r
1803   __HAL_LOCK(hspi);\r
1804 \r
1805   if (hspi->State != HAL_SPI_STATE_READY)\r
1806   {\r
1807     errorcode = HAL_BUSY;\r
1808     goto error;\r
1809   }\r
1810 \r
1811   if ((pData == NULL) || (Size == 0U))\r
1812   {\r
1813     errorcode = HAL_ERROR;\r
1814     goto error;\r
1815   }\r
1816 \r
1817   /* Set the transaction information */\r
1818   hspi->State       = HAL_SPI_STATE_BUSY_TX;\r
1819   hspi->ErrorCode   = HAL_SPI_ERROR_NONE;\r
1820   hspi->pTxBuffPtr  = (uint8_t *)pData;\r
1821   hspi->TxXferSize  = Size;\r
1822   hspi->TxXferCount = Size;\r
1823 \r
1824   /* Init field not used in handle to zero */\r
1825   hspi->pRxBuffPtr  = (uint8_t *)NULL;\r
1826   hspi->TxISR       = NULL;\r
1827   hspi->RxISR       = NULL;\r
1828   hspi->RxXferSize  = 0U;\r
1829   hspi->RxXferCount = 0U;\r
1830 \r
1831   /* Configure communication direction : 1Line */\r
1832   if (hspi->Init.Direction == SPI_DIRECTION_1LINE)\r
1833   {\r
1834     SPI_1LINE_TX(hspi);\r
1835   }\r
1836 \r
1837 #if (USE_SPI_CRC != 0U)\r
1838   /* Reset CRC Calculation */\r
1839   if (hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)\r
1840   {\r
1841     SPI_RESET_CRC(hspi);\r
1842   }\r
1843 #endif /* USE_SPI_CRC */\r
1844 \r
1845   /* Set the SPI TxDMA Half transfer complete callback */\r
1846   hspi->hdmatx->XferHalfCpltCallback = SPI_DMAHalfTransmitCplt;\r
1847 \r
1848   /* Set the SPI TxDMA transfer complete callback */\r
1849   hspi->hdmatx->XferCpltCallback = SPI_DMATransmitCplt;\r
1850 \r
1851   /* Set the DMA error callback */\r
1852   hspi->hdmatx->XferErrorCallback = SPI_DMAError;\r
1853 \r
1854   /* Set the DMA AbortCpltCallback */\r
1855   hspi->hdmatx->XferAbortCallback = NULL;\r
1856 \r
1857   CLEAR_BIT(hspi->Instance->CR2, SPI_CR2_LDMATX);\r
1858   /* Packing mode is enabled only if the DMA setting is HALWORD */\r
1859   if ((hspi->Init.DataSize <= SPI_DATASIZE_8BIT) && (hspi->hdmatx->Init.MemDataAlignment == DMA_MDATAALIGN_HALFWORD))\r
1860   {\r
1861     /* Check the even/odd of the data size + crc if enabled */\r
1862     if ((hspi->TxXferCount & 0x1U) == 0U)\r
1863     {\r
1864       CLEAR_BIT(hspi->Instance->CR2, SPI_CR2_LDMATX);\r
1865       hspi->TxXferCount = (hspi->TxXferCount >> 1U);\r
1866     }\r
1867     else\r
1868     {\r
1869       SET_BIT(hspi->Instance->CR2, SPI_CR2_LDMATX);\r
1870       hspi->TxXferCount = (hspi->TxXferCount >> 1U) + 1U;\r
1871     }\r
1872   }\r
1873 \r
1874   /* Enable the Tx DMA Stream/Channel */\r
1875   if (HAL_OK != HAL_DMA_Start_IT(hspi->hdmatx, (uint32_t)hspi->pTxBuffPtr, (uint32_t)&hspi->Instance->DR, hspi->TxXferCount))\r
1876   {\r
1877     /* Update SPI error code */\r
1878     SET_BIT(hspi->ErrorCode, HAL_SPI_ERROR_DMA);\r
1879     errorcode = HAL_ERROR;\r
1880 \r
1881     hspi->State = HAL_SPI_STATE_READY;\r
1882     goto error;\r
1883   }\r
1884 \r
1885   /* Check if the SPI is already enabled */\r
1886   if ((hspi->Instance->CR1 & SPI_CR1_SPE) != SPI_CR1_SPE)\r
1887   {\r
1888     /* Enable SPI peripheral */\r
1889     __HAL_SPI_ENABLE(hspi);\r
1890   }\r
1891 \r
1892   /* Enable the SPI Error Interrupt Bit */\r
1893   __HAL_SPI_ENABLE_IT(hspi, (SPI_IT_ERR));\r
1894 \r
1895   /* Enable Tx DMA Request */\r
1896   SET_BIT(hspi->Instance->CR2, SPI_CR2_TXDMAEN);\r
1897 \r
1898 error :\r
1899   /* Process Unlocked */\r
1900   __HAL_UNLOCK(hspi);\r
1901   return errorcode;\r
1902 }\r
1903 \r
1904 /**\r
1905   * @brief  Receive an amount of data in non-blocking mode with DMA.\r
1906   * @note   In case of MASTER mode and SPI_DIRECTION_2LINES direction, hdmatx shall be defined.\r
1907   * @param  hspi pointer to a SPI_HandleTypeDef structure that contains\r
1908   *               the configuration information for SPI module.\r
1909   * @param  pData pointer to data buffer\r
1910   * @note   When the CRC feature is enabled the pData Length must be Size + 1.\r
1911   * @param  Size amount of data to be sent\r
1912   * @retval HAL status\r
1913   */\r
1914 HAL_StatusTypeDef HAL_SPI_Receive_DMA(SPI_HandleTypeDef *hspi, uint8_t *pData, uint16_t Size)\r
1915 {\r
1916   HAL_StatusTypeDef errorcode = HAL_OK;\r
1917 \r
1918   /* Check rx dma handle */\r
1919   assert_param(IS_SPI_DMA_HANDLE(hspi->hdmarx));\r
1920 \r
1921   if ((hspi->Init.Direction == SPI_DIRECTION_2LINES) && (hspi->Init.Mode == SPI_MODE_MASTER))\r
1922   {\r
1923     hspi->State = HAL_SPI_STATE_BUSY_RX;\r
1924 \r
1925     /* Check tx dma handle */\r
1926     assert_param(IS_SPI_DMA_HANDLE(hspi->hdmatx));\r
1927 \r
1928     /* Call transmit-receive function to send Dummy data on Tx line and generate clock on CLK line */\r
1929     return HAL_SPI_TransmitReceive_DMA(hspi, pData, pData, Size);\r
1930   }\r
1931 \r
1932   /* Process Locked */\r
1933   __HAL_LOCK(hspi);\r
1934 \r
1935   if (hspi->State != HAL_SPI_STATE_READY)\r
1936   {\r
1937     errorcode = HAL_BUSY;\r
1938     goto error;\r
1939   }\r
1940 \r
1941   if ((pData == NULL) || (Size == 0U))\r
1942   {\r
1943     errorcode = HAL_ERROR;\r
1944     goto error;\r
1945   }\r
1946 \r
1947   /* Set the transaction information */\r
1948   hspi->State       = HAL_SPI_STATE_BUSY_RX;\r
1949   hspi->ErrorCode   = HAL_SPI_ERROR_NONE;\r
1950   hspi->pRxBuffPtr  = (uint8_t *)pData;\r
1951   hspi->RxXferSize  = Size;\r
1952   hspi->RxXferCount = Size;\r
1953 \r
1954   /*Init field not used in handle to zero */\r
1955   hspi->RxISR       = NULL;\r
1956   hspi->TxISR       = NULL;\r
1957   hspi->TxXferSize  = 0U;\r
1958   hspi->TxXferCount = 0U;\r
1959 \r
1960   /* Configure communication direction : 1Line */\r
1961   if (hspi->Init.Direction == SPI_DIRECTION_1LINE)\r
1962   {\r
1963     SPI_1LINE_RX(hspi);\r
1964   }\r
1965 \r
1966 #if (USE_SPI_CRC != 0U)\r
1967   /* Reset CRC Calculation */\r
1968   if (hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)\r
1969   {\r
1970     SPI_RESET_CRC(hspi);\r
1971   }\r
1972 #endif /* USE_SPI_CRC */\r
1973 \r
1974 \r
1975   CLEAR_BIT(hspi->Instance->CR2, SPI_CR2_LDMARX);\r
1976   if (hspi->Init.DataSize > SPI_DATASIZE_8BIT)\r
1977   {\r
1978     /* Set RX Fifo threshold according the reception data length: 16bit */\r
1979     CLEAR_BIT(hspi->Instance->CR2, SPI_RXFIFO_THRESHOLD);\r
1980   }\r
1981   else\r
1982   {\r
1983     /* Set RX Fifo threshold according the reception data length: 8bit */\r
1984     SET_BIT(hspi->Instance->CR2, SPI_RXFIFO_THRESHOLD);\r
1985 \r
1986     if (hspi->hdmarx->Init.MemDataAlignment == DMA_MDATAALIGN_HALFWORD)\r
1987     {\r
1988       /* Set RX Fifo threshold according the reception data length: 16bit */\r
1989       CLEAR_BIT(hspi->Instance->CR2, SPI_RXFIFO_THRESHOLD);\r
1990 \r
1991       if ((hspi->RxXferCount & 0x1U) == 0x0U)\r
1992       {\r
1993         CLEAR_BIT(hspi->Instance->CR2, SPI_CR2_LDMARX);\r
1994         hspi->RxXferCount = hspi->RxXferCount >> 1U;\r
1995       }\r
1996       else\r
1997       {\r
1998         SET_BIT(hspi->Instance->CR2, SPI_CR2_LDMARX);\r
1999         hspi->RxXferCount = (hspi->RxXferCount >> 1U) + 1U;\r
2000       }\r
2001     }\r
2002   }\r
2003 \r
2004   /* Set the SPI RxDMA Half transfer complete callback */\r
2005   hspi->hdmarx->XferHalfCpltCallback = SPI_DMAHalfReceiveCplt;\r
2006 \r
2007   /* Set the SPI Rx DMA transfer complete callback */\r
2008   hspi->hdmarx->XferCpltCallback = SPI_DMAReceiveCplt;\r
2009 \r
2010   /* Set the DMA error callback */\r
2011   hspi->hdmarx->XferErrorCallback = SPI_DMAError;\r
2012 \r
2013   /* Set the DMA AbortCpltCallback */\r
2014   hspi->hdmarx->XferAbortCallback = NULL;\r
2015 \r
2016   /* Enable the Rx DMA Stream/Channel  */\r
2017   if (HAL_OK != HAL_DMA_Start_IT(hspi->hdmarx, (uint32_t)&hspi->Instance->DR, (uint32_t)hspi->pRxBuffPtr, hspi->RxXferCount))\r
2018   {\r
2019     /* Update SPI error code */\r
2020     SET_BIT(hspi->ErrorCode, HAL_SPI_ERROR_DMA);\r
2021     errorcode = HAL_ERROR;\r
2022 \r
2023     hspi->State = HAL_SPI_STATE_READY;\r
2024     goto error;\r
2025   }\r
2026 \r
2027   /* Check if the SPI is already enabled */\r
2028   if ((hspi->Instance->CR1 & SPI_CR1_SPE) != SPI_CR1_SPE)\r
2029   {\r
2030     /* Enable SPI peripheral */\r
2031     __HAL_SPI_ENABLE(hspi);\r
2032   }\r
2033 \r
2034   /* Enable the SPI Error Interrupt Bit */\r
2035   __HAL_SPI_ENABLE_IT(hspi, (SPI_IT_ERR));\r
2036 \r
2037   /* Enable Rx DMA Request */\r
2038   SET_BIT(hspi->Instance->CR2, SPI_CR2_RXDMAEN);\r
2039 \r
2040 error:\r
2041   /* Process Unlocked */\r
2042   __HAL_UNLOCK(hspi);\r
2043   return errorcode;\r
2044 }\r
2045 \r
2046 /**\r
2047   * @brief  Transmit and Receive an amount of data in non-blocking mode with DMA.\r
2048   * @param  hspi pointer to a SPI_HandleTypeDef structure that contains\r
2049   *               the configuration information for SPI module.\r
2050   * @param  pTxData pointer to transmission data buffer\r
2051   * @param  pRxData pointer to reception data buffer\r
2052   * @note   When the CRC feature is enabled the pRxData Length must be Size + 1\r
2053   * @param  Size amount of data to be sent\r
2054   * @retval HAL status\r
2055   */\r
2056 HAL_StatusTypeDef HAL_SPI_TransmitReceive_DMA(SPI_HandleTypeDef *hspi, uint8_t *pTxData, uint8_t *pRxData,\r
2057                                               uint16_t Size)\r
2058 {\r
2059   uint32_t             tmp_mode;\r
2060   HAL_SPI_StateTypeDef tmp_state;\r
2061   HAL_StatusTypeDef errorcode = HAL_OK;\r
2062 \r
2063   /* Check rx & tx dma handles */\r
2064   assert_param(IS_SPI_DMA_HANDLE(hspi->hdmarx));\r
2065   assert_param(IS_SPI_DMA_HANDLE(hspi->hdmatx));\r
2066 \r
2067   /* Check Direction parameter */\r
2068   assert_param(IS_SPI_DIRECTION_2LINES(hspi->Init.Direction));\r
2069 \r
2070   /* Process locked */\r
2071   __HAL_LOCK(hspi);\r
2072 \r
2073   /* Init temporary variables */\r
2074   tmp_state           = hspi->State;\r
2075   tmp_mode            = hspi->Init.Mode;\r
2076 \r
2077   if (!((tmp_state == HAL_SPI_STATE_READY) ||\r
2078         ((tmp_mode == SPI_MODE_MASTER) && (hspi->Init.Direction == SPI_DIRECTION_2LINES) && (tmp_state == HAL_SPI_STATE_BUSY_RX))))\r
2079   {\r
2080     errorcode = HAL_BUSY;\r
2081     goto error;\r
2082   }\r
2083 \r
2084   if ((pTxData == NULL) || (pRxData == NULL) || (Size == 0U))\r
2085   {\r
2086     errorcode = HAL_ERROR;\r
2087     goto error;\r
2088   }\r
2089 \r
2090   /* Don't overwrite in case of HAL_SPI_STATE_BUSY_RX */\r
2091   if (hspi->State != HAL_SPI_STATE_BUSY_RX)\r
2092   {\r
2093     hspi->State = HAL_SPI_STATE_BUSY_TX_RX;\r
2094   }\r
2095 \r
2096   /* Set the transaction information */\r
2097   hspi->ErrorCode   = HAL_SPI_ERROR_NONE;\r
2098   hspi->pTxBuffPtr  = (uint8_t *)pTxData;\r
2099   hspi->TxXferSize  = Size;\r
2100   hspi->TxXferCount = Size;\r
2101   hspi->pRxBuffPtr  = (uint8_t *)pRxData;\r
2102   hspi->RxXferSize  = Size;\r
2103   hspi->RxXferCount = Size;\r
2104 \r
2105   /* Init field not used in handle to zero */\r
2106   hspi->RxISR       = NULL;\r
2107   hspi->TxISR       = NULL;\r
2108 \r
2109 #if (USE_SPI_CRC != 0U)\r
2110   /* Reset CRC Calculation */\r
2111   if (hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)\r
2112   {\r
2113     SPI_RESET_CRC(hspi);\r
2114   }\r
2115 #endif /* USE_SPI_CRC */\r
2116 \r
2117   /* Reset the threshold bit */\r
2118   CLEAR_BIT(hspi->Instance->CR2, SPI_CR2_LDMATX | SPI_CR2_LDMARX);\r
2119 \r
2120   /* The packing mode management is enabled by the DMA settings according the spi data size */\r
2121   if (hspi->Init.DataSize > SPI_DATASIZE_8BIT)\r
2122   {\r
2123     /* Set fiforxthreshold according the reception data length: 16bit */\r
2124     CLEAR_BIT(hspi->Instance->CR2, SPI_RXFIFO_THRESHOLD);\r
2125   }\r
2126   else\r
2127   {\r
2128     /* Set RX Fifo threshold according the reception data length: 8bit */\r
2129     SET_BIT(hspi->Instance->CR2, SPI_RXFIFO_THRESHOLD);\r
2130 \r
2131     if (hspi->hdmatx->Init.MemDataAlignment == DMA_MDATAALIGN_HALFWORD)\r
2132     {\r
2133       if ((hspi->TxXferSize & 0x1U) == 0x0U)\r
2134       {\r
2135         CLEAR_BIT(hspi->Instance->CR2, SPI_CR2_LDMATX);\r
2136         hspi->TxXferCount = hspi->TxXferCount >> 1U;\r
2137       }\r
2138       else\r
2139       {\r
2140         SET_BIT(hspi->Instance->CR2, SPI_CR2_LDMATX);\r
2141         hspi->TxXferCount = (hspi->TxXferCount >> 1U) + 1U;\r
2142       }\r
2143     }\r
2144 \r
2145     if (hspi->hdmarx->Init.MemDataAlignment == DMA_MDATAALIGN_HALFWORD)\r
2146     {\r
2147       /* Set RX Fifo threshold according the reception data length: 16bit */\r
2148       CLEAR_BIT(hspi->Instance->CR2, SPI_RXFIFO_THRESHOLD);\r
2149 \r
2150       if ((hspi->RxXferCount & 0x1U) == 0x0U)\r
2151       {\r
2152         CLEAR_BIT(hspi->Instance->CR2, SPI_CR2_LDMARX);\r
2153         hspi->RxXferCount = hspi->RxXferCount >> 1U;\r
2154       }\r
2155       else\r
2156       {\r
2157         SET_BIT(hspi->Instance->CR2, SPI_CR2_LDMARX);\r
2158         hspi->RxXferCount = (hspi->RxXferCount >> 1U) + 1U;\r
2159       }\r
2160     }\r
2161   }\r
2162 \r
2163   /* Check if we are in Rx only or in Rx/Tx Mode and configure the DMA transfer complete callback */\r
2164   if (hspi->State == HAL_SPI_STATE_BUSY_RX)\r
2165   {\r
2166     /* Set the SPI Rx DMA Half transfer complete callback */\r
2167     hspi->hdmarx->XferHalfCpltCallback = SPI_DMAHalfReceiveCplt;\r
2168     hspi->hdmarx->XferCpltCallback     = SPI_DMAReceiveCplt;\r
2169   }\r
2170   else\r
2171   {\r
2172     /* Set the SPI Tx/Rx DMA Half transfer complete callback */\r
2173     hspi->hdmarx->XferHalfCpltCallback = SPI_DMAHalfTransmitReceiveCplt;\r
2174     hspi->hdmarx->XferCpltCallback     = SPI_DMATransmitReceiveCplt;\r
2175   }\r
2176 \r
2177   /* Set the DMA error callback */\r
2178   hspi->hdmarx->XferErrorCallback = SPI_DMAError;\r
2179 \r
2180   /* Set the DMA AbortCpltCallback */\r
2181   hspi->hdmarx->XferAbortCallback = NULL;\r
2182 \r
2183   /* Enable the Rx DMA Stream/Channel  */\r
2184   if (HAL_OK != HAL_DMA_Start_IT(hspi->hdmarx, (uint32_t)&hspi->Instance->DR, (uint32_t)hspi->pRxBuffPtr, hspi->RxXferCount))\r
2185   {\r
2186     /* Update SPI error code */\r
2187     SET_BIT(hspi->ErrorCode, HAL_SPI_ERROR_DMA);\r
2188     errorcode = HAL_ERROR;\r
2189 \r
2190     hspi->State = HAL_SPI_STATE_READY;\r
2191     goto error;\r
2192   }\r
2193 \r
2194   /* Enable Rx DMA Request */\r
2195   SET_BIT(hspi->Instance->CR2, SPI_CR2_RXDMAEN);\r
2196 \r
2197   /* Set the SPI Tx DMA transfer complete callback as NULL because the communication closing\r
2198   is performed in DMA reception complete callback  */\r
2199   hspi->hdmatx->XferHalfCpltCallback = NULL;\r
2200   hspi->hdmatx->XferCpltCallback     = NULL;\r
2201   hspi->hdmatx->XferErrorCallback    = NULL;\r
2202   hspi->hdmatx->XferAbortCallback    = NULL;\r
2203 \r
2204   /* Enable the Tx DMA Stream/Channel  */\r
2205   if (HAL_OK != HAL_DMA_Start_IT(hspi->hdmatx, (uint32_t)hspi->pTxBuffPtr, (uint32_t)&hspi->Instance->DR, hspi->TxXferCount))\r
2206   {\r
2207     /* Update SPI error code */\r
2208     SET_BIT(hspi->ErrorCode, HAL_SPI_ERROR_DMA);\r
2209     errorcode = HAL_ERROR;\r
2210 \r
2211     hspi->State = HAL_SPI_STATE_READY;\r
2212     goto error;\r
2213   }\r
2214 \r
2215   /* Check if the SPI is already enabled */\r
2216   if ((hspi->Instance->CR1 & SPI_CR1_SPE) != SPI_CR1_SPE)\r
2217   {\r
2218     /* Enable SPI peripheral */\r
2219     __HAL_SPI_ENABLE(hspi);\r
2220   }\r
2221   /* Enable the SPI Error Interrupt Bit */\r
2222   __HAL_SPI_ENABLE_IT(hspi, (SPI_IT_ERR));\r
2223 \r
2224   /* Enable Tx DMA Request */\r
2225   SET_BIT(hspi->Instance->CR2, SPI_CR2_TXDMAEN);\r
2226 \r
2227 error :\r
2228   /* Process Unlocked */\r
2229   __HAL_UNLOCK(hspi);\r
2230   return errorcode;\r
2231 }\r
2232 \r
2233 /**\r
2234   * @brief  Abort ongoing transfer (blocking mode).\r
2235   * @param  hspi SPI handle.\r
2236   * @note   This procedure could be used for aborting any ongoing transfer (Tx and Rx),\r
2237   *         started in Interrupt or DMA mode.\r
2238   *         This procedure performs following operations :\r
2239   *           - Disable SPI Interrupts (depending of transfer direction)\r
2240   *           - Disable the DMA transfer in the peripheral register (if enabled)\r
2241   *           - Abort DMA transfer by calling HAL_DMA_Abort (in case of transfer in DMA mode)\r
2242   *           - Set handle State to READY\r
2243   * @note   This procedure is executed in blocking mode : when exiting function, Abort is considered as completed.\r
2244   * @retval HAL status\r
2245 */\r
2246 HAL_StatusTypeDef HAL_SPI_Abort(SPI_HandleTypeDef *hspi)\r
2247 {\r
2248   HAL_StatusTypeDef errorcode;\r
2249   __IO uint32_t count, resetcount;\r
2250 \r
2251   /* Initialized local variable  */\r
2252   errorcode = HAL_OK;\r
2253   resetcount = SPI_DEFAULT_TIMEOUT * (SystemCoreClock / 24U / 1000U);\r
2254   count = resetcount;\r
2255 \r
2256   /* Clear ERRIE interrupt to avoid error interrupts generation during Abort procedure */\r
2257   CLEAR_BIT(hspi->Instance->CR2, SPI_CR2_ERRIE);\r
2258 \r
2259   /* Disable TXEIE, RXNEIE and ERRIE(mode fault event, overrun error, TI frame error) interrupts */\r
2260   if (HAL_IS_BIT_SET(hspi->Instance->CR2, SPI_CR2_TXEIE))\r
2261   {\r
2262     hspi->TxISR = SPI_AbortTx_ISR;\r
2263     /* Wait HAL_SPI_STATE_ABORT state */\r
2264     do\r
2265     {\r
2266       if (count == 0U)\r
2267       {\r
2268         SET_BIT(hspi->ErrorCode, HAL_SPI_ERROR_ABORT);\r
2269         break;\r
2270       }\r
2271       count--;\r
2272     }\r
2273     while (hspi->State != HAL_SPI_STATE_ABORT);\r
2274     /* Reset Timeout Counter */\r
2275     count = resetcount;\r
2276   }\r
2277 \r
2278   if (HAL_IS_BIT_SET(hspi->Instance->CR2, SPI_CR2_RXNEIE))\r
2279   {\r
2280     hspi->RxISR = SPI_AbortRx_ISR;\r
2281     /* Wait HAL_SPI_STATE_ABORT state */\r
2282     do\r
2283     {\r
2284       if (count == 0U)\r
2285       {\r
2286         SET_BIT(hspi->ErrorCode, HAL_SPI_ERROR_ABORT);\r
2287         break;\r
2288       }\r
2289       count--;\r
2290     }\r
2291     while (hspi->State != HAL_SPI_STATE_ABORT);\r
2292     /* Reset Timeout Counter */\r
2293     count = resetcount;\r
2294   }\r
2295 \r
2296   /* Disable the SPI DMA Tx request if enabled */\r
2297   if (HAL_IS_BIT_SET(hspi->Instance->CR2, SPI_CR2_TXDMAEN))\r
2298   {\r
2299     /* Abort the SPI DMA Tx Stream/Channel : use blocking DMA Abort API (no callback) */\r
2300     if (hspi->hdmatx != NULL)\r
2301     {\r
2302       /* Set the SPI DMA Abort callback :\r
2303       will lead to call HAL_SPI_AbortCpltCallback() at end of DMA abort procedure */\r
2304       hspi->hdmatx->XferAbortCallback = NULL;\r
2305 \r
2306       /* Abort DMA Tx Handle linked to SPI Peripheral */\r
2307       if (HAL_DMA_Abort(hspi->hdmatx) != HAL_OK)\r
2308       {\r
2309         hspi->ErrorCode = HAL_SPI_ERROR_ABORT;\r
2310       }\r
2311 \r
2312       /* Disable Tx DMA Request */\r
2313       CLEAR_BIT(hspi->Instance->CR2, (SPI_CR2_TXDMAEN));\r
2314 \r
2315       if (SPI_EndRxTxTransaction(hspi, SPI_DEFAULT_TIMEOUT, HAL_GetTick()) != HAL_OK)\r
2316       {\r
2317         hspi->ErrorCode = HAL_SPI_ERROR_ABORT;\r
2318       }\r
2319 \r
2320       /* Disable SPI Peripheral */\r
2321       __HAL_SPI_DISABLE(hspi);\r
2322 \r
2323       /* Empty the FRLVL fifo */\r
2324       if (SPI_WaitFifoStateUntilTimeout(hspi, SPI_FLAG_FRLVL, SPI_FRLVL_EMPTY, SPI_DEFAULT_TIMEOUT, HAL_GetTick()) != HAL_OK)\r
2325       {\r
2326         hspi->ErrorCode = HAL_SPI_ERROR_ABORT;\r
2327       }\r
2328     }\r
2329   }\r
2330 \r
2331   /* Disable the SPI DMA Rx request if enabled */\r
2332   if (HAL_IS_BIT_SET(hspi->Instance->CR2, SPI_CR2_RXDMAEN))\r
2333   {\r
2334     /* Abort the SPI DMA Rx Stream/Channel : use blocking DMA Abort API (no callback) */\r
2335     if (hspi->hdmarx != NULL)\r
2336     {\r
2337       /* Set the SPI DMA Abort callback :\r
2338       will lead to call HAL_SPI_AbortCpltCallback() at end of DMA abort procedure */\r
2339       hspi->hdmarx->XferAbortCallback = NULL;\r
2340 \r
2341       /* Abort DMA Rx Handle linked to SPI Peripheral */\r
2342       if (HAL_DMA_Abort(hspi->hdmarx) != HAL_OK)\r
2343       {\r
2344         hspi->ErrorCode = HAL_SPI_ERROR_ABORT;\r
2345       }\r
2346 \r
2347       /* Disable peripheral */\r
2348       __HAL_SPI_DISABLE(hspi);\r
2349 \r
2350       /* Control the BSY flag */\r
2351       if (SPI_WaitFlagStateUntilTimeout(hspi, SPI_FLAG_BSY, RESET, SPI_DEFAULT_TIMEOUT, HAL_GetTick()) != HAL_OK)\r
2352       {\r
2353         hspi->ErrorCode = HAL_SPI_ERROR_ABORT;\r
2354       }\r
2355 \r
2356       /* Empty the FRLVL fifo */\r
2357       if (SPI_WaitFifoStateUntilTimeout(hspi, SPI_FLAG_FRLVL, SPI_FRLVL_EMPTY, SPI_DEFAULT_TIMEOUT, HAL_GetTick()) != HAL_OK)\r
2358       {\r
2359         hspi->ErrorCode = HAL_SPI_ERROR_ABORT;\r
2360       }\r
2361 \r
2362       /* Disable Rx DMA Request */\r
2363       CLEAR_BIT(hspi->Instance->CR2, (SPI_CR2_RXDMAEN));\r
2364     }\r
2365   }\r
2366   /* Reset Tx and Rx transfer counters */\r
2367   hspi->RxXferCount = 0U;\r
2368   hspi->TxXferCount = 0U;\r
2369 \r
2370   /* Check error during Abort procedure */\r
2371   if (hspi->ErrorCode == HAL_SPI_ERROR_ABORT)\r
2372   {\r
2373     /* return HAL_Error in case of error during Abort procedure */\r
2374     errorcode = HAL_ERROR;\r
2375   }\r
2376   else\r
2377   {\r
2378     /* Reset errorCode */\r
2379     hspi->ErrorCode = HAL_SPI_ERROR_NONE;\r
2380   }\r
2381 \r
2382   /* Clear the Error flags in the SR register */\r
2383   __HAL_SPI_CLEAR_OVRFLAG(hspi);\r
2384   __HAL_SPI_CLEAR_FREFLAG(hspi);\r
2385 \r
2386   /* Restore hspi->state to ready */\r
2387   hspi->State = HAL_SPI_STATE_READY;\r
2388 \r
2389   return errorcode;\r
2390 }\r
2391 \r
2392 /**\r
2393   * @brief  Abort ongoing transfer (Interrupt mode).\r
2394   * @param  hspi SPI handle.\r
2395   * @note   This procedure could be used for aborting any ongoing transfer (Tx and Rx),\r
2396   *         started in Interrupt or DMA mode.\r
2397   *         This procedure performs following operations :\r
2398   *           - Disable SPI Interrupts (depending of transfer direction)\r
2399   *           - Disable the DMA transfer in the peripheral register (if enabled)\r
2400   *           - Abort DMA transfer by calling HAL_DMA_Abort_IT (in case of transfer in DMA mode)\r
2401   *           - Set handle State to READY\r
2402   *           - At abort completion, call user abort complete callback\r
2403   * @note   This procedure is executed in Interrupt mode, meaning that abort procedure could be\r
2404   *         considered as completed only when user abort complete callback is executed (not when exiting function).\r
2405   * @retval HAL status\r
2406 */\r
2407 HAL_StatusTypeDef HAL_SPI_Abort_IT(SPI_HandleTypeDef *hspi)\r
2408 {\r
2409   HAL_StatusTypeDef errorcode;\r
2410   uint32_t abortcplt ;\r
2411   __IO uint32_t count, resetcount;\r
2412 \r
2413   /* Initialized local variable  */\r
2414   errorcode = HAL_OK;\r
2415   abortcplt = 1U;\r
2416   resetcount = SPI_DEFAULT_TIMEOUT * (SystemCoreClock / 24U / 1000U);\r
2417   count = resetcount;\r
2418 \r
2419   /* Clear ERRIE interrupt to avoid error interrupts generation during Abort procedure */\r
2420   CLEAR_BIT(hspi->Instance->CR2, SPI_CR2_ERRIE);\r
2421 \r
2422   /* Change Rx and Tx Irq Handler to Disable TXEIE, RXNEIE and ERRIE interrupts */\r
2423   if (HAL_IS_BIT_SET(hspi->Instance->CR2, SPI_CR2_TXEIE))\r
2424   {\r
2425     hspi->TxISR = SPI_AbortTx_ISR;\r
2426     /* Wait HAL_SPI_STATE_ABORT state */\r
2427     do\r
2428     {\r
2429       if (count == 0U)\r
2430       {\r
2431         SET_BIT(hspi->ErrorCode, HAL_SPI_ERROR_ABORT);\r
2432         break;\r
2433       }\r
2434       count--;\r
2435     }\r
2436     while (hspi->State != HAL_SPI_STATE_ABORT);\r
2437     /* Reset Timeout Counter */\r
2438     count = resetcount;\r
2439   }\r
2440 \r
2441   if (HAL_IS_BIT_SET(hspi->Instance->CR2, SPI_CR2_RXNEIE))\r
2442   {\r
2443     hspi->RxISR = SPI_AbortRx_ISR;\r
2444     /* Wait HAL_SPI_STATE_ABORT state */\r
2445     do\r
2446     {\r
2447       if (count == 0U)\r
2448       {\r
2449         SET_BIT(hspi->ErrorCode, HAL_SPI_ERROR_ABORT);\r
2450         break;\r
2451       }\r
2452       count--;\r
2453     }\r
2454     while (hspi->State != HAL_SPI_STATE_ABORT);\r
2455     /* Reset Timeout Counter */\r
2456     count = resetcount;\r
2457   }\r
2458 \r
2459   /* If DMA Tx and/or DMA Rx Handles are associated to SPI Handle, DMA Abort complete callbacks should be initialised\r
2460      before any call to DMA Abort functions */\r
2461   /* DMA Tx Handle is valid */\r
2462   if (hspi->hdmatx != NULL)\r
2463   {\r
2464     /* Set DMA Abort Complete callback if UART DMA Tx request if enabled.\r
2465        Otherwise, set it to NULL */\r
2466     if (HAL_IS_BIT_SET(hspi->Instance->CR2, SPI_CR2_TXDMAEN))\r
2467     {\r
2468       hspi->hdmatx->XferAbortCallback = SPI_DMATxAbortCallback;\r
2469     }\r
2470     else\r
2471     {\r
2472       hspi->hdmatx->XferAbortCallback = NULL;\r
2473     }\r
2474   }\r
2475   /* DMA Rx Handle is valid */\r
2476   if (hspi->hdmarx != NULL)\r
2477   {\r
2478     /* Set DMA Abort Complete callback if UART DMA Rx request if enabled.\r
2479        Otherwise, set it to NULL */\r
2480     if (HAL_IS_BIT_SET(hspi->Instance->CR2, SPI_CR2_RXDMAEN))\r
2481     {\r
2482       hspi->hdmarx->XferAbortCallback = SPI_DMARxAbortCallback;\r
2483     }\r
2484     else\r
2485     {\r
2486       hspi->hdmarx->XferAbortCallback = NULL;\r
2487     }\r
2488   }\r
2489 \r
2490   /* Disable the SPI DMA Tx request if enabled */\r
2491   if (HAL_IS_BIT_SET(hspi->Instance->CR2, SPI_CR2_TXDMAEN))\r
2492   {\r
2493     /* Abort the SPI DMA Tx Stream/Channel */\r
2494     if (hspi->hdmatx != NULL)\r
2495     {\r
2496       /* Abort DMA Tx Handle linked to SPI Peripheral */\r
2497       if (HAL_DMA_Abort_IT(hspi->hdmatx) != HAL_OK)\r
2498       {\r
2499         hspi->hdmatx->XferAbortCallback = NULL;\r
2500         hspi->ErrorCode = HAL_SPI_ERROR_ABORT;\r
2501       }\r
2502       else\r
2503       {\r
2504         abortcplt = 0U;\r
2505       }\r
2506     }\r
2507   }\r
2508   /* Disable the SPI DMA Rx request if enabled */\r
2509   if (HAL_IS_BIT_SET(hspi->Instance->CR2, SPI_CR2_RXDMAEN))\r
2510   {\r
2511     /* Abort the SPI DMA Rx Stream/Channel */\r
2512     if (hspi->hdmarx != NULL)\r
2513     {\r
2514       /* Abort DMA Rx Handle linked to SPI Peripheral */\r
2515       if (HAL_DMA_Abort_IT(hspi->hdmarx) !=  HAL_OK)\r
2516       {\r
2517         hspi->hdmarx->XferAbortCallback = NULL;\r
2518         hspi->ErrorCode = HAL_SPI_ERROR_ABORT;\r
2519       }\r
2520       else\r
2521       {\r
2522         abortcplt = 0U;\r
2523       }\r
2524     }\r
2525   }\r
2526 \r
2527   if (abortcplt == 1U)\r
2528   {\r
2529     /* Reset Tx and Rx transfer counters */\r
2530     hspi->RxXferCount = 0U;\r
2531     hspi->TxXferCount = 0U;\r
2532 \r
2533     /* Check error during Abort procedure */\r
2534     if (hspi->ErrorCode == HAL_SPI_ERROR_ABORT)\r
2535     {\r
2536       /* return HAL_Error in case of error during Abort procedure */\r
2537       errorcode = HAL_ERROR;\r
2538     }\r
2539     else\r
2540     {\r
2541       /* Reset errorCode */\r
2542       hspi->ErrorCode = HAL_SPI_ERROR_NONE;\r
2543     }\r
2544 \r
2545     /* Clear the Error flags in the SR register */\r
2546     __HAL_SPI_CLEAR_OVRFLAG(hspi);\r
2547     __HAL_SPI_CLEAR_FREFLAG(hspi);\r
2548 \r
2549     /* Restore hspi->State to Ready */\r
2550     hspi->State = HAL_SPI_STATE_READY;\r
2551 \r
2552     /* As no DMA to be aborted, call directly user Abort complete callback */\r
2553 #if (USE_HAL_SPI_REGISTER_CALLBACKS == 1U)\r
2554     hspi->AbortCpltCallback(hspi);\r
2555 #else\r
2556     HAL_SPI_AbortCpltCallback(hspi);\r
2557 #endif /* USE_HAL_SPI_REGISTER_CALLBACKS */\r
2558   }\r
2559 \r
2560   return errorcode;\r
2561 }\r
2562 \r
2563 /**\r
2564   * @brief  Pause the DMA Transfer.\r
2565   * @param  hspi pointer to a SPI_HandleTypeDef structure that contains\r
2566   *               the configuration information for the specified SPI module.\r
2567   * @retval HAL status\r
2568   */\r
2569 HAL_StatusTypeDef HAL_SPI_DMAPause(SPI_HandleTypeDef *hspi)\r
2570 {\r
2571   /* Process Locked */\r
2572   __HAL_LOCK(hspi);\r
2573 \r
2574   /* Disable the SPI DMA Tx & Rx requests */\r
2575   CLEAR_BIT(hspi->Instance->CR2, SPI_CR2_TXDMAEN | SPI_CR2_RXDMAEN);\r
2576 \r
2577   /* Process Unlocked */\r
2578   __HAL_UNLOCK(hspi);\r
2579 \r
2580   return HAL_OK;\r
2581 }\r
2582 \r
2583 /**\r
2584   * @brief  Resume the DMA Transfer.\r
2585   * @param  hspi pointer to a SPI_HandleTypeDef structure that contains\r
2586   *               the configuration information for the specified SPI module.\r
2587   * @retval HAL status\r
2588   */\r
2589 HAL_StatusTypeDef HAL_SPI_DMAResume(SPI_HandleTypeDef *hspi)\r
2590 {\r
2591   /* Process Locked */\r
2592   __HAL_LOCK(hspi);\r
2593 \r
2594   /* Enable the SPI DMA Tx & Rx requests */\r
2595   SET_BIT(hspi->Instance->CR2, SPI_CR2_TXDMAEN | SPI_CR2_RXDMAEN);\r
2596 \r
2597   /* Process Unlocked */\r
2598   __HAL_UNLOCK(hspi);\r
2599 \r
2600   return HAL_OK;\r
2601 }\r
2602 \r
2603 /**\r
2604   * @brief  Stop the DMA Transfer.\r
2605   * @param  hspi pointer to a SPI_HandleTypeDef structure that contains\r
2606   *               the configuration information for the specified SPI module.\r
2607   * @retval HAL status\r
2608   */\r
2609 HAL_StatusTypeDef HAL_SPI_DMAStop(SPI_HandleTypeDef *hspi)\r
2610 {\r
2611   HAL_StatusTypeDef errorcode = HAL_OK;\r
2612   /* The Lock is not implemented on this API to allow the user application\r
2613      to call the HAL SPI API under callbacks HAL_SPI_TxCpltCallback() or HAL_SPI_RxCpltCallback() or HAL_SPI_TxRxCpltCallback():\r
2614      when calling HAL_DMA_Abort() API the DMA TX/RX Transfer complete interrupt is generated\r
2615      and the correspond call back is executed HAL_SPI_TxCpltCallback() or HAL_SPI_RxCpltCallback() or HAL_SPI_TxRxCpltCallback()\r
2616      */\r
2617 \r
2618   /* Abort the SPI DMA tx Stream/Channel  */\r
2619   if (hspi->hdmatx != NULL)\r
2620   {\r
2621     if (HAL_OK != HAL_DMA_Abort(hspi->hdmatx))\r
2622     {\r
2623       SET_BIT(hspi->ErrorCode, HAL_SPI_ERROR_DMA);\r
2624       errorcode = HAL_ERROR;\r
2625     }\r
2626   }\r
2627   /* Abort the SPI DMA rx Stream/Channel  */\r
2628   if (hspi->hdmarx != NULL)\r
2629   {\r
2630     if (HAL_OK != HAL_DMA_Abort(hspi->hdmarx))\r
2631     {\r
2632       SET_BIT(hspi->ErrorCode, HAL_SPI_ERROR_DMA);\r
2633       errorcode = HAL_ERROR;\r
2634     }\r
2635   }\r
2636 \r
2637   /* Disable the SPI DMA Tx & Rx requests */\r
2638   CLEAR_BIT(hspi->Instance->CR2, SPI_CR2_TXDMAEN | SPI_CR2_RXDMAEN);\r
2639   hspi->State = HAL_SPI_STATE_READY;\r
2640   return errorcode;\r
2641 }\r
2642 \r
2643 /**\r
2644   * @brief  Handle SPI interrupt request.\r
2645   * @param  hspi pointer to a SPI_HandleTypeDef structure that contains\r
2646   *               the configuration information for the specified SPI module.\r
2647   * @retval None\r
2648   */\r
2649 void HAL_SPI_IRQHandler(SPI_HandleTypeDef *hspi)\r
2650 {\r
2651   uint32_t itsource = hspi->Instance->CR2;\r
2652   uint32_t itflag   = hspi->Instance->SR;\r
2653 \r
2654   /* SPI in mode Receiver ----------------------------------------------------*/\r
2655   if ((SPI_CHECK_FLAG(itflag, SPI_FLAG_OVR) == RESET) &&\r
2656       (SPI_CHECK_FLAG(itflag, SPI_FLAG_RXNE) != RESET) && (SPI_CHECK_IT_SOURCE(itsource, SPI_IT_RXNE) != RESET))\r
2657   {\r
2658     hspi->RxISR(hspi);\r
2659     return;\r
2660   }\r
2661 \r
2662   /* SPI in mode Transmitter -------------------------------------------------*/\r
2663   if ((SPI_CHECK_FLAG(itflag, SPI_FLAG_TXE) != RESET) && (SPI_CHECK_IT_SOURCE(itsource, SPI_IT_TXE) != RESET))\r
2664   {\r
2665     hspi->TxISR(hspi);\r
2666     return;\r
2667   }\r
2668 \r
2669   /* SPI in Error Treatment --------------------------------------------------*/\r
2670   if (((SPI_CHECK_FLAG(itflag, SPI_FLAG_MODF) != RESET) || (SPI_CHECK_FLAG(itflag, SPI_FLAG_OVR) != RESET) || (SPI_CHECK_FLAG(itflag, SPI_FLAG_FRE) != RESET)) && (SPI_CHECK_IT_SOURCE(itsource, SPI_IT_ERR) != RESET))\r
2671   {\r
2672     /* SPI Overrun error interrupt occurred ----------------------------------*/\r
2673     if (SPI_CHECK_FLAG(itflag, SPI_FLAG_OVR) != RESET)\r
2674     {\r
2675       if (hspi->State != HAL_SPI_STATE_BUSY_TX)\r
2676       {\r
2677         SET_BIT(hspi->ErrorCode, HAL_SPI_ERROR_OVR);\r
2678         __HAL_SPI_CLEAR_OVRFLAG(hspi);\r
2679       }\r
2680       else\r
2681       {\r
2682         __HAL_SPI_CLEAR_OVRFLAG(hspi);\r
2683         return;\r
2684       }\r
2685     }\r
2686 \r
2687     /* SPI Mode Fault error interrupt occurred -------------------------------*/\r
2688     if (SPI_CHECK_FLAG(itflag, SPI_FLAG_MODF) != RESET)\r
2689     {\r
2690       SET_BIT(hspi->ErrorCode, HAL_SPI_ERROR_MODF);\r
2691       __HAL_SPI_CLEAR_MODFFLAG(hspi);\r
2692     }\r
2693 \r
2694     /* SPI Frame error interrupt occurred ------------------------------------*/\r
2695     if (SPI_CHECK_FLAG(itflag, SPI_FLAG_FRE) != RESET)\r
2696     {\r
2697       SET_BIT(hspi->ErrorCode, HAL_SPI_ERROR_FRE);\r
2698       __HAL_SPI_CLEAR_FREFLAG(hspi);\r
2699     }\r
2700 \r
2701     if (hspi->ErrorCode != HAL_SPI_ERROR_NONE)\r
2702     {\r
2703       /* Disable all interrupts */\r
2704       __HAL_SPI_DISABLE_IT(hspi, SPI_IT_RXNE | SPI_IT_TXE | SPI_IT_ERR);\r
2705 \r
2706       hspi->State = HAL_SPI_STATE_READY;\r
2707       /* Disable the SPI DMA requests if enabled */\r
2708       if ((HAL_IS_BIT_SET(itsource, SPI_CR2_TXDMAEN)) || (HAL_IS_BIT_SET(itsource, SPI_CR2_RXDMAEN)))\r
2709       {\r
2710         CLEAR_BIT(hspi->Instance->CR2, (SPI_CR2_TXDMAEN | SPI_CR2_RXDMAEN));\r
2711 \r
2712         /* Abort the SPI DMA Rx channel */\r
2713         if (hspi->hdmarx != NULL)\r
2714         {\r
2715           /* Set the SPI DMA Abort callback :\r
2716           will lead to call HAL_SPI_ErrorCallback() at end of DMA abort procedure */\r
2717           hspi->hdmarx->XferAbortCallback = SPI_DMAAbortOnError;\r
2718           if (HAL_OK != HAL_DMA_Abort_IT(hspi->hdmarx))\r
2719           {\r
2720             SET_BIT(hspi->ErrorCode, HAL_SPI_ERROR_ABORT);\r
2721           }\r
2722         }\r
2723         /* Abort the SPI DMA Tx channel */\r
2724         if (hspi->hdmatx != NULL)\r
2725         {\r
2726           /* Set the SPI DMA Abort callback :\r
2727           will lead to call HAL_SPI_ErrorCallback() at end of DMA abort procedure */\r
2728           hspi->hdmatx->XferAbortCallback = SPI_DMAAbortOnError;\r
2729           if (HAL_OK != HAL_DMA_Abort_IT(hspi->hdmatx))\r
2730           {\r
2731             SET_BIT(hspi->ErrorCode, HAL_SPI_ERROR_ABORT);\r
2732           }\r
2733         }\r
2734       }\r
2735       else\r
2736       {\r
2737         /* Call user error callback */\r
2738 #if (USE_HAL_SPI_REGISTER_CALLBACKS == 1U)\r
2739         hspi->ErrorCallback(hspi);\r
2740 #else\r
2741         HAL_SPI_ErrorCallback(hspi);\r
2742 #endif /* USE_HAL_SPI_REGISTER_CALLBACKS */\r
2743       }\r
2744     }\r
2745     return;\r
2746   }\r
2747 }\r
2748 \r
2749 /**\r
2750   * @brief  Tx Transfer completed callback.\r
2751   * @param  hspi pointer to a SPI_HandleTypeDef structure that contains\r
2752   *               the configuration information for SPI module.\r
2753   * @retval None\r
2754   */\r
2755 __weak void HAL_SPI_TxCpltCallback(SPI_HandleTypeDef *hspi)\r
2756 {\r
2757   /* Prevent unused argument(s) compilation warning */\r
2758   UNUSED(hspi);\r
2759 \r
2760   /* NOTE : This function should not be modified, when the callback is needed,\r
2761             the HAL_SPI_TxCpltCallback should be implemented in the user file\r
2762    */\r
2763 }\r
2764 \r
2765 /**\r
2766   * @brief  Rx Transfer completed callback.\r
2767   * @param  hspi pointer to a SPI_HandleTypeDef structure that contains\r
2768   *               the configuration information for SPI module.\r
2769   * @retval None\r
2770   */\r
2771 __weak void HAL_SPI_RxCpltCallback(SPI_HandleTypeDef *hspi)\r
2772 {\r
2773   /* Prevent unused argument(s) compilation warning */\r
2774   UNUSED(hspi);\r
2775 \r
2776   /* NOTE : This function should not be modified, when the callback is needed,\r
2777             the HAL_SPI_RxCpltCallback should be implemented in the user file\r
2778    */\r
2779 }\r
2780 \r
2781 /**\r
2782   * @brief  Tx and Rx Transfer completed callback.\r
2783   * @param  hspi pointer to a SPI_HandleTypeDef structure that contains\r
2784   *               the configuration information for SPI module.\r
2785   * @retval None\r
2786   */\r
2787 __weak void HAL_SPI_TxRxCpltCallback(SPI_HandleTypeDef *hspi)\r
2788 {\r
2789   /* Prevent unused argument(s) compilation warning */\r
2790   UNUSED(hspi);\r
2791 \r
2792   /* NOTE : This function should not be modified, when the callback is needed,\r
2793             the HAL_SPI_TxRxCpltCallback should be implemented in the user file\r
2794    */\r
2795 }\r
2796 \r
2797 /**\r
2798   * @brief  Tx Half Transfer completed callback.\r
2799   * @param  hspi pointer to a SPI_HandleTypeDef structure that contains\r
2800   *               the configuration information for SPI module.\r
2801   * @retval None\r
2802   */\r
2803 __weak void HAL_SPI_TxHalfCpltCallback(SPI_HandleTypeDef *hspi)\r
2804 {\r
2805   /* Prevent unused argument(s) compilation warning */\r
2806   UNUSED(hspi);\r
2807 \r
2808   /* NOTE : This function should not be modified, when the callback is needed,\r
2809             the HAL_SPI_TxHalfCpltCallback should be implemented in the user file\r
2810    */\r
2811 }\r
2812 \r
2813 /**\r
2814   * @brief  Rx Half Transfer completed callback.\r
2815   * @param  hspi pointer to a SPI_HandleTypeDef structure that contains\r
2816   *               the configuration information for SPI module.\r
2817   * @retval None\r
2818   */\r
2819 __weak void HAL_SPI_RxHalfCpltCallback(SPI_HandleTypeDef *hspi)\r
2820 {\r
2821   /* Prevent unused argument(s) compilation warning */\r
2822   UNUSED(hspi);\r
2823 \r
2824   /* NOTE : This function should not be modified, when the callback is needed,\r
2825             the HAL_SPI_RxHalfCpltCallback() should be implemented in the user file\r
2826    */\r
2827 }\r
2828 \r
2829 /**\r
2830   * @brief  Tx and Rx Half Transfer callback.\r
2831   * @param  hspi pointer to a SPI_HandleTypeDef structure that contains\r
2832   *               the configuration information for SPI module.\r
2833   * @retval None\r
2834   */\r
2835 __weak void HAL_SPI_TxRxHalfCpltCallback(SPI_HandleTypeDef *hspi)\r
2836 {\r
2837   /* Prevent unused argument(s) compilation warning */\r
2838   UNUSED(hspi);\r
2839 \r
2840   /* NOTE : This function should not be modified, when the callback is needed,\r
2841             the HAL_SPI_TxRxHalfCpltCallback() should be implemented in the user file\r
2842    */\r
2843 }\r
2844 \r
2845 /**\r
2846   * @brief  SPI error callback.\r
2847   * @param  hspi pointer to a SPI_HandleTypeDef structure that contains\r
2848   *               the configuration information for SPI module.\r
2849   * @retval None\r
2850   */\r
2851 __weak void HAL_SPI_ErrorCallback(SPI_HandleTypeDef *hspi)\r
2852 {\r
2853   /* Prevent unused argument(s) compilation warning */\r
2854   UNUSED(hspi);\r
2855 \r
2856   /* NOTE : This function should not be modified, when the callback is needed,\r
2857             the HAL_SPI_ErrorCallback should be implemented in the user file\r
2858    */\r
2859   /* NOTE : The ErrorCode parameter in the hspi handle is updated by the SPI processes\r
2860             and user can use HAL_SPI_GetError() API to check the latest error occurred\r
2861    */\r
2862 }\r
2863 \r
2864 /**\r
2865   * @brief  SPI Abort Complete callback.\r
2866   * @param  hspi SPI handle.\r
2867   * @retval None\r
2868   */\r
2869 __weak void HAL_SPI_AbortCpltCallback(SPI_HandleTypeDef *hspi)\r
2870 {\r
2871   /* Prevent unused argument(s) compilation warning */\r
2872   UNUSED(hspi);\r
2873 \r
2874   /* NOTE : This function should not be modified, when the callback is needed,\r
2875             the HAL_SPI_AbortCpltCallback can be implemented in the user file.\r
2876    */\r
2877 }\r
2878 \r
2879 /**\r
2880   * @}\r
2881   */\r
2882 \r
2883 /** @defgroup SPI_Exported_Functions_Group3 Peripheral State and Errors functions\r
2884   * @brief   SPI control functions\r
2885   *\r
2886 @verbatim\r
2887  ===============================================================================\r
2888                       ##### Peripheral State and Errors functions #####\r
2889  ===============================================================================\r
2890     [..]\r
2891     This subsection provides a set of functions allowing to control the SPI.\r
2892      (+) HAL_SPI_GetState() API can be helpful to check in run-time the state of the SPI peripheral\r
2893      (+) HAL_SPI_GetError() check in run-time Errors occurring during communication\r
2894 @endverbatim\r
2895   * @{\r
2896   */\r
2897 \r
2898 /**\r
2899   * @brief  Return the SPI handle state.\r
2900   * @param  hspi pointer to a SPI_HandleTypeDef structure that contains\r
2901   *               the configuration information for SPI module.\r
2902   * @retval SPI state\r
2903   */\r
2904 HAL_SPI_StateTypeDef HAL_SPI_GetState(SPI_HandleTypeDef *hspi)\r
2905 {\r
2906   /* Return SPI handle state */\r
2907   return hspi->State;\r
2908 }\r
2909 \r
2910 /**\r
2911   * @brief  Return the SPI error code.\r
2912   * @param  hspi pointer to a SPI_HandleTypeDef structure that contains\r
2913   *               the configuration information for SPI module.\r
2914   * @retval SPI error code in bitmap format\r
2915   */\r
2916 uint32_t HAL_SPI_GetError(SPI_HandleTypeDef *hspi)\r
2917 {\r
2918   /* Return SPI ErrorCode */\r
2919   return hspi->ErrorCode;\r
2920 }\r
2921 \r
2922 /**\r
2923   * @}\r
2924   */\r
2925 \r
2926 /**\r
2927   * @}\r
2928   */\r
2929 \r
2930 /** @addtogroup SPI_Private_Functions\r
2931   * @brief   Private functions\r
2932   * @{\r
2933   */\r
2934 \r
2935 /**\r
2936   * @brief  DMA SPI transmit process complete callback.\r
2937   * @param  hdma pointer to a DMA_HandleTypeDef structure that contains\r
2938   *               the configuration information for the specified DMA module.\r
2939   * @retval None\r
2940   */\r
2941 static void SPI_DMATransmitCplt(DMA_HandleTypeDef *hdma)\r
2942 {\r
2943   SPI_HandleTypeDef *hspi = (SPI_HandleTypeDef *)(((DMA_HandleTypeDef *)hdma)->Parent); /* Derogation MISRAC2012-Rule-11.5 */\r
2944   uint32_t tickstart;\r
2945 \r
2946   /* Init tickstart for timeout management*/\r
2947   tickstart = HAL_GetTick();\r
2948 \r
2949   /* DMA Normal Mode */\r
2950   if ((hdma->Instance->CCR & DMA_CCR_CIRC) != DMA_CCR_CIRC)\r
2951   {\r
2952     /* Disable ERR interrupt */\r
2953     __HAL_SPI_DISABLE_IT(hspi, SPI_IT_ERR);\r
2954 \r
2955     /* Disable Tx DMA Request */\r
2956     CLEAR_BIT(hspi->Instance->CR2, SPI_CR2_TXDMAEN);\r
2957 \r
2958     /* Check the end of the transaction */\r
2959     if (SPI_EndRxTxTransaction(hspi, SPI_DEFAULT_TIMEOUT, tickstart) != HAL_OK)\r
2960     {\r
2961       SET_BIT(hspi->ErrorCode, HAL_SPI_ERROR_FLAG);\r
2962     }\r
2963 \r
2964     /* Clear overrun flag in 2 Lines communication mode because received data is not read */\r
2965     if (hspi->Init.Direction == SPI_DIRECTION_2LINES)\r
2966     {\r
2967       __HAL_SPI_CLEAR_OVRFLAG(hspi);\r
2968     }\r
2969 \r
2970     hspi->TxXferCount = 0U;\r
2971     hspi->State = HAL_SPI_STATE_READY;\r
2972 \r
2973     if (hspi->ErrorCode != HAL_SPI_ERROR_NONE)\r
2974     {\r
2975       /* Call user error callback */\r
2976 #if (USE_HAL_SPI_REGISTER_CALLBACKS == 1U)\r
2977       hspi->ErrorCallback(hspi);\r
2978 #else\r
2979       HAL_SPI_ErrorCallback(hspi);\r
2980 #endif /* USE_HAL_SPI_REGISTER_CALLBACKS */\r
2981       return;\r
2982     }\r
2983   }\r
2984   /* Call user Tx complete callback */\r
2985 #if (USE_HAL_SPI_REGISTER_CALLBACKS == 1U)\r
2986   hspi->TxCpltCallback(hspi);\r
2987 #else\r
2988   HAL_SPI_TxCpltCallback(hspi);\r
2989 #endif /* USE_HAL_SPI_REGISTER_CALLBACKS */\r
2990 }\r
2991 \r
2992 /**\r
2993   * @brief  DMA SPI receive process complete callback.\r
2994   * @param  hdma pointer to a DMA_HandleTypeDef structure that contains\r
2995   *               the configuration information for the specified DMA module.\r
2996   * @retval None\r
2997   */\r
2998 static void SPI_DMAReceiveCplt(DMA_HandleTypeDef *hdma)\r
2999 {\r
3000   SPI_HandleTypeDef *hspi = (SPI_HandleTypeDef *)(((DMA_HandleTypeDef *)hdma)->Parent); /* Derogation MISRAC2012-Rule-11.5 */\r
3001   uint32_t tickstart;\r
3002 \r
3003   /* Init tickstart for timeout management*/\r
3004   tickstart = HAL_GetTick();\r
3005 \r
3006   /* DMA Normal Mode */\r
3007   if ((hdma->Instance->CCR & DMA_CCR_CIRC) != DMA_CCR_CIRC)\r
3008   {\r
3009     /* Disable ERR interrupt */\r
3010     __HAL_SPI_DISABLE_IT(hspi, SPI_IT_ERR);\r
3011 \r
3012 #if (USE_SPI_CRC != 0U)\r
3013     /* CRC handling */\r
3014     if (hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)\r
3015     {\r
3016       /* Wait until RXNE flag */\r
3017       if (SPI_WaitFlagStateUntilTimeout(hspi, SPI_FLAG_RXNE, SET, SPI_DEFAULT_TIMEOUT, tickstart) != HAL_OK)\r
3018       {\r
3019         /* Error on the CRC reception */\r
3020         SET_BIT(hspi->ErrorCode, HAL_SPI_ERROR_CRC);\r
3021       }\r
3022       /* Read CRC */\r
3023       if (hspi->Init.DataSize > SPI_DATASIZE_8BIT)\r
3024       {\r
3025         /* Read 16bit CRC */\r
3026         READ_REG(hspi->Instance->DR);\r
3027       }\r
3028       else\r
3029       {\r
3030         /* Read 8bit CRC */\r
3031         READ_REG(*(__IO uint8_t *)&hspi->Instance->DR);\r
3032 \r
3033         if (hspi->Init.CRCLength == SPI_CRC_LENGTH_16BIT)\r
3034         {\r
3035           if (SPI_WaitFlagStateUntilTimeout(hspi, SPI_FLAG_RXNE, SET, SPI_DEFAULT_TIMEOUT, tickstart) != HAL_OK)\r
3036           {\r
3037             /* Error on the CRC reception */\r
3038             SET_BIT(hspi->ErrorCode, HAL_SPI_ERROR_CRC);\r
3039           }\r
3040           /* Read 8bit CRC again in case of 16bit CRC in 8bit Data mode */\r
3041           READ_REG(*(__IO uint8_t *)&hspi->Instance->DR);\r
3042         }\r
3043       }\r
3044     }\r
3045 #endif /* USE_SPI_CRC */\r
3046 \r
3047     /* Disable Rx/Tx DMA Request (done by default to handle the case master rx direction 2 lines) */\r
3048     CLEAR_BIT(hspi->Instance->CR2, SPI_CR2_TXDMAEN | SPI_CR2_RXDMAEN);\r
3049 \r
3050     /* Check the end of the transaction */\r
3051     if (SPI_EndRxTransaction(hspi, SPI_DEFAULT_TIMEOUT, tickstart) != HAL_OK)\r
3052     {\r
3053       hspi->ErrorCode = HAL_SPI_ERROR_FLAG;\r
3054     }\r
3055 \r
3056     hspi->RxXferCount = 0U;\r
3057     hspi->State = HAL_SPI_STATE_READY;\r
3058 \r
3059 #if (USE_SPI_CRC != 0U)\r
3060     /* Check if CRC error occurred */\r
3061     if (__HAL_SPI_GET_FLAG(hspi, SPI_FLAG_CRCERR))\r
3062     {\r
3063       SET_BIT(hspi->ErrorCode, HAL_SPI_ERROR_CRC);\r
3064       __HAL_SPI_CLEAR_CRCERRFLAG(hspi);\r
3065     }\r
3066 #endif /* USE_SPI_CRC */\r
3067 \r
3068     if (hspi->ErrorCode != HAL_SPI_ERROR_NONE)\r
3069     {\r
3070       /* Call user error callback */\r
3071 #if (USE_HAL_SPI_REGISTER_CALLBACKS == 1U)\r
3072       hspi->ErrorCallback(hspi);\r
3073 #else\r
3074       HAL_SPI_ErrorCallback(hspi);\r
3075 #endif /* USE_HAL_SPI_REGISTER_CALLBACKS */\r
3076       return;\r
3077     }\r
3078   }\r
3079   /* Call user Rx complete callback */\r
3080 #if (USE_HAL_SPI_REGISTER_CALLBACKS == 1U)\r
3081   hspi->RxCpltCallback(hspi);\r
3082 #else\r
3083   HAL_SPI_RxCpltCallback(hspi);\r
3084 #endif /* USE_HAL_SPI_REGISTER_CALLBACKS */\r
3085 }\r
3086 \r
3087 /**\r
3088   * @brief  DMA SPI transmit receive process complete callback.\r
3089   * @param  hdma pointer to a DMA_HandleTypeDef structure that contains\r
3090   *               the configuration information for the specified DMA module.\r
3091   * @retval None\r
3092   */\r
3093 static void SPI_DMATransmitReceiveCplt(DMA_HandleTypeDef *hdma)\r
3094 {\r
3095   SPI_HandleTypeDef *hspi = (SPI_HandleTypeDef *)(((DMA_HandleTypeDef *)hdma)->Parent); /* Derogation MISRAC2012-Rule-11.5 */\r
3096   uint32_t tickstart;\r
3097 \r
3098   /* Init tickstart for timeout management*/\r
3099   tickstart = HAL_GetTick();\r
3100 \r
3101   /* DMA Normal Mode */\r
3102   if ((hdma->Instance->CCR & DMA_CCR_CIRC) != DMA_CCR_CIRC)\r
3103   {\r
3104     /* Disable ERR interrupt */\r
3105     __HAL_SPI_DISABLE_IT(hspi, SPI_IT_ERR);\r
3106 \r
3107 #if (USE_SPI_CRC != 0U)\r
3108     /* CRC handling */\r
3109     if (hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)\r
3110     {\r
3111       if ((hspi->Init.DataSize == SPI_DATASIZE_8BIT) && (hspi->Init.CRCLength == SPI_CRC_LENGTH_8BIT))\r
3112       {\r
3113         if (SPI_WaitFifoStateUntilTimeout(hspi, SPI_FLAG_FRLVL, SPI_FRLVL_QUARTER_FULL, SPI_DEFAULT_TIMEOUT,\r
3114                                           tickstart) != HAL_OK)\r
3115         {\r
3116           /* Error on the CRC reception */\r
3117           SET_BIT(hspi->ErrorCode, HAL_SPI_ERROR_CRC);\r
3118         }\r
3119         /* Read CRC to Flush DR and RXNE flag */\r
3120         READ_REG(*(__IO uint8_t *)&hspi->Instance->DR);\r
3121       }\r
3122       else\r
3123       {\r
3124         if (SPI_WaitFifoStateUntilTimeout(hspi, SPI_FLAG_FRLVL, SPI_FRLVL_HALF_FULL, SPI_DEFAULT_TIMEOUT, tickstart) != HAL_OK)\r
3125         {\r
3126           /* Error on the CRC reception */\r
3127           SET_BIT(hspi->ErrorCode, HAL_SPI_ERROR_CRC);\r
3128         }\r
3129         /* Read CRC to Flush DR and RXNE flag */\r
3130         READ_REG(hspi->Instance->DR);\r
3131       }\r
3132     }\r
3133 #endif /* USE_SPI_CRC */\r
3134 \r
3135     /* Check the end of the transaction */\r
3136     if (SPI_EndRxTxTransaction(hspi, SPI_DEFAULT_TIMEOUT, tickstart) != HAL_OK)\r
3137     {\r
3138       SET_BIT(hspi->ErrorCode, HAL_SPI_ERROR_FLAG);\r
3139     }\r
3140 \r
3141     /* Disable Rx/Tx DMA Request */\r
3142     CLEAR_BIT(hspi->Instance->CR2, SPI_CR2_TXDMAEN | SPI_CR2_RXDMAEN);\r
3143 \r
3144     hspi->TxXferCount = 0U;\r
3145     hspi->RxXferCount = 0U;\r
3146     hspi->State = HAL_SPI_STATE_READY;\r
3147 \r
3148 #if (USE_SPI_CRC != 0U)\r
3149     /* Check if CRC error occurred */\r
3150     if (__HAL_SPI_GET_FLAG(hspi, SPI_FLAG_CRCERR))\r
3151     {\r
3152       SET_BIT(hspi->ErrorCode, HAL_SPI_ERROR_CRC);\r
3153       __HAL_SPI_CLEAR_CRCERRFLAG(hspi);\r
3154     }\r
3155 #endif /* USE_SPI_CRC */\r
3156 \r
3157     if (hspi->ErrorCode != HAL_SPI_ERROR_NONE)\r
3158     {\r
3159       /* Call user error callback */\r
3160 #if (USE_HAL_SPI_REGISTER_CALLBACKS == 1U)\r
3161       hspi->ErrorCallback(hspi);\r
3162 #else\r
3163       HAL_SPI_ErrorCallback(hspi);\r
3164 #endif /* USE_HAL_SPI_REGISTER_CALLBACKS */\r
3165       return;\r
3166     }\r
3167   }\r
3168   /* Call user TxRx complete callback */\r
3169 #if (USE_HAL_SPI_REGISTER_CALLBACKS == 1U)\r
3170   hspi->TxRxCpltCallback(hspi);\r
3171 #else\r
3172   HAL_SPI_TxRxCpltCallback(hspi);\r
3173 #endif /* USE_HAL_SPI_REGISTER_CALLBACKS */\r
3174 }\r
3175 \r
3176 /**\r
3177   * @brief  DMA SPI half transmit process complete callback.\r
3178   * @param  hdma pointer to a DMA_HandleTypeDef structure that contains\r
3179   *               the configuration information for the specified DMA module.\r
3180   * @retval None\r
3181   */\r
3182 static void SPI_DMAHalfTransmitCplt(DMA_HandleTypeDef *hdma)\r
3183 {\r
3184   SPI_HandleTypeDef *hspi = (SPI_HandleTypeDef *)(((DMA_HandleTypeDef *)hdma)->Parent); /* Derogation MISRAC2012-Rule-11.5 */\r
3185 \r
3186   /* Call user Tx half complete callback */\r
3187 #if (USE_HAL_SPI_REGISTER_CALLBACKS == 1U)\r
3188   hspi->TxHalfCpltCallback(hspi);\r
3189 #else\r
3190   HAL_SPI_TxHalfCpltCallback(hspi);\r
3191 #endif /* USE_HAL_SPI_REGISTER_CALLBACKS */\r
3192 }\r
3193 \r
3194 /**\r
3195   * @brief  DMA SPI half receive process complete callback\r
3196   * @param  hdma pointer to a DMA_HandleTypeDef structure that contains\r
3197   *               the configuration information for the specified DMA module.\r
3198   * @retval None\r
3199   */\r
3200 static void SPI_DMAHalfReceiveCplt(DMA_HandleTypeDef *hdma)\r
3201 {\r
3202   SPI_HandleTypeDef *hspi = (SPI_HandleTypeDef *)(((DMA_HandleTypeDef *)hdma)->Parent); /* Derogation MISRAC2012-Rule-11.5 */\r
3203 \r
3204   /* Call user Rx half complete callback */\r
3205 #if (USE_HAL_SPI_REGISTER_CALLBACKS == 1U)\r
3206   hspi->RxHalfCpltCallback(hspi);\r
3207 #else\r
3208   HAL_SPI_RxHalfCpltCallback(hspi);\r
3209 #endif /* USE_HAL_SPI_REGISTER_CALLBACKS */\r
3210 }\r
3211 \r
3212 /**\r
3213   * @brief  DMA SPI half transmit receive process complete callback.\r
3214   * @param  hdma pointer to a DMA_HandleTypeDef structure that contains\r
3215   *               the configuration information for the specified DMA module.\r
3216   * @retval None\r
3217   */\r
3218 static void SPI_DMAHalfTransmitReceiveCplt(DMA_HandleTypeDef *hdma)\r
3219 {\r
3220   SPI_HandleTypeDef *hspi = (SPI_HandleTypeDef *)(((DMA_HandleTypeDef *)hdma)->Parent); /* Derogation MISRAC2012-Rule-11.5 */\r
3221 \r
3222   /* Call user TxRx half complete callback */\r
3223 #if (USE_HAL_SPI_REGISTER_CALLBACKS == 1U)\r
3224   hspi->TxRxHalfCpltCallback(hspi);\r
3225 #else\r
3226   HAL_SPI_TxRxHalfCpltCallback(hspi);\r
3227 #endif /* USE_HAL_SPI_REGISTER_CALLBACKS */\r
3228 }\r
3229 \r
3230 /**\r
3231   * @brief  DMA SPI communication error callback.\r
3232   * @param  hdma pointer to a DMA_HandleTypeDef structure that contains\r
3233   *               the configuration information for the specified DMA module.\r
3234   * @retval None\r
3235   */\r
3236 static void SPI_DMAError(DMA_HandleTypeDef *hdma)\r
3237 {\r
3238   SPI_HandleTypeDef *hspi = (SPI_HandleTypeDef *)(((DMA_HandleTypeDef *)hdma)->Parent); /* Derogation MISRAC2012-Rule-11.5 */\r
3239 \r
3240   /* Stop the disable DMA transfer on SPI side */\r
3241   CLEAR_BIT(hspi->Instance->CR2, SPI_CR2_TXDMAEN | SPI_CR2_RXDMAEN);\r
3242 \r
3243   SET_BIT(hspi->ErrorCode, HAL_SPI_ERROR_DMA);\r
3244   hspi->State = HAL_SPI_STATE_READY;\r
3245   /* Call user error callback */\r
3246 #if (USE_HAL_SPI_REGISTER_CALLBACKS == 1U)\r
3247   hspi->ErrorCallback(hspi);\r
3248 #else\r
3249   HAL_SPI_ErrorCallback(hspi);\r
3250 #endif /* USE_HAL_SPI_REGISTER_CALLBACKS */\r
3251 }\r
3252 \r
3253 /**\r
3254   * @brief  DMA SPI communication abort callback, when initiated by HAL services on Error\r
3255   *         (To be called at end of DMA Abort procedure following error occurrence).\r
3256   * @param  hdma DMA handle.\r
3257   * @retval None\r
3258   */\r
3259 static void SPI_DMAAbortOnError(DMA_HandleTypeDef *hdma)\r
3260 {\r
3261   SPI_HandleTypeDef *hspi = (SPI_HandleTypeDef *)(((DMA_HandleTypeDef *)hdma)->Parent); /* Derogation MISRAC2012-Rule-11.5 */\r
3262   hspi->RxXferCount = 0U;\r
3263   hspi->TxXferCount = 0U;\r
3264 \r
3265   /* Call user error callback */\r
3266 #if (USE_HAL_SPI_REGISTER_CALLBACKS == 1U)\r
3267   hspi->ErrorCallback(hspi);\r
3268 #else\r
3269   HAL_SPI_ErrorCallback(hspi);\r
3270 #endif /* USE_HAL_SPI_REGISTER_CALLBACKS */\r
3271 }\r
3272 \r
3273 /**\r
3274   * @brief  DMA SPI Tx communication abort callback, when initiated by user\r
3275   *         (To be called at end of DMA Tx Abort procedure following user abort request).\r
3276   * @note   When this callback is executed, User Abort complete call back is called only if no\r
3277   *         Abort still ongoing for Rx DMA Handle.\r
3278   * @param  hdma DMA handle.\r
3279   * @retval None\r
3280   */\r
3281 static void SPI_DMATxAbortCallback(DMA_HandleTypeDef *hdma)\r
3282 {\r
3283   SPI_HandleTypeDef *hspi = (SPI_HandleTypeDef *)(((DMA_HandleTypeDef *)hdma)->Parent); /* Derogation MISRAC2012-Rule-11.5 */\r
3284 \r
3285   hspi->hdmatx->XferAbortCallback = NULL;\r
3286 \r
3287   /* Disable Tx DMA Request */\r
3288   CLEAR_BIT(hspi->Instance->CR2, SPI_CR2_TXDMAEN);\r
3289 \r
3290   if (SPI_EndRxTxTransaction(hspi, SPI_DEFAULT_TIMEOUT, HAL_GetTick()) != HAL_OK)\r
3291   {\r
3292     hspi->ErrorCode = HAL_SPI_ERROR_ABORT;\r
3293   }\r
3294 \r
3295   /* Disable SPI Peripheral */\r
3296   __HAL_SPI_DISABLE(hspi);\r
3297 \r
3298   /* Empty the FRLVL fifo */\r
3299   if (SPI_WaitFifoStateUntilTimeout(hspi, SPI_FLAG_FRLVL, SPI_FRLVL_EMPTY, SPI_DEFAULT_TIMEOUT, HAL_GetTick()) != HAL_OK)\r
3300   {\r
3301     hspi->ErrorCode = HAL_SPI_ERROR_ABORT;\r
3302   }\r
3303 \r
3304   /* Check if an Abort process is still ongoing */\r
3305   if (hspi->hdmarx != NULL)\r
3306   {\r
3307     if (hspi->hdmarx->XferAbortCallback != NULL)\r
3308     {\r
3309       return;\r
3310     }\r
3311   }\r
3312 \r
3313   /* No Abort process still ongoing : All DMA Stream/Channel are aborted, call user Abort Complete callback */\r
3314   hspi->RxXferCount = 0U;\r
3315   hspi->TxXferCount = 0U;\r
3316 \r
3317   /* Check no error during Abort procedure */\r
3318   if (hspi->ErrorCode != HAL_SPI_ERROR_ABORT)\r
3319   {\r
3320     /* Reset errorCode */\r
3321     hspi->ErrorCode = HAL_SPI_ERROR_NONE;\r
3322   }\r
3323 \r
3324   /* Clear the Error flags in the SR register */\r
3325   __HAL_SPI_CLEAR_OVRFLAG(hspi);\r
3326   __HAL_SPI_CLEAR_FREFLAG(hspi);\r
3327 \r
3328   /* Restore hspi->State to Ready */\r
3329   hspi->State  = HAL_SPI_STATE_READY;\r
3330 \r
3331   /* Call user Abort complete callback */\r
3332 #if (USE_HAL_SPI_REGISTER_CALLBACKS == 1U)\r
3333   hspi->AbortCpltCallback(hspi);\r
3334 #else\r
3335   HAL_SPI_AbortCpltCallback(hspi);\r
3336 #endif /* USE_HAL_SPI_REGISTER_CALLBACKS */\r
3337 }\r
3338 \r
3339 /**\r
3340   * @brief  DMA SPI Rx communication abort callback, when initiated by user\r
3341   *         (To be called at end of DMA Rx Abort procedure following user abort request).\r
3342   * @note   When this callback is executed, User Abort complete call back is called only if no\r
3343   *         Abort still ongoing for Tx DMA Handle.\r
3344   * @param  hdma DMA handle.\r
3345   * @retval None\r
3346   */\r
3347 static void SPI_DMARxAbortCallback(DMA_HandleTypeDef *hdma)\r
3348 {\r
3349   SPI_HandleTypeDef *hspi = (SPI_HandleTypeDef *)(((DMA_HandleTypeDef *)hdma)->Parent); /* Derogation MISRAC2012-Rule-11.5 */\r
3350 \r
3351   /* Disable SPI Peripheral */\r
3352   __HAL_SPI_DISABLE(hspi);\r
3353 \r
3354   hspi->hdmarx->XferAbortCallback = NULL;\r
3355 \r
3356   /* Disable Rx DMA Request */\r
3357   CLEAR_BIT(hspi->Instance->CR2, SPI_CR2_RXDMAEN);\r
3358 \r
3359   /* Control the BSY flag */\r
3360   if (SPI_WaitFlagStateUntilTimeout(hspi, SPI_FLAG_BSY, RESET, SPI_DEFAULT_TIMEOUT, HAL_GetTick()) != HAL_OK)\r
3361   {\r
3362     hspi->ErrorCode = HAL_SPI_ERROR_ABORT;\r
3363   }\r
3364 \r
3365   /* Empty the FRLVL fifo */\r
3366   if (SPI_WaitFifoStateUntilTimeout(hspi, SPI_FLAG_FRLVL, SPI_FRLVL_EMPTY, SPI_DEFAULT_TIMEOUT, HAL_GetTick()) != HAL_OK)\r
3367   {\r
3368     hspi->ErrorCode = HAL_SPI_ERROR_ABORT;\r
3369   }\r
3370 \r
3371   /* Check if an Abort process is still ongoing */\r
3372   if (hspi->hdmatx != NULL)\r
3373   {\r
3374     if (hspi->hdmatx->XferAbortCallback != NULL)\r
3375     {\r
3376       return;\r
3377     }\r
3378   }\r
3379 \r
3380   /* No Abort process still ongoing : All DMA Stream/Channel are aborted, call user Abort Complete callback */\r
3381   hspi->RxXferCount = 0U;\r
3382   hspi->TxXferCount = 0U;\r
3383 \r
3384   /* Check no error during Abort procedure */\r
3385   if (hspi->ErrorCode != HAL_SPI_ERROR_ABORT)\r
3386   {\r
3387     /* Reset errorCode */\r
3388     hspi->ErrorCode = HAL_SPI_ERROR_NONE;\r
3389   }\r
3390 \r
3391   /* Clear the Error flags in the SR register */\r
3392   __HAL_SPI_CLEAR_OVRFLAG(hspi);\r
3393   __HAL_SPI_CLEAR_FREFLAG(hspi);\r
3394 \r
3395   /* Restore hspi->State to Ready */\r
3396   hspi->State  = HAL_SPI_STATE_READY;\r
3397 \r
3398   /* Call user Abort complete callback */\r
3399 #if (USE_HAL_SPI_REGISTER_CALLBACKS == 1U)\r
3400   hspi->AbortCpltCallback(hspi);\r
3401 #else\r
3402   HAL_SPI_AbortCpltCallback(hspi);\r
3403 #endif /* USE_HAL_SPI_REGISTER_CALLBACKS */\r
3404 }\r
3405 \r
3406 /**\r
3407   * @brief  Rx 8-bit handler for Transmit and Receive in Interrupt mode.\r
3408   * @param  hspi pointer to a SPI_HandleTypeDef structure that contains\r
3409   *               the configuration information for SPI module.\r
3410   * @retval None\r
3411   */\r
3412 static void SPI_2linesRxISR_8BIT(struct __SPI_HandleTypeDef *hspi)\r
3413 {\r
3414   /* Receive data in packing mode */\r
3415   if (hspi->RxXferCount > 1U)\r
3416   {\r
3417     *((uint16_t *)hspi->pRxBuffPtr) = (uint16_t)(hspi->Instance->DR);\r
3418     hspi->pRxBuffPtr += sizeof(uint16_t);\r
3419     hspi->RxXferCount -= 2U;\r
3420     if (hspi->RxXferCount == 1U)\r
3421     {\r
3422       /* Set RX Fifo threshold according the reception data length: 8bit */\r
3423       SET_BIT(hspi->Instance->CR2, SPI_RXFIFO_THRESHOLD);\r
3424     }\r
3425   }\r
3426   /* Receive data in 8 Bit mode */\r
3427   else\r
3428   {\r
3429     *hspi->pRxBuffPtr = *((__IO uint8_t *)&hspi->Instance->DR);\r
3430     hspi->pRxBuffPtr++;\r
3431     hspi->RxXferCount--;\r
3432   }\r
3433 \r
3434   /* Check end of the reception */\r
3435   if (hspi->RxXferCount == 0U)\r
3436   {\r
3437 #if (USE_SPI_CRC != 0U)\r
3438     if (hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)\r
3439     {\r
3440       SET_BIT(hspi->Instance->CR2, SPI_RXFIFO_THRESHOLD);\r
3441       hspi->RxISR =  SPI_2linesRxISR_8BITCRC;\r
3442       return;\r
3443     }\r
3444 #endif /* USE_SPI_CRC */\r
3445 \r
3446     /* Disable RXNE  and ERR interrupt */\r
3447     __HAL_SPI_DISABLE_IT(hspi, (SPI_IT_RXNE | SPI_IT_ERR));\r
3448 \r
3449     if (hspi->TxXferCount == 0U)\r
3450     {\r
3451       SPI_CloseRxTx_ISR(hspi);\r
3452     }\r
3453   }\r
3454 }\r
3455 \r
3456 #if (USE_SPI_CRC != 0U)\r
3457 /**\r
3458   * @brief  Rx 8-bit handler for Transmit and Receive in Interrupt mode.\r
3459   * @param  hspi pointer to a SPI_HandleTypeDef structure that contains\r
3460   *               the configuration information for SPI module.\r
3461   * @retval None\r
3462   */\r
3463 static void SPI_2linesRxISR_8BITCRC(struct __SPI_HandleTypeDef *hspi)\r
3464 {\r
3465   /* Read 8bit CRC to flush Data Regsiter */\r
3466   READ_REG(*(__IO uint8_t *)&hspi->Instance->DR);\r
3467 \r
3468   hspi->CRCSize--;\r
3469 \r
3470   /* Check end of the reception */\r
3471   if (hspi->CRCSize == 0U)\r
3472   {\r
3473     /* Disable RXNE and ERR interrupt */\r
3474     __HAL_SPI_DISABLE_IT(hspi, (SPI_IT_RXNE | SPI_IT_ERR));\r
3475 \r
3476     if (hspi->TxXferCount == 0U)\r
3477     {\r
3478       SPI_CloseRxTx_ISR(hspi);\r
3479     }\r
3480   }\r
3481 }\r
3482 #endif /* USE_SPI_CRC */\r
3483 \r
3484 /**\r
3485   * @brief  Tx 8-bit handler for Transmit and Receive in Interrupt mode.\r
3486   * @param  hspi pointer to a SPI_HandleTypeDef structure that contains\r
3487   *               the configuration information for SPI module.\r
3488   * @retval None\r
3489   */\r
3490 static void SPI_2linesTxISR_8BIT(struct __SPI_HandleTypeDef *hspi)\r
3491 {\r
3492   /* Transmit data in packing Bit mode */\r
3493   if (hspi->TxXferCount >= 2U)\r
3494   {\r
3495     hspi->Instance->DR = *((uint16_t *)hspi->pTxBuffPtr);\r
3496     hspi->pTxBuffPtr += sizeof(uint16_t);\r
3497     hspi->TxXferCount -= 2U;\r
3498   }\r
3499   /* Transmit data in 8 Bit mode */\r
3500   else\r
3501   {\r
3502     *(__IO uint8_t *)&hspi->Instance->DR = (*hspi->pTxBuffPtr);\r
3503     hspi->pTxBuffPtr++;\r
3504     hspi->TxXferCount--;\r
3505   }\r
3506 \r
3507   /* Check the end of the transmission */\r
3508   if (hspi->TxXferCount == 0U)\r
3509   {\r
3510 #if (USE_SPI_CRC != 0U)\r
3511     if (hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)\r
3512     {\r
3513       /* Set CRC Next Bit to send CRC */\r
3514       SET_BIT(hspi->Instance->CR1, SPI_CR1_CRCNEXT);\r
3515       /* Disable TXE interrupt */\r
3516       __HAL_SPI_DISABLE_IT(hspi, SPI_IT_TXE);\r
3517       return;\r
3518     }\r
3519 #endif /* USE_SPI_CRC */\r
3520 \r
3521     /* Disable TXE interrupt */\r
3522     __HAL_SPI_DISABLE_IT(hspi, SPI_IT_TXE);\r
3523 \r
3524     if (hspi->RxXferCount == 0U)\r
3525     {\r
3526       SPI_CloseRxTx_ISR(hspi);\r
3527     }\r
3528   }\r
3529 }\r
3530 \r
3531 /**\r
3532   * @brief  Rx 16-bit handler for Transmit and Receive in Interrupt mode.\r
3533   * @param  hspi pointer to a SPI_HandleTypeDef structure that contains\r
3534   *               the configuration information for SPI module.\r
3535   * @retval None\r
3536   */\r
3537 static void SPI_2linesRxISR_16BIT(struct __SPI_HandleTypeDef *hspi)\r
3538 {\r
3539   /* Receive data in 16 Bit mode */\r
3540   *((uint16_t *)hspi->pRxBuffPtr) = (uint16_t)(hspi->Instance->DR);\r
3541   hspi->pRxBuffPtr += sizeof(uint16_t);\r
3542   hspi->RxXferCount--;\r
3543 \r
3544   if (hspi->RxXferCount == 0U)\r
3545   {\r
3546 #if (USE_SPI_CRC != 0U)\r
3547     if (hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)\r
3548     {\r
3549       hspi->RxISR =  SPI_2linesRxISR_16BITCRC;\r
3550       return;\r
3551     }\r
3552 #endif /* USE_SPI_CRC */\r
3553 \r
3554     /* Disable RXNE interrupt */\r
3555     __HAL_SPI_DISABLE_IT(hspi, SPI_IT_RXNE);\r
3556 \r
3557     if (hspi->TxXferCount == 0U)\r
3558     {\r
3559       SPI_CloseRxTx_ISR(hspi);\r
3560     }\r
3561   }\r
3562 }\r
3563 \r
3564 #if (USE_SPI_CRC != 0U)\r
3565 /**\r
3566   * @brief  Manage the CRC 16-bit receive for Transmit and Receive in Interrupt mode.\r
3567   * @param  hspi pointer to a SPI_HandleTypeDef structure that contains\r
3568   *               the configuration information for SPI module.\r
3569   * @retval None\r
3570   */\r
3571 static void SPI_2linesRxISR_16BITCRC(struct __SPI_HandleTypeDef *hspi)\r
3572 {\r
3573   /* Read 16bit CRC to flush Data Regsiter */\r
3574   READ_REG(hspi->Instance->DR);\r
3575 \r
3576   /* Disable RXNE interrupt */\r
3577   __HAL_SPI_DISABLE_IT(hspi, SPI_IT_RXNE);\r
3578 \r
3579   SPI_CloseRxTx_ISR(hspi);\r
3580 }\r
3581 #endif /* USE_SPI_CRC */\r
3582 \r
3583 /**\r
3584   * @brief  Tx 16-bit handler for Transmit and Receive in Interrupt mode.\r
3585   * @param  hspi pointer to a SPI_HandleTypeDef structure that contains\r
3586   *               the configuration information for SPI module.\r
3587   * @retval None\r
3588   */\r
3589 static void SPI_2linesTxISR_16BIT(struct __SPI_HandleTypeDef *hspi)\r
3590 {\r
3591   /* Transmit data in 16 Bit mode */\r
3592   hspi->Instance->DR = *((uint16_t *)hspi->pTxBuffPtr);\r
3593   hspi->pTxBuffPtr += sizeof(uint16_t);\r
3594   hspi->TxXferCount--;\r
3595 \r
3596   /* Enable CRC Transmission */\r
3597   if (hspi->TxXferCount == 0U)\r
3598   {\r
3599 #if (USE_SPI_CRC != 0U)\r
3600     if (hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)\r
3601     {\r
3602       /* Set CRC Next Bit to send CRC */\r
3603       SET_BIT(hspi->Instance->CR1, SPI_CR1_CRCNEXT);\r
3604       /* Disable TXE interrupt */\r
3605       __HAL_SPI_DISABLE_IT(hspi, SPI_IT_TXE);\r
3606       return;\r
3607     }\r
3608 #endif /* USE_SPI_CRC */\r
3609 \r
3610     /* Disable TXE interrupt */\r
3611     __HAL_SPI_DISABLE_IT(hspi, SPI_IT_TXE);\r
3612 \r
3613     if (hspi->RxXferCount == 0U)\r
3614     {\r
3615       SPI_CloseRxTx_ISR(hspi);\r
3616     }\r
3617   }\r
3618 }\r
3619 \r
3620 #if (USE_SPI_CRC != 0U)\r
3621 /**\r
3622   * @brief  Manage the CRC 8-bit receive in Interrupt context.\r
3623   * @param  hspi pointer to a SPI_HandleTypeDef structure that contains\r
3624   *               the configuration information for SPI module.\r
3625   * @retval None\r
3626   */\r
3627 static void SPI_RxISR_8BITCRC(struct __SPI_HandleTypeDef *hspi)\r
3628 {\r
3629   /* Read 8bit CRC to flush Data Register */\r
3630   READ_REG(*(__IO uint8_t *)&hspi->Instance->DR);\r
3631 \r
3632   hspi->CRCSize--;\r
3633 \r
3634   if (hspi->CRCSize == 0U)\r
3635   {\r
3636     SPI_CloseRx_ISR(hspi);\r
3637   }\r
3638 }\r
3639 #endif /* USE_SPI_CRC */\r
3640 \r
3641 /**\r
3642   * @brief  Manage the receive 8-bit in Interrupt context.\r
3643   * @param  hspi pointer to a SPI_HandleTypeDef structure that contains\r
3644   *               the configuration information for SPI module.\r
3645   * @retval None\r
3646   */\r
3647 static void SPI_RxISR_8BIT(struct __SPI_HandleTypeDef *hspi)\r
3648 {\r
3649   *hspi->pRxBuffPtr = (*(__IO uint8_t *)&hspi->Instance->DR);\r
3650   hspi->pRxBuffPtr++;\r
3651   hspi->RxXferCount--;\r
3652 \r
3653 #if (USE_SPI_CRC != 0U)\r
3654   /* Enable CRC Transmission */\r
3655   if ((hspi->RxXferCount == 1U) && (hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE))\r
3656   {\r
3657     SET_BIT(hspi->Instance->CR1, SPI_CR1_CRCNEXT);\r
3658   }\r
3659 #endif /* USE_SPI_CRC */\r
3660 \r
3661   if (hspi->RxXferCount == 0U)\r
3662   {\r
3663 #if (USE_SPI_CRC != 0U)\r
3664     if (hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)\r
3665     {\r
3666       hspi->RxISR =  SPI_RxISR_8BITCRC;\r
3667       return;\r
3668     }\r
3669 #endif /* USE_SPI_CRC */\r
3670     SPI_CloseRx_ISR(hspi);\r
3671   }\r
3672 }\r
3673 \r
3674 #if (USE_SPI_CRC != 0U)\r
3675 /**\r
3676   * @brief  Manage the CRC 16-bit receive in Interrupt context.\r
3677   * @param  hspi pointer to a SPI_HandleTypeDef structure that contains\r
3678   *               the configuration information for SPI module.\r
3679   * @retval None\r
3680   */\r
3681 static void SPI_RxISR_16BITCRC(struct __SPI_HandleTypeDef *hspi)\r
3682 {\r
3683   /* Read 16bit CRC to flush Data Register */\r
3684   READ_REG(hspi->Instance->DR);\r
3685 \r
3686   /* Disable RXNE and ERR interrupt */\r
3687   __HAL_SPI_DISABLE_IT(hspi, (SPI_IT_RXNE | SPI_IT_ERR));\r
3688 \r
3689   SPI_CloseRx_ISR(hspi);\r
3690 }\r
3691 #endif /* USE_SPI_CRC */\r
3692 \r
3693 /**\r
3694   * @brief  Manage the 16-bit receive in Interrupt context.\r
3695   * @param  hspi pointer to a SPI_HandleTypeDef structure that contains\r
3696   *               the configuration information for SPI module.\r
3697   * @retval None\r
3698   */\r
3699 static void SPI_RxISR_16BIT(struct __SPI_HandleTypeDef *hspi)\r
3700 {\r
3701   *((uint16_t *)hspi->pRxBuffPtr) = (uint16_t)(hspi->Instance->DR);\r
3702   hspi->pRxBuffPtr += sizeof(uint16_t);\r
3703   hspi->RxXferCount--;\r
3704 \r
3705 #if (USE_SPI_CRC != 0U)\r
3706   /* Enable CRC Transmission */\r
3707   if ((hspi->RxXferCount == 1U) && (hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE))\r
3708   {\r
3709     SET_BIT(hspi->Instance->CR1, SPI_CR1_CRCNEXT);\r
3710   }\r
3711 #endif /* USE_SPI_CRC */\r
3712 \r
3713   if (hspi->RxXferCount == 0U)\r
3714   {\r
3715 #if (USE_SPI_CRC != 0U)\r
3716     if (hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)\r
3717     {\r
3718       hspi->RxISR = SPI_RxISR_16BITCRC;\r
3719       return;\r
3720     }\r
3721 #endif /* USE_SPI_CRC */\r
3722     SPI_CloseRx_ISR(hspi);\r
3723   }\r
3724 }\r
3725 \r
3726 /**\r
3727   * @brief  Handle the data 8-bit transmit in Interrupt mode.\r
3728   * @param  hspi pointer to a SPI_HandleTypeDef structure that contains\r
3729   *               the configuration information for SPI module.\r
3730   * @retval None\r
3731   */\r
3732 static void SPI_TxISR_8BIT(struct __SPI_HandleTypeDef *hspi)\r
3733 {\r
3734   *(__IO uint8_t *)&hspi->Instance->DR = (*hspi->pTxBuffPtr);\r
3735   hspi->pTxBuffPtr++;\r
3736   hspi->TxXferCount--;\r
3737 \r
3738   if (hspi->TxXferCount == 0U)\r
3739   {\r
3740 #if (USE_SPI_CRC != 0U)\r
3741     if (hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)\r
3742     {\r
3743       /* Enable CRC Transmission */\r
3744       SET_BIT(hspi->Instance->CR1, SPI_CR1_CRCNEXT);\r
3745     }\r
3746 #endif /* USE_SPI_CRC */\r
3747     SPI_CloseTx_ISR(hspi);\r
3748   }\r
3749 }\r
3750 \r
3751 /**\r
3752   * @brief  Handle the data 16-bit transmit in Interrupt mode.\r
3753   * @param  hspi pointer to a SPI_HandleTypeDef structure that contains\r
3754   *               the configuration information for SPI module.\r
3755   * @retval None\r
3756   */\r
3757 static void SPI_TxISR_16BIT(struct __SPI_HandleTypeDef *hspi)\r
3758 {\r
3759   /* Transmit data in 16 Bit mode */\r
3760   hspi->Instance->DR = *((uint16_t *)hspi->pTxBuffPtr);\r
3761   hspi->pTxBuffPtr += sizeof(uint16_t);\r
3762   hspi->TxXferCount--;\r
3763 \r
3764   if (hspi->TxXferCount == 0U)\r
3765   {\r
3766 #if (USE_SPI_CRC != 0U)\r
3767     if (hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)\r
3768     {\r
3769       /* Enable CRC Transmission */\r
3770       SET_BIT(hspi->Instance->CR1, SPI_CR1_CRCNEXT);\r
3771     }\r
3772 #endif /* USE_SPI_CRC */\r
3773     SPI_CloseTx_ISR(hspi);\r
3774   }\r
3775 }\r
3776 \r
3777 /**\r
3778   * @brief  Handle SPI Communication Timeout.\r
3779   * @param  hspi pointer to a SPI_HandleTypeDef structure that contains\r
3780   *              the configuration information for SPI module.\r
3781   * @param  Flag SPI flag to check\r
3782   * @param  State flag state to check\r
3783   * @param  Timeout Timeout duration\r
3784   * @param  Tickstart tick start value\r
3785   * @retval HAL status\r
3786   */\r
3787 static HAL_StatusTypeDef SPI_WaitFlagStateUntilTimeout(SPI_HandleTypeDef *hspi, uint32_t Flag, FlagStatus State,\r
3788                                                        uint32_t Timeout, uint32_t Tickstart)\r
3789 {\r
3790   while ((__HAL_SPI_GET_FLAG(hspi, Flag) ? SET : RESET) != State)\r
3791   {\r
3792     if (Timeout != HAL_MAX_DELAY)\r
3793     {\r
3794       if (((HAL_GetTick() - Tickstart) >= Timeout) || (Timeout == 0U))\r
3795       {\r
3796         /* Disable the SPI and reset the CRC: the CRC value should be cleared\r
3797         on both master and slave sides in order to resynchronize the master\r
3798         and slave for their respective CRC calculation */\r
3799 \r
3800         /* Disable TXE, RXNE and ERR interrupts for the interrupt process */\r
3801         __HAL_SPI_DISABLE_IT(hspi, (SPI_IT_TXE | SPI_IT_RXNE | SPI_IT_ERR));\r
3802 \r
3803         if ((hspi->Init.Mode == SPI_MODE_MASTER) && ((hspi->Init.Direction == SPI_DIRECTION_1LINE)\r
3804                                                      || (hspi->Init.Direction == SPI_DIRECTION_2LINES_RXONLY)))\r
3805         {\r
3806           /* Disable SPI peripheral */\r
3807           __HAL_SPI_DISABLE(hspi);\r
3808         }\r
3809 \r
3810         /* Reset CRC Calculation */\r
3811         if (hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)\r
3812         {\r
3813           SPI_RESET_CRC(hspi);\r
3814         }\r
3815 \r
3816         hspi->State = HAL_SPI_STATE_READY;\r
3817 \r
3818         /* Process Unlocked */\r
3819         __HAL_UNLOCK(hspi);\r
3820 \r
3821         return HAL_TIMEOUT;\r
3822       }\r
3823     }\r
3824   }\r
3825 \r
3826   return HAL_OK;\r
3827 }\r
3828 \r
3829 /**\r
3830   * @brief  Handle SPI FIFO Communication Timeout.\r
3831   * @param  hspi pointer to a SPI_HandleTypeDef structure that contains\r
3832   *              the configuration information for SPI module.\r
3833   * @param  Fifo Fifo to check\r
3834   * @param  State Fifo state to check\r
3835   * @param  Timeout Timeout duration\r
3836   * @param  Tickstart tick start value\r
3837   * @retval HAL status\r
3838   */\r
3839 static HAL_StatusTypeDef SPI_WaitFifoStateUntilTimeout(SPI_HandleTypeDef *hspi, uint32_t Fifo, uint32_t State,\r
3840                                                        uint32_t Timeout, uint32_t Tickstart)\r
3841 {\r
3842   while ((hspi->Instance->SR & Fifo) != State)\r
3843   {\r
3844     if ((Fifo == SPI_SR_FRLVL) && (State == SPI_FRLVL_EMPTY))\r
3845     {\r
3846       /* Read 8bit CRC to flush Data Register */\r
3847       READ_REG(*((__IO uint8_t *)&hspi->Instance->DR));\r
3848     }\r
3849 \r
3850     if (Timeout != HAL_MAX_DELAY)\r
3851     {\r
3852       if (((HAL_GetTick() - Tickstart) >= Timeout) || (Timeout == 0U))\r
3853       {\r
3854         /* Disable the SPI and reset the CRC: the CRC value should be cleared\r
3855            on both master and slave sides in order to resynchronize the master\r
3856            and slave for their respective CRC calculation */\r
3857 \r
3858         /* Disable TXE, RXNE and ERR interrupts for the interrupt process */\r
3859         __HAL_SPI_DISABLE_IT(hspi, (SPI_IT_TXE | SPI_IT_RXNE | SPI_IT_ERR));\r
3860 \r
3861         if ((hspi->Init.Mode == SPI_MODE_MASTER) && ((hspi->Init.Direction == SPI_DIRECTION_1LINE)\r
3862                                                      || (hspi->Init.Direction == SPI_DIRECTION_2LINES_RXONLY)))\r
3863         {\r
3864           /* Disable SPI peripheral */\r
3865           __HAL_SPI_DISABLE(hspi);\r
3866         }\r
3867 \r
3868         /* Reset CRC Calculation */\r
3869         if (hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)\r
3870         {\r
3871           SPI_RESET_CRC(hspi);\r
3872         }\r
3873 \r
3874         hspi->State = HAL_SPI_STATE_READY;\r
3875 \r
3876         /* Process Unlocked */\r
3877         __HAL_UNLOCK(hspi);\r
3878 \r
3879         return HAL_TIMEOUT;\r
3880       }\r
3881     }\r
3882   }\r
3883 \r
3884   return HAL_OK;\r
3885 }\r
3886 \r
3887 /**\r
3888   * @brief  Handle the check of the RX transaction complete.\r
3889   * @param  hspi pointer to a SPI_HandleTypeDef structure that contains\r
3890   *               the configuration information for SPI module.\r
3891   * @param  Timeout Timeout duration\r
3892   * @param  Tickstart tick start value\r
3893   * @retval HAL status\r
3894   */\r
3895 static HAL_StatusTypeDef SPI_EndRxTransaction(SPI_HandleTypeDef *hspi,  uint32_t Timeout, uint32_t Tickstart)\r
3896 {\r
3897   if ((hspi->Init.Mode == SPI_MODE_MASTER) && ((hspi->Init.Direction == SPI_DIRECTION_1LINE)\r
3898                                                || (hspi->Init.Direction == SPI_DIRECTION_2LINES_RXONLY)))\r
3899   {\r
3900     /* Disable SPI peripheral */\r
3901     __HAL_SPI_DISABLE(hspi);\r
3902   }\r
3903 \r
3904   /* Control the BSY flag */\r
3905   if (SPI_WaitFlagStateUntilTimeout(hspi, SPI_FLAG_BSY, RESET, Timeout, Tickstart) != HAL_OK)\r
3906   {\r
3907     SET_BIT(hspi->ErrorCode, HAL_SPI_ERROR_FLAG);\r
3908     return HAL_TIMEOUT;\r
3909   }\r
3910 \r
3911   if ((hspi->Init.Mode == SPI_MODE_MASTER) && ((hspi->Init.Direction == SPI_DIRECTION_1LINE)\r
3912                                                || (hspi->Init.Direction == SPI_DIRECTION_2LINES_RXONLY)))\r
3913   {\r
3914     /* Empty the FRLVL fifo */\r
3915     if (SPI_WaitFifoStateUntilTimeout(hspi, SPI_FLAG_FRLVL, SPI_FRLVL_EMPTY, Timeout, Tickstart) != HAL_OK)\r
3916     {\r
3917       SET_BIT(hspi->ErrorCode, HAL_SPI_ERROR_FLAG);\r
3918       return HAL_TIMEOUT;\r
3919     }\r
3920   }\r
3921   return HAL_OK;\r
3922 }\r
3923 \r
3924 /**\r
3925   * @brief  Handle the check of the RXTX or TX transaction complete.\r
3926   * @param  hspi SPI handle\r
3927   * @param  Timeout Timeout duration\r
3928   * @param  Tickstart tick start value\r
3929   * @retval HAL status\r
3930   */\r
3931 static HAL_StatusTypeDef SPI_EndRxTxTransaction(SPI_HandleTypeDef *hspi, uint32_t Timeout, uint32_t Tickstart)\r
3932 {\r
3933   /* Control if the TX fifo is empty */\r
3934   if (SPI_WaitFifoStateUntilTimeout(hspi, SPI_FLAG_FTLVL, SPI_FTLVL_EMPTY, Timeout, Tickstart) != HAL_OK)\r
3935   {\r
3936     SET_BIT(hspi->ErrorCode, HAL_SPI_ERROR_FLAG);\r
3937     return HAL_TIMEOUT;\r
3938   }\r
3939 \r
3940   /* Control the BSY flag */\r
3941   if (SPI_WaitFlagStateUntilTimeout(hspi, SPI_FLAG_BSY, RESET, Timeout, Tickstart) != HAL_OK)\r
3942   {\r
3943     SET_BIT(hspi->ErrorCode, HAL_SPI_ERROR_FLAG);\r
3944     return HAL_TIMEOUT;\r
3945   }\r
3946 \r
3947   /* Control if the RX fifo is empty */\r
3948   if (SPI_WaitFifoStateUntilTimeout(hspi, SPI_FLAG_FRLVL, SPI_FRLVL_EMPTY, Timeout, Tickstart) != HAL_OK)\r
3949   {\r
3950     SET_BIT(hspi->ErrorCode, HAL_SPI_ERROR_FLAG);\r
3951     return HAL_TIMEOUT;\r
3952   }\r
3953 \r
3954   return HAL_OK;\r
3955 }\r
3956 \r
3957 /**\r
3958   * @brief  Handle the end of the RXTX transaction.\r
3959   * @param  hspi pointer to a SPI_HandleTypeDef structure that contains\r
3960   *               the configuration information for SPI module.\r
3961   * @retval None\r
3962   */\r
3963 static void SPI_CloseRxTx_ISR(SPI_HandleTypeDef *hspi)\r
3964 {\r
3965   uint32_t tickstart;\r
3966 \r
3967   /* Init tickstart for timeout managment*/\r
3968   tickstart = HAL_GetTick();\r
3969 \r
3970   /* Disable ERR interrupt */\r
3971   __HAL_SPI_DISABLE_IT(hspi, SPI_IT_ERR);\r
3972 \r
3973   /* Check the end of the transaction */\r
3974   if (SPI_EndRxTxTransaction(hspi, SPI_DEFAULT_TIMEOUT, tickstart) != HAL_OK)\r
3975   {\r
3976     SET_BIT(hspi->ErrorCode, HAL_SPI_ERROR_FLAG);\r
3977   }\r
3978 \r
3979 #if (USE_SPI_CRC != 0U)\r
3980   /* Check if CRC error occurred */\r
3981   if (__HAL_SPI_GET_FLAG(hspi, SPI_FLAG_CRCERR) != RESET)\r
3982   {\r
3983     hspi->State = HAL_SPI_STATE_READY;\r
3984     SET_BIT(hspi->ErrorCode, HAL_SPI_ERROR_CRC);\r
3985     __HAL_SPI_CLEAR_CRCERRFLAG(hspi);\r
3986     /* Call user error callback */\r
3987 #if (USE_HAL_SPI_REGISTER_CALLBACKS == 1U)\r
3988     hspi->ErrorCallback(hspi);\r
3989 #else\r
3990     HAL_SPI_ErrorCallback(hspi);\r
3991 #endif /* USE_HAL_SPI_REGISTER_CALLBACKS */\r
3992   }\r
3993   else\r
3994   {\r
3995 #endif /* USE_SPI_CRC */\r
3996     if (hspi->ErrorCode == HAL_SPI_ERROR_NONE)\r
3997     {\r
3998       if (hspi->State == HAL_SPI_STATE_BUSY_RX)\r
3999       {\r
4000         hspi->State = HAL_SPI_STATE_READY;\r
4001         /* Call user Rx complete callback */\r
4002 #if (USE_HAL_SPI_REGISTER_CALLBACKS == 1U)\r
4003         hspi->RxCpltCallback(hspi);\r
4004 #else\r
4005         HAL_SPI_RxCpltCallback(hspi);\r
4006 #endif /* USE_HAL_SPI_REGISTER_CALLBACKS */\r
4007       }\r
4008       else\r
4009       {\r
4010         hspi->State = HAL_SPI_STATE_READY;\r
4011         /* Call user TxRx complete callback */\r
4012 #if (USE_HAL_SPI_REGISTER_CALLBACKS == 1U)\r
4013         hspi->TxRxCpltCallback(hspi);\r
4014 #else\r
4015         HAL_SPI_TxRxCpltCallback(hspi);\r
4016 #endif /* USE_HAL_SPI_REGISTER_CALLBACKS */\r
4017       }\r
4018     }\r
4019     else\r
4020     {\r
4021       hspi->State = HAL_SPI_STATE_READY;\r
4022       /* Call user error callback */\r
4023 #if (USE_HAL_SPI_REGISTER_CALLBACKS == 1U)\r
4024       hspi->ErrorCallback(hspi);\r
4025 #else\r
4026       HAL_SPI_ErrorCallback(hspi);\r
4027 #endif /* USE_HAL_SPI_REGISTER_CALLBACKS */\r
4028     }\r
4029 #if (USE_SPI_CRC != 0U)\r
4030   }\r
4031 #endif /* USE_SPI_CRC */\r
4032 }\r
4033 \r
4034 /**\r
4035   * @brief  Handle the end of the RX transaction.\r
4036   * @param  hspi pointer to a SPI_HandleTypeDef structure that contains\r
4037   *               the configuration information for SPI module.\r
4038   * @retval None\r
4039   */\r
4040 static void SPI_CloseRx_ISR(SPI_HandleTypeDef *hspi)\r
4041 {\r
4042   /* Disable RXNE and ERR interrupt */\r
4043   __HAL_SPI_DISABLE_IT(hspi, (SPI_IT_RXNE | SPI_IT_ERR));\r
4044 \r
4045   /* Check the end of the transaction */\r
4046   if (SPI_EndRxTransaction(hspi, SPI_DEFAULT_TIMEOUT, HAL_GetTick()) != HAL_OK)\r
4047   {\r
4048     SET_BIT(hspi->ErrorCode, HAL_SPI_ERROR_FLAG);\r
4049   }\r
4050   hspi->State = HAL_SPI_STATE_READY;\r
4051 \r
4052 #if (USE_SPI_CRC != 0U)\r
4053   /* Check if CRC error occurred */\r
4054   if (__HAL_SPI_GET_FLAG(hspi, SPI_FLAG_CRCERR) != RESET)\r
4055   {\r
4056     SET_BIT(hspi->ErrorCode, HAL_SPI_ERROR_CRC);\r
4057     __HAL_SPI_CLEAR_CRCERRFLAG(hspi);\r
4058     /* Call user error callback */\r
4059 #if (USE_HAL_SPI_REGISTER_CALLBACKS == 1U)\r
4060     hspi->ErrorCallback(hspi);\r
4061 #else\r
4062     HAL_SPI_ErrorCallback(hspi);\r
4063 #endif /* USE_HAL_SPI_REGISTER_CALLBACKS */\r
4064   }\r
4065   else\r
4066   {\r
4067 #endif /* USE_SPI_CRC */\r
4068     if (hspi->ErrorCode == HAL_SPI_ERROR_NONE)\r
4069     {\r
4070       /* Call user Rx complete callback */\r
4071 #if (USE_HAL_SPI_REGISTER_CALLBACKS == 1U)\r
4072       hspi->RxCpltCallback(hspi);\r
4073 #else\r
4074       HAL_SPI_RxCpltCallback(hspi);\r
4075 #endif /* USE_HAL_SPI_REGISTER_CALLBACKS */\r
4076     }\r
4077     else\r
4078     {\r
4079       /* Call user error callback */\r
4080 #if (USE_HAL_SPI_REGISTER_CALLBACKS == 1U)\r
4081       hspi->ErrorCallback(hspi);\r
4082 #else\r
4083       HAL_SPI_ErrorCallback(hspi);\r
4084 #endif /* USE_HAL_SPI_REGISTER_CALLBACKS */\r
4085     }\r
4086 #if (USE_SPI_CRC != 0U)\r
4087   }\r
4088 #endif /* USE_SPI_CRC */\r
4089 }\r
4090 \r
4091 /**\r
4092   * @brief  Handle the end of the TX transaction.\r
4093   * @param  hspi pointer to a SPI_HandleTypeDef structure that contains\r
4094   *               the configuration information for SPI module.\r
4095   * @retval None\r
4096   */\r
4097 static void SPI_CloseTx_ISR(SPI_HandleTypeDef *hspi)\r
4098 {\r
4099   uint32_t tickstart;\r
4100 \r
4101   /* Init tickstart for timeout management*/\r
4102   tickstart = HAL_GetTick();\r
4103 \r
4104   /* Disable TXE and ERR interrupt */\r
4105   __HAL_SPI_DISABLE_IT(hspi, (SPI_IT_TXE | SPI_IT_ERR));\r
4106 \r
4107   /* Check the end of the transaction */\r
4108   if (SPI_EndRxTxTransaction(hspi, SPI_DEFAULT_TIMEOUT, tickstart) != HAL_OK)\r
4109   {\r
4110     SET_BIT(hspi->ErrorCode, HAL_SPI_ERROR_FLAG);\r
4111   }\r
4112 \r
4113   /* Clear overrun flag in 2 Lines communication mode because received is not read */\r
4114   if (hspi->Init.Direction == SPI_DIRECTION_2LINES)\r
4115   {\r
4116     __HAL_SPI_CLEAR_OVRFLAG(hspi);\r
4117   }\r
4118 \r
4119   hspi->State = HAL_SPI_STATE_READY;\r
4120   if (hspi->ErrorCode != HAL_SPI_ERROR_NONE)\r
4121   {\r
4122     /* Call user error callback */\r
4123 #if (USE_HAL_SPI_REGISTER_CALLBACKS == 1U)\r
4124     hspi->ErrorCallback(hspi);\r
4125 #else\r
4126     HAL_SPI_ErrorCallback(hspi);\r
4127 #endif /* USE_HAL_SPI_REGISTER_CALLBACKS */\r
4128   }\r
4129   else\r
4130   {\r
4131     /* Call user Rx complete callback */\r
4132 #if (USE_HAL_SPI_REGISTER_CALLBACKS == 1U)\r
4133     hspi->TxCpltCallback(hspi);\r
4134 #else\r
4135     HAL_SPI_TxCpltCallback(hspi);\r
4136 #endif /* USE_HAL_SPI_REGISTER_CALLBACKS */\r
4137   }\r
4138 }\r
4139 \r
4140 /**\r
4141   * @brief  Handle abort a Rx transaction.\r
4142   * @param  hspi pointer to a SPI_HandleTypeDef structure that contains\r
4143   *               the configuration information for SPI module.\r
4144   * @retval None\r
4145   */\r
4146 static void SPI_AbortRx_ISR(SPI_HandleTypeDef *hspi)\r
4147 {\r
4148   __IO uint32_t count;\r
4149 \r
4150   /* Disable SPI Peripheral */\r
4151   __HAL_SPI_DISABLE(hspi);\r
4152 \r
4153   count = SPI_DEFAULT_TIMEOUT * (SystemCoreClock / 24U / 1000U);\r
4154 \r
4155   /* Disable RXNEIE interrupt */\r
4156   CLEAR_BIT(hspi->Instance->CR2, (SPI_CR2_RXNEIE));\r
4157 \r
4158   /* Check RXNEIE is disabled */\r
4159   do\r
4160   {\r
4161     if (count == 0U)\r
4162     {\r
4163       SET_BIT(hspi->ErrorCode, HAL_SPI_ERROR_ABORT);\r
4164       break;\r
4165     }\r
4166     count--;\r
4167   }\r
4168   while (HAL_IS_BIT_SET(hspi->Instance->CR2, SPI_CR2_RXNEIE));\r
4169 \r
4170   /* Control the BSY flag */\r
4171   if (SPI_WaitFlagStateUntilTimeout(hspi, SPI_FLAG_BSY, RESET, SPI_DEFAULT_TIMEOUT, HAL_GetTick()) != HAL_OK)\r
4172   {\r
4173     hspi->ErrorCode = HAL_SPI_ERROR_ABORT;\r
4174   }\r
4175 \r
4176   /* Empty the FRLVL fifo */\r
4177   if (SPI_WaitFifoStateUntilTimeout(hspi, SPI_FLAG_FRLVL, SPI_FRLVL_EMPTY, SPI_DEFAULT_TIMEOUT, HAL_GetTick()) != HAL_OK)\r
4178   {\r
4179     hspi->ErrorCode = HAL_SPI_ERROR_ABORT;\r
4180   }\r
4181 \r
4182   hspi->State = HAL_SPI_STATE_ABORT;\r
4183 }\r
4184 \r
4185 /**\r
4186   * @brief  Handle abort a Tx or Rx/Tx transaction.\r
4187   * @param  hspi pointer to a SPI_HandleTypeDef structure that contains\r
4188   *               the configuration information for SPI module.\r
4189   * @retval None\r
4190   */\r
4191 static void SPI_AbortTx_ISR(SPI_HandleTypeDef *hspi)\r
4192 {\r
4193   __IO uint32_t count;\r
4194 \r
4195   count = SPI_DEFAULT_TIMEOUT * (SystemCoreClock / 24U / 1000U);\r
4196 \r
4197   /* Disable TXEIE interrupt */\r
4198   CLEAR_BIT(hspi->Instance->CR2, (SPI_CR2_TXEIE));\r
4199 \r
4200   /* Check TXEIE is disabled */\r
4201   do\r
4202   {\r
4203     if (count == 0U)\r
4204     {\r
4205       SET_BIT(hspi->ErrorCode, HAL_SPI_ERROR_ABORT);\r
4206       break;\r
4207     }\r
4208     count--;\r
4209   }\r
4210   while (HAL_IS_BIT_SET(hspi->Instance->CR2, SPI_CR2_TXEIE));\r
4211 \r
4212   if (SPI_EndRxTxTransaction(hspi, SPI_DEFAULT_TIMEOUT, HAL_GetTick()) != HAL_OK)\r
4213   {\r
4214     hspi->ErrorCode = HAL_SPI_ERROR_ABORT;\r
4215   }\r
4216 \r
4217   /* Disable SPI Peripheral */\r
4218   __HAL_SPI_DISABLE(hspi);\r
4219 \r
4220   /* Empty the FRLVL fifo */\r
4221   if (SPI_WaitFifoStateUntilTimeout(hspi, SPI_FLAG_FRLVL, SPI_FRLVL_EMPTY, SPI_DEFAULT_TIMEOUT, HAL_GetTick()) != HAL_OK)\r
4222   {\r
4223     hspi->ErrorCode = HAL_SPI_ERROR_ABORT;\r
4224   }\r
4225 \r
4226   /* Check case of Full-Duplex Mode and disable directly RXNEIE interrupt */\r
4227   if (HAL_IS_BIT_SET(hspi->Instance->CR2, SPI_CR2_RXNEIE))\r
4228   {\r
4229     /* Disable RXNEIE interrupt */\r
4230     CLEAR_BIT(hspi->Instance->CR2, (SPI_CR2_RXNEIE));\r
4231 \r
4232     /* Check RXNEIE is disabled */\r
4233     do\r
4234     {\r
4235       if (count == 0U)\r
4236       {\r
4237         SET_BIT(hspi->ErrorCode, HAL_SPI_ERROR_ABORT);\r
4238         break;\r
4239       }\r
4240       count--;\r
4241     }\r
4242     while (HAL_IS_BIT_SET(hspi->Instance->CR2, SPI_CR2_RXNEIE));\r
4243 \r
4244     /* Control the BSY flag */\r
4245     if (SPI_WaitFlagStateUntilTimeout(hspi, SPI_FLAG_BSY, RESET, SPI_DEFAULT_TIMEOUT, HAL_GetTick()) != HAL_OK)\r
4246     {\r
4247       hspi->ErrorCode = HAL_SPI_ERROR_ABORT;\r
4248     }\r
4249 \r
4250     /* Empty the FRLVL fifo */\r
4251     if (SPI_WaitFifoStateUntilTimeout(hspi, SPI_FLAG_FRLVL, SPI_FRLVL_EMPTY, SPI_DEFAULT_TIMEOUT, HAL_GetTick()) != HAL_OK)\r
4252     {\r
4253       hspi->ErrorCode = HAL_SPI_ERROR_ABORT;\r
4254     }\r
4255   }\r
4256   hspi->State = HAL_SPI_STATE_ABORT;\r
4257 }\r
4258 \r
4259 /**\r
4260   * @}\r
4261   */\r
4262 \r
4263 #endif /* HAL_SPI_MODULE_ENABLED */\r
4264 \r
4265 /**\r
4266   * @}\r
4267   */\r
4268 \r
4269 /**\r
4270   * @}\r
4271   */\r
4272 \r
4273 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/\r