mbed-dev - mbed library sources. Supersedes mbed-src.

Users » mbed_official » Code » mbed-dev

mbed official / mbed-dev

mbed library sources. Supersedes mbed-src.

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

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

Committer:: <>
Date:: Fri Oct 28 11:17:30 2016 +0100
Revision:: 149:156823d33999
Parent:: targets/cmsis/TARGET_STM/TARGET_STM32F7/stm32f7xx_hal_spi.c@144:ef7eb2e8f9f7
Child:: 157:ff67d9f36b67

This updates the lib to the mbed lib v128

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

include paths in your code may need updating accordingly.

Who changed what in which revision?

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