gabriel della-monica / mbed-src

mbed library sources

Fork of mbed-src by mbed official

targets/cmsis/TARGET_STM/TARGET_STM32F0/stm32f0xx_hal_smartcard.c@445:9a3ffe6cfa19, 2015-01-14 (annotated)

Committer:
moirans2
Date:
Wed Jan 14 20:53:08 2015 +0000
Revision:
445:9a3ffe6cfa19
Parent:
441:d2c15dda23c1 
internal clock stm32L051

Who changed what in which revision?

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