mbed official / mbed-src

mbed library sources

Dependents:   Encrypted my_mbed lklk CyaSSL_DTLS_Cellular ... more

Superseded

This library was superseded by mbed-dev - https://os.mbed.com/users/mbed_official/code/mbed-dev/.

Development branch of the mbed library sources. This library is kept in synch with the latest changes from the mbed SDK and it is not guaranteed to work.

If you are looking for a stable and tested release, please import one of the official mbed library releases:

Import librarymbed

The official Mbed 2 C/C++ SDK provides the software platform and libraries to build your applications.

Last commit 20 Feb 2019 by mbed official

targets/cmsis/TARGET_STM/TARGET_STM32F0/stm32f0xx_hal_smartcard.c@579:53297373a894, 2015-07-01 (annotated)

Committer:
mbed_official
Date:
Wed Jul 01 09:45:11 2015 +0100
Revision:
579:53297373a894
Parent:
441:d2c15dda23c1
Child:
630:825f75ca301e
Synchronized with git revision d5b4d2ab9c47edb4dc5776e7177b0c2263459081



Full URL: https://github.com/mbedmicro/mbed/commit/d5b4d2ab9c47edb4dc5776e7177b0c2263459081/



Initial version of drivers for SAMR21

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****/