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

Users » mbed_official » Code » mbed-dev

mbed official / mbed-dev

mbed library sources. Supersedes mbed-src.

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

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

Committer:: <>
Date:: Fri Oct 28 11:17:30 2016 +0100
Revision:: 149:156823d33999
Parent:: targets/cmsis/TARGET_STM/TARGET_STM32L4/stm32l4xx_hal_smartcard.c@144:ef7eb2e8f9f7
Child:: 167:e84263d55307

This updates the lib to the mbed lib v128

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

include paths in your code may need updating accordingly.

Who changed what in which revision?

User	Revision	Line number	New contents of line
<>	144:ef7eb2e8f9f7	1	/**
<>	144:ef7eb2e8f9f7	2	******************************************************************************
<>	144:ef7eb2e8f9f7	3	* @file stm32l4xx_hal_smartcard.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 SMARTCARD HAL module driver.
<>	144:ef7eb2e8f9f7	8	* This file provides firmware functions to manage the following
<>	144:ef7eb2e8f9f7	9	* functionalities of the SMARTCARD 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 and Error 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 SMARTCARD HAL driver can be used as follows:
<>	144:ef7eb2e8f9f7	21
<>	144:ef7eb2e8f9f7	22	(#) Declare a SMARTCARD_HandleTypeDef handle structure (eg. SMARTCARD_HandleTypeDef hsmartcard).
<>	144:ef7eb2e8f9f7	23	(#) Associate a USART to the SMARTCARD handle hsmartcard.
<>	144:ef7eb2e8f9f7	24	(#) Initialize the SMARTCARD low level resources by implementing the HAL_SMARTCARD_MspInit() API:
<>	144:ef7eb2e8f9f7	25	(++) Enable the USARTx interface clock.
<>	144:ef7eb2e8f9f7	26	(++) USART pins configuration:
<>	144:ef7eb2e8f9f7	27	(+++) Enable the clock for the USART GPIOs.
<>	144:ef7eb2e8f9f7	28	(+++) Configure the USART pins (TX as alternate function pull-up, RX as alternate function Input).
<>	144:ef7eb2e8f9f7	29	(++) NVIC configuration if you need to use interrupt process (HAL_SMARTCARD_Transmit_IT()
<>	144:ef7eb2e8f9f7	30	and HAL_SMARTCARD_Receive_IT() APIs):
<>	144:ef7eb2e8f9f7	31	(++) Configure the USARTx interrupt priority.
<>	144:ef7eb2e8f9f7	32	(++) Enable the NVIC USART IRQ handle.
<>	144:ef7eb2e8f9f7	33	(++) DMA Configuration if you need to use DMA process (HAL_SMARTCARD_Transmit_DMA()
<>	144:ef7eb2e8f9f7	34	and HAL_SMARTCARD_Receive_DMA() APIs):
<>	144:ef7eb2e8f9f7	35	(+++) Declare a DMA handle structure for the Tx/Rx channel.
<>	144:ef7eb2e8f9f7	36	(+++) Enable the DMAx interface clock.
<>	144:ef7eb2e8f9f7	37	(+++) Configure the declared DMA handle structure with the required Tx/Rx parameters.
<>	144:ef7eb2e8f9f7	38	(+++) Configure the DMA Tx/Rx channel.
<>	144:ef7eb2e8f9f7	39	(+++) Associate the initialized DMA handle to the SMARTCARD DMA Tx/Rx handle.
<>	144:ef7eb2e8f9f7	40	(+++) Configure the priority and enable the NVIC for the transfer complete interrupt on the DMA Tx/Rx channel.
<>	144:ef7eb2e8f9f7	41
<>	144:ef7eb2e8f9f7	42	(#) Program the Baud Rate, Parity, Mode(Receiver/Transmitter), clock enabling/disabling and accordingly,
<>	144:ef7eb2e8f9f7	43	the clock parameters (parity, phase, last bit), prescaler value, guard time and NACK on transmission
<>	144:ef7eb2e8f9f7	44	error enabling or disabling in the hsmartcard handle Init structure.
<>	144:ef7eb2e8f9f7	45
<>	144:ef7eb2e8f9f7	46	(#) If required, program SMARTCARD advanced features (TX/RX pins swap, TimeOut, auto-retry counter,...)
<>	144:ef7eb2e8f9f7	47	in the hsmartcard handle AdvancedInit structure.
<>	144:ef7eb2e8f9f7	48
<>	144:ef7eb2e8f9f7	49	(#) Initialize the SMARTCARD registers by calling the HAL_SMARTCARD_Init() API:
<>	144:ef7eb2e8f9f7	50	(++) This API configures also the low level Hardware GPIO, CLOCK, CORTEX...etc)
<>	144:ef7eb2e8f9f7	51	by calling the customized HAL_SMARTCARD_MspInit() API.
<>	144:ef7eb2e8f9f7	52	[..]
<>	144:ef7eb2e8f9f7	53	(@) The specific SMARTCARD interrupts (Transmission complete interrupt,
<>	144:ef7eb2e8f9f7	54	RXNE interrupt and Error Interrupts) will be managed using the macros
<>	144:ef7eb2e8f9f7	55	__HAL_SMARTCARD_ENABLE_IT() and __HAL_SMARTCARD_DISABLE_IT() inside the transmit and receive process.
<>	144:ef7eb2e8f9f7	56
<>	144:ef7eb2e8f9f7	57	[..]
<>	144:ef7eb2e8f9f7	58	[..] Three operation modes are available within this driver :
<>	144:ef7eb2e8f9f7	59
<>	144:ef7eb2e8f9f7	60	* Polling mode IO operation *
<>	144:ef7eb2e8f9f7	61	=================================
<>	144:ef7eb2e8f9f7	62	[..]
<>	144:ef7eb2e8f9f7	63	(+) Send an amount of data in blocking mode using HAL_SMARTCARD_Transmit()
<>	144:ef7eb2e8f9f7	64	(+) Receive an amount of data in blocking mode using HAL_SMARTCARD_Receive()
<>	144:ef7eb2e8f9f7	65
<>	144:ef7eb2e8f9f7	66	* Interrupt mode IO operation *
<>	144:ef7eb2e8f9f7	67	===================================
<>	144:ef7eb2e8f9f7	68	[..]
<>	144:ef7eb2e8f9f7	69	(+) Send an amount of data in non-blocking mode using HAL_SMARTCARD_Transmit_IT()
<>	144:ef7eb2e8f9f7	70	(+) At transmission end of transfer HAL_SMARTCARD_TxCpltCallback() is executed and user can
<>	144:ef7eb2e8f9f7	71	add his own code by customization of function pointer HAL_SMARTCARD_TxCpltCallback()
<>	144:ef7eb2e8f9f7	72	(+) Receive an amount of data in non-blocking mode using HAL_SMARTCARD_Receive_IT()
<>	144:ef7eb2e8f9f7	73	(+) At reception end of transfer HAL_SMARTCARD_RxCpltCallback() is executed and user can
<>	144:ef7eb2e8f9f7	74	add his own code by customization of function pointer HAL_SMARTCARD_RxCpltCallback()
<>	144:ef7eb2e8f9f7	75	(+) In case of transfer Error, HAL_SMARTCARD_ErrorCallback() function is executed and user can
<>	144:ef7eb2e8f9f7	76	add his own code by customization of function pointer HAL_SMARTCARD_ErrorCallback()
<>	144:ef7eb2e8f9f7	77
<>	144:ef7eb2e8f9f7	78	* DMA mode IO operation *
<>	144:ef7eb2e8f9f7	79	==============================
<>	144:ef7eb2e8f9f7	80	[..]
<>	144:ef7eb2e8f9f7	81	(+) Send an amount of data in non-blocking mode (DMA) using HAL_SMARTCARD_Transmit_DMA()
<>	144:ef7eb2e8f9f7	82	(+) At transmission end of transfer HAL_SMARTCARD_TxCpltCallback() is executed and user can
<>	144:ef7eb2e8f9f7	83	add his own code by customization of function pointer HAL_SMARTCARD_TxCpltCallback()
<>	144:ef7eb2e8f9f7	84	(+) Receive an amount of data in non-blocking mode (DMA) using HAL_SMARTCARD_Receive_DMA()
<>	144:ef7eb2e8f9f7	85	(+) At reception end of transfer HAL_SMARTCARD_RxCpltCallback() is executed and user can
<>	144:ef7eb2e8f9f7	86	add his own code by customization of function pointer HAL_SMARTCARD_RxCpltCallback()
<>	144:ef7eb2e8f9f7	87	(+) In case of transfer Error, HAL_SMARTCARD_ErrorCallback() function is executed and user can
<>	144:ef7eb2e8f9f7	88	add his own code by customization of function pointer HAL_SMARTCARD_ErrorCallback()
<>	144:ef7eb2e8f9f7	89
<>	144:ef7eb2e8f9f7	90	* SMARTCARD HAL driver macros list *
<>	144:ef7eb2e8f9f7	91	========================================
<>	144:ef7eb2e8f9f7	92	[..]
<>	144:ef7eb2e8f9f7	93	Below the list of most used macros in SMARTCARD HAL driver.
<>	144:ef7eb2e8f9f7	94
<>	144:ef7eb2e8f9f7	95	(+) __HAL_SMARTCARD_GET_FLAG : Check whether or not the specified SMARTCARD flag is set
<>	144:ef7eb2e8f9f7	96	(+) __HAL_SMARTCARD_CLEAR_FLAG : Clear the specified SMARTCARD pending flag
<>	144:ef7eb2e8f9f7	97	(+) __HAL_SMARTCARD_ENABLE_IT: Enable the specified SMARTCARD interrupt
<>	144:ef7eb2e8f9f7	98	(+) __HAL_SMARTCARD_DISABLE_IT: Disable the specified SMARTCARD interrupt
<>	144:ef7eb2e8f9f7	99	(+) __HAL_SMARTCARD_GET_IT_SOURCE: Check whether or not the specified SMARTCARD interrupt is enabled
<>	144:ef7eb2e8f9f7	100
<>	144:ef7eb2e8f9f7	101	[..]
<>	144:ef7eb2e8f9f7	102	(@) You can refer to the SMARTCARD HAL driver header file for more useful macros
<>	144:ef7eb2e8f9f7	103
<>	144:ef7eb2e8f9f7	104	@endverbatim
<>	144:ef7eb2e8f9f7	105	******************************************************************************
<>	144:ef7eb2e8f9f7	106	* @attention
<>	144:ef7eb2e8f9f7	107	*
<>	144:ef7eb2e8f9f7	108	* <h2><center>© COPYRIGHT(c) 2016 STMicroelectronics</center></h2>
<>	144:ef7eb2e8f9f7	109	*
<>	144:ef7eb2e8f9f7	110	* Redistribution and use in source and binary forms, with or without modification,
<>	144:ef7eb2e8f9f7	111	* are permitted provided that the following conditions are met:
<>	144:ef7eb2e8f9f7	112	* 1. Redistributions of source code must retain the above copyright notice,
<>	144:ef7eb2e8f9f7	113	* this list of conditions and the following disclaimer.
<>	144:ef7eb2e8f9f7	114	* 2. Redistributions in binary form must reproduce the above copyright notice,
<>	144:ef7eb2e8f9f7	115	* this list of conditions and the following disclaimer in the documentation
<>	144:ef7eb2e8f9f7	116	* and/or other materials provided with the distribution.
<>	144:ef7eb2e8f9f7	117	* 3. Neither the name of STMicroelectronics nor the names of its contributors
<>	144:ef7eb2e8f9f7	118	* may be used to endorse or promote products derived from this software
<>	144:ef7eb2e8f9f7	119	* without specific prior written permission.
<>	144:ef7eb2e8f9f7	120	*
<>	144:ef7eb2e8f9f7	121	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
<>	144:ef7eb2e8f9f7	122	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
<>	144:ef7eb2e8f9f7	123	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
<>	144:ef7eb2e8f9f7	124	* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
<>	144:ef7eb2e8f9f7	125	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
<>	144:ef7eb2e8f9f7	126	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
<>	144:ef7eb2e8f9f7	127	* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
<>	144:ef7eb2e8f9f7	128	* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
<>	144:ef7eb2e8f9f7	129	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
<>	144:ef7eb2e8f9f7	130	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
<>	144:ef7eb2e8f9f7	131	*
<>	144:ef7eb2e8f9f7	132	******************************************************************************
<>	144:ef7eb2e8f9f7	133	*/
<>	144:ef7eb2e8f9f7	134
<>	144:ef7eb2e8f9f7	135	/* Includes ------------------------------------------------------------------*/
<>	144:ef7eb2e8f9f7	136	#include "stm32l4xx_hal.h"
<>	144:ef7eb2e8f9f7	137
<>	144:ef7eb2e8f9f7	138	/** @addtogroup STM32L4xx_HAL_Driver
<>	144:ef7eb2e8f9f7	139	* @{
<>	144:ef7eb2e8f9f7	140	*/
<>	144:ef7eb2e8f9f7	141
<>	144:ef7eb2e8f9f7	142	/** @defgroup SMARTCARD SMARTCARD
<>	144:ef7eb2e8f9f7	143	* @brief HAL SMARTCARD module driver
<>	144:ef7eb2e8f9f7	144	* @{
<>	144:ef7eb2e8f9f7	145	*/
<>	144:ef7eb2e8f9f7	146
<>	144:ef7eb2e8f9f7	147	#ifdef HAL_SMARTCARD_MODULE_ENABLED
<>	144:ef7eb2e8f9f7	148
<>	144:ef7eb2e8f9f7	149	/* Private typedef -----------------------------------------------------------*/
<>	144:ef7eb2e8f9f7	150	/* Private define ------------------------------------------------------------*/
<>	144:ef7eb2e8f9f7	151	/** @defgroup SMARTCARD_Private_Constants SMARTCARD Private Constants
<>	144:ef7eb2e8f9f7	152	* @{
<>	144:ef7eb2e8f9f7	153	*/
<>	144:ef7eb2e8f9f7	154	#define SMARTCARD_TEACK_REACK_TIMEOUT 1000 /!< SMARTCARD TX or RX enable acknowledge time-out value /
<>	144:ef7eb2e8f9f7	155
<>	144:ef7eb2e8f9f7	156	#define USART_CR1_FIELDS ((uint32_t)(USART_CR1_M \| USART_CR1_PCE \| USART_CR1_PS \| \
<>	144:ef7eb2e8f9f7	157	USART_CR1_TE \| USART_CR1_RE \| USART_CR1_OVER8)) /!< USART CR1 fields of parameters set by SMARTCARD_SetConfig API /
<>	144:ef7eb2e8f9f7	158	#define USART_CR2_CLK_FIELDS ((uint32_t)(USART_CR2_CLKEN\|USART_CR2_CPOL\|USART_CR2_CPHA\|USART_CR2_LBCL)) /!< SMARTCARD clock-related USART CR2 fields of parameters /
<>	144:ef7eb2e8f9f7	159	#define USART_CR2_FIELDS ((uint32_t)(USART_CR2_RTOEN\|USART_CR2_CLK_FIELDS\|USART_CR2_STOP)) /!< USART CR2 fields of parameters set by SMARTCARD_SetConfig API /
<>	144:ef7eb2e8f9f7	160	#define USART_CR3_FIELDS ((uint32_t)(USART_CR3_ONEBIT\|USART_CR3_NACK\|USART_CR3_SCARCNT)) /!< USART CR3 fields of parameters set by SMARTCARD_SetConfig API /
<>	144:ef7eb2e8f9f7	161	/**
<>	144:ef7eb2e8f9f7	162	* @}
<>	144:ef7eb2e8f9f7	163	*/
<>	144:ef7eb2e8f9f7	164
<>	144:ef7eb2e8f9f7	165	/* Private macros ------------------------------------------------------------*/
<>	144:ef7eb2e8f9f7	166	/* Private variables ---------------------------------------------------------*/
<>	144:ef7eb2e8f9f7	167	/* Private function prototypes -----------------------------------------------*/
<>	144:ef7eb2e8f9f7	168	/** @addtogroup SMARTCARD_Private_Functions
<>	144:ef7eb2e8f9f7	169	* @{
<>	144:ef7eb2e8f9f7	170	*/
<>	144:ef7eb2e8f9f7	171	static void SMARTCARD_DMATransmitCplt(DMA_HandleTypeDef *hdma);
<>	144:ef7eb2e8f9f7	172	static void SMARTCARD_DMAReceiveCplt(DMA_HandleTypeDef *hdma);
<>	144:ef7eb2e8f9f7	173	static void SMARTCARD_DMAError(DMA_HandleTypeDef *hdma);
<>	144:ef7eb2e8f9f7	174	static HAL_StatusTypeDef SMARTCARD_SetConfig(SMARTCARD_HandleTypeDef *hsmartcard);
<>	144:ef7eb2e8f9f7	175	static void SMARTCARD_AdvFeatureConfig(SMARTCARD_HandleTypeDef *hsmartcard);
<>	144:ef7eb2e8f9f7	176	static HAL_StatusTypeDef SMARTCARD_WaitOnFlagUntilTimeout(SMARTCARD_HandleTypeDef *hsmartcard, uint32_t Flag, FlagStatus Status, uint32_t Tickstart, uint32_t Timeout);
<>	144:ef7eb2e8f9f7	177	static HAL_StatusTypeDef SMARTCARD_CheckIdleState(SMARTCARD_HandleTypeDef *hsmartcard);
<>	144:ef7eb2e8f9f7	178	static HAL_StatusTypeDef SMARTCARD_Transmit_IT(SMARTCARD_HandleTypeDef *hsmartcard);
<>	144:ef7eb2e8f9f7	179	static HAL_StatusTypeDef SMARTCARD_EndTransmit_IT(SMARTCARD_HandleTypeDef *hsmartcard);
<>	144:ef7eb2e8f9f7	180	static HAL_StatusTypeDef SMARTCARD_Receive_IT(SMARTCARD_HandleTypeDef *hsmartcard);
<>	144:ef7eb2e8f9f7	181	/**
<>	144:ef7eb2e8f9f7	182	* @}
<>	144:ef7eb2e8f9f7	183	*/
<>	144:ef7eb2e8f9f7	184
<>	144:ef7eb2e8f9f7	185	/* Exported functions --------------------------------------------------------*/
<>	144:ef7eb2e8f9f7	186
<>	144:ef7eb2e8f9f7	187	/** @defgroup SMARTCARD_Exported_Functions SMARTCARD Exported Functions
<>	144:ef7eb2e8f9f7	188	* @{
<>	144:ef7eb2e8f9f7	189	*/
<>	144:ef7eb2e8f9f7	190
<>	144:ef7eb2e8f9f7	191	/** @defgroup SMARTCARD_Exported_Functions_Group1 Initialization and de-initialization functions
<>	144:ef7eb2e8f9f7	192	* @brief Initialization and Configuration functions
<>	144:ef7eb2e8f9f7	193	*
<>	144:ef7eb2e8f9f7	194	@verbatim
<>	144:ef7eb2e8f9f7	195	===============================================================================
<>	144:ef7eb2e8f9f7	196	##### Initialization and Configuration functions #####
<>	144:ef7eb2e8f9f7	197	===============================================================================
<>	144:ef7eb2e8f9f7	198	[..]
<>	144:ef7eb2e8f9f7	199	This subsection provides a set of functions allowing to initialize the USARTx
<>	144:ef7eb2e8f9f7	200	associated to the SmartCard.
<>	144:ef7eb2e8f9f7	201	(+) These parameters can be configured:
<>	144:ef7eb2e8f9f7	202	(++) Baud Rate
<>	144:ef7eb2e8f9f7	203	(++) Parity: parity should be enabled, frame Length is fixed to 8 bits plus parity
<>	144:ef7eb2e8f9f7	204	(++) Receiver/transmitter modes
<>	144:ef7eb2e8f9f7	205	(++) Synchronous mode (and if enabled, phase, polarity and last bit parameters)
<>	144:ef7eb2e8f9f7	206	(++) Prescaler value
<>	144:ef7eb2e8f9f7	207	(++) Guard bit time
<>	144:ef7eb2e8f9f7	208	(++) NACK enabling or disabling on transmission error
<>	144:ef7eb2e8f9f7	209
<>	144:ef7eb2e8f9f7	210	(+) The following advanced features can be configured as well:
<>	144:ef7eb2e8f9f7	211	(++) TX and/or RX pin level inversion
<>	144:ef7eb2e8f9f7	212	(++) data logical level inversion
<>	144:ef7eb2e8f9f7	213	(++) RX and TX pins swap
<>	144:ef7eb2e8f9f7	214	(++) RX overrun detection disabling
<>	144:ef7eb2e8f9f7	215	(++) DMA disabling on RX error
<>	144:ef7eb2e8f9f7	216	(++) MSB first on communication line
<>	144:ef7eb2e8f9f7	217	(++) Time out enabling (and if activated, timeout value)
<>	144:ef7eb2e8f9f7	218	(++) Block length
<>	144:ef7eb2e8f9f7	219	(++) Auto-retry counter
<>	144:ef7eb2e8f9f7	220	[..]
<>	144:ef7eb2e8f9f7	221	The HAL_SMARTCARD_Init() API follows the USART synchronous configuration procedures
<>	144:ef7eb2e8f9f7	222	(details for the procedures are available in reference manual).
<>	144:ef7eb2e8f9f7	223
<>	144:ef7eb2e8f9f7	224	@endverbatim
<>	144:ef7eb2e8f9f7	225
<>	144:ef7eb2e8f9f7	226	The USART frame format is given in the following table:
<>	144:ef7eb2e8f9f7	227
<>	144:ef7eb2e8f9f7	228	Table 1. USART frame format.
<>	144:ef7eb2e8f9f7	229	+---------------------------------------------------------------+
<>	144:ef7eb2e8f9f7	230	\| M1M0 bits \| PCE bit \| USART frame \|
<>	144:ef7eb2e8f9f7	231	\|-----------------------\|---------------------------------------\|
<>	144:ef7eb2e8f9f7	232	\| 01 \| 1 \| \| SB \| 8 bit data \| PB \| STB \| \|
<>	144:ef7eb2e8f9f7	233	+---------------------------------------------------------------+
<>	144:ef7eb2e8f9f7	234
<>	144:ef7eb2e8f9f7	235
<>	144:ef7eb2e8f9f7	236	* @{
<>	144:ef7eb2e8f9f7	237	*/
<>	144:ef7eb2e8f9f7	238
<>	144:ef7eb2e8f9f7	239	/**
<>	144:ef7eb2e8f9f7	240	* @brief Initialize the SMARTCARD mode according to the specified
<>	144:ef7eb2e8f9f7	241	* parameters in the SMARTCARD_HandleTypeDef and initialize the associated handle.
<>	144:ef7eb2e8f9f7	242	* @param hsmartcard: Pointer to a SMARTCARD_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	243	* the configuration information for the specified SMARTCARD module.
<>	144:ef7eb2e8f9f7	244	* @retval HAL status
<>	144:ef7eb2e8f9f7	245	*/
<>	144:ef7eb2e8f9f7	246	HAL_StatusTypeDef HAL_SMARTCARD_Init(SMARTCARD_HandleTypeDef *hsmartcard)
<>	144:ef7eb2e8f9f7	247	{
<>	144:ef7eb2e8f9f7	248	/* Check the SMARTCARD handle allocation */
<>	144:ef7eb2e8f9f7	249	if(hsmartcard == NULL)
<>	144:ef7eb2e8f9f7	250	{
<>	144:ef7eb2e8f9f7	251	return HAL_ERROR;
<>	144:ef7eb2e8f9f7	252	}
<>	144:ef7eb2e8f9f7	253
<>	144:ef7eb2e8f9f7	254	/* Check the USART associated to the SmartCard */
<>	144:ef7eb2e8f9f7	255	assert_param(IS_SMARTCARD_INSTANCE(hsmartcard->Instance));
<>	144:ef7eb2e8f9f7	256
<>	144:ef7eb2e8f9f7	257	if(hsmartcard->gState == HAL_SMARTCARD_STATE_RESET)
<>	144:ef7eb2e8f9f7	258	{
<>	144:ef7eb2e8f9f7	259	/* Allocate lock resource and initialize it */
<>	144:ef7eb2e8f9f7	260	hsmartcard->Lock = HAL_UNLOCKED;
<>	144:ef7eb2e8f9f7	261
<>	144:ef7eb2e8f9f7	262	/* Init the low level hardware : GPIO, CLOCK */
<>	144:ef7eb2e8f9f7	263	HAL_SMARTCARD_MspInit(hsmartcard);
<>	144:ef7eb2e8f9f7	264	}
<>	144:ef7eb2e8f9f7	265
<>	144:ef7eb2e8f9f7	266	hsmartcard->gState = HAL_SMARTCARD_STATE_BUSY;
<>	144:ef7eb2e8f9f7	267
<>	144:ef7eb2e8f9f7	268	/* Disable the Peripheral to set smartcard mode */
<>	144:ef7eb2e8f9f7	269	CLEAR_BIT(hsmartcard->Instance->CR1, USART_CR1_UE);
<>	144:ef7eb2e8f9f7	270
<>	144:ef7eb2e8f9f7	271	/* In SmartCard mode, the following bits must be kept cleared:
<>	144:ef7eb2e8f9f7	272	- LINEN in the USART_CR2 register,
<>	144:ef7eb2e8f9f7	273	- HDSEL and IREN bits in the USART_CR3 register.*/
<>	144:ef7eb2e8f9f7	274	CLEAR_BIT(hsmartcard->Instance->CR2, USART_CR2_LINEN);
<>	144:ef7eb2e8f9f7	275	CLEAR_BIT(hsmartcard->Instance->CR3, (USART_CR3_HDSEL \| USART_CR3_IREN));
<>	144:ef7eb2e8f9f7	276
<>	144:ef7eb2e8f9f7	277	/* set the USART in SMARTCARD mode */
<>	144:ef7eb2e8f9f7	278	SET_BIT(hsmartcard->Instance->CR3, USART_CR3_SCEN);
<>	144:ef7eb2e8f9f7	279
<>	144:ef7eb2e8f9f7	280	/* Set the SMARTCARD Communication parameters */
<>	144:ef7eb2e8f9f7	281	if (SMARTCARD_SetConfig(hsmartcard) == HAL_ERROR)
<>	144:ef7eb2e8f9f7	282	{
<>	144:ef7eb2e8f9f7	283	return HAL_ERROR;
<>	144:ef7eb2e8f9f7	284	}
<>	144:ef7eb2e8f9f7	285
<>	144:ef7eb2e8f9f7	286	/* Set the SMARTCARD transmission completion indication */
<>	144:ef7eb2e8f9f7	287	SMARTCARD_TRANSMISSION_COMPLETION_SETTING(hsmartcard);
<>	144:ef7eb2e8f9f7	288
<>	144:ef7eb2e8f9f7	289	if (hsmartcard->AdvancedInit.AdvFeatureInit != SMARTCARD_ADVFEATURE_NO_INIT)
<>	144:ef7eb2e8f9f7	290	{
<>	144:ef7eb2e8f9f7	291	SMARTCARD_AdvFeatureConfig(hsmartcard);
<>	144:ef7eb2e8f9f7	292	}
<>	144:ef7eb2e8f9f7	293
<>	144:ef7eb2e8f9f7	294	/* Enable the Peripheral */
<>	144:ef7eb2e8f9f7	295	SET_BIT(hsmartcard->Instance->CR1, USART_CR1_UE);
<>	144:ef7eb2e8f9f7	296
<>	144:ef7eb2e8f9f7	297	/* TEACK and/or REACK to check before moving hsmartcard->gState and hsmartcard->RxState to Ready */
<>	144:ef7eb2e8f9f7	298	return (SMARTCARD_CheckIdleState(hsmartcard));
<>	144:ef7eb2e8f9f7	299	}
<>	144:ef7eb2e8f9f7	300
<>	144:ef7eb2e8f9f7	301
<>	144:ef7eb2e8f9f7	302	/**
<>	144:ef7eb2e8f9f7	303	* @brief DeInitialize the SMARTCARD peripheral.
<>	144:ef7eb2e8f9f7	304	* @param hsmartcard: Pointer to a SMARTCARD_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	305	* the configuration information for the specified SMARTCARD module.
<>	144:ef7eb2e8f9f7	306	* @retval HAL status
<>	144:ef7eb2e8f9f7	307	*/
<>	144:ef7eb2e8f9f7	308	HAL_StatusTypeDef HAL_SMARTCARD_DeInit(SMARTCARD_HandleTypeDef *hsmartcard)
<>	144:ef7eb2e8f9f7	309	{
<>	144:ef7eb2e8f9f7	310	/* Check the SMARTCARD handle allocation */
<>	144:ef7eb2e8f9f7	311	if(hsmartcard == NULL)
<>	144:ef7eb2e8f9f7	312	{
<>	144:ef7eb2e8f9f7	313	return HAL_ERROR;
<>	144:ef7eb2e8f9f7	314	}
<>	144:ef7eb2e8f9f7	315
<>	144:ef7eb2e8f9f7	316	/* Check the parameters */
<>	144:ef7eb2e8f9f7	317	assert_param(IS_SMARTCARD_INSTANCE(hsmartcard->Instance));
<>	144:ef7eb2e8f9f7	318
<>	144:ef7eb2e8f9f7	319	hsmartcard->gState = HAL_SMARTCARD_STATE_BUSY;
<>	144:ef7eb2e8f9f7	320
<>	144:ef7eb2e8f9f7	321	/* Disable the Peripheral */
<>	144:ef7eb2e8f9f7	322	CLEAR_BIT(hsmartcard->Instance->CR1, USART_CR1_UE);
<>	144:ef7eb2e8f9f7	323
<>	144:ef7eb2e8f9f7	324	WRITE_REG(hsmartcard->Instance->CR1, 0x0);
<>	144:ef7eb2e8f9f7	325	WRITE_REG(hsmartcard->Instance->CR2, 0x0);
<>	144:ef7eb2e8f9f7	326	WRITE_REG(hsmartcard->Instance->CR3, 0x0);
<>	144:ef7eb2e8f9f7	327	WRITE_REG(hsmartcard->Instance->RTOR, 0x0);
<>	144:ef7eb2e8f9f7	328	WRITE_REG(hsmartcard->Instance->GTPR, 0x0);
<>	144:ef7eb2e8f9f7	329
<>	144:ef7eb2e8f9f7	330	/* DeInit the low level hardware */
<>	144:ef7eb2e8f9f7	331	HAL_SMARTCARD_MspDeInit(hsmartcard);
<>	144:ef7eb2e8f9f7	332
<>	144:ef7eb2e8f9f7	333	hsmartcard->ErrorCode = HAL_SMARTCARD_ERROR_NONE;
<>	144:ef7eb2e8f9f7	334	hsmartcard->gState = HAL_SMARTCARD_STATE_RESET;
<>	144:ef7eb2e8f9f7	335	hsmartcard->RxState = HAL_SMARTCARD_STATE_RESET;
<>	144:ef7eb2e8f9f7	336
<>	144:ef7eb2e8f9f7	337	/* Process Unlock */
<>	144:ef7eb2e8f9f7	338	__HAL_UNLOCK(hsmartcard);
<>	144:ef7eb2e8f9f7	339
<>	144:ef7eb2e8f9f7	340	return HAL_OK;
<>	144:ef7eb2e8f9f7	341	}
<>	144:ef7eb2e8f9f7	342
<>	144:ef7eb2e8f9f7	343	/**
<>	144:ef7eb2e8f9f7	344	* @brief Initialize the SMARTCARD MSP.
<>	144:ef7eb2e8f9f7	345	* @param hsmartcard: Pointer to a SMARTCARD_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	346	* the configuration information for the specified SMARTCARD module.
<>	144:ef7eb2e8f9f7	347	* @retval None
<>	144:ef7eb2e8f9f7	348	*/
<>	144:ef7eb2e8f9f7	349	__weak void HAL_SMARTCARD_MspInit(SMARTCARD_HandleTypeDef *hsmartcard)
<>	144:ef7eb2e8f9f7	350	{
<>	144:ef7eb2e8f9f7	351	/* Prevent unused argument(s) compilation warning */
<>	144:ef7eb2e8f9f7	352	UNUSED(hsmartcard);
<>	144:ef7eb2e8f9f7	353
<>	144:ef7eb2e8f9f7	354	/* NOTE : This function should not be modified, when the callback is needed,
<>	144:ef7eb2e8f9f7	355	the HAL_SMARTCARD_MspInit can be implemented in the user file
<>	144:ef7eb2e8f9f7	356	*/
<>	144:ef7eb2e8f9f7	357	}
<>	144:ef7eb2e8f9f7	358
<>	144:ef7eb2e8f9f7	359	/**
<>	144:ef7eb2e8f9f7	360	* @brief DeInitialize the SMARTCARD MSP.
<>	144:ef7eb2e8f9f7	361	* @param hsmartcard: Pointer to a SMARTCARD_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	362	* the configuration information for the specified SMARTCARD module.
<>	144:ef7eb2e8f9f7	363	* @retval None
<>	144:ef7eb2e8f9f7	364	*/
<>	144:ef7eb2e8f9f7	365	__weak void HAL_SMARTCARD_MspDeInit(SMARTCARD_HandleTypeDef *hsmartcard)
<>	144:ef7eb2e8f9f7	366	{
<>	144:ef7eb2e8f9f7	367	/* Prevent unused argument(s) compilation warning */
<>	144:ef7eb2e8f9f7	368	UNUSED(hsmartcard);
<>	144:ef7eb2e8f9f7	369
<>	144:ef7eb2e8f9f7	370	/* NOTE : This function should not be modified, when the callback is needed,
<>	144:ef7eb2e8f9f7	371	the HAL_SMARTCARD_MspDeInit can be implemented in the user file
<>	144:ef7eb2e8f9f7	372	*/
<>	144:ef7eb2e8f9f7	373	}
<>	144:ef7eb2e8f9f7	374
<>	144:ef7eb2e8f9f7	375	/**
<>	144:ef7eb2e8f9f7	376	* @}
<>	144:ef7eb2e8f9f7	377	*/
<>	144:ef7eb2e8f9f7	378
<>	144:ef7eb2e8f9f7	379	/** @defgroup SMARTCARD_Exported_Functions_Group2 IO operation functions
<>	144:ef7eb2e8f9f7	380	* @brief SMARTCARD Transmit and Receive functions
<>	144:ef7eb2e8f9f7	381	*
<>	144:ef7eb2e8f9f7	382	@verbatim
<>	144:ef7eb2e8f9f7	383	==============================================================================
<>	144:ef7eb2e8f9f7	384	##### IO operation functions #####
<>	144:ef7eb2e8f9f7	385	==============================================================================
<>	144:ef7eb2e8f9f7	386	[..]
<>	144:ef7eb2e8f9f7	387	This subsection provides a set of functions allowing to manage the SMARTCARD data transfers.
<>	144:ef7eb2e8f9f7	388
<>	144:ef7eb2e8f9f7	389	[..]
<>	144:ef7eb2e8f9f7	390	Smartcard is a single wire half duplex communication protocol.
<>	144:ef7eb2e8f9f7	391	The Smartcard interface is designed to support asynchronous protocol Smartcards as
<>	144:ef7eb2e8f9f7	392	defined in the ISO 7816-3 standard. The USART should be configured as:
<>	144:ef7eb2e8f9f7	393	(+) 8 bits plus parity: where M=1 and PCE=1 in the USART_CR1 register
<>	144:ef7eb2e8f9f7	394	(+) 1.5 stop bits when transmitting and receiving: where STOP=11 in the USART_CR2 register.
<>	144:ef7eb2e8f9f7	395
<>	144:ef7eb2e8f9f7	396	[..]
<>	144:ef7eb2e8f9f7	397	(+) There are two modes of transfer:
<>	144:ef7eb2e8f9f7	398	(++) Blocking mode: The communication is performed in polling mode.
<>	144:ef7eb2e8f9f7	399	The HAL status of all data processing is returned by the same function
<>	144:ef7eb2e8f9f7	400	after finishing transfer.
<>	144:ef7eb2e8f9f7	401	(++) No-Blocking mode: The communication is performed using Interrupts
<>	144:ef7eb2e8f9f7	402	or DMA, the relevant API's return the HAL status.
<>	144:ef7eb2e8f9f7	403	The end of the data processing will be indicated through the
<>	144:ef7eb2e8f9f7	404	dedicated SMARTCARD IRQ when using Interrupt mode or the DMA IRQ when
<>	144:ef7eb2e8f9f7	405	using DMA mode.
<>	144:ef7eb2e8f9f7	406	(++) The HAL_SMARTCARD_TxCpltCallback(), HAL_SMARTCARD_RxCpltCallback() user callbacks
<>	144:ef7eb2e8f9f7	407	will be executed respectively at the end of the Transmit or Receive process
<>	144:ef7eb2e8f9f7	408	The HAL_SMARTCARD_ErrorCallback() user callback will be executed when a communication
<>	144:ef7eb2e8f9f7	409	error is detected.
<>	144:ef7eb2e8f9f7	410
<>	144:ef7eb2e8f9f7	411	(+) Blocking mode APIs are :
<>	144:ef7eb2e8f9f7	412	(++) HAL_SMARTCARD_Transmit()
<>	144:ef7eb2e8f9f7	413	(++) HAL_SMARTCARD_Receive()
<>	144:ef7eb2e8f9f7	414
<>	144:ef7eb2e8f9f7	415	(+) Non Blocking mode APIs with Interrupt are :
<>	144:ef7eb2e8f9f7	416	(++) HAL_SMARTCARD_Transmit_IT()
<>	144:ef7eb2e8f9f7	417	(++) HAL_SMARTCARD_Receive_IT()
<>	144:ef7eb2e8f9f7	418	(++) HAL_SMARTCARD_IRQHandler()
<>	144:ef7eb2e8f9f7	419
<>	144:ef7eb2e8f9f7	420	(+) Non Blocking mode functions with DMA are :
<>	144:ef7eb2e8f9f7	421	(++) HAL_SMARTCARD_Transmit_DMA()
<>	144:ef7eb2e8f9f7	422	(++) HAL_SMARTCARD_Receive_DMA()
<>	144:ef7eb2e8f9f7	423
<>	144:ef7eb2e8f9f7	424	(+) A set of Transfer Complete Callbacks are provided in non Blocking mode:
<>	144:ef7eb2e8f9f7	425	(++) HAL_SMARTCARD_TxCpltCallback()
<>	144:ef7eb2e8f9f7	426	(++) HAL_SMARTCARD_RxCpltCallback()
<>	144:ef7eb2e8f9f7	427	(++) HAL_SMARTCARD_ErrorCallback()
<>	144:ef7eb2e8f9f7	428
<>	144:ef7eb2e8f9f7	429	@endverbatim
<>	144:ef7eb2e8f9f7	430	* @{
<>	144:ef7eb2e8f9f7	431	*/
<>	144:ef7eb2e8f9f7	432
<>	144:ef7eb2e8f9f7	433	/**
<>	144:ef7eb2e8f9f7	434	* @brief Send an amount of data in blocking mode.
<>	144:ef7eb2e8f9f7	435	* @param hsmartcard: Pointer to a SMARTCARD_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	436	* the configuration information for the specified SMARTCARD module.
<>	144:ef7eb2e8f9f7	437	* @param pData: pointer to data buffer.
<>	144:ef7eb2e8f9f7	438	* @param Size: amount of data to be sent.
<>	144:ef7eb2e8f9f7	439	* @param Timeout : Timeout duration.
<>	144:ef7eb2e8f9f7	440	* @retval HAL status
<>	144:ef7eb2e8f9f7	441	*/
<>	144:ef7eb2e8f9f7	442	HAL_StatusTypeDef HAL_SMARTCARD_Transmit(SMARTCARD_HandleTypeDef hsmartcard, uint8_t pData, uint16_t Size, uint32_t Timeout)
<>	144:ef7eb2e8f9f7	443	{
<>	144:ef7eb2e8f9f7	444	uint32_t tickstart = 0;
<>	144:ef7eb2e8f9f7	445
<>	144:ef7eb2e8f9f7	446	/* Check that a Tx process is not already ongoing */
<>	144:ef7eb2e8f9f7	447	if (hsmartcard->gState == HAL_SMARTCARD_STATE_READY)
<>	144:ef7eb2e8f9f7	448	{
<>	144:ef7eb2e8f9f7	449	if((pData == NULL) \|\| (Size == 0))
<>	144:ef7eb2e8f9f7	450	{
<>	144:ef7eb2e8f9f7	451	return HAL_ERROR;
<>	144:ef7eb2e8f9f7	452	}
<>	144:ef7eb2e8f9f7	453
<>	144:ef7eb2e8f9f7	454	/* Process Locked */
<>	144:ef7eb2e8f9f7	455	__HAL_LOCK(hsmartcard);
<>	144:ef7eb2e8f9f7	456
<>	144:ef7eb2e8f9f7	457	hsmartcard->gState = HAL_SMARTCARD_STATE_BUSY_TX;
<>	144:ef7eb2e8f9f7	458
<>	144:ef7eb2e8f9f7	459	/* Init tickstart for timeout managment*/
<>	144:ef7eb2e8f9f7	460	tickstart = HAL_GetTick();
<>	144:ef7eb2e8f9f7	461
<>	144:ef7eb2e8f9f7	462	/* Disable the Peripheral first to update mode for TX master */
<>	144:ef7eb2e8f9f7	463	CLEAR_BIT(hsmartcard->Instance->CR1, USART_CR1_UE);
<>	144:ef7eb2e8f9f7	464
<>	144:ef7eb2e8f9f7	465	/* Disable Rx, enable Tx */
<>	144:ef7eb2e8f9f7	466	CLEAR_BIT(hsmartcard->Instance->CR1, USART_CR1_RE);
<>	144:ef7eb2e8f9f7	467	SET_BIT(hsmartcard->Instance->RQR, SMARTCARD_RXDATA_FLUSH_REQUEST);
<>	144:ef7eb2e8f9f7	468	SET_BIT(hsmartcard->Instance->CR1, USART_CR1_TE);
<>	144:ef7eb2e8f9f7	469
<>	144:ef7eb2e8f9f7	470	/* Enable the Peripheral */
<>	144:ef7eb2e8f9f7	471	SET_BIT(hsmartcard->Instance->CR1, USART_CR1_UE);
<>	144:ef7eb2e8f9f7	472
<>	144:ef7eb2e8f9f7	473	hsmartcard->ErrorCode = HAL_SMARTCARD_ERROR_NONE;
<>	144:ef7eb2e8f9f7	474	hsmartcard->TxXferSize = Size;
<>	144:ef7eb2e8f9f7	475	hsmartcard->TxXferCount = Size;
<>	144:ef7eb2e8f9f7	476
<>	144:ef7eb2e8f9f7	477	while(hsmartcard->TxXferCount > 0)
<>	144:ef7eb2e8f9f7	478	{
<>	144:ef7eb2e8f9f7	479	hsmartcard->TxXferCount--;
<>	144:ef7eb2e8f9f7	480	if(SMARTCARD_WaitOnFlagUntilTimeout(hsmartcard, SMARTCARD_FLAG_TXE, RESET, tickstart, Timeout) != HAL_OK)
<>	144:ef7eb2e8f9f7	481	{
<>	144:ef7eb2e8f9f7	482	return HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	483	}
<>	144:ef7eb2e8f9f7	484	hsmartcard->Instance->TDR = (*pData++ & (uint8_t)0xFF);
<>	144:ef7eb2e8f9f7	485	}
<>	144:ef7eb2e8f9f7	486	if(SMARTCARD_WaitOnFlagUntilTimeout(hsmartcard, SMARTCARD_TRANSMISSION_COMPLETION_FLAG(hsmartcard), RESET, tickstart, Timeout) != HAL_OK)
<>	144:ef7eb2e8f9f7	487	{
<>	144:ef7eb2e8f9f7	488	return HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	489	}
<>	144:ef7eb2e8f9f7	490	/* Re-enable Rx at end of transmission if initial mode is Rx/Tx */
<>	144:ef7eb2e8f9f7	491	if(hsmartcard->Init.Mode == SMARTCARD_MODE_TX_RX)
<>	144:ef7eb2e8f9f7	492	{
<>	144:ef7eb2e8f9f7	493	/* Disable the Peripheral first to update modes */
<>	144:ef7eb2e8f9f7	494	CLEAR_BIT(hsmartcard->Instance->CR1, USART_CR1_UE);
<>	144:ef7eb2e8f9f7	495	SET_BIT(hsmartcard->Instance->CR1, USART_CR1_RE);
<>	144:ef7eb2e8f9f7	496	/* Enable the Peripheral */
<>	144:ef7eb2e8f9f7	497	SET_BIT(hsmartcard->Instance->CR1, USART_CR1_UE);
<>	144:ef7eb2e8f9f7	498	}
<>	144:ef7eb2e8f9f7	499
<>	144:ef7eb2e8f9f7	500	/* At end of Tx process, restore hsmartcard->gState to Ready */
<>	144:ef7eb2e8f9f7	501	hsmartcard->gState = HAL_SMARTCARD_STATE_READY;
<>	144:ef7eb2e8f9f7	502
<>	144:ef7eb2e8f9f7	503	/* Process Unlocked */
<>	144:ef7eb2e8f9f7	504	__HAL_UNLOCK(hsmartcard);
<>	144:ef7eb2e8f9f7	505
<>	144:ef7eb2e8f9f7	506	return HAL_OK;
<>	144:ef7eb2e8f9f7	507	}
<>	144:ef7eb2e8f9f7	508	else
<>	144:ef7eb2e8f9f7	509	{
<>	144:ef7eb2e8f9f7	510	return HAL_BUSY;
<>	144:ef7eb2e8f9f7	511	}
<>	144:ef7eb2e8f9f7	512	}
<>	144:ef7eb2e8f9f7	513
<>	144:ef7eb2e8f9f7	514	/**
<>	144:ef7eb2e8f9f7	515	* @brief Receive an amount of data in blocking mode.
<>	144:ef7eb2e8f9f7	516	* @param hsmartcard: Pointer to a SMARTCARD_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	517	* the configuration information for the specified SMARTCARD module.
<>	144:ef7eb2e8f9f7	518	* @param pData: pointer to data buffer.
<>	144:ef7eb2e8f9f7	519	* @param Size: amount of data to be received.
<>	144:ef7eb2e8f9f7	520	* @param Timeout : Timeout duration.
<>	144:ef7eb2e8f9f7	521	* @retval HAL status
<>	144:ef7eb2e8f9f7	522	*/
<>	144:ef7eb2e8f9f7	523	HAL_StatusTypeDef HAL_SMARTCARD_Receive(SMARTCARD_HandleTypeDef hsmartcard, uint8_t pData, uint16_t Size, uint32_t Timeout)
<>	144:ef7eb2e8f9f7	524	{
<>	144:ef7eb2e8f9f7	525	uint32_t tickstart = 0;
<>	144:ef7eb2e8f9f7	526
<>	144:ef7eb2e8f9f7	527	/* Check that a Rx process is not already ongoing */
<>	144:ef7eb2e8f9f7	528	if(hsmartcard->RxState == HAL_SMARTCARD_STATE_READY)
<>	144:ef7eb2e8f9f7	529	{
<>	144:ef7eb2e8f9f7	530	if((pData == NULL) \|\| (Size == 0))
<>	144:ef7eb2e8f9f7	531	{
<>	144:ef7eb2e8f9f7	532	return HAL_ERROR;
<>	144:ef7eb2e8f9f7	533	}
<>	144:ef7eb2e8f9f7	534
<>	144:ef7eb2e8f9f7	535	/* Process Locked */
<>	144:ef7eb2e8f9f7	536	__HAL_LOCK(hsmartcard);
<>	144:ef7eb2e8f9f7	537
<>	144:ef7eb2e8f9f7	538	hsmartcard->ErrorCode = HAL_SMARTCARD_ERROR_NONE;
<>	144:ef7eb2e8f9f7	539	hsmartcard->RxState = HAL_SMARTCARD_STATE_BUSY_RX;
<>	144:ef7eb2e8f9f7	540
<>	144:ef7eb2e8f9f7	541	/* Init tickstart for timeout managment*/
<>	144:ef7eb2e8f9f7	542	tickstart = HAL_GetTick();
<>	144:ef7eb2e8f9f7	543
<>	144:ef7eb2e8f9f7	544	hsmartcard->RxXferSize = Size;
<>	144:ef7eb2e8f9f7	545	hsmartcard->RxXferCount = Size;
<>	144:ef7eb2e8f9f7	546
<>	144:ef7eb2e8f9f7	547	/* Check the remain data to be received */
<>	144:ef7eb2e8f9f7	548	while(hsmartcard->RxXferCount > 0)
<>	144:ef7eb2e8f9f7	549	{
<>	144:ef7eb2e8f9f7	550	hsmartcard->RxXferCount--;
<>	144:ef7eb2e8f9f7	551	if(SMARTCARD_WaitOnFlagUntilTimeout(hsmartcard, SMARTCARD_FLAG_RXNE, RESET, tickstart, Timeout) != HAL_OK)
<>	144:ef7eb2e8f9f7	552	{
<>	144:ef7eb2e8f9f7	553	return HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	554	}
<>	144:ef7eb2e8f9f7	555	*pData++ = (uint8_t)(hsmartcard->Instance->RDR & (uint8_t)0x00FF);
<>	144:ef7eb2e8f9f7	556	}
<>	144:ef7eb2e8f9f7	557
<>	144:ef7eb2e8f9f7	558	/* At end of Rx process, restore hsmartcard->RxState to Ready */
<>	144:ef7eb2e8f9f7	559	hsmartcard->RxState = HAL_SMARTCARD_STATE_READY;
<>	144:ef7eb2e8f9f7	560
<>	144:ef7eb2e8f9f7	561	/* Process Unlocked */
<>	144:ef7eb2e8f9f7	562	__HAL_UNLOCK(hsmartcard);
<>	144:ef7eb2e8f9f7	563
<>	144:ef7eb2e8f9f7	564	return HAL_OK;
<>	144:ef7eb2e8f9f7	565	}
<>	144:ef7eb2e8f9f7	566	else
<>	144:ef7eb2e8f9f7	567	{
<>	144:ef7eb2e8f9f7	568	return HAL_BUSY;
<>	144:ef7eb2e8f9f7	569	}
<>	144:ef7eb2e8f9f7	570	}
<>	144:ef7eb2e8f9f7	571
<>	144:ef7eb2e8f9f7	572	/**
<>	144:ef7eb2e8f9f7	573	* @brief Send an amount of data in interrupt mode.
<>	144:ef7eb2e8f9f7	574	* @param hsmartcard: Pointer to a SMARTCARD_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	575	* the configuration information for the specified SMARTCARD module.
<>	144:ef7eb2e8f9f7	576	* @param pData: pointer to data buffer.
<>	144:ef7eb2e8f9f7	577	* @param Size: amount of data to be sent.
<>	144:ef7eb2e8f9f7	578	* @retval HAL status
<>	144:ef7eb2e8f9f7	579	*/
<>	144:ef7eb2e8f9f7	580	HAL_StatusTypeDef HAL_SMARTCARD_Transmit_IT(SMARTCARD_HandleTypeDef hsmartcard, uint8_t pData, uint16_t Size)
<>	144:ef7eb2e8f9f7	581	{
<>	144:ef7eb2e8f9f7	582	/* Check that a Tx process is not already ongoing */
<>	144:ef7eb2e8f9f7	583	if (hsmartcard->gState == HAL_SMARTCARD_STATE_READY)
<>	144:ef7eb2e8f9f7	584	{
<>	144:ef7eb2e8f9f7	585	if((pData == NULL) \|\| (Size == 0))
<>	144:ef7eb2e8f9f7	586	{
<>	144:ef7eb2e8f9f7	587	return HAL_ERROR;
<>	144:ef7eb2e8f9f7	588	}
<>	144:ef7eb2e8f9f7	589
<>	144:ef7eb2e8f9f7	590	/* Process Locked */
<>	144:ef7eb2e8f9f7	591	__HAL_LOCK(hsmartcard);
<>	144:ef7eb2e8f9f7	592
<>	144:ef7eb2e8f9f7	593	hsmartcard->ErrorCode = HAL_SMARTCARD_ERROR_NONE;
<>	144:ef7eb2e8f9f7	594	hsmartcard->gState = HAL_SMARTCARD_STATE_BUSY_TX;
<>	144:ef7eb2e8f9f7	595
<>	144:ef7eb2e8f9f7	596	hsmartcard->pTxBuffPtr = pData;
<>	144:ef7eb2e8f9f7	597	hsmartcard->TxXferSize = Size;
<>	144:ef7eb2e8f9f7	598	hsmartcard->TxXferCount = Size;
<>	144:ef7eb2e8f9f7	599
<>	144:ef7eb2e8f9f7	600	/* Disable the Peripheral first to update mode for TX master */
<>	144:ef7eb2e8f9f7	601	CLEAR_BIT(hsmartcard->Instance->CR1, USART_CR1_UE);
<>	144:ef7eb2e8f9f7	602
<>	144:ef7eb2e8f9f7	603	/* Disable Rx, enable Tx */
<>	144:ef7eb2e8f9f7	604	CLEAR_BIT(hsmartcard->Instance->CR1, USART_CR1_RE);
<>	144:ef7eb2e8f9f7	605	SET_BIT(hsmartcard->Instance->RQR, SMARTCARD_RXDATA_FLUSH_REQUEST);
<>	144:ef7eb2e8f9f7	606	SET_BIT(hsmartcard->Instance->CR1, USART_CR1_TE);
<>	144:ef7eb2e8f9f7	607
<>	144:ef7eb2e8f9f7	608	/* Enable the Peripheral */
<>	144:ef7eb2e8f9f7	609	SET_BIT(hsmartcard->Instance->CR1, USART_CR1_UE);
<>	144:ef7eb2e8f9f7	610
<>	144:ef7eb2e8f9f7	611	/* Enable the SMARTCARD Error Interrupt: (Frame error, noise error, overrun error) */
<>	144:ef7eb2e8f9f7	612	__HAL_SMARTCARD_ENABLE_IT(hsmartcard, SMARTCARD_IT_ERR);
<>	144:ef7eb2e8f9f7	613
<>	144:ef7eb2e8f9f7	614	/* Process Unlocked */
<>	144:ef7eb2e8f9f7	615	__HAL_UNLOCK(hsmartcard);
<>	144:ef7eb2e8f9f7	616
<>	144:ef7eb2e8f9f7	617	/* Enable the SMARTCARD Transmit Data Register Empty Interrupt */
<>	144:ef7eb2e8f9f7	618	__HAL_SMARTCARD_ENABLE_IT(hsmartcard, SMARTCARD_IT_TXE);
<>	144:ef7eb2e8f9f7	619
<>	144:ef7eb2e8f9f7	620	return HAL_OK;
<>	144:ef7eb2e8f9f7	621	}
<>	144:ef7eb2e8f9f7	622	else
<>	144:ef7eb2e8f9f7	623	{
<>	144:ef7eb2e8f9f7	624	return HAL_BUSY;
<>	144:ef7eb2e8f9f7	625	}
<>	144:ef7eb2e8f9f7	626	}
<>	144:ef7eb2e8f9f7	627
<>	144:ef7eb2e8f9f7	628	/**
<>	144:ef7eb2e8f9f7	629	* @brief Receive an amount of data in interrupt mode.
<>	144:ef7eb2e8f9f7	630	* @param hsmartcard: Pointer to a SMARTCARD_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	631	* the configuration information for the specified SMARTCARD module.
<>	144:ef7eb2e8f9f7	632	* @param pData: pointer to data buffer.
<>	144:ef7eb2e8f9f7	633	* @param Size: amount of data to be received.
<>	144:ef7eb2e8f9f7	634	* @retval HAL status
<>	144:ef7eb2e8f9f7	635	*/
<>	144:ef7eb2e8f9f7	636	HAL_StatusTypeDef HAL_SMARTCARD_Receive_IT(SMARTCARD_HandleTypeDef hsmartcard, uint8_t pData, uint16_t Size)
<>	144:ef7eb2e8f9f7	637	{
<>	144:ef7eb2e8f9f7	638	/* Check that a Rx process is not already ongoing */
<>	144:ef7eb2e8f9f7	639	if(hsmartcard->RxState == HAL_SMARTCARD_STATE_READY)
<>	144:ef7eb2e8f9f7	640	{
<>	144:ef7eb2e8f9f7	641	if((pData == NULL) \|\| (Size == 0))
<>	144:ef7eb2e8f9f7	642	{
<>	144:ef7eb2e8f9f7	643	return HAL_ERROR;
<>	144:ef7eb2e8f9f7	644	}
<>	144:ef7eb2e8f9f7	645
<>	144:ef7eb2e8f9f7	646	/* Process Locked */
<>	144:ef7eb2e8f9f7	647	__HAL_LOCK(hsmartcard);
<>	144:ef7eb2e8f9f7	648
<>	144:ef7eb2e8f9f7	649	hsmartcard->ErrorCode = HAL_SMARTCARD_ERROR_NONE;
<>	144:ef7eb2e8f9f7	650	hsmartcard->RxState = HAL_SMARTCARD_STATE_BUSY_RX;
<>	144:ef7eb2e8f9f7	651
<>	144:ef7eb2e8f9f7	652	hsmartcard->pRxBuffPtr = pData;
<>	144:ef7eb2e8f9f7	653	hsmartcard->RxXferSize = Size;
<>	144:ef7eb2e8f9f7	654	hsmartcard->RxXferCount = Size;
<>	144:ef7eb2e8f9f7	655
<>	144:ef7eb2e8f9f7	656	/* Process Unlocked */
<>	144:ef7eb2e8f9f7	657	__HAL_UNLOCK(hsmartcard);
<>	144:ef7eb2e8f9f7	658
<>	144:ef7eb2e8f9f7	659	/* Enable the SMARTCARD Parity Error Interrupt */
<>	144:ef7eb2e8f9f7	660	__HAL_SMARTCARD_ENABLE_IT(hsmartcard, SMARTCARD_IT_PE);
<>	144:ef7eb2e8f9f7	661
<>	144:ef7eb2e8f9f7	662	/* Enable the SMARTCARD Error Interrupt: (Frame error, noise error, overrun error) */
<>	144:ef7eb2e8f9f7	663	__HAL_SMARTCARD_ENABLE_IT(hsmartcard, SMARTCARD_IT_ERR);
<>	144:ef7eb2e8f9f7	664
<>	144:ef7eb2e8f9f7	665	/* Enable the SMARTCARD Data Register not empty Interrupt */
<>	144:ef7eb2e8f9f7	666	__HAL_SMARTCARD_ENABLE_IT(hsmartcard, SMARTCARD_IT_RXNE);
<>	144:ef7eb2e8f9f7	667
<>	144:ef7eb2e8f9f7	668	return HAL_OK;
<>	144:ef7eb2e8f9f7	669	}
<>	144:ef7eb2e8f9f7	670	else
<>	144:ef7eb2e8f9f7	671	{
<>	144:ef7eb2e8f9f7	672	return HAL_BUSY;
<>	144:ef7eb2e8f9f7	673	}
<>	144:ef7eb2e8f9f7	674	}
<>	144:ef7eb2e8f9f7	675
<>	144:ef7eb2e8f9f7	676	/**
<>	144:ef7eb2e8f9f7	677	* @brief Send an amount of data in DMA mode.
<>	144:ef7eb2e8f9f7	678	* @param hsmartcard: Pointer to a SMARTCARD_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	679	* the configuration information for the specified SMARTCARD module.
<>	144:ef7eb2e8f9f7	680	* @param pData: pointer to data buffer.
<>	144:ef7eb2e8f9f7	681	* @param Size: amount of data to be sent.
<>	144:ef7eb2e8f9f7	682	* @retval HAL status
<>	144:ef7eb2e8f9f7	683	*/
<>	144:ef7eb2e8f9f7	684	HAL_StatusTypeDef HAL_SMARTCARD_Transmit_DMA(SMARTCARD_HandleTypeDef hsmartcard, uint8_t pData, uint16_t Size)
<>	144:ef7eb2e8f9f7	685	{
<>	144:ef7eb2e8f9f7	686	uint32_t *tmp;
<>	144:ef7eb2e8f9f7	687
<>	144:ef7eb2e8f9f7	688	/* Check that a Tx process is not already ongoing */
<>	144:ef7eb2e8f9f7	689	if (hsmartcard->gState == HAL_SMARTCARD_STATE_READY)
<>	144:ef7eb2e8f9f7	690	{
<>	144:ef7eb2e8f9f7	691	if((pData == NULL) \|\| (Size == 0))
<>	144:ef7eb2e8f9f7	692	{
<>	144:ef7eb2e8f9f7	693	return HAL_ERROR;
<>	144:ef7eb2e8f9f7	694	}
<>	144:ef7eb2e8f9f7	695
<>	144:ef7eb2e8f9f7	696	/* Process Locked */
<>	144:ef7eb2e8f9f7	697	__HAL_LOCK(hsmartcard);
<>	144:ef7eb2e8f9f7	698
<>	144:ef7eb2e8f9f7	699	hsmartcard->gState = HAL_SMARTCARD_STATE_BUSY_TX;
<>	144:ef7eb2e8f9f7	700
<>	144:ef7eb2e8f9f7	701	hsmartcard->ErrorCode = HAL_SMARTCARD_ERROR_NONE;
<>	144:ef7eb2e8f9f7	702	hsmartcard->pTxBuffPtr = pData;
<>	144:ef7eb2e8f9f7	703	hsmartcard->TxXferSize = Size;
<>	144:ef7eb2e8f9f7	704	hsmartcard->TxXferCount = Size;
<>	144:ef7eb2e8f9f7	705
<>	144:ef7eb2e8f9f7	706	/* Disable the Peripheral first to update mode for TX master */
<>	144:ef7eb2e8f9f7	707	CLEAR_BIT(hsmartcard->Instance->CR1, USART_CR1_UE);
<>	144:ef7eb2e8f9f7	708
<>	144:ef7eb2e8f9f7	709	/* Disable Rx, enable Tx */
<>	144:ef7eb2e8f9f7	710	CLEAR_BIT(hsmartcard->Instance->CR1, USART_CR1_RE);
<>	144:ef7eb2e8f9f7	711	SET_BIT(hsmartcard->Instance->RQR, SMARTCARD_RXDATA_FLUSH_REQUEST);
<>	144:ef7eb2e8f9f7	712	SET_BIT(hsmartcard->Instance->CR1, USART_CR1_TE);
<>	144:ef7eb2e8f9f7	713
<>	144:ef7eb2e8f9f7	714	/* Enable the Peripheral */
<>	144:ef7eb2e8f9f7	715	SET_BIT(hsmartcard->Instance->CR1, USART_CR1_UE);
<>	144:ef7eb2e8f9f7	716
<>	144:ef7eb2e8f9f7	717	/* Set the SMARTCARD DMA transfer complete callback */
<>	144:ef7eb2e8f9f7	718	hsmartcard->hdmatx->XferCpltCallback = SMARTCARD_DMATransmitCplt;
<>	144:ef7eb2e8f9f7	719
<>	144:ef7eb2e8f9f7	720	/* Set the SMARTCARD error callback */
<>	144:ef7eb2e8f9f7	721	hsmartcard->hdmatx->XferErrorCallback = SMARTCARD_DMAError;
<>	144:ef7eb2e8f9f7	722
<>	144:ef7eb2e8f9f7	723	/* Enable the SMARTCARD transmit DMA channel */
<>	144:ef7eb2e8f9f7	724	tmp = (uint32_t*)&pData;
<>	144:ef7eb2e8f9f7	725	HAL_DMA_Start_IT(hsmartcard->hdmatx, (uint32_t)tmp, (uint32_t)&hsmartcard->Instance->TDR, Size);
<>	144:ef7eb2e8f9f7	726
<>	144:ef7eb2e8f9f7	727	/* Clear the TC flag in the ICR register */
<>	144:ef7eb2e8f9f7	728	__HAL_SMARTCARD_CLEAR_FLAG(hsmartcard, SMARTCARD_CLEAR_TCF);
<>	144:ef7eb2e8f9f7	729
<>	144:ef7eb2e8f9f7	730	/* Enable the DMA transfer for transmit request by setting the DMAT bit
<>	144:ef7eb2e8f9f7	731	in the SMARTCARD associated USART CR3 register */
<>	144:ef7eb2e8f9f7	732	SET_BIT(hsmartcard->Instance->CR3, USART_CR3_DMAT);
<>	144:ef7eb2e8f9f7	733
<>	144:ef7eb2e8f9f7	734	/* Process Unlocked */
<>	144:ef7eb2e8f9f7	735	__HAL_UNLOCK(hsmartcard);
<>	144:ef7eb2e8f9f7	736
<>	144:ef7eb2e8f9f7	737	return HAL_OK;
<>	144:ef7eb2e8f9f7	738	}
<>	144:ef7eb2e8f9f7	739	else
<>	144:ef7eb2e8f9f7	740	{
<>	144:ef7eb2e8f9f7	741	return HAL_BUSY;
<>	144:ef7eb2e8f9f7	742	}
<>	144:ef7eb2e8f9f7	743	}
<>	144:ef7eb2e8f9f7	744
<>	144:ef7eb2e8f9f7	745	/**
<>	144:ef7eb2e8f9f7	746	* @brief Receive an amount of data in DMA mode.
<>	144:ef7eb2e8f9f7	747	* @param hsmartcard: Pointer to a SMARTCARD_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	748	* the configuration information for the specified SMARTCARD module.
<>	144:ef7eb2e8f9f7	749	* @param pData: pointer to data buffer.
<>	144:ef7eb2e8f9f7	750	* @param Size: amount of data to be received.
<>	144:ef7eb2e8f9f7	751	* @note The SMARTCARD-associated USART parity is enabled (PCE = 1),
<>	144:ef7eb2e8f9f7	752	* the received data contain the parity bit (MSB position).
<>	144:ef7eb2e8f9f7	753	* @retval HAL status
<>	144:ef7eb2e8f9f7	754	*/
<>	144:ef7eb2e8f9f7	755	HAL_StatusTypeDef HAL_SMARTCARD_Receive_DMA(SMARTCARD_HandleTypeDef hsmartcard, uint8_t pData, uint16_t Size)
<>	144:ef7eb2e8f9f7	756	{
<>	144:ef7eb2e8f9f7	757	uint32_t *tmp;
<>	144:ef7eb2e8f9f7	758
<>	144:ef7eb2e8f9f7	759	/* Check that a Rx process is not already ongoing */
<>	144:ef7eb2e8f9f7	760	if(hsmartcard->RxState == HAL_SMARTCARD_STATE_READY)
<>	144:ef7eb2e8f9f7	761	{
<>	144:ef7eb2e8f9f7	762	if((pData == NULL) \|\| (Size == 0))
<>	144:ef7eb2e8f9f7	763	{
<>	144:ef7eb2e8f9f7	764	return HAL_ERROR;
<>	144:ef7eb2e8f9f7	765	}
<>	144:ef7eb2e8f9f7	766
<>	144:ef7eb2e8f9f7	767	/* Process Locked */
<>	144:ef7eb2e8f9f7	768	__HAL_LOCK(hsmartcard);
<>	144:ef7eb2e8f9f7	769
<>	144:ef7eb2e8f9f7	770	hsmartcard->ErrorCode = HAL_SMARTCARD_ERROR_NONE;
<>	144:ef7eb2e8f9f7	771	hsmartcard->RxState = HAL_SMARTCARD_STATE_BUSY_RX;
<>	144:ef7eb2e8f9f7	772
<>	144:ef7eb2e8f9f7	773	hsmartcard->pRxBuffPtr = pData;
<>	144:ef7eb2e8f9f7	774	hsmartcard->RxXferSize = Size;
<>	144:ef7eb2e8f9f7	775
<>	144:ef7eb2e8f9f7	776	/* Set the SMARTCARD DMA transfer complete callback */
<>	144:ef7eb2e8f9f7	777	hsmartcard->hdmarx->XferCpltCallback = SMARTCARD_DMAReceiveCplt;
<>	144:ef7eb2e8f9f7	778
<>	144:ef7eb2e8f9f7	779	/* Set the SMARTCARD DMA error callback */
<>	144:ef7eb2e8f9f7	780	hsmartcard->hdmarx->XferErrorCallback = SMARTCARD_DMAError;
<>	144:ef7eb2e8f9f7	781
<>	144:ef7eb2e8f9f7	782	/* Enable the DMA channel */
<>	144:ef7eb2e8f9f7	783	tmp = (uint32_t*)&pData;
<>	144:ef7eb2e8f9f7	784	HAL_DMA_Start_IT(hsmartcard->hdmarx, (uint32_t)&hsmartcard->Instance->RDR, (uint32_t)tmp, Size);
<>	144:ef7eb2e8f9f7	785
<>	144:ef7eb2e8f9f7	786	/* Enable the DMA transfer for the receiver request by setting the DMAR bit
<>	144:ef7eb2e8f9f7	787	in the SMARTCARD associated USART CR3 register */
<>	144:ef7eb2e8f9f7	788	SET_BIT(hsmartcard->Instance->CR3, USART_CR3_DMAR);
<>	144:ef7eb2e8f9f7	789
<>	144:ef7eb2e8f9f7	790	/* Process Unlocked */
<>	144:ef7eb2e8f9f7	791	__HAL_UNLOCK(hsmartcard);
<>	144:ef7eb2e8f9f7	792
<>	144:ef7eb2e8f9f7	793	return HAL_OK;
<>	144:ef7eb2e8f9f7	794	}
<>	144:ef7eb2e8f9f7	795	else
<>	144:ef7eb2e8f9f7	796	{
<>	144:ef7eb2e8f9f7	797	return HAL_BUSY;
<>	144:ef7eb2e8f9f7	798	}
<>	144:ef7eb2e8f9f7	799	}
<>	144:ef7eb2e8f9f7	800
<>	144:ef7eb2e8f9f7	801	/**
<>	144:ef7eb2e8f9f7	802	* @brief Handle SMARTCARD interrupt requests.
<>	144:ef7eb2e8f9f7	803	* @param hsmartcard: Pointer to a SMARTCARD_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	804	* the configuration information for the specified SMARTCARD module.
<>	144:ef7eb2e8f9f7	805	* @retval None
<>	144:ef7eb2e8f9f7	806	*/
<>	144:ef7eb2e8f9f7	807	void HAL_SMARTCARD_IRQHandler(SMARTCARD_HandleTypeDef *hsmartcard)
<>	144:ef7eb2e8f9f7	808	{
<>	144:ef7eb2e8f9f7	809	/* SMARTCARD parity error interrupt occurred -------------------------------------*/
<>	144:ef7eb2e8f9f7	810	if((__HAL_SMARTCARD_GET_IT(hsmartcard, SMARTCARD_IT_PE) != RESET) && (__HAL_SMARTCARD_GET_IT_SOURCE(hsmartcard, SMARTCARD_IT_PE) != RESET))
<>	144:ef7eb2e8f9f7	811	{
<>	144:ef7eb2e8f9f7	812	__HAL_SMARTCARD_CLEAR_IT(hsmartcard, SMARTCARD_CLEAR_PEF);
<>	144:ef7eb2e8f9f7	813	hsmartcard->ErrorCode \|= HAL_SMARTCARD_ERROR_PE;
<>	144:ef7eb2e8f9f7	814	/* Set the SMARTCARD states ready to be able to start again the process */
<>	144:ef7eb2e8f9f7	815	hsmartcard->gState = HAL_SMARTCARD_STATE_READY;
<>	144:ef7eb2e8f9f7	816	hsmartcard->RxState = HAL_SMARTCARD_STATE_READY;
<>	144:ef7eb2e8f9f7	817	}
<>	144:ef7eb2e8f9f7	818
<>	144:ef7eb2e8f9f7	819	/* SMARTCARD frame error interrupt occurred --------------------------------------*/
<>	144:ef7eb2e8f9f7	820	if((__HAL_SMARTCARD_GET_IT(hsmartcard, SMARTCARD_IT_FE) != RESET) && (__HAL_SMARTCARD_GET_IT_SOURCE(hsmartcard, SMARTCARD_IT_ERR) != RESET))
<>	144:ef7eb2e8f9f7	821	{
<>	144:ef7eb2e8f9f7	822	__HAL_SMARTCARD_CLEAR_IT(hsmartcard, SMARTCARD_CLEAR_FEF);
<>	144:ef7eb2e8f9f7	823	hsmartcard->ErrorCode \|= HAL_SMARTCARD_ERROR_FE;
<>	144:ef7eb2e8f9f7	824	/* Set the SMARTCARD states ready to be able to start again the process */
<>	144:ef7eb2e8f9f7	825	hsmartcard->gState = HAL_SMARTCARD_STATE_READY;
<>	144:ef7eb2e8f9f7	826	hsmartcard->RxState = HAL_SMARTCARD_STATE_READY;
<>	144:ef7eb2e8f9f7	827	}
<>	144:ef7eb2e8f9f7	828
<>	144:ef7eb2e8f9f7	829	/* SMARTCARD noise error interrupt occurred --------------------------------------*/
<>	144:ef7eb2e8f9f7	830	if((__HAL_SMARTCARD_GET_IT(hsmartcard, SMARTCARD_IT_NE) != RESET) && (__HAL_SMARTCARD_GET_IT_SOURCE(hsmartcard, SMARTCARD_IT_ERR) != RESET))
<>	144:ef7eb2e8f9f7	831	{
<>	144:ef7eb2e8f9f7	832	__HAL_SMARTCARD_CLEAR_IT(hsmartcard, SMARTCARD_CLEAR_NEF);
<>	144:ef7eb2e8f9f7	833	hsmartcard->ErrorCode \|= HAL_SMARTCARD_ERROR_NE;
<>	144:ef7eb2e8f9f7	834	/* Set the SMARTCARD states ready to be able to start again the process */
<>	144:ef7eb2e8f9f7	835	hsmartcard->gState = HAL_SMARTCARD_STATE_READY;
<>	144:ef7eb2e8f9f7	836	hsmartcard->RxState = HAL_SMARTCARD_STATE_READY;
<>	144:ef7eb2e8f9f7	837	}
<>	144:ef7eb2e8f9f7	838
<>	144:ef7eb2e8f9f7	839	/* SMARTCARD Over-Run interrupt occurred -----------------------------------------*/
<>	144:ef7eb2e8f9f7	840	if((__HAL_SMARTCARD_GET_IT(hsmartcard, SMARTCARD_IT_ORE) != RESET) && (__HAL_SMARTCARD_GET_IT_SOURCE(hsmartcard, SMARTCARD_IT_ERR) != RESET))
<>	144:ef7eb2e8f9f7	841	{
<>	144:ef7eb2e8f9f7	842	__HAL_SMARTCARD_CLEAR_IT(hsmartcard, SMARTCARD_CLEAR_OREF);
<>	144:ef7eb2e8f9f7	843	hsmartcard->ErrorCode \|= HAL_SMARTCARD_ERROR_ORE;
<>	144:ef7eb2e8f9f7	844	/* Set the SMARTCARD states ready to be able to start again the process */
<>	144:ef7eb2e8f9f7	845	hsmartcard->gState = HAL_SMARTCARD_STATE_READY;
<>	144:ef7eb2e8f9f7	846	hsmartcard->RxState = HAL_SMARTCARD_STATE_READY;
<>	144:ef7eb2e8f9f7	847	}
<>	144:ef7eb2e8f9f7	848
<>	144:ef7eb2e8f9f7	849	/* SMARTCARD receiver timeout interrupt occurred -----------------------------------------*/
<>	144:ef7eb2e8f9f7	850	if((__HAL_SMARTCARD_GET_IT(hsmartcard, SMARTCARD_IT_RTO) != RESET) && (__HAL_SMARTCARD_GET_IT_SOURCE(hsmartcard, SMARTCARD_IT_RTO) != RESET))
<>	144:ef7eb2e8f9f7	851	{
<>	144:ef7eb2e8f9f7	852	__HAL_SMARTCARD_CLEAR_IT(hsmartcard, SMARTCARD_CLEAR_RTOF);
<>	144:ef7eb2e8f9f7	853	hsmartcard->ErrorCode \|= HAL_SMARTCARD_ERROR_RTO;
<>	144:ef7eb2e8f9f7	854	/* Set the SMARTCARD states ready to be able to start again the process */
<>	144:ef7eb2e8f9f7	855	hsmartcard->gState = HAL_SMARTCARD_STATE_READY;
<>	144:ef7eb2e8f9f7	856	hsmartcard->RxState = HAL_SMARTCARD_STATE_READY;
<>	144:ef7eb2e8f9f7	857	}
<>	144:ef7eb2e8f9f7	858
<>	144:ef7eb2e8f9f7	859	/* Call SMARTCARD Error Call back function if need be --------------------------*/
<>	144:ef7eb2e8f9f7	860	if(hsmartcard->ErrorCode != HAL_SMARTCARD_ERROR_NONE)
<>	144:ef7eb2e8f9f7	861	{
<>	144:ef7eb2e8f9f7	862	HAL_SMARTCARD_ErrorCallback(hsmartcard);
<>	144:ef7eb2e8f9f7	863	}
<>	144:ef7eb2e8f9f7	864
<>	144:ef7eb2e8f9f7	865	/* SMARTCARD in mode Receiver ---------------------------------------------------*/
<>	144:ef7eb2e8f9f7	866	if((__HAL_SMARTCARD_GET_IT(hsmartcard, SMARTCARD_IT_RXNE) != RESET) && (__HAL_SMARTCARD_GET_IT_SOURCE(hsmartcard, SMARTCARD_IT_RXNE) != RESET))
<>	144:ef7eb2e8f9f7	867	{
<>	144:ef7eb2e8f9f7	868	SMARTCARD_Receive_IT(hsmartcard);
<>	144:ef7eb2e8f9f7	869	/* Clear RXNE interrupt flag done by reading RDR in SMARTCARD_Receive_IT() */
<>	144:ef7eb2e8f9f7	870	}
<>	144:ef7eb2e8f9f7	871
<>	144:ef7eb2e8f9f7	872	/* SMARTCARD in mode Receiver, end of block interruption ------------------------*/
<>	144:ef7eb2e8f9f7	873	if((__HAL_SMARTCARD_GET_IT(hsmartcard, SMARTCARD_IT_EOB) != RESET) && (__HAL_SMARTCARD_GET_IT_SOURCE(hsmartcard, SMARTCARD_IT_EOB) != RESET))
<>	144:ef7eb2e8f9f7	874	{
<>	144:ef7eb2e8f9f7	875	hsmartcard->RxState = HAL_SMARTCARD_STATE_READY;
<>	144:ef7eb2e8f9f7	876	__HAL_UNLOCK(hsmartcard);
<>	144:ef7eb2e8f9f7	877	HAL_SMARTCARD_RxCpltCallback(hsmartcard);
<>	144:ef7eb2e8f9f7	878	/* Clear EOBF interrupt after HAL_SMARTCARD_RxCpltCallback() call for the End of Block information
<>	144:ef7eb2e8f9f7	879	* to be available during HAL_SMARTCARD_RxCpltCallback() processing */
<>	144:ef7eb2e8f9f7	880	__HAL_SMARTCARD_CLEAR_IT(hsmartcard, SMARTCARD_CLEAR_EOBF);
<>	144:ef7eb2e8f9f7	881	}
<>	144:ef7eb2e8f9f7	882
<>	144:ef7eb2e8f9f7	883	/* SMARTCARD in mode Transmitter ------------------------------------------------*/
<>	144:ef7eb2e8f9f7	884	if((__HAL_SMARTCARD_GET_IT(hsmartcard, SMARTCARD_IT_TXE) != RESET) &&(__HAL_SMARTCARD_GET_IT_SOURCE(hsmartcard, SMARTCARD_IT_TXE) != RESET))
<>	144:ef7eb2e8f9f7	885	{
<>	144:ef7eb2e8f9f7	886	SMARTCARD_Transmit_IT(hsmartcard);
<>	144:ef7eb2e8f9f7	887	}
<>	144:ef7eb2e8f9f7	888
<>	144:ef7eb2e8f9f7	889	/* SMARTCARD in mode Transmitter (transmission end) ------------------------*/
<>	144:ef7eb2e8f9f7	890	if((__HAL_SMARTCARD_GET_IT(hsmartcard, hsmartcard->AdvancedInit.TxCompletionIndication) != RESET) &&(__HAL_SMARTCARD_GET_IT_SOURCE(hsmartcard, hsmartcard->AdvancedInit.TxCompletionIndication) != RESET))
<>	144:ef7eb2e8f9f7	891	{
<>	144:ef7eb2e8f9f7	892	SMARTCARD_EndTransmit_IT(hsmartcard);
<>	144:ef7eb2e8f9f7	893	}
<>	144:ef7eb2e8f9f7	894	}
<>	144:ef7eb2e8f9f7	895
<>	144:ef7eb2e8f9f7	896	/**
<>	144:ef7eb2e8f9f7	897	* @brief Tx Transfer completed callback.
<>	144:ef7eb2e8f9f7	898	* @param hsmartcard: Pointer to a SMARTCARD_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	899	* the configuration information for the specified SMARTCARD module.
<>	144:ef7eb2e8f9f7	900	* @retval None
<>	144:ef7eb2e8f9f7	901	*/
<>	144:ef7eb2e8f9f7	902	__weak void HAL_SMARTCARD_TxCpltCallback(SMARTCARD_HandleTypeDef *hsmartcard)
<>	144:ef7eb2e8f9f7	903	{
<>	144:ef7eb2e8f9f7	904	/* Prevent unused argument(s) compilation warning */
<>	144:ef7eb2e8f9f7	905	UNUSED(hsmartcard);
<>	144:ef7eb2e8f9f7	906
<>	144:ef7eb2e8f9f7	907	/* NOTE : This function should not be modified, when the callback is needed,
<>	144:ef7eb2e8f9f7	908	the HAL_SMARTCARD_TxCpltCallback can be implemented in the user file.
<>	144:ef7eb2e8f9f7	909	*/
<>	144:ef7eb2e8f9f7	910	}
<>	144:ef7eb2e8f9f7	911
<>	144:ef7eb2e8f9f7	912	/**
<>	144:ef7eb2e8f9f7	913	* @brief Rx Transfer completed callback.
<>	144:ef7eb2e8f9f7	914	* @param hsmartcard: Pointer to a SMARTCARD_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	915	* the configuration information for the specified SMARTCARD module.
<>	144:ef7eb2e8f9f7	916	* @retval None
<>	144:ef7eb2e8f9f7	917	*/
<>	144:ef7eb2e8f9f7	918	__weak void HAL_SMARTCARD_RxCpltCallback(SMARTCARD_HandleTypeDef *hsmartcard)
<>	144:ef7eb2e8f9f7	919	{
<>	144:ef7eb2e8f9f7	920	/* Prevent unused argument(s) compilation warning */
<>	144:ef7eb2e8f9f7	921	UNUSED(hsmartcard);
<>	144:ef7eb2e8f9f7	922
<>	144:ef7eb2e8f9f7	923	/* NOTE : This function should not be modified, when the callback is needed,
<>	144:ef7eb2e8f9f7	924	the HAL_SMARTCARD_RxCpltCallback can be implemented in the user file.
<>	144:ef7eb2e8f9f7	925	*/
<>	144:ef7eb2e8f9f7	926	}
<>	144:ef7eb2e8f9f7	927
<>	144:ef7eb2e8f9f7	928	/**
<>	144:ef7eb2e8f9f7	929	* @brief SMARTCARD error callback.
<>	144:ef7eb2e8f9f7	930	* @param hsmartcard: Pointer to a SMARTCARD_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	931	* the configuration information for the specified SMARTCARD module.
<>	144:ef7eb2e8f9f7	932	* @retval None
<>	144:ef7eb2e8f9f7	933	*/
<>	144:ef7eb2e8f9f7	934	__weak void HAL_SMARTCARD_ErrorCallback(SMARTCARD_HandleTypeDef *hsmartcard)
<>	144:ef7eb2e8f9f7	935	{
<>	144:ef7eb2e8f9f7	936	/* Prevent unused argument(s) compilation warning */
<>	144:ef7eb2e8f9f7	937	UNUSED(hsmartcard);
<>	144:ef7eb2e8f9f7	938
<>	144:ef7eb2e8f9f7	939	/* NOTE : This function should not be modified, when the callback is needed,
<>	144:ef7eb2e8f9f7	940	the HAL_SMARTCARD_ErrorCallback can be implemented in the user file.
<>	144:ef7eb2e8f9f7	941	*/
<>	144:ef7eb2e8f9f7	942	}
<>	144:ef7eb2e8f9f7	943
<>	144:ef7eb2e8f9f7	944	/**
<>	144:ef7eb2e8f9f7	945	* @}
<>	144:ef7eb2e8f9f7	946	*/
<>	144:ef7eb2e8f9f7	947
<>	144:ef7eb2e8f9f7	948	/** @defgroup SMARTCARD_Exported_Functions_Group4 Peripheral State and Errors functions
<>	144:ef7eb2e8f9f7	949	* @brief SMARTCARD State and Errors functions
<>	144:ef7eb2e8f9f7	950	*
<>	144:ef7eb2e8f9f7	951	@verbatim
<>	144:ef7eb2e8f9f7	952	==============================================================================
<>	144:ef7eb2e8f9f7	953	##### Peripheral State and Errors functions #####
<>	144:ef7eb2e8f9f7	954	==============================================================================
<>	144:ef7eb2e8f9f7	955	[..]
<>	144:ef7eb2e8f9f7	956	This subsection provides a set of functions allowing to return the State of SmartCard
<>	144:ef7eb2e8f9f7	957	handle and also return Peripheral Errors occurred during communication process
<>	144:ef7eb2e8f9f7	958	(+) HAL_SMARTCARD_GetState() API can be helpful to check in run-time the state
<>	144:ef7eb2e8f9f7	959	of the SMARTCARD peripheral.
<>	144:ef7eb2e8f9f7	960	(+) HAL_SMARTCARD_GetError() checks in run-time errors that could occur during
<>	144:ef7eb2e8f9f7	961	communication.
<>	144:ef7eb2e8f9f7	962
<>	144:ef7eb2e8f9f7	963	@endverbatim
<>	144:ef7eb2e8f9f7	964	* @{
<>	144:ef7eb2e8f9f7	965	*/
<>	144:ef7eb2e8f9f7	966
<>	144:ef7eb2e8f9f7	967
<>	144:ef7eb2e8f9f7	968	/**
<>	144:ef7eb2e8f9f7	969	* @brief Return the SMARTCARD handle state.
<>	144:ef7eb2e8f9f7	970	* @param hsmartcard: Pointer to a SMARTCARD_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	971	* the configuration information for the specified SMARTCARD module.
<>	144:ef7eb2e8f9f7	972	* @retval SMARTCARD handle state
<>	144:ef7eb2e8f9f7	973	*/
<>	144:ef7eb2e8f9f7	974	HAL_SMARTCARD_StateTypeDef HAL_SMARTCARD_GetState(SMARTCARD_HandleTypeDef *hsmartcard)
<>	144:ef7eb2e8f9f7	975	{
<>	144:ef7eb2e8f9f7	976	uint32_t temp1= 0x00, temp2 = 0x00;
<>	144:ef7eb2e8f9f7	977	temp1 = hsmartcard->gState;
<>	144:ef7eb2e8f9f7	978	temp2 = hsmartcard->RxState;
<>	144:ef7eb2e8f9f7	979
<>	144:ef7eb2e8f9f7	980	return (HAL_SMARTCARD_StateTypeDef)(temp1 \| temp2);
<>	144:ef7eb2e8f9f7	981	}
<>	144:ef7eb2e8f9f7	982
<>	144:ef7eb2e8f9f7	983	/**
<>	144:ef7eb2e8f9f7	984	* @brief Return the SMARTCARD handle error code.
<>	144:ef7eb2e8f9f7	985	* @param hsmartcard: Pointer to a SMARTCARD_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	986	* the configuration information for the specified SMARTCARD module.
<>	144:ef7eb2e8f9f7	987	* @retval SMARTCARD handle Error Code
<>	144:ef7eb2e8f9f7	988	*/
<>	144:ef7eb2e8f9f7	989	uint32_t HAL_SMARTCARD_GetError(SMARTCARD_HandleTypeDef *hsmartcard)
<>	144:ef7eb2e8f9f7	990	{
<>	144:ef7eb2e8f9f7	991	return hsmartcard->ErrorCode;
<>	144:ef7eb2e8f9f7	992	}
<>	144:ef7eb2e8f9f7	993
<>	144:ef7eb2e8f9f7	994	/**
<>	144:ef7eb2e8f9f7	995	* @}
<>	144:ef7eb2e8f9f7	996	*/
<>	144:ef7eb2e8f9f7	997
<>	144:ef7eb2e8f9f7	998	/**
<>	144:ef7eb2e8f9f7	999	* @}
<>	144:ef7eb2e8f9f7	1000	*/
<>	144:ef7eb2e8f9f7	1001
<>	144:ef7eb2e8f9f7	1002	/** @defgroup SMARTCARD_Private_Functions SMARTCARD Private Functions
<>	144:ef7eb2e8f9f7	1003	* @{
<>	144:ef7eb2e8f9f7	1004	*/
<>	144:ef7eb2e8f9f7	1005
<>	144:ef7eb2e8f9f7	1006	/**
<>	144:ef7eb2e8f9f7	1007	* @brief Send an amount of data in non-blocking mode.
<>	144:ef7eb2e8f9f7	1008	* @param hsmartcard: Pointer to a SMARTCARD_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	1009	* the configuration information for the specified SMARTCARD module.
<>	144:ef7eb2e8f9f7	1010	* Function called under interruption only, once
<>	144:ef7eb2e8f9f7	1011	* interruptions have been enabled by HAL_SMARTCARD_Transmit_IT()
<>	144:ef7eb2e8f9f7	1012	* @retval HAL status
<>	144:ef7eb2e8f9f7	1013	*/
<>	144:ef7eb2e8f9f7	1014	static HAL_StatusTypeDef SMARTCARD_Transmit_IT(SMARTCARD_HandleTypeDef *hsmartcard)
<>	144:ef7eb2e8f9f7	1015	{
<>	144:ef7eb2e8f9f7	1016	/* Check that a Tx process is ongoing */
<>	144:ef7eb2e8f9f7	1017	if (hsmartcard->gState == HAL_SMARTCARD_STATE_BUSY_TX)
<>	144:ef7eb2e8f9f7	1018	{
<>	144:ef7eb2e8f9f7	1019
<>	144:ef7eb2e8f9f7	1020	if(hsmartcard->TxXferCount == 0)
<>	144:ef7eb2e8f9f7	1021	{
<>	144:ef7eb2e8f9f7	1022	/* Disable the SMARTCARD Transmit Data Register Empty Interrupt */
<>	144:ef7eb2e8f9f7	1023	__HAL_SMARTCARD_DISABLE_IT(hsmartcard, SMARTCARD_IT_TXE);
<>	144:ef7eb2e8f9f7	1024
<>	144:ef7eb2e8f9f7	1025	/* Enable the SMARTCARD Transmit Complete Interrupt */
<>	144:ef7eb2e8f9f7	1026	__HAL_SMARTCARD_ENABLE_IT(hsmartcard, hsmartcard->AdvancedInit.TxCompletionIndication);
<>	144:ef7eb2e8f9f7	1027
<>	144:ef7eb2e8f9f7	1028	return HAL_OK;
<>	144:ef7eb2e8f9f7	1029	}
<>	144:ef7eb2e8f9f7	1030	else
<>	144:ef7eb2e8f9f7	1031	{
<>	144:ef7eb2e8f9f7	1032	hsmartcard->Instance->TDR = (*hsmartcard->pTxBuffPtr++ & (uint8_t)0xFF);
<>	144:ef7eb2e8f9f7	1033	hsmartcard->TxXferCount--;
<>	144:ef7eb2e8f9f7	1034
<>	144:ef7eb2e8f9f7	1035	return HAL_OK;
<>	144:ef7eb2e8f9f7	1036	}
<>	144:ef7eb2e8f9f7	1037	}
<>	144:ef7eb2e8f9f7	1038	else
<>	144:ef7eb2e8f9f7	1039	{
<>	144:ef7eb2e8f9f7	1040	return HAL_BUSY;
<>	144:ef7eb2e8f9f7	1041	}
<>	144:ef7eb2e8f9f7	1042	}
<>	144:ef7eb2e8f9f7	1043
<>	144:ef7eb2e8f9f7	1044	/**
<>	144:ef7eb2e8f9f7	1045	* @brief Wrap up transmission in non-blocking mode.
<>	144:ef7eb2e8f9f7	1046	* @param hsmartcard: Pointer to a SMARTCARD_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	1047	* the configuration information for the specified SMARTCARD module.
<>	144:ef7eb2e8f9f7	1048	* @retval HAL status
<>	144:ef7eb2e8f9f7	1049	*/
<>	144:ef7eb2e8f9f7	1050	static HAL_StatusTypeDef SMARTCARD_EndTransmit_IT(SMARTCARD_HandleTypeDef *hsmartcard)
<>	144:ef7eb2e8f9f7	1051	{
<>	144:ef7eb2e8f9f7	1052	/* Disable the SMARTCARD Transmit Complete Interrupt */
<>	144:ef7eb2e8f9f7	1053	__HAL_SMARTCARD_DISABLE_IT(hsmartcard, hsmartcard->AdvancedInit.TxCompletionIndication);
<>	144:ef7eb2e8f9f7	1054
<>	144:ef7eb2e8f9f7	1055	/* Check if a receive process is ongoing or not. If not disable ERR IT */
<>	144:ef7eb2e8f9f7	1056	if(hsmartcard->RxState == HAL_SMARTCARD_STATE_READY)
<>	144:ef7eb2e8f9f7	1057	{
<>	144:ef7eb2e8f9f7	1058	/* Disable the SMARTCARD Error Interrupt: (Frame error, noise error, overrun error) */
<>	144:ef7eb2e8f9f7	1059	__HAL_SMARTCARD_DISABLE_IT(hsmartcard, SMARTCARD_IT_ERR);
<>	144:ef7eb2e8f9f7	1060	}
<>	144:ef7eb2e8f9f7	1061	else
<>	144:ef7eb2e8f9f7	1062	{
<>	144:ef7eb2e8f9f7	1063	/* Re-enable Rx at end of transmission if initial mode is Rx/Tx */
<>	144:ef7eb2e8f9f7	1064	if(hsmartcard->Init.Mode == SMARTCARD_MODE_TX_RX)
<>	144:ef7eb2e8f9f7	1065	{
<>	144:ef7eb2e8f9f7	1066	/* Disable the Peripheral first to update modes */
<>	144:ef7eb2e8f9f7	1067	CLEAR_BIT(hsmartcard->Instance->CR1, USART_CR1_UE);
<>	144:ef7eb2e8f9f7	1068	SET_BIT(hsmartcard->Instance->CR1, USART_CR1_RE);
<>	144:ef7eb2e8f9f7	1069	/* Enable the Peripheral */
<>	144:ef7eb2e8f9f7	1070	SET_BIT(hsmartcard->Instance->CR1, USART_CR1_UE);
<>	144:ef7eb2e8f9f7	1071	}
<>	144:ef7eb2e8f9f7	1072	}
<>	144:ef7eb2e8f9f7	1073
<>	144:ef7eb2e8f9f7	1074	/* Tx process is ended, restore hsmartcard->gState to Ready */
<>	144:ef7eb2e8f9f7	1075	hsmartcard->gState = HAL_SMARTCARD_STATE_READY;
<>	144:ef7eb2e8f9f7	1076
<>	144:ef7eb2e8f9f7	1077	HAL_SMARTCARD_TxCpltCallback(hsmartcard);
<>	144:ef7eb2e8f9f7	1078
<>	144:ef7eb2e8f9f7	1079	return HAL_OK;
<>	144:ef7eb2e8f9f7	1080	}
<>	144:ef7eb2e8f9f7	1081
<>	144:ef7eb2e8f9f7	1082
<>	144:ef7eb2e8f9f7	1083	/**
<>	144:ef7eb2e8f9f7	1084	* @brief Receive an amount of data in non-blocking mode.
<>	144:ef7eb2e8f9f7	1085	* @param hsmartcard: Pointer to a SMARTCARD_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	1086	* the configuration information for the specified SMARTCARD module.
<>	144:ef7eb2e8f9f7	1087	* Function called under interruption only, once
<>	144:ef7eb2e8f9f7	1088	* interruptions have been enabled by HAL_SMARTCARD_Receive_IT().
<>	144:ef7eb2e8f9f7	1089	* @retval HAL status
<>	144:ef7eb2e8f9f7	1090	*/
<>	144:ef7eb2e8f9f7	1091	static HAL_StatusTypeDef SMARTCARD_Receive_IT(SMARTCARD_HandleTypeDef *hsmartcard)
<>	144:ef7eb2e8f9f7	1092	{
<>	144:ef7eb2e8f9f7	1093	/* Check that a Rx process is ongoing */
<>	144:ef7eb2e8f9f7	1094	if (hsmartcard->RxState == HAL_SMARTCARD_STATE_BUSY_RX)
<>	144:ef7eb2e8f9f7	1095	{
<>	144:ef7eb2e8f9f7	1096	*hsmartcard->pRxBuffPtr++ = (uint8_t)(hsmartcard->Instance->RDR & (uint8_t)0xFF);
<>	144:ef7eb2e8f9f7	1097
<>	144:ef7eb2e8f9f7	1098	if(--hsmartcard->RxXferCount == 0)
<>	144:ef7eb2e8f9f7	1099	{
<>	144:ef7eb2e8f9f7	1100	__HAL_SMARTCARD_DISABLE_IT(hsmartcard, SMARTCARD_IT_RXNE);
<>	144:ef7eb2e8f9f7	1101
<>	144:ef7eb2e8f9f7	1102	/* Check if a transmit process is ongoing or not. If not disable ERR IT */
<>	144:ef7eb2e8f9f7	1103	if(hsmartcard->gState == HAL_SMARTCARD_STATE_READY)
<>	144:ef7eb2e8f9f7	1104	{
<>	144:ef7eb2e8f9f7	1105	/* Disable the SMARTCARD Error Interrupt: (Frame error, noise error, overrun error) */
<>	144:ef7eb2e8f9f7	1106	__HAL_SMARTCARD_DISABLE_IT(hsmartcard, SMARTCARD_IT_ERR);
<>	144:ef7eb2e8f9f7	1107	}
<>	144:ef7eb2e8f9f7	1108
<>	144:ef7eb2e8f9f7	1109	/* Disable the SMARTCARD Parity Error Interrupt */
<>	144:ef7eb2e8f9f7	1110	__HAL_SMARTCARD_DISABLE_IT(hsmartcard, SMARTCARD_IT_PE);
<>	144:ef7eb2e8f9f7	1111
<>	144:ef7eb2e8f9f7	1112	hsmartcard->RxState = HAL_SMARTCARD_STATE_READY;
<>	144:ef7eb2e8f9f7	1113
<>	144:ef7eb2e8f9f7	1114	HAL_SMARTCARD_RxCpltCallback(hsmartcard);
<>	144:ef7eb2e8f9f7	1115
<>	144:ef7eb2e8f9f7	1116	return HAL_OK;
<>	144:ef7eb2e8f9f7	1117	}
<>	144:ef7eb2e8f9f7	1118
<>	144:ef7eb2e8f9f7	1119	return HAL_OK;
<>	144:ef7eb2e8f9f7	1120	}
<>	144:ef7eb2e8f9f7	1121	else
<>	144:ef7eb2e8f9f7	1122	{
<>	144:ef7eb2e8f9f7	1123	return HAL_BUSY;
<>	144:ef7eb2e8f9f7	1124	}
<>	144:ef7eb2e8f9f7	1125	}
<>	144:ef7eb2e8f9f7	1126
<>	144:ef7eb2e8f9f7	1127	/**
<>	144:ef7eb2e8f9f7	1128	* @brief Handle SMARTCARD Communication Timeout.
<>	144:ef7eb2e8f9f7	1129	* @param hsmartcard Pointer to a SMARTCARD_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	1130	* the configuration information for the specified SMARTCARD module.
<>	144:ef7eb2e8f9f7	1131	* @param Flag Specifies the SMARTCARD flag to check.
<>	144:ef7eb2e8f9f7	1132	* @param Status The new Flag status (SET or RESET).
<>	144:ef7eb2e8f9f7	1133	* @param Tickstart Tick start value
<>	144:ef7eb2e8f9f7	1134	* @param Timeout Timeout duration.
<>	144:ef7eb2e8f9f7	1135	* @retval HAL status
<>	144:ef7eb2e8f9f7	1136	*/
<>	144:ef7eb2e8f9f7	1137	static HAL_StatusTypeDef SMARTCARD_WaitOnFlagUntilTimeout(SMARTCARD_HandleTypeDef *hsmartcard, uint32_t Flag, FlagStatus Status, uint32_t Tickstart, uint32_t Timeout)
<>	144:ef7eb2e8f9f7	1138	{
<>	144:ef7eb2e8f9f7	1139	/* Wait until flag is set */
<>	144:ef7eb2e8f9f7	1140	while((__HAL_SMARTCARD_GET_FLAG(hsmartcard, Flag) ? SET : RESET) == Status)
<>	144:ef7eb2e8f9f7	1141	{
<>	144:ef7eb2e8f9f7	1142	/* Check for the Timeout */
<>	144:ef7eb2e8f9f7	1143	if(Timeout != HAL_MAX_DELAY)
<>	144:ef7eb2e8f9f7	1144	{
<>	144:ef7eb2e8f9f7	1145	if((Timeout == 0) \|\| ((HAL_GetTick()-Tickstart) > Timeout))
<>	144:ef7eb2e8f9f7	1146	{
<>	144:ef7eb2e8f9f7	1147	/* Disable TXE, RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts for the interrupt process */
<>	144:ef7eb2e8f9f7	1148	CLEAR_BIT(hsmartcard->Instance->CR1, (USART_CR1_RXNEIE \| USART_CR1_PEIE \| USART_CR1_TXEIE));
<>	144:ef7eb2e8f9f7	1149	CLEAR_BIT(hsmartcard->Instance->CR3, USART_CR3_EIE);
<>	144:ef7eb2e8f9f7	1150
<>	144:ef7eb2e8f9f7	1151	hsmartcard->gState = HAL_SMARTCARD_STATE_READY;
<>	144:ef7eb2e8f9f7	1152	hsmartcard->RxState = HAL_SMARTCARD_STATE_READY;
<>	144:ef7eb2e8f9f7	1153
<>	144:ef7eb2e8f9f7	1154	/* Process Unlocked */
<>	144:ef7eb2e8f9f7	1155	__HAL_UNLOCK(hsmartcard);
<>	144:ef7eb2e8f9f7	1156
<>	144:ef7eb2e8f9f7	1157	return HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	1158	}
<>	144:ef7eb2e8f9f7	1159	}
<>	144:ef7eb2e8f9f7	1160	}
<>	144:ef7eb2e8f9f7	1161	return HAL_OK;
<>	144:ef7eb2e8f9f7	1162	}
<>	144:ef7eb2e8f9f7	1163
<>	144:ef7eb2e8f9f7	1164	/**
<>	144:ef7eb2e8f9f7	1165	* @brief DMA SMARTCARD transmit process complete callback.
<>	144:ef7eb2e8f9f7	1166	* @param hdma: Pointer to a DMA_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	1167	* the configuration information for the specified DMA module.
<>	144:ef7eb2e8f9f7	1168	* @retval None
<>	144:ef7eb2e8f9f7	1169	*/
<>	144:ef7eb2e8f9f7	1170	static void SMARTCARD_DMATransmitCplt(DMA_HandleTypeDef *hdma)
<>	144:ef7eb2e8f9f7	1171	{
<>	144:ef7eb2e8f9f7	1172	SMARTCARD_HandleTypeDef* hsmartcard = ( SMARTCARD_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
<>	144:ef7eb2e8f9f7	1173	hsmartcard->TxXferCount = 0;
<>	144:ef7eb2e8f9f7	1174
<>	144:ef7eb2e8f9f7	1175	/* Disable the DMA transfer for transmit request by resetting the DMAT bit
<>	144:ef7eb2e8f9f7	1176	in the SMARTCARD associated USART CR3 register */
<>	144:ef7eb2e8f9f7	1177	CLEAR_BIT(hsmartcard->Instance->CR3, USART_CR3_DMAT);
<>	144:ef7eb2e8f9f7	1178
<>	144:ef7eb2e8f9f7	1179	/* Enable the SMARTCARD Transmit Complete Interrupt */
<>	144:ef7eb2e8f9f7	1180	__HAL_SMARTCARD_ENABLE_IT(hsmartcard, hsmartcard->AdvancedInit.TxCompletionIndication);
<>	144:ef7eb2e8f9f7	1181	}
<>	144:ef7eb2e8f9f7	1182
<>	144:ef7eb2e8f9f7	1183	/**
<>	144:ef7eb2e8f9f7	1184	* @brief DMA SMARTCARD receive process complete callback.
<>	144:ef7eb2e8f9f7	1185	* @param hdma: Pointer to a DMA_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	1186	* the configuration information for the specified DMA module.
<>	144:ef7eb2e8f9f7	1187	* @retval None
<>	144:ef7eb2e8f9f7	1188	*/
<>	144:ef7eb2e8f9f7	1189	static void SMARTCARD_DMAReceiveCplt(DMA_HandleTypeDef *hdma)
<>	144:ef7eb2e8f9f7	1190	{
<>	144:ef7eb2e8f9f7	1191	SMARTCARD_HandleTypeDef* hsmartcard = ( SMARTCARD_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
<>	144:ef7eb2e8f9f7	1192	hsmartcard->RxXferCount = 0;
<>	144:ef7eb2e8f9f7	1193
<>	144:ef7eb2e8f9f7	1194	/* Disable the DMA transfer for the receiver request by resetting the DMAR bit
<>	144:ef7eb2e8f9f7	1195	in the SMARTCARD associated USART CR3 register */
<>	144:ef7eb2e8f9f7	1196	CLEAR_BIT(hsmartcard->Instance->CR3, USART_CR3_DMAR);
<>	144:ef7eb2e8f9f7	1197
<>	144:ef7eb2e8f9f7	1198	/* At end of Rx process, restore hsmartcard->RxState to Ready */
<>	144:ef7eb2e8f9f7	1199	hsmartcard->RxState = HAL_SMARTCARD_STATE_READY;
<>	144:ef7eb2e8f9f7	1200
<>	144:ef7eb2e8f9f7	1201	HAL_SMARTCARD_RxCpltCallback(hsmartcard);
<>	144:ef7eb2e8f9f7	1202	}
<>	144:ef7eb2e8f9f7	1203
<>	144:ef7eb2e8f9f7	1204	/**
<>	144:ef7eb2e8f9f7	1205	* @brief DMA SMARTCARD communication error callback.
<>	144:ef7eb2e8f9f7	1206	* @param hdma: Pointer to a DMA_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	1207	* the configuration information for the specified DMA module.
<>	144:ef7eb2e8f9f7	1208	* @retval None
<>	144:ef7eb2e8f9f7	1209	*/
<>	144:ef7eb2e8f9f7	1210	static void SMARTCARD_DMAError(DMA_HandleTypeDef *hdma)
<>	144:ef7eb2e8f9f7	1211	{
<>	144:ef7eb2e8f9f7	1212	SMARTCARD_HandleTypeDef* hsmartcard = ( SMARTCARD_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
<>	144:ef7eb2e8f9f7	1213	hsmartcard->RxXferCount = 0;
<>	144:ef7eb2e8f9f7	1214	hsmartcard->TxXferCount = 0;
<>	144:ef7eb2e8f9f7	1215	hsmartcard->gState = HAL_SMARTCARD_STATE_READY;
<>	144:ef7eb2e8f9f7	1216	hsmartcard->RxState = HAL_SMARTCARD_STATE_READY;
<>	144:ef7eb2e8f9f7	1217	hsmartcard->ErrorCode \|= HAL_SMARTCARD_ERROR_DMA;
<>	144:ef7eb2e8f9f7	1218	HAL_SMARTCARD_ErrorCallback(hsmartcard);
<>	144:ef7eb2e8f9f7	1219	}
<>	144:ef7eb2e8f9f7	1220
<>	144:ef7eb2e8f9f7	1221	/**
<>	144:ef7eb2e8f9f7	1222	* @brief Configure the SMARTCARD associated USART peripheral.
<>	144:ef7eb2e8f9f7	1223	* @param hsmartcard: Pointer to a SMARTCARD_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	1224	* the configuration information for the specified SMARTCARD module.
<>	144:ef7eb2e8f9f7	1225	* @retval None
<>	144:ef7eb2e8f9f7	1226	*/
<>	144:ef7eb2e8f9f7	1227	static HAL_StatusTypeDef SMARTCARD_SetConfig(SMARTCARD_HandleTypeDef *hsmartcard)
<>	144:ef7eb2e8f9f7	1228	{
<>	144:ef7eb2e8f9f7	1229	uint32_t tmpreg = 0x00000000;
<>	144:ef7eb2e8f9f7	1230	SMARTCARD_ClockSourceTypeDef clocksource = SMARTCARD_CLOCKSOURCE_UNDEFINED;
<>	144:ef7eb2e8f9f7	1231	HAL_StatusTypeDef ret = HAL_OK;
<>	144:ef7eb2e8f9f7	1232
<>	144:ef7eb2e8f9f7	1233	/* Check the parameters */
<>	144:ef7eb2e8f9f7	1234	assert_param(IS_SMARTCARD_INSTANCE(hsmartcard->Instance));
<>	144:ef7eb2e8f9f7	1235	assert_param(IS_SMARTCARD_BAUDRATE(hsmartcard->Init.BaudRate));
<>	144:ef7eb2e8f9f7	1236	assert_param(IS_SMARTCARD_WORD_LENGTH(hsmartcard->Init.WordLength));
<>	144:ef7eb2e8f9f7	1237	assert_param(IS_SMARTCARD_STOPBITS(hsmartcard->Init.StopBits));
<>	144:ef7eb2e8f9f7	1238	assert_param(IS_SMARTCARD_PARITY(hsmartcard->Init.Parity));
<>	144:ef7eb2e8f9f7	1239	assert_param(IS_SMARTCARD_MODE(hsmartcard->Init.Mode));
<>	144:ef7eb2e8f9f7	1240	assert_param(IS_SMARTCARD_POLARITY(hsmartcard->Init.CLKPolarity));
<>	144:ef7eb2e8f9f7	1241	assert_param(IS_SMARTCARD_PHASE(hsmartcard->Init.CLKPhase));
<>	144:ef7eb2e8f9f7	1242	assert_param(IS_SMARTCARD_LASTBIT(hsmartcard->Init.CLKLastBit));
<>	144:ef7eb2e8f9f7	1243	assert_param(IS_SMARTCARD_ONE_BIT_SAMPLE(hsmartcard->Init.OneBitSampling));
<>	144:ef7eb2e8f9f7	1244	assert_param(IS_SMARTCARD_NACK(hsmartcard->Init.NACKEnable));
<>	144:ef7eb2e8f9f7	1245	assert_param(IS_SMARTCARD_TIMEOUT(hsmartcard->Init.TimeOutEnable));
<>	144:ef7eb2e8f9f7	1246	assert_param(IS_SMARTCARD_AUTORETRY_COUNT(hsmartcard->Init.AutoRetryCount));
<>	144:ef7eb2e8f9f7	1247
<>	144:ef7eb2e8f9f7	1248	/-------------------------- USART CR1 Configuration -----------------------/
<>	144:ef7eb2e8f9f7	1249	/* In SmartCard mode, M and PCE are forced to 1 (8 bits + parity).
<>	144:ef7eb2e8f9f7	1250	* Oversampling is forced to 16 (OVER8 = 0).
<>	144:ef7eb2e8f9f7	1251	* Configure the Parity and Mode:
<>	144:ef7eb2e8f9f7	1252	* set PS bit according to hsmartcard->Init.Parity value
<>	144:ef7eb2e8f9f7	1253	* set TE and RE bits according to hsmartcard->Init.Mode value */
<>	144:ef7eb2e8f9f7	1254	tmpreg = (uint32_t) hsmartcard->Init.Parity \| hsmartcard->Init.Mode;
<>	144:ef7eb2e8f9f7	1255	tmpreg \|= (uint32_t) hsmartcard->Init.WordLength;
<>	144:ef7eb2e8f9f7	1256	MODIFY_REG(hsmartcard->Instance->CR1, USART_CR1_FIELDS, tmpreg);
<>	144:ef7eb2e8f9f7	1257
<>	144:ef7eb2e8f9f7	1258	/-------------------------- USART CR2 Configuration -----------------------/
<>	144:ef7eb2e8f9f7	1259	tmpreg = hsmartcard->Init.StopBits;
<>	144:ef7eb2e8f9f7	1260	/* Synchronous mode is activated by default */
<>	144:ef7eb2e8f9f7	1261	tmpreg \|= (uint32_t) USART_CR2_CLKEN \| hsmartcard->Init.CLKPolarity;
<>	144:ef7eb2e8f9f7	1262	tmpreg \|= (uint32_t) hsmartcard->Init.CLKPhase \| hsmartcard->Init.CLKLastBit;
<>	144:ef7eb2e8f9f7	1263	tmpreg \|= (uint32_t) hsmartcard->Init.TimeOutEnable;
<>	144:ef7eb2e8f9f7	1264	MODIFY_REG(hsmartcard->Instance->CR2, USART_CR2_FIELDS, tmpreg);
<>	144:ef7eb2e8f9f7	1265
<>	144:ef7eb2e8f9f7	1266	/-------------------------- USART CR3 Configuration -----------------------/
<>	144:ef7eb2e8f9f7	1267	/* Configure
<>	144:ef7eb2e8f9f7	1268	* - one-bit sampling method versus three samples' majority rule
<>	144:ef7eb2e8f9f7	1269	* according to hsmartcard->Init.OneBitSampling
<>	144:ef7eb2e8f9f7	1270	* - NACK transmission in case of parity error according
<>	144:ef7eb2e8f9f7	1271	* to hsmartcard->Init.NACKEnable
<>	144:ef7eb2e8f9f7	1272	* - autoretry counter according to hsmartcard->Init.AutoRetryCount */
<>	144:ef7eb2e8f9f7	1273	tmpreg = (uint32_t) hsmartcard->Init.OneBitSampling \| hsmartcard->Init.NACKEnable;
<>	144:ef7eb2e8f9f7	1274	tmpreg \|= ((uint32_t)hsmartcard->Init.AutoRetryCount << SMARTCARD_CR3_SCARCNT_LSB_POS);
<>	144:ef7eb2e8f9f7	1275	MODIFY_REG(hsmartcard->Instance-> CR3,USART_CR3_FIELDS, tmpreg);
<>	144:ef7eb2e8f9f7	1276
<>	144:ef7eb2e8f9f7	1277	/-------------------------- USART GTPR Configuration ----------------------/
<>	144:ef7eb2e8f9f7	1278	tmpreg = (hsmartcard->Init.Prescaler \| ((uint32_t)hsmartcard->Init.GuardTime << SMARTCARD_GTPR_GT_LSB_POS));
<>	144:ef7eb2e8f9f7	1279	MODIFY_REG(hsmartcard->Instance->GTPR, (USART_GTPR_GT\|USART_GTPR_PSC), tmpreg);
<>	144:ef7eb2e8f9f7	1280
<>	144:ef7eb2e8f9f7	1281	/-------------------------- USART RTOR Configuration ----------------------/
<>	144:ef7eb2e8f9f7	1282	tmpreg = ((uint32_t)hsmartcard->Init.BlockLength << SMARTCARD_RTOR_BLEN_LSB_POS);
<>	144:ef7eb2e8f9f7	1283	if (hsmartcard->Init.TimeOutEnable == SMARTCARD_TIMEOUT_ENABLE)
<>	144:ef7eb2e8f9f7	1284	{
<>	144:ef7eb2e8f9f7	1285	assert_param(IS_SMARTCARD_TIMEOUT_VALUE(hsmartcard->Init.TimeOutValue));
<>	144:ef7eb2e8f9f7	1286	tmpreg \|= (uint32_t) hsmartcard->Init.TimeOutValue;
<>	144:ef7eb2e8f9f7	1287	}
<>	144:ef7eb2e8f9f7	1288	MODIFY_REG(hsmartcard->Instance->RTOR, (USART_RTOR_RTO\|USART_RTOR_BLEN), tmpreg);
<>	144:ef7eb2e8f9f7	1289
<>	144:ef7eb2e8f9f7	1290	/-------------------------- USART BRR Configuration -----------------------/
<>	144:ef7eb2e8f9f7	1291	SMARTCARD_GETCLOCKSOURCE(hsmartcard, clocksource);
<>	144:ef7eb2e8f9f7	1292	switch (clocksource)
<>	144:ef7eb2e8f9f7	1293	{
<>	144:ef7eb2e8f9f7	1294	case SMARTCARD_CLOCKSOURCE_PCLK1:
<>	144:ef7eb2e8f9f7	1295	hsmartcard->Instance->BRR = (uint16_t)((HAL_RCC_GetPCLK1Freq() + (hsmartcard->Init.BaudRate/2)) / hsmartcard->Init.BaudRate);
<>	144:ef7eb2e8f9f7	1296	break;
<>	144:ef7eb2e8f9f7	1297	case SMARTCARD_CLOCKSOURCE_PCLK2:
<>	144:ef7eb2e8f9f7	1298	hsmartcard->Instance->BRR = (uint16_t)((HAL_RCC_GetPCLK2Freq() + (hsmartcard->Init.BaudRate/2)) / hsmartcard->Init.BaudRate);
<>	144:ef7eb2e8f9f7	1299	break;
<>	144:ef7eb2e8f9f7	1300	case SMARTCARD_CLOCKSOURCE_HSI:
<>	144:ef7eb2e8f9f7	1301	hsmartcard->Instance->BRR = (uint16_t)((HSI_VALUE + (hsmartcard->Init.BaudRate/2)) / hsmartcard->Init.BaudRate);
<>	144:ef7eb2e8f9f7	1302	break;
<>	144:ef7eb2e8f9f7	1303	case SMARTCARD_CLOCKSOURCE_SYSCLK:
<>	144:ef7eb2e8f9f7	1304	hsmartcard->Instance->BRR = (uint16_t)((HAL_RCC_GetSysClockFreq() + (hsmartcard->Init.BaudRate/2)) / hsmartcard->Init.BaudRate);
<>	144:ef7eb2e8f9f7	1305	break;
<>	144:ef7eb2e8f9f7	1306	case SMARTCARD_CLOCKSOURCE_LSE:
<>	144:ef7eb2e8f9f7	1307	hsmartcard->Instance->BRR = (uint16_t)((LSE_VALUE + (hsmartcard->Init.BaudRate/2)) / hsmartcard->Init.BaudRate);
<>	144:ef7eb2e8f9f7	1308	break;
<>	144:ef7eb2e8f9f7	1309	case SMARTCARD_CLOCKSOURCE_UNDEFINED:
<>	144:ef7eb2e8f9f7	1310	default:
<>	144:ef7eb2e8f9f7	1311	ret = HAL_ERROR;
<>	144:ef7eb2e8f9f7	1312	break;
<>	144:ef7eb2e8f9f7	1313	}
<>	144:ef7eb2e8f9f7	1314
<>	144:ef7eb2e8f9f7	1315	return ret;
<>	144:ef7eb2e8f9f7	1316	}
<>	144:ef7eb2e8f9f7	1317
<>	144:ef7eb2e8f9f7	1318
<>	144:ef7eb2e8f9f7	1319	/**
<>	144:ef7eb2e8f9f7	1320	* @brief Configure the SMARTCARD associated USART peripheral advanced features.
<>	144:ef7eb2e8f9f7	1321	* @param hsmartcard: Pointer to a SMARTCARD_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	1322	* the configuration information for the specified SMARTCARD module.
<>	144:ef7eb2e8f9f7	1323	* @retval None
<>	144:ef7eb2e8f9f7	1324	*/
<>	144:ef7eb2e8f9f7	1325	static void SMARTCARD_AdvFeatureConfig(SMARTCARD_HandleTypeDef *hsmartcard)
<>	144:ef7eb2e8f9f7	1326	{
<>	144:ef7eb2e8f9f7	1327	/* Check whether the set of advanced features to configure is properly set */
<>	144:ef7eb2e8f9f7	1328	assert_param(IS_SMARTCARD_ADVFEATURE_INIT(hsmartcard->AdvancedInit.AdvFeatureInit));
<>	144:ef7eb2e8f9f7	1329
<>	144:ef7eb2e8f9f7	1330	/* if required, configure TX pin active level inversion */
<>	144:ef7eb2e8f9f7	1331	if (HAL_IS_BIT_SET(hsmartcard->AdvancedInit.AdvFeatureInit, SMARTCARD_ADVFEATURE_TXINVERT_INIT))
<>	144:ef7eb2e8f9f7	1332	{
<>	144:ef7eb2e8f9f7	1333	assert_param(IS_SMARTCARD_ADVFEATURE_TXINV(hsmartcard->AdvancedInit.TxPinLevelInvert));
<>	144:ef7eb2e8f9f7	1334	MODIFY_REG(hsmartcard->Instance->CR2, USART_CR2_TXINV, hsmartcard->AdvancedInit.TxPinLevelInvert);
<>	144:ef7eb2e8f9f7	1335	}
<>	144:ef7eb2e8f9f7	1336
<>	144:ef7eb2e8f9f7	1337	/* if required, configure RX pin active level inversion */
<>	144:ef7eb2e8f9f7	1338	if (HAL_IS_BIT_SET(hsmartcard->AdvancedInit.AdvFeatureInit, SMARTCARD_ADVFEATURE_RXINVERT_INIT))
<>	144:ef7eb2e8f9f7	1339	{
<>	144:ef7eb2e8f9f7	1340	assert_param(IS_SMARTCARD_ADVFEATURE_RXINV(hsmartcard->AdvancedInit.RxPinLevelInvert));
<>	144:ef7eb2e8f9f7	1341	MODIFY_REG(hsmartcard->Instance->CR2, USART_CR2_RXINV, hsmartcard->AdvancedInit.RxPinLevelInvert);
<>	144:ef7eb2e8f9f7	1342	}
<>	144:ef7eb2e8f9f7	1343
<>	144:ef7eb2e8f9f7	1344	/* if required, configure data inversion */
<>	144:ef7eb2e8f9f7	1345	if (HAL_IS_BIT_SET(hsmartcard->AdvancedInit.AdvFeatureInit, SMARTCARD_ADVFEATURE_DATAINVERT_INIT))
<>	144:ef7eb2e8f9f7	1346	{
<>	144:ef7eb2e8f9f7	1347	assert_param(IS_SMARTCARD_ADVFEATURE_DATAINV(hsmartcard->AdvancedInit.DataInvert));
<>	144:ef7eb2e8f9f7	1348	MODIFY_REG(hsmartcard->Instance->CR2, USART_CR2_DATAINV, hsmartcard->AdvancedInit.DataInvert);
<>	144:ef7eb2e8f9f7	1349	}
<>	144:ef7eb2e8f9f7	1350
<>	144:ef7eb2e8f9f7	1351	/* if required, configure RX/TX pins swap */
<>	144:ef7eb2e8f9f7	1352	if (HAL_IS_BIT_SET(hsmartcard->AdvancedInit.AdvFeatureInit, SMARTCARD_ADVFEATURE_SWAP_INIT))
<>	144:ef7eb2e8f9f7	1353	{
<>	144:ef7eb2e8f9f7	1354	assert_param(IS_SMARTCARD_ADVFEATURE_SWAP(hsmartcard->AdvancedInit.Swap));
<>	144:ef7eb2e8f9f7	1355	MODIFY_REG(hsmartcard->Instance->CR2, USART_CR2_SWAP, hsmartcard->AdvancedInit.Swap);
<>	144:ef7eb2e8f9f7	1356	}
<>	144:ef7eb2e8f9f7	1357
<>	144:ef7eb2e8f9f7	1358	/* if required, configure RX overrun detection disabling */
<>	144:ef7eb2e8f9f7	1359	if (HAL_IS_BIT_SET(hsmartcard->AdvancedInit.AdvFeatureInit, SMARTCARD_ADVFEATURE_RXOVERRUNDISABLE_INIT))
<>	144:ef7eb2e8f9f7	1360	{
<>	144:ef7eb2e8f9f7	1361	assert_param(IS_SMARTCARD_OVERRUN(hsmartcard->AdvancedInit.OverrunDisable));
<>	144:ef7eb2e8f9f7	1362	MODIFY_REG(hsmartcard->Instance->CR3, USART_CR3_OVRDIS, hsmartcard->AdvancedInit.OverrunDisable);
<>	144:ef7eb2e8f9f7	1363	}
<>	144:ef7eb2e8f9f7	1364
<>	144:ef7eb2e8f9f7	1365	/* if required, configure DMA disabling on reception error */
<>	144:ef7eb2e8f9f7	1366	if (HAL_IS_BIT_SET(hsmartcard->AdvancedInit.AdvFeatureInit, SMARTCARD_ADVFEATURE_DMADISABLEONERROR_INIT))
<>	144:ef7eb2e8f9f7	1367	{
<>	144:ef7eb2e8f9f7	1368	assert_param(IS_SMARTCARD_ADVFEATURE_DMAONRXERROR(hsmartcard->AdvancedInit.DMADisableonRxError));
<>	144:ef7eb2e8f9f7	1369	MODIFY_REG(hsmartcard->Instance->CR3, USART_CR3_DDRE, hsmartcard->AdvancedInit.DMADisableonRxError);
<>	144:ef7eb2e8f9f7	1370	}
<>	144:ef7eb2e8f9f7	1371
<>	144:ef7eb2e8f9f7	1372	/* if required, configure MSB first on communication line */
<>	144:ef7eb2e8f9f7	1373	if (HAL_IS_BIT_SET(hsmartcard->AdvancedInit.AdvFeatureInit, SMARTCARD_ADVFEATURE_MSBFIRST_INIT))
<>	144:ef7eb2e8f9f7	1374	{
<>	144:ef7eb2e8f9f7	1375	assert_param(IS_SMARTCARD_ADVFEATURE_MSBFIRST(hsmartcard->AdvancedInit.MSBFirst));
<>	144:ef7eb2e8f9f7	1376	MODIFY_REG(hsmartcard->Instance->CR2, USART_CR2_MSBFIRST, hsmartcard->AdvancedInit.MSBFirst);
<>	144:ef7eb2e8f9f7	1377	}
<>	144:ef7eb2e8f9f7	1378
<>	144:ef7eb2e8f9f7	1379	}
<>	144:ef7eb2e8f9f7	1380
<>	144:ef7eb2e8f9f7	1381	/**
<>	144:ef7eb2e8f9f7	1382	* @brief Check the SMARTCARD Idle State.
<>	144:ef7eb2e8f9f7	1383	* @param hsmartcard: Pointer to a SMARTCARD_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	1384	* the configuration information for the specified SMARTCARD module.
<>	144:ef7eb2e8f9f7	1385	* @retval HAL status
<>	144:ef7eb2e8f9f7	1386	*/
<>	144:ef7eb2e8f9f7	1387	static HAL_StatusTypeDef SMARTCARD_CheckIdleState(SMARTCARD_HandleTypeDef *hsmartcard)
<>	144:ef7eb2e8f9f7	1388	{
<>	144:ef7eb2e8f9f7	1389	uint32_t tickstart = 0;
<>	144:ef7eb2e8f9f7	1390
<>	144:ef7eb2e8f9f7	1391	/* Initialize the SMARTCARD ErrorCode */
<>	144:ef7eb2e8f9f7	1392	hsmartcard->ErrorCode = HAL_SMARTCARD_ERROR_NONE;
<>	144:ef7eb2e8f9f7	1393
<>	144:ef7eb2e8f9f7	1394	/* Init tickstart for timeout managment*/
<>	144:ef7eb2e8f9f7	1395	tickstart = HAL_GetTick();
<>	144:ef7eb2e8f9f7	1396
<>	144:ef7eb2e8f9f7	1397	/* Check if the Transmitter is enabled */
<>	144:ef7eb2e8f9f7	1398	if((hsmartcard->Instance->CR1 & USART_CR1_TE) == USART_CR1_TE)
<>	144:ef7eb2e8f9f7	1399	{
<>	144:ef7eb2e8f9f7	1400	/* Wait until TEACK flag is set */
<>	144:ef7eb2e8f9f7	1401	if(SMARTCARD_WaitOnFlagUntilTimeout(hsmartcard, USART_ISR_TEACK, RESET, tickstart, SMARTCARD_TEACK_REACK_TIMEOUT) != HAL_OK)
<>	144:ef7eb2e8f9f7	1402	{
<>	144:ef7eb2e8f9f7	1403	return HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	1404	}
<>	144:ef7eb2e8f9f7	1405	}
<>	144:ef7eb2e8f9f7	1406	/* Check if the Receiver is enabled */
<>	144:ef7eb2e8f9f7	1407	if((hsmartcard->Instance->CR1 & USART_CR1_RE) == USART_CR1_RE)
<>	144:ef7eb2e8f9f7	1408	{
<>	144:ef7eb2e8f9f7	1409	/* Wait until REACK flag is set */
<>	144:ef7eb2e8f9f7	1410	if(SMARTCARD_WaitOnFlagUntilTimeout(hsmartcard, USART_ISR_REACK, RESET, tickstart, SMARTCARD_TEACK_REACK_TIMEOUT) != HAL_OK)
<>	144:ef7eb2e8f9f7	1411	{
<>	144:ef7eb2e8f9f7	1412	return HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	1413	}
<>	144:ef7eb2e8f9f7	1414	}
<>	144:ef7eb2e8f9f7	1415
<>	144:ef7eb2e8f9f7	1416	/* Initialize the SMARTCARD states */
<>	144:ef7eb2e8f9f7	1417	hsmartcard->gState = HAL_SMARTCARD_STATE_READY;
<>	144:ef7eb2e8f9f7	1418	hsmartcard->RxState = HAL_SMARTCARD_STATE_READY;
<>	144:ef7eb2e8f9f7	1419
<>	144:ef7eb2e8f9f7	1420	/* Process Unlocked */
<>	144:ef7eb2e8f9f7	1421	__HAL_UNLOCK(hsmartcard);
<>	144:ef7eb2e8f9f7	1422
<>	144:ef7eb2e8f9f7	1423	return HAL_OK;
<>	144:ef7eb2e8f9f7	1424	}
<>	144:ef7eb2e8f9f7	1425
<>	144:ef7eb2e8f9f7	1426	/**
<>	144:ef7eb2e8f9f7	1427	* @}
<>	144:ef7eb2e8f9f7	1428	*/
<>	144:ef7eb2e8f9f7	1429
<>	144:ef7eb2e8f9f7	1430	#endif /* HAL_SMARTCARD_MODULE_ENABLED */
<>	144:ef7eb2e8f9f7	1431	/**
<>	144:ef7eb2e8f9f7	1432	* @}
<>	144:ef7eb2e8f9f7	1433	*/
<>	144:ef7eb2e8f9f7	1434
<>	144:ef7eb2e8f9f7	1435	/**
<>	144:ef7eb2e8f9f7	1436	* @}
<>	144:ef7eb2e8f9f7	1437	*/
<>	144:ef7eb2e8f9f7	1438
<>	144:ef7eb2e8f9f7	1439	/********************** (C) COPYRIGHT STMicroelectronics *END OF FILE**/