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

Users » mbed_official » Code » mbed-dev

mbed library sources. Supersedes mbed-src.

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

targets/cmsis/TARGET_STM/TARGET_STM32L4/stm32l4xx_hal_spi.c@144:ef7eb2e8f9f7, 2016-09-02 (annotated)

Committer:: <>
Date:: Fri Sep 02 15:07:44 2016 +0100
Revision:: 144:ef7eb2e8f9f7
Parent:: 0:9b334a45a8ff

This updates the lib to the mbed lib v125

Who changed what in which revision?

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