TUKS MCU Introductory course / TUKS-COURSE-TIMER

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

HAL_L476/stm32l4xx_hal_spi.c@1:d0dfbce63a89, 2017-02-24 (annotated)

Committer:
elmot
Date:
Fri Feb 24 21:13:56 2017 +0000
Revision:
1:d0dfbce63a89
Ready-to-copy

Who changed what in which revision?

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