mbed official / mbed-dev

mbed library sources. Supersedes mbed-src.

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

targets/TARGET_STM/TARGET_STM32L4/device/stm32l4xx_hal_smartcard.c@167:e84263d55307, 2017-06-21 (annotated)

Committer:
AnnaBridge
Date:
Wed Jun 21 17:46:44 2017 +0100
Revision:
167:e84263d55307
Parent:
149:156823d33999
Child:
181:57724642e740
This updates the lib to the mbed lib v 145

Who changed what in which revision?

UserRevisionLine numberNew contents of line
<> 144:ef7eb2e8f9f7 1 /**
<> 144:ef7eb2e8f9f7 2 ******************************************************************************
<> 144:ef7eb2e8f9f7 3 * @file stm32l4xx_hal_smartcard.c
<> 144:ef7eb2e8f9f7 4 * @author MCD Application Team
AnnaBridge 167:e84263d55307 5 * @version V1.7.1
AnnaBridge 167:e84263d55307 6 * @date 21-April-2017
<> 144:ef7eb2e8f9f7 7 * @brief SMARTCARD HAL module driver.
<> 144:ef7eb2e8f9f7 8 * This file provides firmware functions to manage the following
<> 144:ef7eb2e8f9f7 9 * functionalities of the SMARTCARD peripheral:
<> 144:ef7eb2e8f9f7 10 * + Initialization and de-initialization functions
<> 144:ef7eb2e8f9f7 11 * + IO operation functions
<> 144:ef7eb2e8f9f7 12 * + Peripheral Control functions
<> 144:ef7eb2e8f9f7 13 * + Peripheral State and Error functions
<> 144:ef7eb2e8f9f7 14 *
<> 144:ef7eb2e8f9f7 15 @verbatim
<> 144:ef7eb2e8f9f7 16 ==============================================================================
<> 144:ef7eb2e8f9f7 17 ##### How to use this driver #####
<> 144:ef7eb2e8f9f7 18 ==============================================================================
<> 144:ef7eb2e8f9f7 19 [..]
<> 144:ef7eb2e8f9f7 20 The SMARTCARD HAL driver can be used as follows:
<> 144:ef7eb2e8f9f7 21
<> 144:ef7eb2e8f9f7 22 (#) Declare a SMARTCARD_HandleTypeDef handle structure (eg. SMARTCARD_HandleTypeDef hsmartcard).
<> 144:ef7eb2e8f9f7 23 (#) Associate a USART to the SMARTCARD handle hsmartcard.
<> 144:ef7eb2e8f9f7 24 (#) Initialize the SMARTCARD low level resources by implementing the HAL_SMARTCARD_MspInit() API:
<> 144:ef7eb2e8f9f7 25 (++) Enable the USARTx interface clock.
<> 144:ef7eb2e8f9f7 26 (++) USART pins configuration:
AnnaBridge 167:e84263d55307 27 (+++) Enable the clock for the USART GPIOs.
AnnaBridge 167:e84263d55307 28 (+++) Configure the USART pins (TX as alternate function pull-up, RX as alternate function Input).
<> 144:ef7eb2e8f9f7 29 (++) NVIC configuration if you need to use interrupt process (HAL_SMARTCARD_Transmit_IT()
<> 144:ef7eb2e8f9f7 30 and HAL_SMARTCARD_Receive_IT() APIs):
AnnaBridge 167:e84263d55307 31 (+++) Configure the USARTx interrupt priority.
AnnaBridge 167:e84263d55307 32 (+++) Enable the NVIC USART IRQ handle.
<> 144:ef7eb2e8f9f7 33 (++) DMA Configuration if you need to use DMA process (HAL_SMARTCARD_Transmit_DMA()
<> 144:ef7eb2e8f9f7 34 and HAL_SMARTCARD_Receive_DMA() APIs):
AnnaBridge 167:e84263d55307 35 (+++) Declare a DMA handle structure for the Tx/Rx channel.
AnnaBridge 167:e84263d55307 36 (+++) Enable the DMAx interface clock.
AnnaBridge 167:e84263d55307 37 (+++) Configure the declared DMA handle structure with the required Tx/Rx parameters.
AnnaBridge 167:e84263d55307 38 (+++) Configure the DMA Tx/Rx channel.
AnnaBridge 167:e84263d55307 39 (+++) Associate the initialized DMA handle to the SMARTCARD DMA Tx/Rx handle.
AnnaBridge 167:e84263d55307 40 (+++) Configure the priority and enable the NVIC for the transfer complete interrupt on the DMA Tx/Rx channel.
<> 144:ef7eb2e8f9f7 41
<> 144:ef7eb2e8f9f7 42 (#) Program the Baud Rate, Parity, Mode(Receiver/Transmitter), clock enabling/disabling and accordingly,
<> 144:ef7eb2e8f9f7 43 the clock parameters (parity, phase, last bit), prescaler value, guard time and NACK on transmission
<> 144:ef7eb2e8f9f7 44 error enabling or disabling in the hsmartcard handle Init structure.
<> 144:ef7eb2e8f9f7 45
<> 144:ef7eb2e8f9f7 46 (#) If required, program SMARTCARD advanced features (TX/RX pins swap, TimeOut, auto-retry counter,...)
<> 144:ef7eb2e8f9f7 47 in the hsmartcard handle AdvancedInit structure.
<> 144:ef7eb2e8f9f7 48
<> 144:ef7eb2e8f9f7 49 (#) Initialize the SMARTCARD registers by calling the HAL_SMARTCARD_Init() API:
<> 144:ef7eb2e8f9f7 50 (++) This API configures also the low level Hardware GPIO, CLOCK, CORTEX...etc)
<> 144:ef7eb2e8f9f7 51 by calling the customized HAL_SMARTCARD_MspInit() API.
<> 144:ef7eb2e8f9f7 52 [..]
<> 144:ef7eb2e8f9f7 53 (@) The specific SMARTCARD interrupts (Transmission complete interrupt,
<> 144:ef7eb2e8f9f7 54 RXNE interrupt and Error Interrupts) will be managed using the macros
<> 144:ef7eb2e8f9f7 55 __HAL_SMARTCARD_ENABLE_IT() and __HAL_SMARTCARD_DISABLE_IT() inside the transmit and receive process.
<> 144:ef7eb2e8f9f7 56
<> 144:ef7eb2e8f9f7 57 [..]
<> 144:ef7eb2e8f9f7 58 [..] Three operation modes are available within this driver :
<> 144:ef7eb2e8f9f7 59
<> 144:ef7eb2e8f9f7 60 *** Polling mode IO operation ***
<> 144:ef7eb2e8f9f7 61 =================================
<> 144:ef7eb2e8f9f7 62 [..]
<> 144:ef7eb2e8f9f7 63 (+) Send an amount of data in blocking mode using HAL_SMARTCARD_Transmit()
<> 144:ef7eb2e8f9f7 64 (+) Receive an amount of data in blocking mode using HAL_SMARTCARD_Receive()
<> 144:ef7eb2e8f9f7 65
<> 144:ef7eb2e8f9f7 66 *** Interrupt mode IO operation ***
<> 144:ef7eb2e8f9f7 67 ===================================
<> 144:ef7eb2e8f9f7 68 [..]
<> 144:ef7eb2e8f9f7 69 (+) Send an amount of data in non-blocking mode using HAL_SMARTCARD_Transmit_IT()
<> 144:ef7eb2e8f9f7 70 (+) At transmission end of transfer HAL_SMARTCARD_TxCpltCallback() is executed and user can
<> 144:ef7eb2e8f9f7 71 add his own code by customization of function pointer HAL_SMARTCARD_TxCpltCallback()
<> 144:ef7eb2e8f9f7 72 (+) Receive an amount of data in non-blocking mode using HAL_SMARTCARD_Receive_IT()
<> 144:ef7eb2e8f9f7 73 (+) At reception end of transfer HAL_SMARTCARD_RxCpltCallback() is executed and user can
<> 144:ef7eb2e8f9f7 74 add his own code by customization of function pointer HAL_SMARTCARD_RxCpltCallback()
<> 144:ef7eb2e8f9f7 75 (+) In case of transfer Error, HAL_SMARTCARD_ErrorCallback() function is executed and user can
<> 144:ef7eb2e8f9f7 76 add his own code by customization of function pointer HAL_SMARTCARD_ErrorCallback()
<> 144:ef7eb2e8f9f7 77
<> 144:ef7eb2e8f9f7 78 *** DMA mode IO operation ***
<> 144:ef7eb2e8f9f7 79 ==============================
<> 144:ef7eb2e8f9f7 80 [..]
<> 144:ef7eb2e8f9f7 81 (+) Send an amount of data in non-blocking mode (DMA) using HAL_SMARTCARD_Transmit_DMA()
<> 144:ef7eb2e8f9f7 82 (+) At transmission end of transfer HAL_SMARTCARD_TxCpltCallback() is executed and user can
<> 144:ef7eb2e8f9f7 83 add his own code by customization of function pointer HAL_SMARTCARD_TxCpltCallback()
<> 144:ef7eb2e8f9f7 84 (+) Receive an amount of data in non-blocking mode (DMA) using HAL_SMARTCARD_Receive_DMA()
<> 144:ef7eb2e8f9f7 85 (+) At reception end of transfer HAL_SMARTCARD_RxCpltCallback() is executed and user can
<> 144:ef7eb2e8f9f7 86 add his own code by customization of function pointer HAL_SMARTCARD_RxCpltCallback()
<> 144:ef7eb2e8f9f7 87 (+) In case of transfer Error, HAL_SMARTCARD_ErrorCallback() function is executed and user can
<> 144:ef7eb2e8f9f7 88 add his own code by customization of function pointer HAL_SMARTCARD_ErrorCallback()
<> 144:ef7eb2e8f9f7 89
<> 144:ef7eb2e8f9f7 90 *** SMARTCARD HAL driver macros list ***
<> 144:ef7eb2e8f9f7 91 ========================================
<> 144:ef7eb2e8f9f7 92 [..]
<> 144:ef7eb2e8f9f7 93 Below the list of most used macros in SMARTCARD HAL driver.
<> 144:ef7eb2e8f9f7 94
<> 144:ef7eb2e8f9f7 95 (+) __HAL_SMARTCARD_GET_FLAG : Check whether or not the specified SMARTCARD flag is set
<> 144:ef7eb2e8f9f7 96 (+) __HAL_SMARTCARD_CLEAR_FLAG : Clear the specified SMARTCARD pending flag
<> 144:ef7eb2e8f9f7 97 (+) __HAL_SMARTCARD_ENABLE_IT: Enable the specified SMARTCARD interrupt
<> 144:ef7eb2e8f9f7 98 (+) __HAL_SMARTCARD_DISABLE_IT: Disable the specified SMARTCARD interrupt
<> 144:ef7eb2e8f9f7 99 (+) __HAL_SMARTCARD_GET_IT_SOURCE: Check whether or not the specified SMARTCARD interrupt is enabled
<> 144:ef7eb2e8f9f7 100
<> 144:ef7eb2e8f9f7 101 [..]
<> 144:ef7eb2e8f9f7 102 (@) You can refer to the SMARTCARD HAL driver header file for more useful macros
<> 144:ef7eb2e8f9f7 103
<> 144:ef7eb2e8f9f7 104 @endverbatim
<> 144:ef7eb2e8f9f7 105 ******************************************************************************
<> 144:ef7eb2e8f9f7 106 * @attention
<> 144:ef7eb2e8f9f7 107 *
AnnaBridge 167:e84263d55307 108 * <h2><center>&copy; COPYRIGHT(c) 2017 STMicroelectronics</center></h2>
<> 144:ef7eb2e8f9f7 109 *
<> 144:ef7eb2e8f9f7 110 * Redistribution and use in source and binary forms, with or without modification,
<> 144:ef7eb2e8f9f7 111 * are permitted provided that the following conditions are met:
<> 144:ef7eb2e8f9f7 112 * 1. Redistributions of source code must retain the above copyright notice,
<> 144:ef7eb2e8f9f7 113 * this list of conditions and the following disclaimer.
<> 144:ef7eb2e8f9f7 114 * 2. Redistributions in binary form must reproduce the above copyright notice,
<> 144:ef7eb2e8f9f7 115 * this list of conditions and the following disclaimer in the documentation
<> 144:ef7eb2e8f9f7 116 * and/or other materials provided with the distribution.
<> 144:ef7eb2e8f9f7 117 * 3. Neither the name of STMicroelectronics nor the names of its contributors
<> 144:ef7eb2e8f9f7 118 * may be used to endorse or promote products derived from this software
<> 144:ef7eb2e8f9f7 119 * without specific prior written permission.
<> 144:ef7eb2e8f9f7 120 *
<> 144:ef7eb2e8f9f7 121 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
<> 144:ef7eb2e8f9f7 122 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
<> 144:ef7eb2e8f9f7 123 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
<> 144:ef7eb2e8f9f7 124 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
<> 144:ef7eb2e8f9f7 125 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
<> 144:ef7eb2e8f9f7 126 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
<> 144:ef7eb2e8f9f7 127 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
<> 144:ef7eb2e8f9f7 128 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
<> 144:ef7eb2e8f9f7 129 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
<> 144:ef7eb2e8f9f7 130 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
<> 144:ef7eb2e8f9f7 131 *
<> 144:ef7eb2e8f9f7 132 ******************************************************************************
<> 144:ef7eb2e8f9f7 133 */
<> 144:ef7eb2e8f9f7 134
<> 144:ef7eb2e8f9f7 135 /* Includes ------------------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 136 #include "stm32l4xx_hal.h"
<> 144:ef7eb2e8f9f7 137
<> 144:ef7eb2e8f9f7 138 /** @addtogroup STM32L4xx_HAL_Driver
<> 144:ef7eb2e8f9f7 139 * @{
<> 144:ef7eb2e8f9f7 140 */
<> 144:ef7eb2e8f9f7 141
<> 144:ef7eb2e8f9f7 142 /** @defgroup SMARTCARD SMARTCARD
<> 144:ef7eb2e8f9f7 143 * @brief HAL SMARTCARD module driver
<> 144:ef7eb2e8f9f7 144 * @{
<> 144:ef7eb2e8f9f7 145 */
<> 144:ef7eb2e8f9f7 146
<> 144:ef7eb2e8f9f7 147 #ifdef HAL_SMARTCARD_MODULE_ENABLED
<> 144:ef7eb2e8f9f7 148
<> 144:ef7eb2e8f9f7 149 /* Private typedef -----------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 150 /* Private define ------------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 151 /** @defgroup SMARTCARD_Private_Constants SMARTCARD Private Constants
<> 144:ef7eb2e8f9f7 152 * @{
<> 144:ef7eb2e8f9f7 153 */
<> 144:ef7eb2e8f9f7 154 #define SMARTCARD_TEACK_REACK_TIMEOUT 1000 /*!< SMARTCARD TX or RX enable acknowledge time-out value */
<> 144:ef7eb2e8f9f7 155
<> 144:ef7eb2e8f9f7 156 #define USART_CR1_FIELDS ((uint32_t)(USART_CR1_M | USART_CR1_PCE | USART_CR1_PS | \
<> 144:ef7eb2e8f9f7 157 USART_CR1_TE | USART_CR1_RE | USART_CR1_OVER8)) /*!< USART CR1 fields of parameters set by SMARTCARD_SetConfig API */
<> 144:ef7eb2e8f9f7 158 #define USART_CR2_CLK_FIELDS ((uint32_t)(USART_CR2_CLKEN|USART_CR2_CPOL|USART_CR2_CPHA|USART_CR2_LBCL)) /*!< SMARTCARD clock-related USART CR2 fields of parameters */
<> 144:ef7eb2e8f9f7 159 #define USART_CR2_FIELDS ((uint32_t)(USART_CR2_RTOEN|USART_CR2_CLK_FIELDS|USART_CR2_STOP)) /*!< USART CR2 fields of parameters set by SMARTCARD_SetConfig API */
<> 144:ef7eb2e8f9f7 160 #define USART_CR3_FIELDS ((uint32_t)(USART_CR3_ONEBIT|USART_CR3_NACK|USART_CR3_SCARCNT)) /*!< USART CR3 fields of parameters set by SMARTCARD_SetConfig API */
<> 144:ef7eb2e8f9f7 161 /**
<> 144:ef7eb2e8f9f7 162 * @}
<> 144:ef7eb2e8f9f7 163 */
<> 144:ef7eb2e8f9f7 164
<> 144:ef7eb2e8f9f7 165 /* Private macros ------------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 166 /* Private variables ---------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 167 /* Private function prototypes -----------------------------------------------*/
<> 144:ef7eb2e8f9f7 168 /** @addtogroup SMARTCARD_Private_Functions
<> 144:ef7eb2e8f9f7 169 * @{
<> 144:ef7eb2e8f9f7 170 */
AnnaBridge 167:e84263d55307 171 static HAL_StatusTypeDef SMARTCARD_SetConfig(SMARTCARD_HandleTypeDef *hsmartcard);
AnnaBridge 167:e84263d55307 172 static void SMARTCARD_AdvFeatureConfig(SMARTCARD_HandleTypeDef *hsmartcard);
AnnaBridge 167:e84263d55307 173 static HAL_StatusTypeDef SMARTCARD_CheckIdleState(SMARTCARD_HandleTypeDef *hsmartcard);
AnnaBridge 167:e84263d55307 174 static HAL_StatusTypeDef SMARTCARD_WaitOnFlagUntilTimeout(SMARTCARD_HandleTypeDef *hsmartcard, uint32_t Flag, FlagStatus Status, uint32_t Tickstart, uint32_t Timeout);
AnnaBridge 167:e84263d55307 175 static void SMARTCARD_EndTxTransfer(SMARTCARD_HandleTypeDef *hsmartcard);
AnnaBridge 167:e84263d55307 176 static void SMARTCARD_EndRxTransfer(SMARTCARD_HandleTypeDef *hsmartcard);
<> 144:ef7eb2e8f9f7 177 static void SMARTCARD_DMATransmitCplt(DMA_HandleTypeDef *hdma);
<> 144:ef7eb2e8f9f7 178 static void SMARTCARD_DMAReceiveCplt(DMA_HandleTypeDef *hdma);
<> 144:ef7eb2e8f9f7 179 static void SMARTCARD_DMAError(DMA_HandleTypeDef *hdma);
AnnaBridge 167:e84263d55307 180 static void SMARTCARD_DMAAbortOnError(DMA_HandleTypeDef *hdma);
AnnaBridge 167:e84263d55307 181 static void SMARTCARD_DMATxAbortCallback(DMA_HandleTypeDef *hdma);
AnnaBridge 167:e84263d55307 182 static void SMARTCARD_DMARxAbortCallback(DMA_HandleTypeDef *hdma);
AnnaBridge 167:e84263d55307 183 static void SMARTCARD_DMATxOnlyAbortCallback(DMA_HandleTypeDef *hdma);
AnnaBridge 167:e84263d55307 184 static void SMARTCARD_DMARxOnlyAbortCallback(DMA_HandleTypeDef *hdma);
<> 144:ef7eb2e8f9f7 185 static HAL_StatusTypeDef SMARTCARD_Transmit_IT(SMARTCARD_HandleTypeDef *hsmartcard);
<> 144:ef7eb2e8f9f7 186 static HAL_StatusTypeDef SMARTCARD_EndTransmit_IT(SMARTCARD_HandleTypeDef *hsmartcard);
<> 144:ef7eb2e8f9f7 187 static HAL_StatusTypeDef SMARTCARD_Receive_IT(SMARTCARD_HandleTypeDef *hsmartcard);
<> 144:ef7eb2e8f9f7 188 /**
<> 144:ef7eb2e8f9f7 189 * @}
<> 144:ef7eb2e8f9f7 190 */
<> 144:ef7eb2e8f9f7 191
<> 144:ef7eb2e8f9f7 192 /* Exported functions --------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 193
<> 144:ef7eb2e8f9f7 194 /** @defgroup SMARTCARD_Exported_Functions SMARTCARD Exported Functions
<> 144:ef7eb2e8f9f7 195 * @{
<> 144:ef7eb2e8f9f7 196 */
<> 144:ef7eb2e8f9f7 197
<> 144:ef7eb2e8f9f7 198 /** @defgroup SMARTCARD_Exported_Functions_Group1 Initialization and de-initialization functions
<> 144:ef7eb2e8f9f7 199 * @brief Initialization and Configuration functions
<> 144:ef7eb2e8f9f7 200 *
<> 144:ef7eb2e8f9f7 201 @verbatim
AnnaBridge 167:e84263d55307 202 ==============================================================================
<> 144:ef7eb2e8f9f7 203 ##### Initialization and Configuration functions #####
AnnaBridge 167:e84263d55307 204 ==============================================================================
<> 144:ef7eb2e8f9f7 205 [..]
<> 144:ef7eb2e8f9f7 206 This subsection provides a set of functions allowing to initialize the USARTx
<> 144:ef7eb2e8f9f7 207 associated to the SmartCard.
<> 144:ef7eb2e8f9f7 208 (+) These parameters can be configured:
<> 144:ef7eb2e8f9f7 209 (++) Baud Rate
<> 144:ef7eb2e8f9f7 210 (++) Parity: parity should be enabled, frame Length is fixed to 8 bits plus parity
<> 144:ef7eb2e8f9f7 211 (++) Receiver/transmitter modes
<> 144:ef7eb2e8f9f7 212 (++) Synchronous mode (and if enabled, phase, polarity and last bit parameters)
<> 144:ef7eb2e8f9f7 213 (++) Prescaler value
<> 144:ef7eb2e8f9f7 214 (++) Guard bit time
<> 144:ef7eb2e8f9f7 215 (++) NACK enabling or disabling on transmission error
<> 144:ef7eb2e8f9f7 216
<> 144:ef7eb2e8f9f7 217 (+) The following advanced features can be configured as well:
<> 144:ef7eb2e8f9f7 218 (++) TX and/or RX pin level inversion
<> 144:ef7eb2e8f9f7 219 (++) data logical level inversion
<> 144:ef7eb2e8f9f7 220 (++) RX and TX pins swap
<> 144:ef7eb2e8f9f7 221 (++) RX overrun detection disabling
<> 144:ef7eb2e8f9f7 222 (++) DMA disabling on RX error
<> 144:ef7eb2e8f9f7 223 (++) MSB first on communication line
<> 144:ef7eb2e8f9f7 224 (++) Time out enabling (and if activated, timeout value)
<> 144:ef7eb2e8f9f7 225 (++) Block length
<> 144:ef7eb2e8f9f7 226 (++) Auto-retry counter
<> 144:ef7eb2e8f9f7 227 [..]
<> 144:ef7eb2e8f9f7 228 The HAL_SMARTCARD_Init() API follows the USART synchronous configuration procedures
<> 144:ef7eb2e8f9f7 229 (details for the procedures are available in reference manual).
<> 144:ef7eb2e8f9f7 230
<> 144:ef7eb2e8f9f7 231 @endverbatim
<> 144:ef7eb2e8f9f7 232
<> 144:ef7eb2e8f9f7 233 The USART frame format is given in the following table:
<> 144:ef7eb2e8f9f7 234
<> 144:ef7eb2e8f9f7 235 Table 1. USART frame format.
<> 144:ef7eb2e8f9f7 236 +---------------------------------------------------------------+
<> 144:ef7eb2e8f9f7 237 | M1M0 bits | PCE bit | USART frame |
<> 144:ef7eb2e8f9f7 238 |-----------------------|---------------------------------------|
<> 144:ef7eb2e8f9f7 239 | 01 | 1 | | SB | 8 bit data | PB | STB | |
<> 144:ef7eb2e8f9f7 240 +---------------------------------------------------------------+
<> 144:ef7eb2e8f9f7 241
<> 144:ef7eb2e8f9f7 242
<> 144:ef7eb2e8f9f7 243 * @{
<> 144:ef7eb2e8f9f7 244 */
<> 144:ef7eb2e8f9f7 245
<> 144:ef7eb2e8f9f7 246 /**
AnnaBridge 167:e84263d55307 247 * @brief Initialize the SMARTCARD mode according to the specified
AnnaBridge 167:e84263d55307 248 * parameters in the SMARTCARD_HandleTypeDef and initialize the associated handle.
AnnaBridge 167:e84263d55307 249 * @param hsmartcard Pointer to a SMARTCARD_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 250 * the configuration information for the specified SMARTCARD module.
<> 144:ef7eb2e8f9f7 251 * @retval HAL status
<> 144:ef7eb2e8f9f7 252 */
<> 144:ef7eb2e8f9f7 253 HAL_StatusTypeDef HAL_SMARTCARD_Init(SMARTCARD_HandleTypeDef *hsmartcard)
<> 144:ef7eb2e8f9f7 254 {
<> 144:ef7eb2e8f9f7 255 /* Check the SMARTCARD handle allocation */
<> 144:ef7eb2e8f9f7 256 if(hsmartcard == NULL)
<> 144:ef7eb2e8f9f7 257 {
<> 144:ef7eb2e8f9f7 258 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 259 }
<> 144:ef7eb2e8f9f7 260
AnnaBridge 167:e84263d55307 261 /* Check the USART associated to the SMARTCARD handle */
<> 144:ef7eb2e8f9f7 262 assert_param(IS_SMARTCARD_INSTANCE(hsmartcard->Instance));
<> 144:ef7eb2e8f9f7 263
<> 144:ef7eb2e8f9f7 264 if(hsmartcard->gState == HAL_SMARTCARD_STATE_RESET)
<> 144:ef7eb2e8f9f7 265 {
<> 144:ef7eb2e8f9f7 266 /* Allocate lock resource and initialize it */
<> 144:ef7eb2e8f9f7 267 hsmartcard->Lock = HAL_UNLOCKED;
<> 144:ef7eb2e8f9f7 268
<> 144:ef7eb2e8f9f7 269 /* Init the low level hardware : GPIO, CLOCK */
<> 144:ef7eb2e8f9f7 270 HAL_SMARTCARD_MspInit(hsmartcard);
<> 144:ef7eb2e8f9f7 271 }
<> 144:ef7eb2e8f9f7 272
<> 144:ef7eb2e8f9f7 273 hsmartcard->gState = HAL_SMARTCARD_STATE_BUSY;
<> 144:ef7eb2e8f9f7 274
<> 144:ef7eb2e8f9f7 275 /* Disable the Peripheral to set smartcard mode */
<> 144:ef7eb2e8f9f7 276 CLEAR_BIT(hsmartcard->Instance->CR1, USART_CR1_UE);
<> 144:ef7eb2e8f9f7 277
<> 144:ef7eb2e8f9f7 278 /* In SmartCard mode, the following bits must be kept cleared:
<> 144:ef7eb2e8f9f7 279 - LINEN in the USART_CR2 register,
<> 144:ef7eb2e8f9f7 280 - HDSEL and IREN bits in the USART_CR3 register.*/
<> 144:ef7eb2e8f9f7 281 CLEAR_BIT(hsmartcard->Instance->CR2, USART_CR2_LINEN);
<> 144:ef7eb2e8f9f7 282 CLEAR_BIT(hsmartcard->Instance->CR3, (USART_CR3_HDSEL | USART_CR3_IREN));
<> 144:ef7eb2e8f9f7 283
<> 144:ef7eb2e8f9f7 284 /* set the USART in SMARTCARD mode */
<> 144:ef7eb2e8f9f7 285 SET_BIT(hsmartcard->Instance->CR3, USART_CR3_SCEN);
<> 144:ef7eb2e8f9f7 286
<> 144:ef7eb2e8f9f7 287 /* Set the SMARTCARD Communication parameters */
<> 144:ef7eb2e8f9f7 288 if (SMARTCARD_SetConfig(hsmartcard) == HAL_ERROR)
<> 144:ef7eb2e8f9f7 289 {
<> 144:ef7eb2e8f9f7 290 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 291 }
<> 144:ef7eb2e8f9f7 292
<> 144:ef7eb2e8f9f7 293 /* Set the SMARTCARD transmission completion indication */
<> 144:ef7eb2e8f9f7 294 SMARTCARD_TRANSMISSION_COMPLETION_SETTING(hsmartcard);
<> 144:ef7eb2e8f9f7 295
<> 144:ef7eb2e8f9f7 296 if (hsmartcard->AdvancedInit.AdvFeatureInit != SMARTCARD_ADVFEATURE_NO_INIT)
<> 144:ef7eb2e8f9f7 297 {
<> 144:ef7eb2e8f9f7 298 SMARTCARD_AdvFeatureConfig(hsmartcard);
<> 144:ef7eb2e8f9f7 299 }
<> 144:ef7eb2e8f9f7 300
<> 144:ef7eb2e8f9f7 301 /* Enable the Peripheral */
<> 144:ef7eb2e8f9f7 302 SET_BIT(hsmartcard->Instance->CR1, USART_CR1_UE);
<> 144:ef7eb2e8f9f7 303
<> 144:ef7eb2e8f9f7 304 /* TEACK and/or REACK to check before moving hsmartcard->gState and hsmartcard->RxState to Ready */
<> 144:ef7eb2e8f9f7 305 return (SMARTCARD_CheckIdleState(hsmartcard));
<> 144:ef7eb2e8f9f7 306 }
<> 144:ef7eb2e8f9f7 307
<> 144:ef7eb2e8f9f7 308 /**
AnnaBridge 167:e84263d55307 309 * @brief DeInitialize the SMARTCARD peripheral.
AnnaBridge 167:e84263d55307 310 * @param hsmartcard Pointer to a SMARTCARD_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 311 * the configuration information for the specified SMARTCARD module.
<> 144:ef7eb2e8f9f7 312 * @retval HAL status
<> 144:ef7eb2e8f9f7 313 */
<> 144:ef7eb2e8f9f7 314 HAL_StatusTypeDef HAL_SMARTCARD_DeInit(SMARTCARD_HandleTypeDef *hsmartcard)
<> 144:ef7eb2e8f9f7 315 {
<> 144:ef7eb2e8f9f7 316 /* Check the SMARTCARD handle allocation */
<> 144:ef7eb2e8f9f7 317 if(hsmartcard == NULL)
<> 144:ef7eb2e8f9f7 318 {
<> 144:ef7eb2e8f9f7 319 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 320 }
<> 144:ef7eb2e8f9f7 321
AnnaBridge 167:e84263d55307 322 /* Check the USART/UART associated to the SMARTCARD handle */
<> 144:ef7eb2e8f9f7 323 assert_param(IS_SMARTCARD_INSTANCE(hsmartcard->Instance));
<> 144:ef7eb2e8f9f7 324
<> 144:ef7eb2e8f9f7 325 hsmartcard->gState = HAL_SMARTCARD_STATE_BUSY;
<> 144:ef7eb2e8f9f7 326
<> 144:ef7eb2e8f9f7 327 /* Disable the Peripheral */
<> 144:ef7eb2e8f9f7 328 CLEAR_BIT(hsmartcard->Instance->CR1, USART_CR1_UE);
<> 144:ef7eb2e8f9f7 329
<> 144:ef7eb2e8f9f7 330 WRITE_REG(hsmartcard->Instance->CR1, 0x0);
<> 144:ef7eb2e8f9f7 331 WRITE_REG(hsmartcard->Instance->CR2, 0x0);
<> 144:ef7eb2e8f9f7 332 WRITE_REG(hsmartcard->Instance->CR3, 0x0);
<> 144:ef7eb2e8f9f7 333 WRITE_REG(hsmartcard->Instance->RTOR, 0x0);
<> 144:ef7eb2e8f9f7 334 WRITE_REG(hsmartcard->Instance->GTPR, 0x0);
<> 144:ef7eb2e8f9f7 335
<> 144:ef7eb2e8f9f7 336 /* DeInit the low level hardware */
<> 144:ef7eb2e8f9f7 337 HAL_SMARTCARD_MspDeInit(hsmartcard);
<> 144:ef7eb2e8f9f7 338
<> 144:ef7eb2e8f9f7 339 hsmartcard->ErrorCode = HAL_SMARTCARD_ERROR_NONE;
<> 144:ef7eb2e8f9f7 340 hsmartcard->gState = HAL_SMARTCARD_STATE_RESET;
<> 144:ef7eb2e8f9f7 341 hsmartcard->RxState = HAL_SMARTCARD_STATE_RESET;
<> 144:ef7eb2e8f9f7 342
<> 144:ef7eb2e8f9f7 343 /* Process Unlock */
<> 144:ef7eb2e8f9f7 344 __HAL_UNLOCK(hsmartcard);
<> 144:ef7eb2e8f9f7 345
<> 144:ef7eb2e8f9f7 346 return HAL_OK;
<> 144:ef7eb2e8f9f7 347 }
<> 144:ef7eb2e8f9f7 348
<> 144:ef7eb2e8f9f7 349 /**
AnnaBridge 167:e84263d55307 350 * @brief Initialize the SMARTCARD MSP.
AnnaBridge 167:e84263d55307 351 * @param hsmartcard Pointer to a SMARTCARD_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 352 * the configuration information for the specified SMARTCARD module.
<> 144:ef7eb2e8f9f7 353 * @retval None
<> 144:ef7eb2e8f9f7 354 */
<> 144:ef7eb2e8f9f7 355 __weak void HAL_SMARTCARD_MspInit(SMARTCARD_HandleTypeDef *hsmartcard)
<> 144:ef7eb2e8f9f7 356 {
<> 144:ef7eb2e8f9f7 357 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 358 UNUSED(hsmartcard);
<> 144:ef7eb2e8f9f7 359
<> 144:ef7eb2e8f9f7 360 /* NOTE : This function should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 361 the HAL_SMARTCARD_MspInit can be implemented in the user file
<> 144:ef7eb2e8f9f7 362 */
<> 144:ef7eb2e8f9f7 363 }
<> 144:ef7eb2e8f9f7 364
<> 144:ef7eb2e8f9f7 365 /**
AnnaBridge 167:e84263d55307 366 * @brief DeInitialize the SMARTCARD MSP.
AnnaBridge 167:e84263d55307 367 * @param hsmartcard Pointer to a SMARTCARD_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 368 * the configuration information for the specified SMARTCARD module.
<> 144:ef7eb2e8f9f7 369 * @retval None
<> 144:ef7eb2e8f9f7 370 */
<> 144:ef7eb2e8f9f7 371 __weak void HAL_SMARTCARD_MspDeInit(SMARTCARD_HandleTypeDef *hsmartcard)
<> 144:ef7eb2e8f9f7 372 {
<> 144:ef7eb2e8f9f7 373 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 374 UNUSED(hsmartcard);
<> 144:ef7eb2e8f9f7 375
<> 144:ef7eb2e8f9f7 376 /* NOTE : This function should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 377 the HAL_SMARTCARD_MspDeInit can be implemented in the user file
<> 144:ef7eb2e8f9f7 378 */
<> 144:ef7eb2e8f9f7 379 }
<> 144:ef7eb2e8f9f7 380
<> 144:ef7eb2e8f9f7 381 /**
<> 144:ef7eb2e8f9f7 382 * @}
<> 144:ef7eb2e8f9f7 383 */
<> 144:ef7eb2e8f9f7 384
<> 144:ef7eb2e8f9f7 385 /** @defgroup SMARTCARD_Exported_Functions_Group2 IO operation functions
<> 144:ef7eb2e8f9f7 386 * @brief SMARTCARD Transmit and Receive functions
<> 144:ef7eb2e8f9f7 387 *
<> 144:ef7eb2e8f9f7 388 @verbatim
<> 144:ef7eb2e8f9f7 389 ==============================================================================
<> 144:ef7eb2e8f9f7 390 ##### IO operation functions #####
<> 144:ef7eb2e8f9f7 391 ==============================================================================
<> 144:ef7eb2e8f9f7 392 [..]
<> 144:ef7eb2e8f9f7 393 This subsection provides a set of functions allowing to manage the SMARTCARD data transfers.
<> 144:ef7eb2e8f9f7 394
<> 144:ef7eb2e8f9f7 395 [..]
<> 144:ef7eb2e8f9f7 396 Smartcard is a single wire half duplex communication protocol.
<> 144:ef7eb2e8f9f7 397 The Smartcard interface is designed to support asynchronous protocol Smartcards as
<> 144:ef7eb2e8f9f7 398 defined in the ISO 7816-3 standard. The USART should be configured as:
<> 144:ef7eb2e8f9f7 399 (+) 8 bits plus parity: where M=1 and PCE=1 in the USART_CR1 register
<> 144:ef7eb2e8f9f7 400 (+) 1.5 stop bits when transmitting and receiving: where STOP=11 in the USART_CR2 register.
<> 144:ef7eb2e8f9f7 401
<> 144:ef7eb2e8f9f7 402 [..]
<> 144:ef7eb2e8f9f7 403 (+) There are two modes of transfer:
<> 144:ef7eb2e8f9f7 404 (++) Blocking mode: The communication is performed in polling mode.
<> 144:ef7eb2e8f9f7 405 The HAL status of all data processing is returned by the same function
<> 144:ef7eb2e8f9f7 406 after finishing transfer.
AnnaBridge 167:e84263d55307 407 (++) Non-Blocking mode: The communication is performed using Interrupts
<> 144:ef7eb2e8f9f7 408 or DMA, the relevant API's return the HAL status.
<> 144:ef7eb2e8f9f7 409 The end of the data processing will be indicated through the
<> 144:ef7eb2e8f9f7 410 dedicated SMARTCARD IRQ when using Interrupt mode or the DMA IRQ when
<> 144:ef7eb2e8f9f7 411 using DMA mode.
<> 144:ef7eb2e8f9f7 412 (++) The HAL_SMARTCARD_TxCpltCallback(), HAL_SMARTCARD_RxCpltCallback() user callbacks
<> 144:ef7eb2e8f9f7 413 will be executed respectively at the end of the Transmit or Receive process
<> 144:ef7eb2e8f9f7 414 The HAL_SMARTCARD_ErrorCallback() user callback will be executed when a communication
<> 144:ef7eb2e8f9f7 415 error is detected.
<> 144:ef7eb2e8f9f7 416
<> 144:ef7eb2e8f9f7 417 (+) Blocking mode APIs are :
<> 144:ef7eb2e8f9f7 418 (++) HAL_SMARTCARD_Transmit()
<> 144:ef7eb2e8f9f7 419 (++) HAL_SMARTCARD_Receive()
<> 144:ef7eb2e8f9f7 420
<> 144:ef7eb2e8f9f7 421 (+) Non Blocking mode APIs with Interrupt are :
<> 144:ef7eb2e8f9f7 422 (++) HAL_SMARTCARD_Transmit_IT()
<> 144:ef7eb2e8f9f7 423 (++) HAL_SMARTCARD_Receive_IT()
<> 144:ef7eb2e8f9f7 424 (++) HAL_SMARTCARD_IRQHandler()
<> 144:ef7eb2e8f9f7 425
<> 144:ef7eb2e8f9f7 426 (+) Non Blocking mode functions with DMA are :
<> 144:ef7eb2e8f9f7 427 (++) HAL_SMARTCARD_Transmit_DMA()
<> 144:ef7eb2e8f9f7 428 (++) HAL_SMARTCARD_Receive_DMA()
<> 144:ef7eb2e8f9f7 429
<> 144:ef7eb2e8f9f7 430 (+) A set of Transfer Complete Callbacks are provided in non Blocking mode:
<> 144:ef7eb2e8f9f7 431 (++) HAL_SMARTCARD_TxCpltCallback()
<> 144:ef7eb2e8f9f7 432 (++) HAL_SMARTCARD_RxCpltCallback()
<> 144:ef7eb2e8f9f7 433 (++) HAL_SMARTCARD_ErrorCallback()
<> 144:ef7eb2e8f9f7 434
AnnaBridge 167:e84263d55307 435 (#) Non-Blocking mode transfers could be aborted using Abort API's :
AnnaBridge 167:e84263d55307 436 (+) HAL_SMARTCARD_Abort()
AnnaBridge 167:e84263d55307 437 (+) HAL_SMARTCARD_AbortTransmit()
AnnaBridge 167:e84263d55307 438 (+) HAL_SMARTCARD_AbortReceive()
AnnaBridge 167:e84263d55307 439 (+) HAL_SMARTCARD_Abort_IT()
AnnaBridge 167:e84263d55307 440 (+) HAL_SMARTCARD_AbortTransmit_IT()
AnnaBridge 167:e84263d55307 441 (+) HAL_SMARTCARD_AbortReceive_IT()
AnnaBridge 167:e84263d55307 442
AnnaBridge 167:e84263d55307 443 (#) For Abort services based on interrupts (HAL_SMARTCARD_Abortxxx_IT), a set of Abort Complete Callbacks are provided:
AnnaBridge 167:e84263d55307 444 (+) HAL_SMARTCARD_AbortCpltCallback()
AnnaBridge 167:e84263d55307 445 (+) HAL_SMARTCARD_AbortTransmitCpltCallback()
AnnaBridge 167:e84263d55307 446 (+) HAL_SMARTCARD_AbortReceiveCpltCallback()
AnnaBridge 167:e84263d55307 447
AnnaBridge 167:e84263d55307 448 (#) In Non-Blocking mode transfers, possible errors are split into 2 categories.
AnnaBridge 167:e84263d55307 449 Errors are handled as follows :
AnnaBridge 167:e84263d55307 450 (+) Error is considered as Recoverable and non blocking : Transfer could go till end, but error severity is
AnnaBridge 167:e84263d55307 451 to be evaluated by user : this concerns Frame Error, Parity Error or Noise Error in Interrupt mode reception .
AnnaBridge 167:e84263d55307 452 Received character is then retrieved and stored in Rx buffer, Error code is set to allow user to identify error type,
AnnaBridge 167:e84263d55307 453 and HAL_SMARTCARD_ErrorCallback() user callback is executed. Transfer is kept ongoing on SMARTCARD side.
AnnaBridge 167:e84263d55307 454 If user wants to abort it, Abort services should be called by user.
AnnaBridge 167:e84263d55307 455 (+) Error is considered as Blocking : Transfer could not be completed properly and is aborted.
AnnaBridge 167:e84263d55307 456 This concerns Frame Error in Interrupt mode tranmission, Overrun Error in Interrupt mode reception and all errors in DMA mode.
AnnaBridge 167:e84263d55307 457 Error code is set to allow user to identify error type, and HAL_SMARTCARD_ErrorCallback() user callback is executed.
AnnaBridge 167:e84263d55307 458
<> 144:ef7eb2e8f9f7 459 @endverbatim
<> 144:ef7eb2e8f9f7 460 * @{
<> 144:ef7eb2e8f9f7 461 */
<> 144:ef7eb2e8f9f7 462
<> 144:ef7eb2e8f9f7 463 /**
AnnaBridge 167:e84263d55307 464 * @brief Send an amount of data in blocking mode.
AnnaBridge 167:e84263d55307 465 * @param hsmartcard Pointer to a SMARTCARD_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 466 * the configuration information for the specified SMARTCARD module.
AnnaBridge 167:e84263d55307 467 * @param pData pointer to data buffer.
AnnaBridge 167:e84263d55307 468 * @param Size amount of data to be sent.
AnnaBridge 167:e84263d55307 469 * @param Timeout Timeout duration.
<> 144:ef7eb2e8f9f7 470 * @retval HAL status
<> 144:ef7eb2e8f9f7 471 */
<> 144:ef7eb2e8f9f7 472 HAL_StatusTypeDef HAL_SMARTCARD_Transmit(SMARTCARD_HandleTypeDef *hsmartcard, uint8_t *pData, uint16_t Size, uint32_t Timeout)
<> 144:ef7eb2e8f9f7 473 {
<> 144:ef7eb2e8f9f7 474 uint32_t tickstart = 0;
<> 144:ef7eb2e8f9f7 475
<> 144:ef7eb2e8f9f7 476 /* Check that a Tx process is not already ongoing */
<> 144:ef7eb2e8f9f7 477 if (hsmartcard->gState == HAL_SMARTCARD_STATE_READY)
<> 144:ef7eb2e8f9f7 478 {
<> 144:ef7eb2e8f9f7 479 if((pData == NULL) || (Size == 0))
<> 144:ef7eb2e8f9f7 480 {
<> 144:ef7eb2e8f9f7 481 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 482 }
<> 144:ef7eb2e8f9f7 483
<> 144:ef7eb2e8f9f7 484 /* Process Locked */
<> 144:ef7eb2e8f9f7 485 __HAL_LOCK(hsmartcard);
<> 144:ef7eb2e8f9f7 486
<> 144:ef7eb2e8f9f7 487 hsmartcard->gState = HAL_SMARTCARD_STATE_BUSY_TX;
<> 144:ef7eb2e8f9f7 488
<> 144:ef7eb2e8f9f7 489 /* Init tickstart for timeout managment*/
<> 144:ef7eb2e8f9f7 490 tickstart = HAL_GetTick();
<> 144:ef7eb2e8f9f7 491
<> 144:ef7eb2e8f9f7 492 /* Disable the Peripheral first to update mode for TX master */
<> 144:ef7eb2e8f9f7 493 CLEAR_BIT(hsmartcard->Instance->CR1, USART_CR1_UE);
<> 144:ef7eb2e8f9f7 494
<> 144:ef7eb2e8f9f7 495 /* Disable Rx, enable Tx */
<> 144:ef7eb2e8f9f7 496 CLEAR_BIT(hsmartcard->Instance->CR1, USART_CR1_RE);
<> 144:ef7eb2e8f9f7 497 SET_BIT(hsmartcard->Instance->RQR, SMARTCARD_RXDATA_FLUSH_REQUEST);
<> 144:ef7eb2e8f9f7 498 SET_BIT(hsmartcard->Instance->CR1, USART_CR1_TE);
<> 144:ef7eb2e8f9f7 499
<> 144:ef7eb2e8f9f7 500 /* Enable the Peripheral */
<> 144:ef7eb2e8f9f7 501 SET_BIT(hsmartcard->Instance->CR1, USART_CR1_UE);
<> 144:ef7eb2e8f9f7 502
<> 144:ef7eb2e8f9f7 503 hsmartcard->ErrorCode = HAL_SMARTCARD_ERROR_NONE;
<> 144:ef7eb2e8f9f7 504 hsmartcard->TxXferSize = Size;
<> 144:ef7eb2e8f9f7 505 hsmartcard->TxXferCount = Size;
<> 144:ef7eb2e8f9f7 506
<> 144:ef7eb2e8f9f7 507 while(hsmartcard->TxXferCount > 0)
<> 144:ef7eb2e8f9f7 508 {
<> 144:ef7eb2e8f9f7 509 hsmartcard->TxXferCount--;
<> 144:ef7eb2e8f9f7 510 if(SMARTCARD_WaitOnFlagUntilTimeout(hsmartcard, SMARTCARD_FLAG_TXE, RESET, tickstart, Timeout) != HAL_OK)
<> 144:ef7eb2e8f9f7 511 {
<> 144:ef7eb2e8f9f7 512 return HAL_TIMEOUT;
<> 144:ef7eb2e8f9f7 513 }
<> 144:ef7eb2e8f9f7 514 hsmartcard->Instance->TDR = (*pData++ & (uint8_t)0xFF);
<> 144:ef7eb2e8f9f7 515 }
<> 144:ef7eb2e8f9f7 516 if(SMARTCARD_WaitOnFlagUntilTimeout(hsmartcard, SMARTCARD_TRANSMISSION_COMPLETION_FLAG(hsmartcard), RESET, tickstart, Timeout) != HAL_OK)
<> 144:ef7eb2e8f9f7 517 {
<> 144:ef7eb2e8f9f7 518 return HAL_TIMEOUT;
<> 144:ef7eb2e8f9f7 519 }
<> 144:ef7eb2e8f9f7 520 /* Re-enable Rx at end of transmission if initial mode is Rx/Tx */
<> 144:ef7eb2e8f9f7 521 if(hsmartcard->Init.Mode == SMARTCARD_MODE_TX_RX)
<> 144:ef7eb2e8f9f7 522 {
<> 144:ef7eb2e8f9f7 523 /* Disable the Peripheral first to update modes */
<> 144:ef7eb2e8f9f7 524 CLEAR_BIT(hsmartcard->Instance->CR1, USART_CR1_UE);
<> 144:ef7eb2e8f9f7 525 SET_BIT(hsmartcard->Instance->CR1, USART_CR1_RE);
<> 144:ef7eb2e8f9f7 526 /* Enable the Peripheral */
<> 144:ef7eb2e8f9f7 527 SET_BIT(hsmartcard->Instance->CR1, USART_CR1_UE);
<> 144:ef7eb2e8f9f7 528 }
<> 144:ef7eb2e8f9f7 529
<> 144:ef7eb2e8f9f7 530 /* At end of Tx process, restore hsmartcard->gState to Ready */
<> 144:ef7eb2e8f9f7 531 hsmartcard->gState = HAL_SMARTCARD_STATE_READY;
<> 144:ef7eb2e8f9f7 532
<> 144:ef7eb2e8f9f7 533 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 534 __HAL_UNLOCK(hsmartcard);
<> 144:ef7eb2e8f9f7 535
<> 144:ef7eb2e8f9f7 536 return HAL_OK;
<> 144:ef7eb2e8f9f7 537 }
<> 144:ef7eb2e8f9f7 538 else
<> 144:ef7eb2e8f9f7 539 {
<> 144:ef7eb2e8f9f7 540 return HAL_BUSY;
<> 144:ef7eb2e8f9f7 541 }
<> 144:ef7eb2e8f9f7 542 }
<> 144:ef7eb2e8f9f7 543
<> 144:ef7eb2e8f9f7 544 /**
AnnaBridge 167:e84263d55307 545 * @brief Receive an amount of data in blocking mode.
AnnaBridge 167:e84263d55307 546 * @param hsmartcard Pointer to a SMARTCARD_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 547 * the configuration information for the specified SMARTCARD module.
AnnaBridge 167:e84263d55307 548 * @param pData pointer to data buffer.
AnnaBridge 167:e84263d55307 549 * @param Size amount of data to be received.
AnnaBridge 167:e84263d55307 550 * @param Timeout Timeout duration.
<> 144:ef7eb2e8f9f7 551 * @retval HAL status
<> 144:ef7eb2e8f9f7 552 */
<> 144:ef7eb2e8f9f7 553 HAL_StatusTypeDef HAL_SMARTCARD_Receive(SMARTCARD_HandleTypeDef *hsmartcard, uint8_t *pData, uint16_t Size, uint32_t Timeout)
<> 144:ef7eb2e8f9f7 554 {
<> 144:ef7eb2e8f9f7 555 uint32_t tickstart = 0;
<> 144:ef7eb2e8f9f7 556
<> 144:ef7eb2e8f9f7 557 /* Check that a Rx process is not already ongoing */
<> 144:ef7eb2e8f9f7 558 if(hsmartcard->RxState == HAL_SMARTCARD_STATE_READY)
<> 144:ef7eb2e8f9f7 559 {
<> 144:ef7eb2e8f9f7 560 if((pData == NULL) || (Size == 0))
<> 144:ef7eb2e8f9f7 561 {
<> 144:ef7eb2e8f9f7 562 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 563 }
<> 144:ef7eb2e8f9f7 564
<> 144:ef7eb2e8f9f7 565 /* Process Locked */
<> 144:ef7eb2e8f9f7 566 __HAL_LOCK(hsmartcard);
<> 144:ef7eb2e8f9f7 567
<> 144:ef7eb2e8f9f7 568 hsmartcard->ErrorCode = HAL_SMARTCARD_ERROR_NONE;
<> 144:ef7eb2e8f9f7 569 hsmartcard->RxState = HAL_SMARTCARD_STATE_BUSY_RX;
<> 144:ef7eb2e8f9f7 570
<> 144:ef7eb2e8f9f7 571 /* Init tickstart for timeout managment*/
<> 144:ef7eb2e8f9f7 572 tickstart = HAL_GetTick();
AnnaBridge 167:e84263d55307 573
<> 144:ef7eb2e8f9f7 574 hsmartcard->RxXferSize = Size;
<> 144:ef7eb2e8f9f7 575 hsmartcard->RxXferCount = Size;
<> 144:ef7eb2e8f9f7 576
<> 144:ef7eb2e8f9f7 577 /* Check the remain data to be received */
<> 144:ef7eb2e8f9f7 578 while(hsmartcard->RxXferCount > 0)
<> 144:ef7eb2e8f9f7 579 {
<> 144:ef7eb2e8f9f7 580 hsmartcard->RxXferCount--;
AnnaBridge 167:e84263d55307 581
<> 144:ef7eb2e8f9f7 582 if(SMARTCARD_WaitOnFlagUntilTimeout(hsmartcard, SMARTCARD_FLAG_RXNE, RESET, tickstart, Timeout) != HAL_OK)
<> 144:ef7eb2e8f9f7 583 {
<> 144:ef7eb2e8f9f7 584 return HAL_TIMEOUT;
<> 144:ef7eb2e8f9f7 585 }
<> 144:ef7eb2e8f9f7 586 *pData++ = (uint8_t)(hsmartcard->Instance->RDR & (uint8_t)0x00FF);
<> 144:ef7eb2e8f9f7 587 }
<> 144:ef7eb2e8f9f7 588
<> 144:ef7eb2e8f9f7 589 /* At end of Rx process, restore hsmartcard->RxState to Ready */
<> 144:ef7eb2e8f9f7 590 hsmartcard->RxState = HAL_SMARTCARD_STATE_READY;
<> 144:ef7eb2e8f9f7 591
<> 144:ef7eb2e8f9f7 592 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 593 __HAL_UNLOCK(hsmartcard);
<> 144:ef7eb2e8f9f7 594
<> 144:ef7eb2e8f9f7 595 return HAL_OK;
<> 144:ef7eb2e8f9f7 596 }
<> 144:ef7eb2e8f9f7 597 else
<> 144:ef7eb2e8f9f7 598 {
<> 144:ef7eb2e8f9f7 599 return HAL_BUSY;
<> 144:ef7eb2e8f9f7 600 }
<> 144:ef7eb2e8f9f7 601 }
<> 144:ef7eb2e8f9f7 602
<> 144:ef7eb2e8f9f7 603 /**
AnnaBridge 167:e84263d55307 604 * @brief Send an amount of data in interrupt mode.
AnnaBridge 167:e84263d55307 605 * @param hsmartcard Pointer to a SMARTCARD_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 606 * the configuration information for the specified SMARTCARD module.
AnnaBridge 167:e84263d55307 607 * @param pData pointer to data buffer.
AnnaBridge 167:e84263d55307 608 * @param Size amount of data to be sent.
<> 144:ef7eb2e8f9f7 609 * @retval HAL status
<> 144:ef7eb2e8f9f7 610 */
<> 144:ef7eb2e8f9f7 611 HAL_StatusTypeDef HAL_SMARTCARD_Transmit_IT(SMARTCARD_HandleTypeDef *hsmartcard, uint8_t *pData, uint16_t Size)
<> 144:ef7eb2e8f9f7 612 {
<> 144:ef7eb2e8f9f7 613 /* Check that a Tx process is not already ongoing */
<> 144:ef7eb2e8f9f7 614 if (hsmartcard->gState == HAL_SMARTCARD_STATE_READY)
<> 144:ef7eb2e8f9f7 615 {
<> 144:ef7eb2e8f9f7 616 if((pData == NULL) || (Size == 0))
<> 144:ef7eb2e8f9f7 617 {
<> 144:ef7eb2e8f9f7 618 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 619 }
<> 144:ef7eb2e8f9f7 620
<> 144:ef7eb2e8f9f7 621 /* Process Locked */
<> 144:ef7eb2e8f9f7 622 __HAL_LOCK(hsmartcard);
<> 144:ef7eb2e8f9f7 623
<> 144:ef7eb2e8f9f7 624 hsmartcard->ErrorCode = HAL_SMARTCARD_ERROR_NONE;
<> 144:ef7eb2e8f9f7 625 hsmartcard->gState = HAL_SMARTCARD_STATE_BUSY_TX;
<> 144:ef7eb2e8f9f7 626
<> 144:ef7eb2e8f9f7 627 hsmartcard->pTxBuffPtr = pData;
<> 144:ef7eb2e8f9f7 628 hsmartcard->TxXferSize = Size;
<> 144:ef7eb2e8f9f7 629 hsmartcard->TxXferCount = Size;
<> 144:ef7eb2e8f9f7 630
<> 144:ef7eb2e8f9f7 631 /* Disable the Peripheral first to update mode for TX master */
<> 144:ef7eb2e8f9f7 632 CLEAR_BIT(hsmartcard->Instance->CR1, USART_CR1_UE);
<> 144:ef7eb2e8f9f7 633
<> 144:ef7eb2e8f9f7 634 /* Disable Rx, enable Tx */
<> 144:ef7eb2e8f9f7 635 CLEAR_BIT(hsmartcard->Instance->CR1, USART_CR1_RE);
<> 144:ef7eb2e8f9f7 636 SET_BIT(hsmartcard->Instance->RQR, SMARTCARD_RXDATA_FLUSH_REQUEST);
<> 144:ef7eb2e8f9f7 637 SET_BIT(hsmartcard->Instance->CR1, USART_CR1_TE);
<> 144:ef7eb2e8f9f7 638
<> 144:ef7eb2e8f9f7 639 /* Enable the Peripheral */
<> 144:ef7eb2e8f9f7 640 SET_BIT(hsmartcard->Instance->CR1, USART_CR1_UE);
<> 144:ef7eb2e8f9f7 641
<> 144:ef7eb2e8f9f7 642 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 643 __HAL_UNLOCK(hsmartcard);
<> 144:ef7eb2e8f9f7 644
AnnaBridge 167:e84263d55307 645 /* Enable the SMARTCARD Error Interrupt: (Frame error) */
AnnaBridge 167:e84263d55307 646 SET_BIT(hsmartcard->Instance->CR3, USART_CR3_EIE);
AnnaBridge 167:e84263d55307 647
<> 144:ef7eb2e8f9f7 648 /* Enable the SMARTCARD Transmit Data Register Empty Interrupt */
AnnaBridge 167:e84263d55307 649 SET_BIT(hsmartcard->Instance->CR1, USART_CR1_TXEIE);
<> 144:ef7eb2e8f9f7 650
<> 144:ef7eb2e8f9f7 651 return HAL_OK;
<> 144:ef7eb2e8f9f7 652 }
<> 144:ef7eb2e8f9f7 653 else
<> 144:ef7eb2e8f9f7 654 {
<> 144:ef7eb2e8f9f7 655 return HAL_BUSY;
<> 144:ef7eb2e8f9f7 656 }
<> 144:ef7eb2e8f9f7 657 }
<> 144:ef7eb2e8f9f7 658
<> 144:ef7eb2e8f9f7 659 /**
AnnaBridge 167:e84263d55307 660 * @brief Receive an amount of data in interrupt mode.
AnnaBridge 167:e84263d55307 661 * @param hsmartcard Pointer to a SMARTCARD_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 662 * the configuration information for the specified SMARTCARD module.
AnnaBridge 167:e84263d55307 663 * @param pData pointer to data buffer.
AnnaBridge 167:e84263d55307 664 * @param Size amount of data to be received.
<> 144:ef7eb2e8f9f7 665 * @retval HAL status
<> 144:ef7eb2e8f9f7 666 */
<> 144:ef7eb2e8f9f7 667 HAL_StatusTypeDef HAL_SMARTCARD_Receive_IT(SMARTCARD_HandleTypeDef *hsmartcard, uint8_t *pData, uint16_t Size)
<> 144:ef7eb2e8f9f7 668 {
<> 144:ef7eb2e8f9f7 669 /* Check that a Rx process is not already ongoing */
<> 144:ef7eb2e8f9f7 670 if(hsmartcard->RxState == HAL_SMARTCARD_STATE_READY)
<> 144:ef7eb2e8f9f7 671 {
<> 144:ef7eb2e8f9f7 672 if((pData == NULL) || (Size == 0))
<> 144:ef7eb2e8f9f7 673 {
<> 144:ef7eb2e8f9f7 674 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 675 }
<> 144:ef7eb2e8f9f7 676
<> 144:ef7eb2e8f9f7 677 /* Process Locked */
<> 144:ef7eb2e8f9f7 678 __HAL_LOCK(hsmartcard);
<> 144:ef7eb2e8f9f7 679
<> 144:ef7eb2e8f9f7 680 hsmartcard->ErrorCode = HAL_SMARTCARD_ERROR_NONE;
<> 144:ef7eb2e8f9f7 681 hsmartcard->RxState = HAL_SMARTCARD_STATE_BUSY_RX;
<> 144:ef7eb2e8f9f7 682
<> 144:ef7eb2e8f9f7 683 hsmartcard->pRxBuffPtr = pData;
<> 144:ef7eb2e8f9f7 684 hsmartcard->RxXferSize = Size;
<> 144:ef7eb2e8f9f7 685 hsmartcard->RxXferCount = Size;
<> 144:ef7eb2e8f9f7 686
<> 144:ef7eb2e8f9f7 687 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 688 __HAL_UNLOCK(hsmartcard);
<> 144:ef7eb2e8f9f7 689
AnnaBridge 167:e84263d55307 690 /* Enable the SMARTCARD Parity Error and Data Register not empty Interrupts */
AnnaBridge 167:e84263d55307 691 SET_BIT(hsmartcard->Instance->CR1, USART_CR1_PEIE| USART_CR1_RXNEIE);
<> 144:ef7eb2e8f9f7 692
<> 144:ef7eb2e8f9f7 693 /* Enable the SMARTCARD Error Interrupt: (Frame error, noise error, overrun error) */
AnnaBridge 167:e84263d55307 694 SET_BIT(hsmartcard->Instance->CR3, USART_CR3_EIE);
<> 144:ef7eb2e8f9f7 695
<> 144:ef7eb2e8f9f7 696 return HAL_OK;
<> 144:ef7eb2e8f9f7 697 }
<> 144:ef7eb2e8f9f7 698 else
<> 144:ef7eb2e8f9f7 699 {
<> 144:ef7eb2e8f9f7 700 return HAL_BUSY;
<> 144:ef7eb2e8f9f7 701 }
<> 144:ef7eb2e8f9f7 702 }
<> 144:ef7eb2e8f9f7 703
<> 144:ef7eb2e8f9f7 704 /**
AnnaBridge 167:e84263d55307 705 * @brief Send an amount of data in DMA mode.
AnnaBridge 167:e84263d55307 706 * @param hsmartcard Pointer to a SMARTCARD_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 707 * the configuration information for the specified SMARTCARD module.
AnnaBridge 167:e84263d55307 708 * @param pData pointer to data buffer.
AnnaBridge 167:e84263d55307 709 * @param Size amount of data to be sent.
<> 144:ef7eb2e8f9f7 710 * @retval HAL status
<> 144:ef7eb2e8f9f7 711 */
<> 144:ef7eb2e8f9f7 712 HAL_StatusTypeDef HAL_SMARTCARD_Transmit_DMA(SMARTCARD_HandleTypeDef *hsmartcard, uint8_t *pData, uint16_t Size)
<> 144:ef7eb2e8f9f7 713 {
<> 144:ef7eb2e8f9f7 714 /* Check that a Tx process is not already ongoing */
<> 144:ef7eb2e8f9f7 715 if (hsmartcard->gState == HAL_SMARTCARD_STATE_READY)
<> 144:ef7eb2e8f9f7 716 {
<> 144:ef7eb2e8f9f7 717 if((pData == NULL) || (Size == 0))
<> 144:ef7eb2e8f9f7 718 {
<> 144:ef7eb2e8f9f7 719 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 720 }
<> 144:ef7eb2e8f9f7 721
<> 144:ef7eb2e8f9f7 722 /* Process Locked */
<> 144:ef7eb2e8f9f7 723 __HAL_LOCK(hsmartcard);
<> 144:ef7eb2e8f9f7 724
<> 144:ef7eb2e8f9f7 725 hsmartcard->gState = HAL_SMARTCARD_STATE_BUSY_TX;
<> 144:ef7eb2e8f9f7 726
<> 144:ef7eb2e8f9f7 727 hsmartcard->ErrorCode = HAL_SMARTCARD_ERROR_NONE;
<> 144:ef7eb2e8f9f7 728 hsmartcard->pTxBuffPtr = pData;
<> 144:ef7eb2e8f9f7 729 hsmartcard->TxXferSize = Size;
<> 144:ef7eb2e8f9f7 730 hsmartcard->TxXferCount = Size;
<> 144:ef7eb2e8f9f7 731
<> 144:ef7eb2e8f9f7 732 /* Disable the Peripheral first to update mode for TX master */
<> 144:ef7eb2e8f9f7 733 CLEAR_BIT(hsmartcard->Instance->CR1, USART_CR1_UE);
<> 144:ef7eb2e8f9f7 734
<> 144:ef7eb2e8f9f7 735 /* Disable Rx, enable Tx */
<> 144:ef7eb2e8f9f7 736 CLEAR_BIT(hsmartcard->Instance->CR1, USART_CR1_RE);
<> 144:ef7eb2e8f9f7 737 SET_BIT(hsmartcard->Instance->RQR, SMARTCARD_RXDATA_FLUSH_REQUEST);
<> 144:ef7eb2e8f9f7 738 SET_BIT(hsmartcard->Instance->CR1, USART_CR1_TE);
<> 144:ef7eb2e8f9f7 739
<> 144:ef7eb2e8f9f7 740 /* Enable the Peripheral */
<> 144:ef7eb2e8f9f7 741 SET_BIT(hsmartcard->Instance->CR1, USART_CR1_UE);
<> 144:ef7eb2e8f9f7 742
<> 144:ef7eb2e8f9f7 743 /* Set the SMARTCARD DMA transfer complete callback */
<> 144:ef7eb2e8f9f7 744 hsmartcard->hdmatx->XferCpltCallback = SMARTCARD_DMATransmitCplt;
<> 144:ef7eb2e8f9f7 745
<> 144:ef7eb2e8f9f7 746 /* Set the SMARTCARD error callback */
<> 144:ef7eb2e8f9f7 747 hsmartcard->hdmatx->XferErrorCallback = SMARTCARD_DMAError;
<> 144:ef7eb2e8f9f7 748
AnnaBridge 167:e84263d55307 749 /* Set the DMA abort callback */
AnnaBridge 167:e84263d55307 750 hsmartcard->hdmatx->XferAbortCallback = NULL;
AnnaBridge 167:e84263d55307 751
<> 144:ef7eb2e8f9f7 752 /* Enable the SMARTCARD transmit DMA channel */
AnnaBridge 167:e84263d55307 753 HAL_DMA_Start_IT(hsmartcard->hdmatx, (uint32_t)hsmartcard->pTxBuffPtr, (uint32_t)&hsmartcard->Instance->TDR, Size);
<> 144:ef7eb2e8f9f7 754
<> 144:ef7eb2e8f9f7 755 /* Clear the TC flag in the ICR register */
AnnaBridge 167:e84263d55307 756 CLEAR_BIT(hsmartcard->Instance->ICR, USART_ICR_TCCF);
AnnaBridge 167:e84263d55307 757
AnnaBridge 167:e84263d55307 758 /* Process Unlocked */
AnnaBridge 167:e84263d55307 759 __HAL_UNLOCK(hsmartcard);
AnnaBridge 167:e84263d55307 760
AnnaBridge 167:e84263d55307 761 /* Enable the UART Error Interrupt: (Frame error) */
AnnaBridge 167:e84263d55307 762 SET_BIT(hsmartcard->Instance->CR3, USART_CR3_EIE);
<> 144:ef7eb2e8f9f7 763
<> 144:ef7eb2e8f9f7 764 /* Enable the DMA transfer for transmit request by setting the DMAT bit
<> 144:ef7eb2e8f9f7 765 in the SMARTCARD associated USART CR3 register */
<> 144:ef7eb2e8f9f7 766 SET_BIT(hsmartcard->Instance->CR3, USART_CR3_DMAT);
<> 144:ef7eb2e8f9f7 767
<> 144:ef7eb2e8f9f7 768 return HAL_OK;
<> 144:ef7eb2e8f9f7 769 }
<> 144:ef7eb2e8f9f7 770 else
<> 144:ef7eb2e8f9f7 771 {
<> 144:ef7eb2e8f9f7 772 return HAL_BUSY;
<> 144:ef7eb2e8f9f7 773 }
<> 144:ef7eb2e8f9f7 774 }
<> 144:ef7eb2e8f9f7 775
<> 144:ef7eb2e8f9f7 776 /**
AnnaBridge 167:e84263d55307 777 * @brief Receive an amount of data in DMA mode.
AnnaBridge 167:e84263d55307 778 * @param hsmartcard Pointer to a SMARTCARD_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 779 * the configuration information for the specified SMARTCARD module.
AnnaBridge 167:e84263d55307 780 * @param pData pointer to data buffer.
AnnaBridge 167:e84263d55307 781 * @param Size amount of data to be received.
<> 144:ef7eb2e8f9f7 782 * @note The SMARTCARD-associated USART parity is enabled (PCE = 1),
<> 144:ef7eb2e8f9f7 783 * the received data contain the parity bit (MSB position).
<> 144:ef7eb2e8f9f7 784 * @retval HAL status
<> 144:ef7eb2e8f9f7 785 */
<> 144:ef7eb2e8f9f7 786 HAL_StatusTypeDef HAL_SMARTCARD_Receive_DMA(SMARTCARD_HandleTypeDef *hsmartcard, uint8_t *pData, uint16_t Size)
<> 144:ef7eb2e8f9f7 787 {
<> 144:ef7eb2e8f9f7 788 /* Check that a Rx process is not already ongoing */
<> 144:ef7eb2e8f9f7 789 if(hsmartcard->RxState == HAL_SMARTCARD_STATE_READY)
<> 144:ef7eb2e8f9f7 790 {
<> 144:ef7eb2e8f9f7 791 if((pData == NULL) || (Size == 0))
<> 144:ef7eb2e8f9f7 792 {
<> 144:ef7eb2e8f9f7 793 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 794 }
<> 144:ef7eb2e8f9f7 795
<> 144:ef7eb2e8f9f7 796 /* Process Locked */
<> 144:ef7eb2e8f9f7 797 __HAL_LOCK(hsmartcard);
<> 144:ef7eb2e8f9f7 798
<> 144:ef7eb2e8f9f7 799 hsmartcard->ErrorCode = HAL_SMARTCARD_ERROR_NONE;
<> 144:ef7eb2e8f9f7 800 hsmartcard->RxState = HAL_SMARTCARD_STATE_BUSY_RX;
<> 144:ef7eb2e8f9f7 801
<> 144:ef7eb2e8f9f7 802 hsmartcard->pRxBuffPtr = pData;
<> 144:ef7eb2e8f9f7 803 hsmartcard->RxXferSize = Size;
<> 144:ef7eb2e8f9f7 804
<> 144:ef7eb2e8f9f7 805 /* Set the SMARTCARD DMA transfer complete callback */
<> 144:ef7eb2e8f9f7 806 hsmartcard->hdmarx->XferCpltCallback = SMARTCARD_DMAReceiveCplt;
<> 144:ef7eb2e8f9f7 807
<> 144:ef7eb2e8f9f7 808 /* Set the SMARTCARD DMA error callback */
<> 144:ef7eb2e8f9f7 809 hsmartcard->hdmarx->XferErrorCallback = SMARTCARD_DMAError;
<> 144:ef7eb2e8f9f7 810
AnnaBridge 167:e84263d55307 811 /* Set the DMA abort callback */
AnnaBridge 167:e84263d55307 812 hsmartcard->hdmarx->XferAbortCallback = NULL;
AnnaBridge 167:e84263d55307 813
<> 144:ef7eb2e8f9f7 814 /* Enable the DMA channel */
AnnaBridge 167:e84263d55307 815 HAL_DMA_Start_IT(hsmartcard->hdmarx, (uint32_t)&hsmartcard->Instance->RDR, (uint32_t)hsmartcard->pRxBuffPtr, Size);
AnnaBridge 167:e84263d55307 816
AnnaBridge 167:e84263d55307 817 /* Process Unlocked */
AnnaBridge 167:e84263d55307 818 __HAL_UNLOCK(hsmartcard);
AnnaBridge 167:e84263d55307 819
AnnaBridge 167:e84263d55307 820 /* Enable the UART Parity Error Interrupt */
AnnaBridge 167:e84263d55307 821 SET_BIT(hsmartcard->Instance->CR1, USART_CR1_PEIE);
AnnaBridge 167:e84263d55307 822
AnnaBridge 167:e84263d55307 823 /* Enable the UART Error Interrupt: (Frame error, noise error, overrun error) */
AnnaBridge 167:e84263d55307 824 SET_BIT(hsmartcard->Instance->CR3, USART_CR3_EIE);
<> 144:ef7eb2e8f9f7 825
<> 144:ef7eb2e8f9f7 826 /* Enable the DMA transfer for the receiver request by setting the DMAR bit
<> 144:ef7eb2e8f9f7 827 in the SMARTCARD associated USART CR3 register */
<> 144:ef7eb2e8f9f7 828 SET_BIT(hsmartcard->Instance->CR3, USART_CR3_DMAR);
<> 144:ef7eb2e8f9f7 829
<> 144:ef7eb2e8f9f7 830 return HAL_OK;
<> 144:ef7eb2e8f9f7 831 }
<> 144:ef7eb2e8f9f7 832 else
<> 144:ef7eb2e8f9f7 833 {
<> 144:ef7eb2e8f9f7 834 return HAL_BUSY;
<> 144:ef7eb2e8f9f7 835 }
<> 144:ef7eb2e8f9f7 836 }
<> 144:ef7eb2e8f9f7 837
<> 144:ef7eb2e8f9f7 838 /**
AnnaBridge 167:e84263d55307 839 * @brief Abort ongoing transfers (blocking mode).
AnnaBridge 167:e84263d55307 840 * @param hsmartcard Pointer to a SMARTCARD_HandleTypeDef structure that contains
AnnaBridge 167:e84263d55307 841 * the configuration information for the specified SMARTCARD module.
AnnaBridge 167:e84263d55307 842 * @note This procedure could be used for aborting any ongoing transfer started in Interrupt or DMA mode.
AnnaBridge 167:e84263d55307 843 * This procedure performs following operations :
AnnaBridge 167:e84263d55307 844 * - Disable SMARTCARD Interrupts (Tx and Rx)
AnnaBridge 167:e84263d55307 845 * - Disable the DMA transfer in the peripheral register (if enabled)
AnnaBridge 167:e84263d55307 846 * - Abort DMA transfer by calling HAL_DMA_Abort (in case of transfer in DMA mode)
AnnaBridge 167:e84263d55307 847 * - Set handle State to READY
AnnaBridge 167:e84263d55307 848 * @note This procedure is executed in blocking mode : when exiting function, Abort is considered as completed.
AnnaBridge 167:e84263d55307 849 * @retval HAL status
AnnaBridge 167:e84263d55307 850 */
AnnaBridge 167:e84263d55307 851 HAL_StatusTypeDef HAL_SMARTCARD_Abort(SMARTCARD_HandleTypeDef *hsmartcard)
AnnaBridge 167:e84263d55307 852 {
AnnaBridge 167:e84263d55307 853 /* Disable RTOIE, EOBIE, TXEIE, TCIE, RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts */
AnnaBridge 167:e84263d55307 854 CLEAR_BIT(hsmartcard->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE | USART_CR1_TXEIE | USART_CR1_TCIE | USART_CR1_RTOIE | USART_CR1_EOBIE));
AnnaBridge 167:e84263d55307 855 CLEAR_BIT(hsmartcard->Instance->CR3, USART_CR3_EIE);
AnnaBridge 167:e84263d55307 856
AnnaBridge 167:e84263d55307 857 /* Disable the SMARTCARD DMA Tx request if enabled */
AnnaBridge 167:e84263d55307 858 if (HAL_IS_BIT_SET(hsmartcard->Instance->CR3, USART_CR3_DMAT))
AnnaBridge 167:e84263d55307 859 {
AnnaBridge 167:e84263d55307 860 CLEAR_BIT(hsmartcard->Instance->CR3, USART_CR3_DMAT);
AnnaBridge 167:e84263d55307 861
AnnaBridge 167:e84263d55307 862 /* Abort the SMARTCARD DMA Tx channel : use blocking DMA Abort API (no callback) */
AnnaBridge 167:e84263d55307 863 if(hsmartcard->hdmatx != NULL)
AnnaBridge 167:e84263d55307 864 {
AnnaBridge 167:e84263d55307 865 /* Set the SMARTCARD DMA Abort callback to Null.
AnnaBridge 167:e84263d55307 866 No call back execution at end of DMA abort procedure */
AnnaBridge 167:e84263d55307 867 hsmartcard->hdmatx->XferAbortCallback = NULL;
AnnaBridge 167:e84263d55307 868
AnnaBridge 167:e84263d55307 869 HAL_DMA_Abort(hsmartcard->hdmatx);
AnnaBridge 167:e84263d55307 870 }
AnnaBridge 167:e84263d55307 871 }
AnnaBridge 167:e84263d55307 872
AnnaBridge 167:e84263d55307 873 /* Disable the SMARTCARD DMA Rx request if enabled */
AnnaBridge 167:e84263d55307 874 if (HAL_IS_BIT_SET(hsmartcard->Instance->CR3, USART_CR3_DMAR))
AnnaBridge 167:e84263d55307 875 {
AnnaBridge 167:e84263d55307 876 CLEAR_BIT(hsmartcard->Instance->CR3, USART_CR3_DMAR);
AnnaBridge 167:e84263d55307 877
AnnaBridge 167:e84263d55307 878 /* Abort the SMARTCARD DMA Rx channel : use blocking DMA Abort API (no callback) */
AnnaBridge 167:e84263d55307 879 if(hsmartcard->hdmarx != NULL)
AnnaBridge 167:e84263d55307 880 {
AnnaBridge 167:e84263d55307 881 /* Set the SMARTCARD DMA Abort callback to Null.
AnnaBridge 167:e84263d55307 882 No call back execution at end of DMA abort procedure */
AnnaBridge 167:e84263d55307 883 hsmartcard->hdmarx->XferAbortCallback = NULL;
AnnaBridge 167:e84263d55307 884
AnnaBridge 167:e84263d55307 885 HAL_DMA_Abort(hsmartcard->hdmarx);
AnnaBridge 167:e84263d55307 886 }
AnnaBridge 167:e84263d55307 887 }
AnnaBridge 167:e84263d55307 888
AnnaBridge 167:e84263d55307 889 /* Reset Tx and Rx transfer counters */
AnnaBridge 167:e84263d55307 890 hsmartcard->TxXferCount = 0;
AnnaBridge 167:e84263d55307 891 hsmartcard->RxXferCount = 0;
AnnaBridge 167:e84263d55307 892
AnnaBridge 167:e84263d55307 893 /* Clear the Error flags in the ICR register */
AnnaBridge 167:e84263d55307 894 __HAL_SMARTCARD_CLEAR_FLAG(hsmartcard, SMARTCARD_CLEAR_OREF | SMARTCARD_CLEAR_NEF | SMARTCARD_CLEAR_PEF | SMARTCARD_CLEAR_FEF | SMARTCARD_CLEAR_RTOF | SMARTCARD_CLEAR_EOBF);
AnnaBridge 167:e84263d55307 895
AnnaBridge 167:e84263d55307 896 /* Restore hsmartcard->gState and hsmartcard->RxState to Ready */
AnnaBridge 167:e84263d55307 897 hsmartcard->gState = HAL_SMARTCARD_STATE_READY;
AnnaBridge 167:e84263d55307 898 hsmartcard->RxState = HAL_SMARTCARD_STATE_READY;
AnnaBridge 167:e84263d55307 899
AnnaBridge 167:e84263d55307 900 /* Reset Handle ErrorCode to No Error */
AnnaBridge 167:e84263d55307 901 hsmartcard->ErrorCode = HAL_SMARTCARD_ERROR_NONE;
AnnaBridge 167:e84263d55307 902
AnnaBridge 167:e84263d55307 903 return HAL_OK;
AnnaBridge 167:e84263d55307 904 }
AnnaBridge 167:e84263d55307 905
AnnaBridge 167:e84263d55307 906 /**
AnnaBridge 167:e84263d55307 907 * @brief Abort ongoing Transmit transfer (blocking mode).
AnnaBridge 167:e84263d55307 908 * @param hsmartcard Pointer to a SMARTCARD_HandleTypeDef structure that contains
AnnaBridge 167:e84263d55307 909 * the configuration information for the specified SMARTCARD module.
AnnaBridge 167:e84263d55307 910 * @note This procedure could be used for aborting any ongoing Tx transfer started in Interrupt or DMA mode.
AnnaBridge 167:e84263d55307 911 * This procedure performs following operations :
AnnaBridge 167:e84263d55307 912 * - Disable SMARTCARD Interrupts (Tx)
AnnaBridge 167:e84263d55307 913 * - Disable the DMA transfer in the peripheral register (if enabled)
AnnaBridge 167:e84263d55307 914 * - Abort DMA transfer by calling HAL_DMA_Abort (in case of transfer in DMA mode)
AnnaBridge 167:e84263d55307 915 * - Set handle State to READY
AnnaBridge 167:e84263d55307 916 * @note This procedure is executed in blocking mode : when exiting function, Abort is considered as completed.
AnnaBridge 167:e84263d55307 917 * @retval HAL status
AnnaBridge 167:e84263d55307 918 */
AnnaBridge 167:e84263d55307 919 HAL_StatusTypeDef HAL_SMARTCARD_AbortTransmit(SMARTCARD_HandleTypeDef *hsmartcard)
AnnaBridge 167:e84263d55307 920 {
AnnaBridge 167:e84263d55307 921 /* Disable TXEIE and TCIE interrupts */
AnnaBridge 167:e84263d55307 922 CLEAR_BIT(hsmartcard->Instance->CR1, (USART_CR1_TXEIE | USART_CR1_TCIE));
AnnaBridge 167:e84263d55307 923
AnnaBridge 167:e84263d55307 924 /* Check if a receive process is ongoing or not. If not disable ERR IT */
AnnaBridge 167:e84263d55307 925 if(hsmartcard->RxState == HAL_SMARTCARD_STATE_READY)
AnnaBridge 167:e84263d55307 926 {
AnnaBridge 167:e84263d55307 927 /* Disable the SMARTCARD Error Interrupt: (Frame error) */
AnnaBridge 167:e84263d55307 928 CLEAR_BIT(hsmartcard->Instance->CR3, USART_CR3_EIE);
AnnaBridge 167:e84263d55307 929 }
AnnaBridge 167:e84263d55307 930
AnnaBridge 167:e84263d55307 931 /* Disable the SMARTCARD DMA Tx request if enabled */
AnnaBridge 167:e84263d55307 932 if (HAL_IS_BIT_SET(hsmartcard->Instance->CR3, USART_CR3_DMAT))
AnnaBridge 167:e84263d55307 933 {
AnnaBridge 167:e84263d55307 934 CLEAR_BIT(hsmartcard->Instance->CR3, USART_CR3_DMAT);
AnnaBridge 167:e84263d55307 935
AnnaBridge 167:e84263d55307 936 /* Abort the SMARTCARD DMA Tx channel : use blocking DMA Abort API (no callback) */
AnnaBridge 167:e84263d55307 937 if(hsmartcard->hdmatx != NULL)
AnnaBridge 167:e84263d55307 938 {
AnnaBridge 167:e84263d55307 939 /* Set the SMARTCARD DMA Abort callback to Null.
AnnaBridge 167:e84263d55307 940 No call back execution at end of DMA abort procedure */
AnnaBridge 167:e84263d55307 941 hsmartcard->hdmatx->XferAbortCallback = NULL;
AnnaBridge 167:e84263d55307 942
AnnaBridge 167:e84263d55307 943 HAL_DMA_Abort(hsmartcard->hdmatx);
AnnaBridge 167:e84263d55307 944 }
AnnaBridge 167:e84263d55307 945 }
AnnaBridge 167:e84263d55307 946
AnnaBridge 167:e84263d55307 947 /* Reset Tx transfer counter */
AnnaBridge 167:e84263d55307 948 hsmartcard->TxXferCount = 0;
AnnaBridge 167:e84263d55307 949
AnnaBridge 167:e84263d55307 950 /* Clear the Error flags in the ICR register */
AnnaBridge 167:e84263d55307 951 __HAL_SMARTCARD_CLEAR_FLAG(hsmartcard, SMARTCARD_CLEAR_FEF);
AnnaBridge 167:e84263d55307 952
AnnaBridge 167:e84263d55307 953 /* Restore hsmartcard->gState to Ready */
AnnaBridge 167:e84263d55307 954 hsmartcard->gState = HAL_SMARTCARD_STATE_READY;
AnnaBridge 167:e84263d55307 955
AnnaBridge 167:e84263d55307 956 return HAL_OK;
AnnaBridge 167:e84263d55307 957 }
AnnaBridge 167:e84263d55307 958
AnnaBridge 167:e84263d55307 959 /**
AnnaBridge 167:e84263d55307 960 * @brief Abort ongoing Receive transfer (blocking mode).
AnnaBridge 167:e84263d55307 961 * @param hsmartcard Pointer to a SMARTCARD_HandleTypeDef structure that contains
AnnaBridge 167:e84263d55307 962 * the configuration information for the specified SMARTCARD module.
AnnaBridge 167:e84263d55307 963 * @note This procedure could be used for aborting any ongoing Rx transfer started in Interrupt or DMA mode.
AnnaBridge 167:e84263d55307 964 * This procedure performs following operations :
AnnaBridge 167:e84263d55307 965 * - Disable SMARTCARD Interrupts (Rx)
AnnaBridge 167:e84263d55307 966 * - Disable the DMA transfer in the peripheral register (if enabled)
AnnaBridge 167:e84263d55307 967 * - Abort DMA transfer by calling HAL_DMA_Abort (in case of transfer in DMA mode)
AnnaBridge 167:e84263d55307 968 * - Set handle State to READY
AnnaBridge 167:e84263d55307 969 * @note This procedure is executed in blocking mode : when exiting function, Abort is considered as completed.
AnnaBridge 167:e84263d55307 970 * @retval HAL status
AnnaBridge 167:e84263d55307 971 */
AnnaBridge 167:e84263d55307 972 HAL_StatusTypeDef HAL_SMARTCARD_AbortReceive(SMARTCARD_HandleTypeDef *hsmartcard)
AnnaBridge 167:e84263d55307 973 {
AnnaBridge 167:e84263d55307 974 /* Disable RTOIE, EOBIE, RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts */
AnnaBridge 167:e84263d55307 975 CLEAR_BIT(hsmartcard->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE | USART_CR1_RTOIE | USART_CR1_EOBIE));
AnnaBridge 167:e84263d55307 976
AnnaBridge 167:e84263d55307 977 /* Check if a Transmit process is ongoing or not. If not disable ERR IT */
AnnaBridge 167:e84263d55307 978 if(hsmartcard->gState == HAL_SMARTCARD_STATE_READY)
AnnaBridge 167:e84263d55307 979 {
AnnaBridge 167:e84263d55307 980 /* Disable the SMARTCARD Error Interrupt: (Frame error) */
AnnaBridge 167:e84263d55307 981 CLEAR_BIT(hsmartcard->Instance->CR3, USART_CR3_EIE);
AnnaBridge 167:e84263d55307 982 }
AnnaBridge 167:e84263d55307 983
AnnaBridge 167:e84263d55307 984 /* Disable the SMARTCARD DMA Rx request if enabled */
AnnaBridge 167:e84263d55307 985 if (HAL_IS_BIT_SET(hsmartcard->Instance->CR3, USART_CR3_DMAR))
AnnaBridge 167:e84263d55307 986 {
AnnaBridge 167:e84263d55307 987 CLEAR_BIT(hsmartcard->Instance->CR3, USART_CR3_DMAR);
AnnaBridge 167:e84263d55307 988
AnnaBridge 167:e84263d55307 989 /* Abort the SMARTCARD DMA Rx channel : use blocking DMA Abort API (no callback) */
AnnaBridge 167:e84263d55307 990 if(hsmartcard->hdmarx != NULL)
AnnaBridge 167:e84263d55307 991 {
AnnaBridge 167:e84263d55307 992 /* Set the SMARTCARD DMA Abort callback to Null.
AnnaBridge 167:e84263d55307 993 No call back execution at end of DMA abort procedure */
AnnaBridge 167:e84263d55307 994 hsmartcard->hdmarx->XferAbortCallback = NULL;
AnnaBridge 167:e84263d55307 995
AnnaBridge 167:e84263d55307 996 HAL_DMA_Abort(hsmartcard->hdmarx);
AnnaBridge 167:e84263d55307 997 }
AnnaBridge 167:e84263d55307 998 }
AnnaBridge 167:e84263d55307 999
AnnaBridge 167:e84263d55307 1000 /* Reset Rx transfer counter */
AnnaBridge 167:e84263d55307 1001 hsmartcard->RxXferCount = 0;
AnnaBridge 167:e84263d55307 1002
AnnaBridge 167:e84263d55307 1003 /* Clear the Error flags in the ICR register */
AnnaBridge 167:e84263d55307 1004 __HAL_SMARTCARD_CLEAR_FLAG(hsmartcard, SMARTCARD_CLEAR_OREF | SMARTCARD_CLEAR_NEF | SMARTCARD_CLEAR_PEF | SMARTCARD_CLEAR_FEF | SMARTCARD_CLEAR_RTOF | SMARTCARD_CLEAR_EOBF);
AnnaBridge 167:e84263d55307 1005
AnnaBridge 167:e84263d55307 1006 /* Restore hsmartcard->RxState to Ready */
AnnaBridge 167:e84263d55307 1007 hsmartcard->RxState = HAL_SMARTCARD_STATE_READY;
AnnaBridge 167:e84263d55307 1008
AnnaBridge 167:e84263d55307 1009 return HAL_OK;
AnnaBridge 167:e84263d55307 1010 }
AnnaBridge 167:e84263d55307 1011
AnnaBridge 167:e84263d55307 1012 /**
AnnaBridge 167:e84263d55307 1013 * @brief Abort ongoing transfers (Interrupt mode).
AnnaBridge 167:e84263d55307 1014 * @param hsmartcard Pointer to a SMARTCARD_HandleTypeDef structure that contains
AnnaBridge 167:e84263d55307 1015 * the configuration information for the specified SMARTCARD module.
AnnaBridge 167:e84263d55307 1016 * @note This procedure could be used for aborting any ongoing transfer started in Interrupt or DMA mode.
AnnaBridge 167:e84263d55307 1017 * This procedure performs following operations :
AnnaBridge 167:e84263d55307 1018 * - Disable SMARTCARD Interrupts (Tx and Rx)
AnnaBridge 167:e84263d55307 1019 * - Disable the DMA transfer in the peripheral register (if enabled)
AnnaBridge 167:e84263d55307 1020 * - Abort DMA transfer by calling HAL_DMA_Abort_IT (in case of transfer in DMA mode)
AnnaBridge 167:e84263d55307 1021 * - Set handle State to READY
AnnaBridge 167:e84263d55307 1022 * - At abort completion, call user abort complete callback
AnnaBridge 167:e84263d55307 1023 * @note This procedure is executed in Interrupt mode, meaning that abort procedure could be
AnnaBridge 167:e84263d55307 1024 * considered as completed only when user abort complete callback is executed (not when exiting function).
AnnaBridge 167:e84263d55307 1025 * @retval HAL status
AnnaBridge 167:e84263d55307 1026 */
AnnaBridge 167:e84263d55307 1027 HAL_StatusTypeDef HAL_SMARTCARD_Abort_IT(SMARTCARD_HandleTypeDef *hsmartcard)
AnnaBridge 167:e84263d55307 1028 {
AnnaBridge 167:e84263d55307 1029 uint32_t abortcplt = 1;
AnnaBridge 167:e84263d55307 1030
AnnaBridge 167:e84263d55307 1031 /* Disable RTOIE, EOBIE, TXEIE, TCIE, RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts */
AnnaBridge 167:e84263d55307 1032 CLEAR_BIT(hsmartcard->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE | USART_CR1_TXEIE | USART_CR1_TCIE | USART_CR1_RTOIE | USART_CR1_EOBIE));
AnnaBridge 167:e84263d55307 1033 CLEAR_BIT(hsmartcard->Instance->CR3, USART_CR3_EIE);
AnnaBridge 167:e84263d55307 1034
AnnaBridge 167:e84263d55307 1035 /* If DMA Tx and/or DMA Rx Handles are associated to SMARTCARD Handle, DMA Abort complete callbacks should be initialised
AnnaBridge 167:e84263d55307 1036 before any call to DMA Abort functions */
AnnaBridge 167:e84263d55307 1037 /* DMA Tx Handle is valid */
AnnaBridge 167:e84263d55307 1038 if(hsmartcard->hdmatx != NULL)
AnnaBridge 167:e84263d55307 1039 {
AnnaBridge 167:e84263d55307 1040 /* Set DMA Abort Complete callback if SMARTCARD DMA Tx request if enabled.
AnnaBridge 167:e84263d55307 1041 Otherwise, set it to NULL */
AnnaBridge 167:e84263d55307 1042 if(HAL_IS_BIT_SET(hsmartcard->Instance->CR3, USART_CR3_DMAT))
AnnaBridge 167:e84263d55307 1043 {
AnnaBridge 167:e84263d55307 1044 hsmartcard->hdmatx->XferAbortCallback = SMARTCARD_DMATxAbortCallback;
AnnaBridge 167:e84263d55307 1045 }
AnnaBridge 167:e84263d55307 1046 else
AnnaBridge 167:e84263d55307 1047 {
AnnaBridge 167:e84263d55307 1048 hsmartcard->hdmatx->XferAbortCallback = NULL;
AnnaBridge 167:e84263d55307 1049 }
AnnaBridge 167:e84263d55307 1050 }
AnnaBridge 167:e84263d55307 1051 /* DMA Rx Handle is valid */
AnnaBridge 167:e84263d55307 1052 if(hsmartcard->hdmarx != NULL)
AnnaBridge 167:e84263d55307 1053 {
AnnaBridge 167:e84263d55307 1054 /* Set DMA Abort Complete callback if SMARTCARD DMA Rx request if enabled.
AnnaBridge 167:e84263d55307 1055 Otherwise, set it to NULL */
AnnaBridge 167:e84263d55307 1056 if(HAL_IS_BIT_SET(hsmartcard->Instance->CR3, USART_CR3_DMAR))
AnnaBridge 167:e84263d55307 1057 {
AnnaBridge 167:e84263d55307 1058 hsmartcard->hdmarx->XferAbortCallback = SMARTCARD_DMARxAbortCallback;
AnnaBridge 167:e84263d55307 1059 }
AnnaBridge 167:e84263d55307 1060 else
AnnaBridge 167:e84263d55307 1061 {
AnnaBridge 167:e84263d55307 1062 hsmartcard->hdmarx->XferAbortCallback = NULL;
AnnaBridge 167:e84263d55307 1063 }
AnnaBridge 167:e84263d55307 1064 }
AnnaBridge 167:e84263d55307 1065
AnnaBridge 167:e84263d55307 1066 /* Disable the SMARTCARD DMA Tx request if enabled */
AnnaBridge 167:e84263d55307 1067 if(HAL_IS_BIT_SET(hsmartcard->Instance->CR3, USART_CR3_DMAT))
AnnaBridge 167:e84263d55307 1068 {
AnnaBridge 167:e84263d55307 1069 /* Disable DMA Tx at UART level */
AnnaBridge 167:e84263d55307 1070 CLEAR_BIT(hsmartcard->Instance->CR3, USART_CR3_DMAT);
AnnaBridge 167:e84263d55307 1071
AnnaBridge 167:e84263d55307 1072 /* Abort the SMARTCARD DMA Tx channel : use non blocking DMA Abort API (callback) */
AnnaBridge 167:e84263d55307 1073 if(hsmartcard->hdmatx != NULL)
AnnaBridge 167:e84263d55307 1074 {
AnnaBridge 167:e84263d55307 1075 /* SMARTCARD Tx DMA Abort callback has already been initialised :
AnnaBridge 167:e84263d55307 1076 will lead to call HAL_SMARTCARD_AbortCpltCallback() at end of DMA abort procedure */
AnnaBridge 167:e84263d55307 1077
AnnaBridge 167:e84263d55307 1078 /* Abort DMA TX */
AnnaBridge 167:e84263d55307 1079 if(HAL_DMA_Abort_IT(hsmartcard->hdmatx) != HAL_OK)
AnnaBridge 167:e84263d55307 1080 {
AnnaBridge 167:e84263d55307 1081 hsmartcard->hdmatx->XferAbortCallback = NULL;
AnnaBridge 167:e84263d55307 1082 }
AnnaBridge 167:e84263d55307 1083 else
AnnaBridge 167:e84263d55307 1084 {
AnnaBridge 167:e84263d55307 1085 abortcplt = 0;
AnnaBridge 167:e84263d55307 1086 }
AnnaBridge 167:e84263d55307 1087 }
AnnaBridge 167:e84263d55307 1088 }
AnnaBridge 167:e84263d55307 1089
AnnaBridge 167:e84263d55307 1090 /* Disable the SMARTCARD DMA Rx request if enabled */
AnnaBridge 167:e84263d55307 1091 if (HAL_IS_BIT_SET(hsmartcard->Instance->CR3, USART_CR3_DMAR))
AnnaBridge 167:e84263d55307 1092 {
AnnaBridge 167:e84263d55307 1093 CLEAR_BIT(hsmartcard->Instance->CR3, USART_CR3_DMAR);
AnnaBridge 167:e84263d55307 1094
AnnaBridge 167:e84263d55307 1095 /* Abort the SMARTCARD DMA Rx channel : use non blocking DMA Abort API (callback) */
AnnaBridge 167:e84263d55307 1096 if(hsmartcard->hdmarx != NULL)
AnnaBridge 167:e84263d55307 1097 {
AnnaBridge 167:e84263d55307 1098 /* SMARTCARD Rx DMA Abort callback has already been initialised :
AnnaBridge 167:e84263d55307 1099 will lead to call HAL_SMARTCARD_AbortCpltCallback() at end of DMA abort procedure */
AnnaBridge 167:e84263d55307 1100
AnnaBridge 167:e84263d55307 1101 /* Abort DMA RX */
AnnaBridge 167:e84263d55307 1102 if(HAL_DMA_Abort_IT(hsmartcard->hdmarx) != HAL_OK)
AnnaBridge 167:e84263d55307 1103 {
AnnaBridge 167:e84263d55307 1104 hsmartcard->hdmarx->XferAbortCallback = NULL;
AnnaBridge 167:e84263d55307 1105 abortcplt = 1;
AnnaBridge 167:e84263d55307 1106 }
AnnaBridge 167:e84263d55307 1107 else
AnnaBridge 167:e84263d55307 1108 {
AnnaBridge 167:e84263d55307 1109 abortcplt = 0;
AnnaBridge 167:e84263d55307 1110 }
AnnaBridge 167:e84263d55307 1111 }
AnnaBridge 167:e84263d55307 1112 }
AnnaBridge 167:e84263d55307 1113
AnnaBridge 167:e84263d55307 1114 /* if no DMA abort complete callback execution is required => call user Abort Complete callback */
AnnaBridge 167:e84263d55307 1115 if (abortcplt == 1)
AnnaBridge 167:e84263d55307 1116 {
AnnaBridge 167:e84263d55307 1117 /* Reset Tx and Rx transfer counters */
AnnaBridge 167:e84263d55307 1118 hsmartcard->TxXferCount = 0;
AnnaBridge 167:e84263d55307 1119 hsmartcard->RxXferCount = 0;
AnnaBridge 167:e84263d55307 1120
AnnaBridge 167:e84263d55307 1121 /* Reset errorCode */
AnnaBridge 167:e84263d55307 1122 hsmartcard->ErrorCode = HAL_SMARTCARD_ERROR_NONE;
AnnaBridge 167:e84263d55307 1123
AnnaBridge 167:e84263d55307 1124 /* Clear the Error flags in the ICR register */
AnnaBridge 167:e84263d55307 1125 __HAL_SMARTCARD_CLEAR_FLAG(hsmartcard, SMARTCARD_CLEAR_OREF | SMARTCARD_CLEAR_NEF | SMARTCARD_CLEAR_PEF | SMARTCARD_CLEAR_FEF | SMARTCARD_CLEAR_RTOF | SMARTCARD_CLEAR_EOBF);
AnnaBridge 167:e84263d55307 1126
AnnaBridge 167:e84263d55307 1127 /* Restore hsmartcard->gState and hsmartcard->RxState to Ready */
AnnaBridge 167:e84263d55307 1128 hsmartcard->gState = HAL_SMARTCARD_STATE_READY;
AnnaBridge 167:e84263d55307 1129 hsmartcard->RxState = HAL_SMARTCARD_STATE_READY;
AnnaBridge 167:e84263d55307 1130
AnnaBridge 167:e84263d55307 1131 /* As no DMA to be aborted, call directly user Abort complete callback */
AnnaBridge 167:e84263d55307 1132 HAL_SMARTCARD_AbortCpltCallback(hsmartcard);
AnnaBridge 167:e84263d55307 1133 }
AnnaBridge 167:e84263d55307 1134
AnnaBridge 167:e84263d55307 1135 return HAL_OK;
AnnaBridge 167:e84263d55307 1136 }
AnnaBridge 167:e84263d55307 1137
AnnaBridge 167:e84263d55307 1138 /**
AnnaBridge 167:e84263d55307 1139 * @brief Abort ongoing Transmit transfer (Interrupt mode).
AnnaBridge 167:e84263d55307 1140 * @param hsmartcard Pointer to a SMARTCARD_HandleTypeDef structure that contains
AnnaBridge 167:e84263d55307 1141 * the configuration information for the specified SMARTCARD module.
AnnaBridge 167:e84263d55307 1142 * @note This procedure could be used for aborting any ongoing Tx transfer started in Interrupt or DMA mode.
AnnaBridge 167:e84263d55307 1143 * This procedure performs following operations :
AnnaBridge 167:e84263d55307 1144 * - Disable SMARTCARD Interrupts (Tx)
AnnaBridge 167:e84263d55307 1145 * - Disable the DMA transfer in the peripheral register (if enabled)
AnnaBridge 167:e84263d55307 1146 * - Abort DMA transfer by calling HAL_DMA_Abort_IT (in case of transfer in DMA mode)
AnnaBridge 167:e84263d55307 1147 * - Set handle State to READY
AnnaBridge 167:e84263d55307 1148 * - At abort completion, call user abort complete callback
AnnaBridge 167:e84263d55307 1149 * @note This procedure is executed in Interrupt mode, meaning that abort procedure could be
AnnaBridge 167:e84263d55307 1150 * considered as completed only when user abort complete callback is executed (not when exiting function).
AnnaBridge 167:e84263d55307 1151 * @retval HAL status
AnnaBridge 167:e84263d55307 1152 */
AnnaBridge 167:e84263d55307 1153 HAL_StatusTypeDef HAL_SMARTCARD_AbortTransmit_IT(SMARTCARD_HandleTypeDef *hsmartcard)
AnnaBridge 167:e84263d55307 1154 {
AnnaBridge 167:e84263d55307 1155 /* Disable TXEIE and TCIE interrupts */
AnnaBridge 167:e84263d55307 1156 CLEAR_BIT(hsmartcard->Instance->CR1, (USART_CR1_TXEIE | USART_CR1_TCIE));
AnnaBridge 167:e84263d55307 1157
AnnaBridge 167:e84263d55307 1158 /* Check if a receive process is ongoing or not. If not disable ERR IT */
AnnaBridge 167:e84263d55307 1159 if(hsmartcard->RxState == HAL_SMARTCARD_STATE_READY)
AnnaBridge 167:e84263d55307 1160 {
AnnaBridge 167:e84263d55307 1161 /* Disable the SMARTCARD Error Interrupt: (Frame error) */
AnnaBridge 167:e84263d55307 1162 CLEAR_BIT(hsmartcard->Instance->CR3, USART_CR3_EIE);
AnnaBridge 167:e84263d55307 1163 }
AnnaBridge 167:e84263d55307 1164
AnnaBridge 167:e84263d55307 1165 /* Disable the SMARTCARD DMA Tx request if enabled */
AnnaBridge 167:e84263d55307 1166 if (HAL_IS_BIT_SET(hsmartcard->Instance->CR3, USART_CR3_DMAT))
AnnaBridge 167:e84263d55307 1167 {
AnnaBridge 167:e84263d55307 1168 CLEAR_BIT(hsmartcard->Instance->CR3, USART_CR3_DMAT);
AnnaBridge 167:e84263d55307 1169
AnnaBridge 167:e84263d55307 1170 /* Abort the SMARTCARD DMA Tx channel : use non blocking DMA Abort API (callback) */
AnnaBridge 167:e84263d55307 1171 if(hsmartcard->hdmatx != NULL)
AnnaBridge 167:e84263d55307 1172 {
AnnaBridge 167:e84263d55307 1173 /* Set the SMARTCARD DMA Abort callback :
AnnaBridge 167:e84263d55307 1174 will lead to call HAL_SMARTCARD_AbortCpltCallback() at end of DMA abort procedure */
AnnaBridge 167:e84263d55307 1175 hsmartcard->hdmatx->XferAbortCallback = SMARTCARD_DMATxOnlyAbortCallback;
AnnaBridge 167:e84263d55307 1176
AnnaBridge 167:e84263d55307 1177 /* Abort DMA TX */
AnnaBridge 167:e84263d55307 1178 if(HAL_DMA_Abort_IT(hsmartcard->hdmatx) != HAL_OK)
AnnaBridge 167:e84263d55307 1179 {
AnnaBridge 167:e84263d55307 1180 /* Call Directly hsmartcard->hdmatx->XferAbortCallback function in case of error */
AnnaBridge 167:e84263d55307 1181 hsmartcard->hdmatx->XferAbortCallback(hsmartcard->hdmatx);
AnnaBridge 167:e84263d55307 1182 }
AnnaBridge 167:e84263d55307 1183 }
AnnaBridge 167:e84263d55307 1184 else
AnnaBridge 167:e84263d55307 1185 {
AnnaBridge 167:e84263d55307 1186 /* Reset Tx transfer counter */
AnnaBridge 167:e84263d55307 1187 hsmartcard->TxXferCount = 0;
AnnaBridge 167:e84263d55307 1188
AnnaBridge 167:e84263d55307 1189 /* Restore hsmartcard->gState to Ready */
AnnaBridge 167:e84263d55307 1190 hsmartcard->gState = HAL_SMARTCARD_STATE_READY;
AnnaBridge 167:e84263d55307 1191
AnnaBridge 167:e84263d55307 1192 /* As no DMA to be aborted, call directly user Abort complete callback */
AnnaBridge 167:e84263d55307 1193 HAL_SMARTCARD_AbortTransmitCpltCallback(hsmartcard);
AnnaBridge 167:e84263d55307 1194 }
AnnaBridge 167:e84263d55307 1195 }
AnnaBridge 167:e84263d55307 1196 else
AnnaBridge 167:e84263d55307 1197 {
AnnaBridge 167:e84263d55307 1198 /* Reset Tx transfer counter */
AnnaBridge 167:e84263d55307 1199 hsmartcard->TxXferCount = 0;
AnnaBridge 167:e84263d55307 1200
AnnaBridge 167:e84263d55307 1201 /* Clear the Error flags in the ICR register */
AnnaBridge 167:e84263d55307 1202 __HAL_SMARTCARD_CLEAR_FLAG(hsmartcard, SMARTCARD_CLEAR_FEF);
AnnaBridge 167:e84263d55307 1203
AnnaBridge 167:e84263d55307 1204 /* Restore hsmartcard->gState to Ready */
AnnaBridge 167:e84263d55307 1205 hsmartcard->gState = HAL_SMARTCARD_STATE_READY;
AnnaBridge 167:e84263d55307 1206
AnnaBridge 167:e84263d55307 1207 /* As no DMA to be aborted, call directly user Abort complete callback */
AnnaBridge 167:e84263d55307 1208 HAL_SMARTCARD_AbortTransmitCpltCallback(hsmartcard);
AnnaBridge 167:e84263d55307 1209 }
AnnaBridge 167:e84263d55307 1210
AnnaBridge 167:e84263d55307 1211 return HAL_OK;
AnnaBridge 167:e84263d55307 1212 }
AnnaBridge 167:e84263d55307 1213
AnnaBridge 167:e84263d55307 1214 /**
AnnaBridge 167:e84263d55307 1215 * @brief Abort ongoing Receive transfer (Interrupt mode).
AnnaBridge 167:e84263d55307 1216 * @param hsmartcard Pointer to a SMARTCARD_HandleTypeDef structure that contains
AnnaBridge 167:e84263d55307 1217 * the configuration information for the specified SMARTCARD module.
AnnaBridge 167:e84263d55307 1218 * @note This procedure could be used for aborting any ongoing Rx transfer started in Interrupt or DMA mode.
AnnaBridge 167:e84263d55307 1219 * This procedure performs following operations :
AnnaBridge 167:e84263d55307 1220 * - Disable SMARTCARD Interrupts (Rx)
AnnaBridge 167:e84263d55307 1221 * - Disable the DMA transfer in the peripheral register (if enabled)
AnnaBridge 167:e84263d55307 1222 * - Abort DMA transfer by calling HAL_DMA_Abort_IT (in case of transfer in DMA mode)
AnnaBridge 167:e84263d55307 1223 * - Set handle State to READY
AnnaBridge 167:e84263d55307 1224 * - At abort completion, call user abort complete callback
AnnaBridge 167:e84263d55307 1225 * @note This procedure is executed in Interrupt mode, meaning that abort procedure could be
AnnaBridge 167:e84263d55307 1226 * considered as completed only when user abort complete callback is executed (not when exiting function).
AnnaBridge 167:e84263d55307 1227 * @retval HAL status
AnnaBridge 167:e84263d55307 1228 */
AnnaBridge 167:e84263d55307 1229 HAL_StatusTypeDef HAL_SMARTCARD_AbortReceive_IT(SMARTCARD_HandleTypeDef *hsmartcard)
AnnaBridge 167:e84263d55307 1230 {
AnnaBridge 167:e84263d55307 1231 /* Disable RTOIE, EOBIE, RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts */
AnnaBridge 167:e84263d55307 1232 CLEAR_BIT(hsmartcard->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE | USART_CR1_RTOIE | USART_CR1_EOBIE));
AnnaBridge 167:e84263d55307 1233
AnnaBridge 167:e84263d55307 1234 /* Check if a Transmit process is ongoing or not. If not disable ERR IT */
AnnaBridge 167:e84263d55307 1235 if(hsmartcard->gState == HAL_SMARTCARD_STATE_READY)
AnnaBridge 167:e84263d55307 1236 {
AnnaBridge 167:e84263d55307 1237 /* Disable the SMARTCARD Error Interrupt: (Frame error) */
AnnaBridge 167:e84263d55307 1238 CLEAR_BIT(hsmartcard->Instance->CR3, USART_CR3_EIE);
AnnaBridge 167:e84263d55307 1239 }
AnnaBridge 167:e84263d55307 1240
AnnaBridge 167:e84263d55307 1241 /* Disable the SMARTCARD DMA Rx request if enabled */
AnnaBridge 167:e84263d55307 1242 if (HAL_IS_BIT_SET(hsmartcard->Instance->CR3, USART_CR3_DMAR))
AnnaBridge 167:e84263d55307 1243 {
AnnaBridge 167:e84263d55307 1244 CLEAR_BIT(hsmartcard->Instance->CR3, USART_CR3_DMAR);
AnnaBridge 167:e84263d55307 1245
AnnaBridge 167:e84263d55307 1246 /* Abort the SMARTCARD DMA Rx channel : use non blocking DMA Abort API (callback) */
AnnaBridge 167:e84263d55307 1247 if(hsmartcard->hdmarx != NULL)
AnnaBridge 167:e84263d55307 1248 {
AnnaBridge 167:e84263d55307 1249 /* Set the SMARTCARD DMA Abort callback :
AnnaBridge 167:e84263d55307 1250 will lead to call HAL_SMARTCARD_AbortCpltCallback() at end of DMA abort procedure */
AnnaBridge 167:e84263d55307 1251 hsmartcard->hdmarx->XferAbortCallback = SMARTCARD_DMARxOnlyAbortCallback;
AnnaBridge 167:e84263d55307 1252
AnnaBridge 167:e84263d55307 1253 /* Abort DMA RX */
AnnaBridge 167:e84263d55307 1254 if(HAL_DMA_Abort_IT(hsmartcard->hdmarx) != HAL_OK)
AnnaBridge 167:e84263d55307 1255 {
AnnaBridge 167:e84263d55307 1256 /* Call Directly hsmartcard->hdmarx->XferAbortCallback function in case of error */
AnnaBridge 167:e84263d55307 1257 hsmartcard->hdmarx->XferAbortCallback(hsmartcard->hdmarx);
AnnaBridge 167:e84263d55307 1258 }
AnnaBridge 167:e84263d55307 1259 }
AnnaBridge 167:e84263d55307 1260 else
AnnaBridge 167:e84263d55307 1261 {
AnnaBridge 167:e84263d55307 1262 /* Reset Rx transfer counter */
AnnaBridge 167:e84263d55307 1263 hsmartcard->RxXferCount = 0;
AnnaBridge 167:e84263d55307 1264
AnnaBridge 167:e84263d55307 1265 /* Clear the Error flags in the ICR register */
AnnaBridge 167:e84263d55307 1266 __HAL_SMARTCARD_CLEAR_FLAG(hsmartcard, SMARTCARD_CLEAR_OREF | SMARTCARD_CLEAR_NEF | SMARTCARD_CLEAR_PEF | SMARTCARD_CLEAR_FEF | SMARTCARD_CLEAR_RTOF | SMARTCARD_CLEAR_EOBF);
AnnaBridge 167:e84263d55307 1267
AnnaBridge 167:e84263d55307 1268 /* Restore hsmartcard->RxState to Ready */
AnnaBridge 167:e84263d55307 1269 hsmartcard->RxState = HAL_SMARTCARD_STATE_READY;
AnnaBridge 167:e84263d55307 1270
AnnaBridge 167:e84263d55307 1271 /* As no DMA to be aborted, call directly user Abort complete callback */
AnnaBridge 167:e84263d55307 1272 HAL_SMARTCARD_AbortReceiveCpltCallback(hsmartcard);
AnnaBridge 167:e84263d55307 1273 }
AnnaBridge 167:e84263d55307 1274 }
AnnaBridge 167:e84263d55307 1275 else
AnnaBridge 167:e84263d55307 1276 {
AnnaBridge 167:e84263d55307 1277 /* Reset Rx transfer counter */
AnnaBridge 167:e84263d55307 1278 hsmartcard->RxXferCount = 0;
AnnaBridge 167:e84263d55307 1279
AnnaBridge 167:e84263d55307 1280 /* Clear the Error flags in the ICR register */
AnnaBridge 167:e84263d55307 1281 __HAL_SMARTCARD_CLEAR_FLAG(hsmartcard, SMARTCARD_CLEAR_OREF | SMARTCARD_CLEAR_NEF | SMARTCARD_CLEAR_PEF | SMARTCARD_CLEAR_FEF | SMARTCARD_CLEAR_RTOF | SMARTCARD_CLEAR_EOBF);
AnnaBridge 167:e84263d55307 1282
AnnaBridge 167:e84263d55307 1283 /* Restore hsmartcard->RxState to Ready */
AnnaBridge 167:e84263d55307 1284 hsmartcard->RxState = HAL_SMARTCARD_STATE_READY;
AnnaBridge 167:e84263d55307 1285
AnnaBridge 167:e84263d55307 1286 /* As no DMA to be aborted, call directly user Abort complete callback */
AnnaBridge 167:e84263d55307 1287 HAL_SMARTCARD_AbortReceiveCpltCallback(hsmartcard);
AnnaBridge 167:e84263d55307 1288 }
AnnaBridge 167:e84263d55307 1289
AnnaBridge 167:e84263d55307 1290 return HAL_OK;
AnnaBridge 167:e84263d55307 1291 }
AnnaBridge 167:e84263d55307 1292
AnnaBridge 167:e84263d55307 1293 /**
<> 144:ef7eb2e8f9f7 1294 * @brief Handle SMARTCARD interrupt requests.
<> 144:ef7eb2e8f9f7 1295 * @param hsmartcard: Pointer to a SMARTCARD_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1296 * the configuration information for the specified SMARTCARD module.
<> 144:ef7eb2e8f9f7 1297 * @retval None
<> 144:ef7eb2e8f9f7 1298 */
<> 144:ef7eb2e8f9f7 1299 void HAL_SMARTCARD_IRQHandler(SMARTCARD_HandleTypeDef *hsmartcard)
<> 144:ef7eb2e8f9f7 1300 {
AnnaBridge 167:e84263d55307 1301 uint32_t isrflags = READ_REG(hsmartcard->Instance->ISR);
AnnaBridge 167:e84263d55307 1302 uint32_t cr1its = READ_REG(hsmartcard->Instance->CR1);
AnnaBridge 167:e84263d55307 1303 uint32_t cr3its;
AnnaBridge 167:e84263d55307 1304 uint32_t errorflags;
AnnaBridge 167:e84263d55307 1305
AnnaBridge 167:e84263d55307 1306 /* If no error occurs */
AnnaBridge 167:e84263d55307 1307 errorflags = (isrflags & (uint32_t)(USART_ISR_PE | USART_ISR_FE | USART_ISR_ORE | USART_ISR_NE | USART_ISR_RTOF));
AnnaBridge 167:e84263d55307 1308 if (errorflags == RESET)
<> 144:ef7eb2e8f9f7 1309 {
AnnaBridge 167:e84263d55307 1310 /* SMARTCARD in mode Receiver ---------------------------------------------------*/
AnnaBridge 167:e84263d55307 1311 if(((isrflags & USART_ISR_RXNE) != RESET) && ((cr1its & USART_CR1_RXNEIE) != RESET))
AnnaBridge 167:e84263d55307 1312 {
AnnaBridge 167:e84263d55307 1313 SMARTCARD_Receive_IT(hsmartcard);
AnnaBridge 167:e84263d55307 1314 /* Clear RXNE interrupt flag done by reading RDR in SMARTCARD_Receive_IT() */
AnnaBridge 167:e84263d55307 1315 return;
AnnaBridge 167:e84263d55307 1316 }
AnnaBridge 167:e84263d55307 1317 }
<> 144:ef7eb2e8f9f7 1318
AnnaBridge 167:e84263d55307 1319 /* If some errors occur */
AnnaBridge 167:e84263d55307 1320 cr3its = READ_REG(hsmartcard->Instance->CR3);
AnnaBridge 167:e84263d55307 1321 if( (errorflags != RESET)
AnnaBridge 167:e84263d55307 1322 && ( ((cr3its & USART_CR3_EIE) != RESET)
AnnaBridge 167:e84263d55307 1323 || ((cr1its & (USART_CR1_RXNEIE | USART_CR1_PEIE | USART_CR1_RTOIE)) != RESET)) )
<> 144:ef7eb2e8f9f7 1324 {
AnnaBridge 167:e84263d55307 1325 /* SMARTCARD parity error interrupt occurred -------------------------------------*/
AnnaBridge 167:e84263d55307 1326 if(((isrflags & USART_ISR_PE) != RESET) && ((cr1its & USART_CR1_PEIE) != RESET))
AnnaBridge 167:e84263d55307 1327 {
AnnaBridge 167:e84263d55307 1328 __HAL_SMARTCARD_CLEAR_IT(hsmartcard, SMARTCARD_CLEAR_PEF);
AnnaBridge 167:e84263d55307 1329
AnnaBridge 167:e84263d55307 1330 hsmartcard->ErrorCode |= HAL_SMARTCARD_ERROR_PE;
AnnaBridge 167:e84263d55307 1331 }
AnnaBridge 167:e84263d55307 1332
AnnaBridge 167:e84263d55307 1333 /* SMARTCARD frame error interrupt occurred --------------------------------------*/
AnnaBridge 167:e84263d55307 1334 if(((isrflags & USART_ISR_FE) != RESET) && ((cr3its & USART_CR3_EIE) != RESET))
AnnaBridge 167:e84263d55307 1335 {
AnnaBridge 167:e84263d55307 1336 __HAL_SMARTCARD_CLEAR_IT(hsmartcard, SMARTCARD_CLEAR_FEF);
AnnaBridge 167:e84263d55307 1337
AnnaBridge 167:e84263d55307 1338 hsmartcard->ErrorCode |= HAL_SMARTCARD_ERROR_FE;
AnnaBridge 167:e84263d55307 1339 }
AnnaBridge 167:e84263d55307 1340
AnnaBridge 167:e84263d55307 1341 /* SMARTCARD noise error interrupt occurred --------------------------------------*/
AnnaBridge 167:e84263d55307 1342 if(((isrflags & USART_ISR_NE) != RESET) && ((cr3its & USART_CR3_EIE) != RESET))
AnnaBridge 167:e84263d55307 1343 {
AnnaBridge 167:e84263d55307 1344 __HAL_SMARTCARD_CLEAR_IT(hsmartcard, SMARTCARD_CLEAR_NEF);
AnnaBridge 167:e84263d55307 1345
AnnaBridge 167:e84263d55307 1346 hsmartcard->ErrorCode |= HAL_SMARTCARD_ERROR_NE;
AnnaBridge 167:e84263d55307 1347 }
<> 144:ef7eb2e8f9f7 1348
AnnaBridge 167:e84263d55307 1349 /* SMARTCARD Over-Run interrupt occurred -----------------------------------------*/
AnnaBridge 167:e84263d55307 1350 if(((isrflags & USART_ISR_ORE) != RESET) &&
AnnaBridge 167:e84263d55307 1351 (((cr1its & USART_CR1_RXNEIE) != RESET) || ((cr3its & USART_CR3_EIE) != RESET)))
AnnaBridge 167:e84263d55307 1352 {
AnnaBridge 167:e84263d55307 1353 __HAL_SMARTCARD_CLEAR_IT(hsmartcard, SMARTCARD_CLEAR_OREF);
AnnaBridge 167:e84263d55307 1354
AnnaBridge 167:e84263d55307 1355 hsmartcard->ErrorCode |= HAL_SMARTCARD_ERROR_ORE;
AnnaBridge 167:e84263d55307 1356 }
AnnaBridge 167:e84263d55307 1357
AnnaBridge 167:e84263d55307 1358 /* SMARTCARD receiver timeout interrupt occurred -----------------------------------------*/
AnnaBridge 167:e84263d55307 1359 if(((isrflags & USART_ISR_RTOF) != RESET) && ((cr1its & USART_CR1_RTOIE) != RESET))
AnnaBridge 167:e84263d55307 1360 {
AnnaBridge 167:e84263d55307 1361 __HAL_SMARTCARD_CLEAR_IT(hsmartcard, SMARTCARD_CLEAR_RTOF);
AnnaBridge 167:e84263d55307 1362
AnnaBridge 167:e84263d55307 1363 hsmartcard->ErrorCode |= HAL_SMARTCARD_ERROR_RTO;
AnnaBridge 167:e84263d55307 1364 }
AnnaBridge 167:e84263d55307 1365
AnnaBridge 167:e84263d55307 1366 /* Call SMARTCARD Error Call back function if need be --------------------------*/
AnnaBridge 167:e84263d55307 1367 if(hsmartcard->ErrorCode != HAL_SMARTCARD_ERROR_NONE)
AnnaBridge 167:e84263d55307 1368 {
AnnaBridge 167:e84263d55307 1369 /* SMARTCARD in mode Receiver ---------------------------------------------------*/
AnnaBridge 167:e84263d55307 1370 if(((isrflags & USART_ISR_RXNE) != RESET) && ((cr1its & USART_CR1_RXNEIE) != RESET))
AnnaBridge 167:e84263d55307 1371 {
AnnaBridge 167:e84263d55307 1372 SMARTCARD_Receive_IT(hsmartcard);
AnnaBridge 167:e84263d55307 1373 }
<> 144:ef7eb2e8f9f7 1374
AnnaBridge 167:e84263d55307 1375 /* If Error is to be considered as blocking :
AnnaBridge 167:e84263d55307 1376 - Receiver Timeout error in Reception
AnnaBridge 167:e84263d55307 1377 - Overrun error in Reception
AnnaBridge 167:e84263d55307 1378 - any error occurs in DMA mode reception
AnnaBridge 167:e84263d55307 1379 */
AnnaBridge 167:e84263d55307 1380 if ( ((hsmartcard->ErrorCode & (HAL_SMARTCARD_ERROR_RTO | HAL_SMARTCARD_ERROR_ORE)) != RESET)
AnnaBridge 167:e84263d55307 1381 || (HAL_IS_BIT_SET(hsmartcard->Instance->CR3, USART_CR3_DMAR)))
AnnaBridge 167:e84263d55307 1382 {
AnnaBridge 167:e84263d55307 1383 /* Blocking error : transfer is aborted
AnnaBridge 167:e84263d55307 1384 Set the SMARTCARD state ready to be able to start again the process,
AnnaBridge 167:e84263d55307 1385 Disable Rx Interrupts, and disable Rx DMA request, if ongoing */
AnnaBridge 167:e84263d55307 1386 SMARTCARD_EndRxTransfer(hsmartcard);
AnnaBridge 167:e84263d55307 1387
AnnaBridge 167:e84263d55307 1388 /* Disable the SMARTCARD DMA Rx request if enabled */
AnnaBridge 167:e84263d55307 1389 if (HAL_IS_BIT_SET(hsmartcard->Instance->CR3, USART_CR3_DMAR))
AnnaBridge 167:e84263d55307 1390 {
AnnaBridge 167:e84263d55307 1391 CLEAR_BIT(hsmartcard->Instance->CR3, USART_CR3_DMAR);
AnnaBridge 167:e84263d55307 1392
AnnaBridge 167:e84263d55307 1393 /* Abort the SMARTCARD DMA Rx channel */
AnnaBridge 167:e84263d55307 1394 if(hsmartcard->hdmarx != NULL)
AnnaBridge 167:e84263d55307 1395 {
AnnaBridge 167:e84263d55307 1396 /* Set the SMARTCARD DMA Abort callback :
AnnaBridge 167:e84263d55307 1397 will lead to call HAL_SMARTCARD_ErrorCallback() at end of DMA abort procedure */
AnnaBridge 167:e84263d55307 1398 hsmartcard->hdmarx->XferAbortCallback = SMARTCARD_DMAAbortOnError;
<> 144:ef7eb2e8f9f7 1399
AnnaBridge 167:e84263d55307 1400 /* Abort DMA RX */
AnnaBridge 167:e84263d55307 1401 if(HAL_DMA_Abort_IT(hsmartcard->hdmarx) != HAL_OK)
AnnaBridge 167:e84263d55307 1402 {
AnnaBridge 167:e84263d55307 1403 /* Call Directly hsmartcard->hdmarx->XferAbortCallback function in case of error */
AnnaBridge 167:e84263d55307 1404 hsmartcard->hdmarx->XferAbortCallback(hsmartcard->hdmarx);
AnnaBridge 167:e84263d55307 1405 }
AnnaBridge 167:e84263d55307 1406 }
AnnaBridge 167:e84263d55307 1407 else
AnnaBridge 167:e84263d55307 1408 {
AnnaBridge 167:e84263d55307 1409 /* Call user error callback */
AnnaBridge 167:e84263d55307 1410 HAL_SMARTCARD_ErrorCallback(hsmartcard);
AnnaBridge 167:e84263d55307 1411 }
AnnaBridge 167:e84263d55307 1412 }
AnnaBridge 167:e84263d55307 1413 else
AnnaBridge 167:e84263d55307 1414 {
AnnaBridge 167:e84263d55307 1415 /* Call user error callback */
AnnaBridge 167:e84263d55307 1416 HAL_SMARTCARD_ErrorCallback(hsmartcard);
AnnaBridge 167:e84263d55307 1417 }
AnnaBridge 167:e84263d55307 1418 }
AnnaBridge 167:e84263d55307 1419 /* other error type to be considered as blocking :
AnnaBridge 167:e84263d55307 1420 - Frame error in Transmission
AnnaBridge 167:e84263d55307 1421 */
AnnaBridge 167:e84263d55307 1422 else if ((hsmartcard->gState == HAL_SMARTCARD_STATE_BUSY_TX) && ((hsmartcard->ErrorCode & HAL_SMARTCARD_ERROR_FE) != RESET))
AnnaBridge 167:e84263d55307 1423 {
AnnaBridge 167:e84263d55307 1424 /* Blocking error : transfer is aborted
AnnaBridge 167:e84263d55307 1425 Set the SMARTCARD state ready to be able to start again the process,
AnnaBridge 167:e84263d55307 1426 Disable Tx Interrupts, and disable Tx DMA request, if ongoing */
AnnaBridge 167:e84263d55307 1427 SMARTCARD_EndTxTransfer(hsmartcard);
AnnaBridge 167:e84263d55307 1428
AnnaBridge 167:e84263d55307 1429 /* Disable the SMARTCARD DMA Tx request if enabled */
AnnaBridge 167:e84263d55307 1430 if (HAL_IS_BIT_SET(hsmartcard->Instance->CR3, USART_CR3_DMAT))
AnnaBridge 167:e84263d55307 1431 {
AnnaBridge 167:e84263d55307 1432 CLEAR_BIT(hsmartcard->Instance->CR3, USART_CR3_DMAT);
<> 144:ef7eb2e8f9f7 1433
AnnaBridge 167:e84263d55307 1434 /* Abort the SMARTCARD DMA Tx channel */
AnnaBridge 167:e84263d55307 1435 if(hsmartcard->hdmatx != NULL)
AnnaBridge 167:e84263d55307 1436 {
AnnaBridge 167:e84263d55307 1437 /* Set the SMARTCARD DMA Abort callback :
AnnaBridge 167:e84263d55307 1438 will lead to call HAL_SMARTCARD_ErrorCallback() at end of DMA abort procedure */
AnnaBridge 167:e84263d55307 1439 hsmartcard->hdmatx->XferAbortCallback = SMARTCARD_DMAAbortOnError;
<> 144:ef7eb2e8f9f7 1440
AnnaBridge 167:e84263d55307 1441 /* Abort DMA TX */
AnnaBridge 167:e84263d55307 1442 if(HAL_DMA_Abort_IT(hsmartcard->hdmatx) != HAL_OK)
AnnaBridge 167:e84263d55307 1443 {
AnnaBridge 167:e84263d55307 1444 /* Call Directly hsmartcard->hdmatx->XferAbortCallback function in case of error */
AnnaBridge 167:e84263d55307 1445 hsmartcard->hdmatx->XferAbortCallback(hsmartcard->hdmatx);
AnnaBridge 167:e84263d55307 1446 }
AnnaBridge 167:e84263d55307 1447 }
AnnaBridge 167:e84263d55307 1448 else
AnnaBridge 167:e84263d55307 1449 {
AnnaBridge 167:e84263d55307 1450 /* Call user error callback */
AnnaBridge 167:e84263d55307 1451 HAL_SMARTCARD_ErrorCallback(hsmartcard);
AnnaBridge 167:e84263d55307 1452 }
AnnaBridge 167:e84263d55307 1453 }
AnnaBridge 167:e84263d55307 1454 else
AnnaBridge 167:e84263d55307 1455 {
AnnaBridge 167:e84263d55307 1456 /* Call user error callback */
AnnaBridge 167:e84263d55307 1457 HAL_SMARTCARD_ErrorCallback(hsmartcard);
AnnaBridge 167:e84263d55307 1458 }
AnnaBridge 167:e84263d55307 1459 }
AnnaBridge 167:e84263d55307 1460 else
AnnaBridge 167:e84263d55307 1461 {
AnnaBridge 167:e84263d55307 1462 /* Non Blocking error : transfer could go on.
AnnaBridge 167:e84263d55307 1463 Error is notified to user through user error callback */
AnnaBridge 167:e84263d55307 1464 HAL_SMARTCARD_ErrorCallback(hsmartcard);
AnnaBridge 167:e84263d55307 1465 hsmartcard->ErrorCode = HAL_SMARTCARD_ERROR_NONE;
AnnaBridge 167:e84263d55307 1466 }
AnnaBridge 167:e84263d55307 1467 }
AnnaBridge 167:e84263d55307 1468 return;
AnnaBridge 167:e84263d55307 1469
AnnaBridge 167:e84263d55307 1470 } /* End if some error occurs */
<> 144:ef7eb2e8f9f7 1471
<> 144:ef7eb2e8f9f7 1472 /* SMARTCARD in mode Receiver, end of block interruption ------------------------*/
AnnaBridge 167:e84263d55307 1473 if(((isrflags & USART_ISR_EOBF) != RESET) && ((cr1its & USART_CR1_EOBIE) != RESET))
<> 144:ef7eb2e8f9f7 1474 {
<> 144:ef7eb2e8f9f7 1475 hsmartcard->RxState = HAL_SMARTCARD_STATE_READY;
<> 144:ef7eb2e8f9f7 1476 __HAL_UNLOCK(hsmartcard);
<> 144:ef7eb2e8f9f7 1477 HAL_SMARTCARD_RxCpltCallback(hsmartcard);
<> 144:ef7eb2e8f9f7 1478 /* Clear EOBF interrupt after HAL_SMARTCARD_RxCpltCallback() call for the End of Block information
<> 144:ef7eb2e8f9f7 1479 * to be available during HAL_SMARTCARD_RxCpltCallback() processing */
<> 144:ef7eb2e8f9f7 1480 __HAL_SMARTCARD_CLEAR_IT(hsmartcard, SMARTCARD_CLEAR_EOBF);
AnnaBridge 167:e84263d55307 1481 return;
<> 144:ef7eb2e8f9f7 1482 }
<> 144:ef7eb2e8f9f7 1483
<> 144:ef7eb2e8f9f7 1484 /* SMARTCARD in mode Transmitter ------------------------------------------------*/
AnnaBridge 167:e84263d55307 1485 if(((isrflags & USART_ISR_TXE) != RESET) && ((cr1its & USART_CR1_TXEIE) != RESET))
<> 144:ef7eb2e8f9f7 1486 {
<> 144:ef7eb2e8f9f7 1487 SMARTCARD_Transmit_IT(hsmartcard);
AnnaBridge 167:e84263d55307 1488 return;
<> 144:ef7eb2e8f9f7 1489 }
<> 144:ef7eb2e8f9f7 1490
<> 144:ef7eb2e8f9f7 1491 /* SMARTCARD in mode Transmitter (transmission end) ------------------------*/
AnnaBridge 167:e84263d55307 1492 if((__HAL_SMARTCARD_GET_IT(hsmartcard, hsmartcard->AdvancedInit.TxCompletionIndication) != RESET) &&(__HAL_SMARTCARD_GET_IT_SOURCE(hsmartcard, hsmartcard->AdvancedInit.TxCompletionIndication) != RESET))
<> 144:ef7eb2e8f9f7 1493 {
<> 144:ef7eb2e8f9f7 1494 SMARTCARD_EndTransmit_IT(hsmartcard);
AnnaBridge 167:e84263d55307 1495 return;
<> 144:ef7eb2e8f9f7 1496 }
<> 144:ef7eb2e8f9f7 1497 }
<> 144:ef7eb2e8f9f7 1498
<> 144:ef7eb2e8f9f7 1499 /**
AnnaBridge 167:e84263d55307 1500 * @brief Tx Transfer completed callback.
AnnaBridge 167:e84263d55307 1501 * @param hsmartcard Pointer to a SMARTCARD_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1502 * the configuration information for the specified SMARTCARD module.
<> 144:ef7eb2e8f9f7 1503 * @retval None
<> 144:ef7eb2e8f9f7 1504 */
<> 144:ef7eb2e8f9f7 1505 __weak void HAL_SMARTCARD_TxCpltCallback(SMARTCARD_HandleTypeDef *hsmartcard)
<> 144:ef7eb2e8f9f7 1506 {
<> 144:ef7eb2e8f9f7 1507 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 1508 UNUSED(hsmartcard);
<> 144:ef7eb2e8f9f7 1509
<> 144:ef7eb2e8f9f7 1510 /* NOTE : This function should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 1511 the HAL_SMARTCARD_TxCpltCallback can be implemented in the user file.
<> 144:ef7eb2e8f9f7 1512 */
<> 144:ef7eb2e8f9f7 1513 }
<> 144:ef7eb2e8f9f7 1514
<> 144:ef7eb2e8f9f7 1515 /**
AnnaBridge 167:e84263d55307 1516 * @brief Rx Transfer completed callback.
AnnaBridge 167:e84263d55307 1517 * @param hsmartcard Pointer to a SMARTCARD_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1518 * the configuration information for the specified SMARTCARD module.
<> 144:ef7eb2e8f9f7 1519 * @retval None
<> 144:ef7eb2e8f9f7 1520 */
<> 144:ef7eb2e8f9f7 1521 __weak void HAL_SMARTCARD_RxCpltCallback(SMARTCARD_HandleTypeDef *hsmartcard)
<> 144:ef7eb2e8f9f7 1522 {
<> 144:ef7eb2e8f9f7 1523 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 1524 UNUSED(hsmartcard);
<> 144:ef7eb2e8f9f7 1525
<> 144:ef7eb2e8f9f7 1526 /* NOTE : This function should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 1527 the HAL_SMARTCARD_RxCpltCallback can be implemented in the user file.
<> 144:ef7eb2e8f9f7 1528 */
<> 144:ef7eb2e8f9f7 1529 }
<> 144:ef7eb2e8f9f7 1530
<> 144:ef7eb2e8f9f7 1531 /**
AnnaBridge 167:e84263d55307 1532 * @brief SMARTCARD error callback.
AnnaBridge 167:e84263d55307 1533 * @param hsmartcard Pointer to a SMARTCARD_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1534 * the configuration information for the specified SMARTCARD module.
<> 144:ef7eb2e8f9f7 1535 * @retval None
<> 144:ef7eb2e8f9f7 1536 */
<> 144:ef7eb2e8f9f7 1537 __weak void HAL_SMARTCARD_ErrorCallback(SMARTCARD_HandleTypeDef *hsmartcard)
<> 144:ef7eb2e8f9f7 1538 {
<> 144:ef7eb2e8f9f7 1539 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 1540 UNUSED(hsmartcard);
<> 144:ef7eb2e8f9f7 1541
<> 144:ef7eb2e8f9f7 1542 /* NOTE : This function should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 1543 the HAL_SMARTCARD_ErrorCallback can be implemented in the user file.
<> 144:ef7eb2e8f9f7 1544 */
<> 144:ef7eb2e8f9f7 1545 }
<> 144:ef7eb2e8f9f7 1546
<> 144:ef7eb2e8f9f7 1547 /**
AnnaBridge 167:e84263d55307 1548 * @brief SMARTCARD Abort Complete callback.
AnnaBridge 167:e84263d55307 1549 * @param hsmartcard Pointer to a SMARTCARD_HandleTypeDef structure that contains
AnnaBridge 167:e84263d55307 1550 * the configuration information for the specified SMARTCARD module.
AnnaBridge 167:e84263d55307 1551 * @retval None
AnnaBridge 167:e84263d55307 1552 */
AnnaBridge 167:e84263d55307 1553 __weak void HAL_SMARTCARD_AbortCpltCallback (SMARTCARD_HandleTypeDef *hsmartcard)
AnnaBridge 167:e84263d55307 1554 {
AnnaBridge 167:e84263d55307 1555 /* Prevent unused argument(s) compilation warning */
AnnaBridge 167:e84263d55307 1556 UNUSED(hsmartcard);
AnnaBridge 167:e84263d55307 1557
AnnaBridge 167:e84263d55307 1558 /* NOTE : This function should not be modified, when the callback is needed,
AnnaBridge 167:e84263d55307 1559 the HAL_SMARTCARD_AbortCpltCallback can be implemented in the user file.
AnnaBridge 167:e84263d55307 1560 */
AnnaBridge 167:e84263d55307 1561 }
AnnaBridge 167:e84263d55307 1562
AnnaBridge 167:e84263d55307 1563 /**
AnnaBridge 167:e84263d55307 1564 * @brief SMARTCARD Abort Complete callback.
AnnaBridge 167:e84263d55307 1565 * @param hsmartcard Pointer to a SMARTCARD_HandleTypeDef structure that contains
AnnaBridge 167:e84263d55307 1566 * the configuration information for the specified SMARTCARD module.
AnnaBridge 167:e84263d55307 1567 * @retval None
AnnaBridge 167:e84263d55307 1568 */
AnnaBridge 167:e84263d55307 1569 __weak void HAL_SMARTCARD_AbortTransmitCpltCallback (SMARTCARD_HandleTypeDef *hsmartcard)
AnnaBridge 167:e84263d55307 1570 {
AnnaBridge 167:e84263d55307 1571 /* Prevent unused argument(s) compilation warning */
AnnaBridge 167:e84263d55307 1572 UNUSED(hsmartcard);
AnnaBridge 167:e84263d55307 1573
AnnaBridge 167:e84263d55307 1574 /* NOTE : This function should not be modified, when the callback is needed,
AnnaBridge 167:e84263d55307 1575 the HAL_SMARTCARD_AbortTransmitCpltCallback can be implemented in the user file.
AnnaBridge 167:e84263d55307 1576 */
AnnaBridge 167:e84263d55307 1577 }
AnnaBridge 167:e84263d55307 1578
AnnaBridge 167:e84263d55307 1579 /**
AnnaBridge 167:e84263d55307 1580 * @brief SMARTCARD Abort Receive Complete callback.
AnnaBridge 167:e84263d55307 1581 * @param hsmartcard Pointer to a SMARTCARD_HandleTypeDef structure that contains
AnnaBridge 167:e84263d55307 1582 * the configuration information for the specified SMARTCARD module.
AnnaBridge 167:e84263d55307 1583 * @retval None
AnnaBridge 167:e84263d55307 1584 */
AnnaBridge 167:e84263d55307 1585 __weak void HAL_SMARTCARD_AbortReceiveCpltCallback (SMARTCARD_HandleTypeDef *hsmartcard)
AnnaBridge 167:e84263d55307 1586 {
AnnaBridge 167:e84263d55307 1587 /* Prevent unused argument(s) compilation warning */
AnnaBridge 167:e84263d55307 1588 UNUSED(hsmartcard);
AnnaBridge 167:e84263d55307 1589
AnnaBridge 167:e84263d55307 1590 /* NOTE : This function should not be modified, when the callback is needed,
AnnaBridge 167:e84263d55307 1591 the HAL_SMARTCARD_AbortReceiveCpltCallback can be implemented in the user file.
AnnaBridge 167:e84263d55307 1592 */
AnnaBridge 167:e84263d55307 1593 }
AnnaBridge 167:e84263d55307 1594
AnnaBridge 167:e84263d55307 1595 /**
<> 144:ef7eb2e8f9f7 1596 * @}
<> 144:ef7eb2e8f9f7 1597 */
<> 144:ef7eb2e8f9f7 1598
<> 144:ef7eb2e8f9f7 1599 /** @defgroup SMARTCARD_Exported_Functions_Group4 Peripheral State and Errors functions
<> 144:ef7eb2e8f9f7 1600 * @brief SMARTCARD State and Errors functions
<> 144:ef7eb2e8f9f7 1601 *
<> 144:ef7eb2e8f9f7 1602 @verbatim
<> 144:ef7eb2e8f9f7 1603 ==============================================================================
<> 144:ef7eb2e8f9f7 1604 ##### Peripheral State and Errors functions #####
<> 144:ef7eb2e8f9f7 1605 ==============================================================================
<> 144:ef7eb2e8f9f7 1606 [..]
<> 144:ef7eb2e8f9f7 1607 This subsection provides a set of functions allowing to return the State of SmartCard
<> 144:ef7eb2e8f9f7 1608 handle and also return Peripheral Errors occurred during communication process
<> 144:ef7eb2e8f9f7 1609 (+) HAL_SMARTCARD_GetState() API can be helpful to check in run-time the state
<> 144:ef7eb2e8f9f7 1610 of the SMARTCARD peripheral.
<> 144:ef7eb2e8f9f7 1611 (+) HAL_SMARTCARD_GetError() checks in run-time errors that could occur during
<> 144:ef7eb2e8f9f7 1612 communication.
<> 144:ef7eb2e8f9f7 1613
<> 144:ef7eb2e8f9f7 1614 @endverbatim
<> 144:ef7eb2e8f9f7 1615 * @{
<> 144:ef7eb2e8f9f7 1616 */
<> 144:ef7eb2e8f9f7 1617
<> 144:ef7eb2e8f9f7 1618 /**
<> 144:ef7eb2e8f9f7 1619 * @brief Return the SMARTCARD handle state.
AnnaBridge 167:e84263d55307 1620 * @param hsmartcard Pointer to a SMARTCARD_HandleTypeDef structure that contains
AnnaBridge 167:e84263d55307 1621 * the configuration information for the specified SMARTCARD module.
<> 144:ef7eb2e8f9f7 1622 * @retval SMARTCARD handle state
<> 144:ef7eb2e8f9f7 1623 */
<> 144:ef7eb2e8f9f7 1624 HAL_SMARTCARD_StateTypeDef HAL_SMARTCARD_GetState(SMARTCARD_HandleTypeDef *hsmartcard)
<> 144:ef7eb2e8f9f7 1625 {
AnnaBridge 167:e84263d55307 1626 /* Return SMARTCARD handle state */
<> 144:ef7eb2e8f9f7 1627 uint32_t temp1= 0x00, temp2 = 0x00;
<> 144:ef7eb2e8f9f7 1628 temp1 = hsmartcard->gState;
<> 144:ef7eb2e8f9f7 1629 temp2 = hsmartcard->RxState;
AnnaBridge 167:e84263d55307 1630
<> 144:ef7eb2e8f9f7 1631 return (HAL_SMARTCARD_StateTypeDef)(temp1 | temp2);
<> 144:ef7eb2e8f9f7 1632 }
<> 144:ef7eb2e8f9f7 1633
<> 144:ef7eb2e8f9f7 1634 /**
<> 144:ef7eb2e8f9f7 1635 * @brief Return the SMARTCARD handle error code.
AnnaBridge 167:e84263d55307 1636 * @param hsmartcard Pointer to a SMARTCARD_HandleTypeDef structure that contains
AnnaBridge 167:e84263d55307 1637 * the configuration information for the specified SMARTCARD module.
<> 144:ef7eb2e8f9f7 1638 * @retval SMARTCARD handle Error Code
<> 144:ef7eb2e8f9f7 1639 */
<> 144:ef7eb2e8f9f7 1640 uint32_t HAL_SMARTCARD_GetError(SMARTCARD_HandleTypeDef *hsmartcard)
<> 144:ef7eb2e8f9f7 1641 {
<> 144:ef7eb2e8f9f7 1642 return hsmartcard->ErrorCode;
<> 144:ef7eb2e8f9f7 1643 }
<> 144:ef7eb2e8f9f7 1644
<> 144:ef7eb2e8f9f7 1645 /**
<> 144:ef7eb2e8f9f7 1646 * @}
<> 144:ef7eb2e8f9f7 1647 */
<> 144:ef7eb2e8f9f7 1648
<> 144:ef7eb2e8f9f7 1649 /**
<> 144:ef7eb2e8f9f7 1650 * @}
<> 144:ef7eb2e8f9f7 1651 */
<> 144:ef7eb2e8f9f7 1652
AnnaBridge 167:e84263d55307 1653 /** @defgroup SMARTCARD_Private_Functions SMARTCARD Private Functions
<> 144:ef7eb2e8f9f7 1654 * @{
<> 144:ef7eb2e8f9f7 1655 */
<> 144:ef7eb2e8f9f7 1656
<> 144:ef7eb2e8f9f7 1657 /**
<> 144:ef7eb2e8f9f7 1658 * @brief Configure the SMARTCARD associated USART peripheral.
<> 144:ef7eb2e8f9f7 1659 * @param hsmartcard: Pointer to a SMARTCARD_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1660 * the configuration information for the specified SMARTCARD module.
AnnaBridge 167:e84263d55307 1661 * @retval HAL status
<> 144:ef7eb2e8f9f7 1662 */
<> 144:ef7eb2e8f9f7 1663 static HAL_StatusTypeDef SMARTCARD_SetConfig(SMARTCARD_HandleTypeDef *hsmartcard)
<> 144:ef7eb2e8f9f7 1664 {
<> 144:ef7eb2e8f9f7 1665 uint32_t tmpreg = 0x00000000;
<> 144:ef7eb2e8f9f7 1666 SMARTCARD_ClockSourceTypeDef clocksource = SMARTCARD_CLOCKSOURCE_UNDEFINED;
<> 144:ef7eb2e8f9f7 1667 HAL_StatusTypeDef ret = HAL_OK;
<> 144:ef7eb2e8f9f7 1668
<> 144:ef7eb2e8f9f7 1669 /* Check the parameters */
<> 144:ef7eb2e8f9f7 1670 assert_param(IS_SMARTCARD_INSTANCE(hsmartcard->Instance));
<> 144:ef7eb2e8f9f7 1671 assert_param(IS_SMARTCARD_BAUDRATE(hsmartcard->Init.BaudRate));
<> 144:ef7eb2e8f9f7 1672 assert_param(IS_SMARTCARD_WORD_LENGTH(hsmartcard->Init.WordLength));
<> 144:ef7eb2e8f9f7 1673 assert_param(IS_SMARTCARD_STOPBITS(hsmartcard->Init.StopBits));
<> 144:ef7eb2e8f9f7 1674 assert_param(IS_SMARTCARD_PARITY(hsmartcard->Init.Parity));
<> 144:ef7eb2e8f9f7 1675 assert_param(IS_SMARTCARD_MODE(hsmartcard->Init.Mode));
<> 144:ef7eb2e8f9f7 1676 assert_param(IS_SMARTCARD_POLARITY(hsmartcard->Init.CLKPolarity));
<> 144:ef7eb2e8f9f7 1677 assert_param(IS_SMARTCARD_PHASE(hsmartcard->Init.CLKPhase));
<> 144:ef7eb2e8f9f7 1678 assert_param(IS_SMARTCARD_LASTBIT(hsmartcard->Init.CLKLastBit));
<> 144:ef7eb2e8f9f7 1679 assert_param(IS_SMARTCARD_ONE_BIT_SAMPLE(hsmartcard->Init.OneBitSampling));
<> 144:ef7eb2e8f9f7 1680 assert_param(IS_SMARTCARD_NACK(hsmartcard->Init.NACKEnable));
<> 144:ef7eb2e8f9f7 1681 assert_param(IS_SMARTCARD_TIMEOUT(hsmartcard->Init.TimeOutEnable));
<> 144:ef7eb2e8f9f7 1682 assert_param(IS_SMARTCARD_AUTORETRY_COUNT(hsmartcard->Init.AutoRetryCount));
<> 144:ef7eb2e8f9f7 1683
<> 144:ef7eb2e8f9f7 1684 /*-------------------------- USART CR1 Configuration -----------------------*/
<> 144:ef7eb2e8f9f7 1685 /* In SmartCard mode, M and PCE are forced to 1 (8 bits + parity).
<> 144:ef7eb2e8f9f7 1686 * Oversampling is forced to 16 (OVER8 = 0).
<> 144:ef7eb2e8f9f7 1687 * Configure the Parity and Mode:
<> 144:ef7eb2e8f9f7 1688 * set PS bit according to hsmartcard->Init.Parity value
<> 144:ef7eb2e8f9f7 1689 * set TE and RE bits according to hsmartcard->Init.Mode value */
<> 144:ef7eb2e8f9f7 1690 tmpreg = (uint32_t) hsmartcard->Init.Parity | hsmartcard->Init.Mode;
<> 144:ef7eb2e8f9f7 1691 tmpreg |= (uint32_t) hsmartcard->Init.WordLength;
<> 144:ef7eb2e8f9f7 1692 MODIFY_REG(hsmartcard->Instance->CR1, USART_CR1_FIELDS, tmpreg);
<> 144:ef7eb2e8f9f7 1693
<> 144:ef7eb2e8f9f7 1694 /*-------------------------- USART CR2 Configuration -----------------------*/
<> 144:ef7eb2e8f9f7 1695 tmpreg = hsmartcard->Init.StopBits;
<> 144:ef7eb2e8f9f7 1696 /* Synchronous mode is activated by default */
<> 144:ef7eb2e8f9f7 1697 tmpreg |= (uint32_t) USART_CR2_CLKEN | hsmartcard->Init.CLKPolarity;
<> 144:ef7eb2e8f9f7 1698 tmpreg |= (uint32_t) hsmartcard->Init.CLKPhase | hsmartcard->Init.CLKLastBit;
<> 144:ef7eb2e8f9f7 1699 tmpreg |= (uint32_t) hsmartcard->Init.TimeOutEnable;
<> 144:ef7eb2e8f9f7 1700 MODIFY_REG(hsmartcard->Instance->CR2, USART_CR2_FIELDS, tmpreg);
<> 144:ef7eb2e8f9f7 1701
<> 144:ef7eb2e8f9f7 1702 /*-------------------------- USART CR3 Configuration -----------------------*/
<> 144:ef7eb2e8f9f7 1703 /* Configure
<> 144:ef7eb2e8f9f7 1704 * - one-bit sampling method versus three samples' majority rule
<> 144:ef7eb2e8f9f7 1705 * according to hsmartcard->Init.OneBitSampling
<> 144:ef7eb2e8f9f7 1706 * - NACK transmission in case of parity error according
<> 144:ef7eb2e8f9f7 1707 * to hsmartcard->Init.NACKEnable
<> 144:ef7eb2e8f9f7 1708 * - autoretry counter according to hsmartcard->Init.AutoRetryCount */
<> 144:ef7eb2e8f9f7 1709 tmpreg = (uint32_t) hsmartcard->Init.OneBitSampling | hsmartcard->Init.NACKEnable;
<> 144:ef7eb2e8f9f7 1710 tmpreg |= ((uint32_t)hsmartcard->Init.AutoRetryCount << SMARTCARD_CR3_SCARCNT_LSB_POS);
<> 144:ef7eb2e8f9f7 1711 MODIFY_REG(hsmartcard->Instance-> CR3,USART_CR3_FIELDS, tmpreg);
<> 144:ef7eb2e8f9f7 1712
<> 144:ef7eb2e8f9f7 1713 /*-------------------------- USART GTPR Configuration ----------------------*/
<> 144:ef7eb2e8f9f7 1714 tmpreg = (hsmartcard->Init.Prescaler | ((uint32_t)hsmartcard->Init.GuardTime << SMARTCARD_GTPR_GT_LSB_POS));
<> 144:ef7eb2e8f9f7 1715 MODIFY_REG(hsmartcard->Instance->GTPR, (USART_GTPR_GT|USART_GTPR_PSC), tmpreg);
<> 144:ef7eb2e8f9f7 1716
<> 144:ef7eb2e8f9f7 1717 /*-------------------------- USART RTOR Configuration ----------------------*/
<> 144:ef7eb2e8f9f7 1718 tmpreg = ((uint32_t)hsmartcard->Init.BlockLength << SMARTCARD_RTOR_BLEN_LSB_POS);
<> 144:ef7eb2e8f9f7 1719 if (hsmartcard->Init.TimeOutEnable == SMARTCARD_TIMEOUT_ENABLE)
<> 144:ef7eb2e8f9f7 1720 {
<> 144:ef7eb2e8f9f7 1721 assert_param(IS_SMARTCARD_TIMEOUT_VALUE(hsmartcard->Init.TimeOutValue));
<> 144:ef7eb2e8f9f7 1722 tmpreg |= (uint32_t) hsmartcard->Init.TimeOutValue;
<> 144:ef7eb2e8f9f7 1723 }
<> 144:ef7eb2e8f9f7 1724 MODIFY_REG(hsmartcard->Instance->RTOR, (USART_RTOR_RTO|USART_RTOR_BLEN), tmpreg);
<> 144:ef7eb2e8f9f7 1725
<> 144:ef7eb2e8f9f7 1726 /*-------------------------- USART BRR Configuration -----------------------*/
<> 144:ef7eb2e8f9f7 1727 SMARTCARD_GETCLOCKSOURCE(hsmartcard, clocksource);
<> 144:ef7eb2e8f9f7 1728 switch (clocksource)
<> 144:ef7eb2e8f9f7 1729 {
<> 144:ef7eb2e8f9f7 1730 case SMARTCARD_CLOCKSOURCE_PCLK1:
<> 144:ef7eb2e8f9f7 1731 hsmartcard->Instance->BRR = (uint16_t)((HAL_RCC_GetPCLK1Freq() + (hsmartcard->Init.BaudRate/2)) / hsmartcard->Init.BaudRate);
<> 144:ef7eb2e8f9f7 1732 break;
<> 144:ef7eb2e8f9f7 1733 case SMARTCARD_CLOCKSOURCE_PCLK2:
<> 144:ef7eb2e8f9f7 1734 hsmartcard->Instance->BRR = (uint16_t)((HAL_RCC_GetPCLK2Freq() + (hsmartcard->Init.BaudRate/2)) / hsmartcard->Init.BaudRate);
<> 144:ef7eb2e8f9f7 1735 break;
<> 144:ef7eb2e8f9f7 1736 case SMARTCARD_CLOCKSOURCE_HSI:
<> 144:ef7eb2e8f9f7 1737 hsmartcard->Instance->BRR = (uint16_t)((HSI_VALUE + (hsmartcard->Init.BaudRate/2)) / hsmartcard->Init.BaudRate);
<> 144:ef7eb2e8f9f7 1738 break;
<> 144:ef7eb2e8f9f7 1739 case SMARTCARD_CLOCKSOURCE_SYSCLK:
<> 144:ef7eb2e8f9f7 1740 hsmartcard->Instance->BRR = (uint16_t)((HAL_RCC_GetSysClockFreq() + (hsmartcard->Init.BaudRate/2)) / hsmartcard->Init.BaudRate);
<> 144:ef7eb2e8f9f7 1741 break;
<> 144:ef7eb2e8f9f7 1742 case SMARTCARD_CLOCKSOURCE_LSE:
<> 144:ef7eb2e8f9f7 1743 hsmartcard->Instance->BRR = (uint16_t)((LSE_VALUE + (hsmartcard->Init.BaudRate/2)) / hsmartcard->Init.BaudRate);
<> 144:ef7eb2e8f9f7 1744 break;
<> 144:ef7eb2e8f9f7 1745 case SMARTCARD_CLOCKSOURCE_UNDEFINED:
<> 144:ef7eb2e8f9f7 1746 default:
<> 144:ef7eb2e8f9f7 1747 ret = HAL_ERROR;
<> 144:ef7eb2e8f9f7 1748 break;
<> 144:ef7eb2e8f9f7 1749 }
<> 144:ef7eb2e8f9f7 1750
<> 144:ef7eb2e8f9f7 1751 return ret;
<> 144:ef7eb2e8f9f7 1752 }
<> 144:ef7eb2e8f9f7 1753
<> 144:ef7eb2e8f9f7 1754
<> 144:ef7eb2e8f9f7 1755 /**
<> 144:ef7eb2e8f9f7 1756 * @brief Configure the SMARTCARD associated USART peripheral advanced features.
<> 144:ef7eb2e8f9f7 1757 * @param hsmartcard: Pointer to a SMARTCARD_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1758 * the configuration information for the specified SMARTCARD module.
<> 144:ef7eb2e8f9f7 1759 * @retval None
<> 144:ef7eb2e8f9f7 1760 */
<> 144:ef7eb2e8f9f7 1761 static void SMARTCARD_AdvFeatureConfig(SMARTCARD_HandleTypeDef *hsmartcard)
<> 144:ef7eb2e8f9f7 1762 {
<> 144:ef7eb2e8f9f7 1763 /* Check whether the set of advanced features to configure is properly set */
<> 144:ef7eb2e8f9f7 1764 assert_param(IS_SMARTCARD_ADVFEATURE_INIT(hsmartcard->AdvancedInit.AdvFeatureInit));
<> 144:ef7eb2e8f9f7 1765
<> 144:ef7eb2e8f9f7 1766 /* if required, configure TX pin active level inversion */
<> 144:ef7eb2e8f9f7 1767 if (HAL_IS_BIT_SET(hsmartcard->AdvancedInit.AdvFeatureInit, SMARTCARD_ADVFEATURE_TXINVERT_INIT))
<> 144:ef7eb2e8f9f7 1768 {
<> 144:ef7eb2e8f9f7 1769 assert_param(IS_SMARTCARD_ADVFEATURE_TXINV(hsmartcard->AdvancedInit.TxPinLevelInvert));
<> 144:ef7eb2e8f9f7 1770 MODIFY_REG(hsmartcard->Instance->CR2, USART_CR2_TXINV, hsmartcard->AdvancedInit.TxPinLevelInvert);
<> 144:ef7eb2e8f9f7 1771 }
<> 144:ef7eb2e8f9f7 1772
<> 144:ef7eb2e8f9f7 1773 /* if required, configure RX pin active level inversion */
<> 144:ef7eb2e8f9f7 1774 if (HAL_IS_BIT_SET(hsmartcard->AdvancedInit.AdvFeatureInit, SMARTCARD_ADVFEATURE_RXINVERT_INIT))
<> 144:ef7eb2e8f9f7 1775 {
<> 144:ef7eb2e8f9f7 1776 assert_param(IS_SMARTCARD_ADVFEATURE_RXINV(hsmartcard->AdvancedInit.RxPinLevelInvert));
<> 144:ef7eb2e8f9f7 1777 MODIFY_REG(hsmartcard->Instance->CR2, USART_CR2_RXINV, hsmartcard->AdvancedInit.RxPinLevelInvert);
<> 144:ef7eb2e8f9f7 1778 }
<> 144:ef7eb2e8f9f7 1779
<> 144:ef7eb2e8f9f7 1780 /* if required, configure data inversion */
<> 144:ef7eb2e8f9f7 1781 if (HAL_IS_BIT_SET(hsmartcard->AdvancedInit.AdvFeatureInit, SMARTCARD_ADVFEATURE_DATAINVERT_INIT))
<> 144:ef7eb2e8f9f7 1782 {
<> 144:ef7eb2e8f9f7 1783 assert_param(IS_SMARTCARD_ADVFEATURE_DATAINV(hsmartcard->AdvancedInit.DataInvert));
<> 144:ef7eb2e8f9f7 1784 MODIFY_REG(hsmartcard->Instance->CR2, USART_CR2_DATAINV, hsmartcard->AdvancedInit.DataInvert);
<> 144:ef7eb2e8f9f7 1785 }
<> 144:ef7eb2e8f9f7 1786
<> 144:ef7eb2e8f9f7 1787 /* if required, configure RX/TX pins swap */
<> 144:ef7eb2e8f9f7 1788 if (HAL_IS_BIT_SET(hsmartcard->AdvancedInit.AdvFeatureInit, SMARTCARD_ADVFEATURE_SWAP_INIT))
<> 144:ef7eb2e8f9f7 1789 {
<> 144:ef7eb2e8f9f7 1790 assert_param(IS_SMARTCARD_ADVFEATURE_SWAP(hsmartcard->AdvancedInit.Swap));
<> 144:ef7eb2e8f9f7 1791 MODIFY_REG(hsmartcard->Instance->CR2, USART_CR2_SWAP, hsmartcard->AdvancedInit.Swap);
<> 144:ef7eb2e8f9f7 1792 }
<> 144:ef7eb2e8f9f7 1793
<> 144:ef7eb2e8f9f7 1794 /* if required, configure RX overrun detection disabling */
<> 144:ef7eb2e8f9f7 1795 if (HAL_IS_BIT_SET(hsmartcard->AdvancedInit.AdvFeatureInit, SMARTCARD_ADVFEATURE_RXOVERRUNDISABLE_INIT))
<> 144:ef7eb2e8f9f7 1796 {
<> 144:ef7eb2e8f9f7 1797 assert_param(IS_SMARTCARD_OVERRUN(hsmartcard->AdvancedInit.OverrunDisable));
<> 144:ef7eb2e8f9f7 1798 MODIFY_REG(hsmartcard->Instance->CR3, USART_CR3_OVRDIS, hsmartcard->AdvancedInit.OverrunDisable);
<> 144:ef7eb2e8f9f7 1799 }
<> 144:ef7eb2e8f9f7 1800
<> 144:ef7eb2e8f9f7 1801 /* if required, configure DMA disabling on reception error */
<> 144:ef7eb2e8f9f7 1802 if (HAL_IS_BIT_SET(hsmartcard->AdvancedInit.AdvFeatureInit, SMARTCARD_ADVFEATURE_DMADISABLEONERROR_INIT))
<> 144:ef7eb2e8f9f7 1803 {
<> 144:ef7eb2e8f9f7 1804 assert_param(IS_SMARTCARD_ADVFEATURE_DMAONRXERROR(hsmartcard->AdvancedInit.DMADisableonRxError));
<> 144:ef7eb2e8f9f7 1805 MODIFY_REG(hsmartcard->Instance->CR3, USART_CR3_DDRE, hsmartcard->AdvancedInit.DMADisableonRxError);
<> 144:ef7eb2e8f9f7 1806 }
<> 144:ef7eb2e8f9f7 1807
<> 144:ef7eb2e8f9f7 1808 /* if required, configure MSB first on communication line */
<> 144:ef7eb2e8f9f7 1809 if (HAL_IS_BIT_SET(hsmartcard->AdvancedInit.AdvFeatureInit, SMARTCARD_ADVFEATURE_MSBFIRST_INIT))
<> 144:ef7eb2e8f9f7 1810 {
<> 144:ef7eb2e8f9f7 1811 assert_param(IS_SMARTCARD_ADVFEATURE_MSBFIRST(hsmartcard->AdvancedInit.MSBFirst));
<> 144:ef7eb2e8f9f7 1812 MODIFY_REG(hsmartcard->Instance->CR2, USART_CR2_MSBFIRST, hsmartcard->AdvancedInit.MSBFirst);
<> 144:ef7eb2e8f9f7 1813 }
<> 144:ef7eb2e8f9f7 1814
<> 144:ef7eb2e8f9f7 1815 }
<> 144:ef7eb2e8f9f7 1816
<> 144:ef7eb2e8f9f7 1817 /**
<> 144:ef7eb2e8f9f7 1818 * @brief Check the SMARTCARD Idle State.
<> 144:ef7eb2e8f9f7 1819 * @param hsmartcard: Pointer to a SMARTCARD_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1820 * the configuration information for the specified SMARTCARD module.
<> 144:ef7eb2e8f9f7 1821 * @retval HAL status
<> 144:ef7eb2e8f9f7 1822 */
<> 144:ef7eb2e8f9f7 1823 static HAL_StatusTypeDef SMARTCARD_CheckIdleState(SMARTCARD_HandleTypeDef *hsmartcard)
<> 144:ef7eb2e8f9f7 1824 {
<> 144:ef7eb2e8f9f7 1825 uint32_t tickstart = 0;
<> 144:ef7eb2e8f9f7 1826
<> 144:ef7eb2e8f9f7 1827 /* Initialize the SMARTCARD ErrorCode */
<> 144:ef7eb2e8f9f7 1828 hsmartcard->ErrorCode = HAL_SMARTCARD_ERROR_NONE;
<> 144:ef7eb2e8f9f7 1829
<> 144:ef7eb2e8f9f7 1830 /* Init tickstart for timeout managment*/
<> 144:ef7eb2e8f9f7 1831 tickstart = HAL_GetTick();
<> 144:ef7eb2e8f9f7 1832
<> 144:ef7eb2e8f9f7 1833 /* Check if the Transmitter is enabled */
<> 144:ef7eb2e8f9f7 1834 if((hsmartcard->Instance->CR1 & USART_CR1_TE) == USART_CR1_TE)
<> 144:ef7eb2e8f9f7 1835 {
<> 144:ef7eb2e8f9f7 1836 /* Wait until TEACK flag is set */
<> 144:ef7eb2e8f9f7 1837 if(SMARTCARD_WaitOnFlagUntilTimeout(hsmartcard, USART_ISR_TEACK, RESET, tickstart, SMARTCARD_TEACK_REACK_TIMEOUT) != HAL_OK)
<> 144:ef7eb2e8f9f7 1838 {
AnnaBridge 167:e84263d55307 1839 /* Timeout occurred */
<> 144:ef7eb2e8f9f7 1840 return HAL_TIMEOUT;
<> 144:ef7eb2e8f9f7 1841 }
<> 144:ef7eb2e8f9f7 1842 }
<> 144:ef7eb2e8f9f7 1843 /* Check if the Receiver is enabled */
<> 144:ef7eb2e8f9f7 1844 if((hsmartcard->Instance->CR1 & USART_CR1_RE) == USART_CR1_RE)
<> 144:ef7eb2e8f9f7 1845 {
<> 144:ef7eb2e8f9f7 1846 /* Wait until REACK flag is set */
<> 144:ef7eb2e8f9f7 1847 if(SMARTCARD_WaitOnFlagUntilTimeout(hsmartcard, USART_ISR_REACK, RESET, tickstart, SMARTCARD_TEACK_REACK_TIMEOUT) != HAL_OK)
<> 144:ef7eb2e8f9f7 1848 {
AnnaBridge 167:e84263d55307 1849 /* Timeout occurred */
<> 144:ef7eb2e8f9f7 1850 return HAL_TIMEOUT;
<> 144:ef7eb2e8f9f7 1851 }
<> 144:ef7eb2e8f9f7 1852 }
<> 144:ef7eb2e8f9f7 1853
<> 144:ef7eb2e8f9f7 1854 /* Initialize the SMARTCARD states */
<> 144:ef7eb2e8f9f7 1855 hsmartcard->gState = HAL_SMARTCARD_STATE_READY;
<> 144:ef7eb2e8f9f7 1856 hsmartcard->RxState = HAL_SMARTCARD_STATE_READY;
<> 144:ef7eb2e8f9f7 1857
<> 144:ef7eb2e8f9f7 1858 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 1859 __HAL_UNLOCK(hsmartcard);
<> 144:ef7eb2e8f9f7 1860
<> 144:ef7eb2e8f9f7 1861 return HAL_OK;
<> 144:ef7eb2e8f9f7 1862 }
<> 144:ef7eb2e8f9f7 1863
<> 144:ef7eb2e8f9f7 1864 /**
AnnaBridge 167:e84263d55307 1865 * @brief Handle SMARTCARD Communication Timeout.
AnnaBridge 167:e84263d55307 1866 * @param hsmartcard Pointer to a SMARTCARD_HandleTypeDef structure that contains
AnnaBridge 167:e84263d55307 1867 * the configuration information for the specified SMARTCARD module.
AnnaBridge 167:e84263d55307 1868 * @param Flag Specifies the SMARTCARD flag to check.
AnnaBridge 167:e84263d55307 1869 * @param Status The new Flag status (SET or RESET).
AnnaBridge 167:e84263d55307 1870 * @param Tickstart Tick start value
AnnaBridge 167:e84263d55307 1871 * @param Timeout Timeout duration.
AnnaBridge 167:e84263d55307 1872 * @retval HAL status
AnnaBridge 167:e84263d55307 1873 */
AnnaBridge 167:e84263d55307 1874 static HAL_StatusTypeDef SMARTCARD_WaitOnFlagUntilTimeout(SMARTCARD_HandleTypeDef *hsmartcard, uint32_t Flag, FlagStatus Status, uint32_t Tickstart, uint32_t Timeout)
AnnaBridge 167:e84263d55307 1875 {
AnnaBridge 167:e84263d55307 1876 /* Wait until flag is set */
AnnaBridge 167:e84263d55307 1877 while((__HAL_SMARTCARD_GET_FLAG(hsmartcard, Flag) ? SET : RESET) == Status)
AnnaBridge 167:e84263d55307 1878 {
AnnaBridge 167:e84263d55307 1879 /* Check for the Timeout */
AnnaBridge 167:e84263d55307 1880 if(Timeout != HAL_MAX_DELAY)
AnnaBridge 167:e84263d55307 1881 {
AnnaBridge 167:e84263d55307 1882 if((Timeout == 0) || ((HAL_GetTick()-Tickstart) > Timeout))
AnnaBridge 167:e84263d55307 1883 {
AnnaBridge 167:e84263d55307 1884 /* Disable TXE, RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts for the interrupt process */
AnnaBridge 167:e84263d55307 1885 CLEAR_BIT(hsmartcard->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE | USART_CR1_TXEIE));
AnnaBridge 167:e84263d55307 1886 CLEAR_BIT(hsmartcard->Instance->CR3, USART_CR3_EIE);
AnnaBridge 167:e84263d55307 1887
AnnaBridge 167:e84263d55307 1888 hsmartcard->gState = HAL_SMARTCARD_STATE_READY;
AnnaBridge 167:e84263d55307 1889 hsmartcard->RxState = HAL_SMARTCARD_STATE_READY;
AnnaBridge 167:e84263d55307 1890
AnnaBridge 167:e84263d55307 1891 /* Process Unlocked */
AnnaBridge 167:e84263d55307 1892 __HAL_UNLOCK(hsmartcard);
AnnaBridge 167:e84263d55307 1893 return HAL_TIMEOUT;
AnnaBridge 167:e84263d55307 1894 }
AnnaBridge 167:e84263d55307 1895 }
AnnaBridge 167:e84263d55307 1896 }
AnnaBridge 167:e84263d55307 1897 return HAL_OK;
AnnaBridge 167:e84263d55307 1898 }
AnnaBridge 167:e84263d55307 1899
AnnaBridge 167:e84263d55307 1900
AnnaBridge 167:e84263d55307 1901 /**
AnnaBridge 167:e84263d55307 1902 * @brief End ongoing Tx transfer on SMARTCARD peripheral (following error detection or Transmit completion).
AnnaBridge 167:e84263d55307 1903 * @param hsmartcard Pointer to a SMARTCARD_HandleTypeDef structure that contains
AnnaBridge 167:e84263d55307 1904 * the configuration information for the specified SMARTCARD module.
AnnaBridge 167:e84263d55307 1905 * @retval None
AnnaBridge 167:e84263d55307 1906 */
AnnaBridge 167:e84263d55307 1907 static void SMARTCARD_EndTxTransfer(SMARTCARD_HandleTypeDef *hsmartcard)
AnnaBridge 167:e84263d55307 1908 {
AnnaBridge 167:e84263d55307 1909 /* Disable TXEIE, TCIE and ERR (Frame error, noise error, overrun error) interrupts */
AnnaBridge 167:e84263d55307 1910 CLEAR_BIT(hsmartcard->Instance->CR1, (USART_CR1_TXEIE | USART_CR1_TCIE));
AnnaBridge 167:e84263d55307 1911 CLEAR_BIT(hsmartcard->Instance->CR3, USART_CR3_EIE);
AnnaBridge 167:e84263d55307 1912
AnnaBridge 167:e84263d55307 1913 /* At end of Tx process, restore hsmartcard->gState to Ready */
AnnaBridge 167:e84263d55307 1914 hsmartcard->gState = HAL_SMARTCARD_STATE_READY;
AnnaBridge 167:e84263d55307 1915 }
AnnaBridge 167:e84263d55307 1916
AnnaBridge 167:e84263d55307 1917
AnnaBridge 167:e84263d55307 1918 /**
AnnaBridge 167:e84263d55307 1919 * @brief End ongoing Rx transfer on UART peripheral (following error detection or Reception completion).
AnnaBridge 167:e84263d55307 1920 * @param hsmartcard Pointer to a SMARTCARD_HandleTypeDef structure that contains
AnnaBridge 167:e84263d55307 1921 * the configuration information for the specified SMARTCARD module.
AnnaBridge 167:e84263d55307 1922 * @retval None
AnnaBridge 167:e84263d55307 1923 */
AnnaBridge 167:e84263d55307 1924 static void SMARTCARD_EndRxTransfer(SMARTCARD_HandleTypeDef *hsmartcard)
AnnaBridge 167:e84263d55307 1925 {
AnnaBridge 167:e84263d55307 1926 /* Disable RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts */
AnnaBridge 167:e84263d55307 1927 CLEAR_BIT(hsmartcard->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE));
AnnaBridge 167:e84263d55307 1928 CLEAR_BIT(hsmartcard->Instance->CR3, USART_CR3_EIE);
AnnaBridge 167:e84263d55307 1929
AnnaBridge 167:e84263d55307 1930 /* At end of Rx process, restore hsmartcard->RxState to Ready */
AnnaBridge 167:e84263d55307 1931 hsmartcard->RxState = HAL_SMARTCARD_STATE_READY;
AnnaBridge 167:e84263d55307 1932 }
AnnaBridge 167:e84263d55307 1933
AnnaBridge 167:e84263d55307 1934
AnnaBridge 167:e84263d55307 1935 /**
AnnaBridge 167:e84263d55307 1936 * @brief DMA SMARTCARD transmit process complete callback.
AnnaBridge 167:e84263d55307 1937 * @param hdma Pointer to a DMA_HandleTypeDef structure that contains
AnnaBridge 167:e84263d55307 1938 * the configuration information for the specified DMA module.
AnnaBridge 167:e84263d55307 1939 * @retval None
AnnaBridge 167:e84263d55307 1940 */
AnnaBridge 167:e84263d55307 1941 static void SMARTCARD_DMATransmitCplt(DMA_HandleTypeDef *hdma)
AnnaBridge 167:e84263d55307 1942 {
AnnaBridge 167:e84263d55307 1943 SMARTCARD_HandleTypeDef* hsmartcard = (SMARTCARD_HandleTypeDef*)(hdma->Parent);
AnnaBridge 167:e84263d55307 1944 hsmartcard->TxXferCount = 0;
AnnaBridge 167:e84263d55307 1945
AnnaBridge 167:e84263d55307 1946 /* Disable the DMA transfer for transmit request by resetting the DMAT bit
AnnaBridge 167:e84263d55307 1947 in the SMARTCARD associated USART CR3 register */
AnnaBridge 167:e84263d55307 1948 CLEAR_BIT(hsmartcard->Instance->CR3, USART_CR3_DMAT);
AnnaBridge 167:e84263d55307 1949
AnnaBridge 167:e84263d55307 1950 /* Enable the SMARTCARD Transmit Complete Interrupt */
AnnaBridge 167:e84263d55307 1951 __HAL_SMARTCARD_ENABLE_IT(hsmartcard, hsmartcard->AdvancedInit.TxCompletionIndication);
AnnaBridge 167:e84263d55307 1952 }
AnnaBridge 167:e84263d55307 1953
AnnaBridge 167:e84263d55307 1954 /**
AnnaBridge 167:e84263d55307 1955 * @brief DMA SMARTCARD receive process complete callback.
AnnaBridge 167:e84263d55307 1956 * @param hdma Pointer to a DMA_HandleTypeDef structure that contains
AnnaBridge 167:e84263d55307 1957 * the configuration information for the specified DMA module.
AnnaBridge 167:e84263d55307 1958 * @retval None
AnnaBridge 167:e84263d55307 1959 */
AnnaBridge 167:e84263d55307 1960 static void SMARTCARD_DMAReceiveCplt(DMA_HandleTypeDef *hdma)
AnnaBridge 167:e84263d55307 1961 {
AnnaBridge 167:e84263d55307 1962 SMARTCARD_HandleTypeDef* hsmartcard = (SMARTCARD_HandleTypeDef*)(hdma->Parent);
AnnaBridge 167:e84263d55307 1963 hsmartcard->RxXferCount = 0;
AnnaBridge 167:e84263d55307 1964
AnnaBridge 167:e84263d55307 1965 /* Disable PE and ERR (Frame error, noise error, overrun error) interrupts */
AnnaBridge 167:e84263d55307 1966 CLEAR_BIT(hsmartcard->Instance->CR1, USART_CR1_PEIE);
AnnaBridge 167:e84263d55307 1967 CLEAR_BIT(hsmartcard->Instance->CR3, USART_CR3_EIE);
AnnaBridge 167:e84263d55307 1968
AnnaBridge 167:e84263d55307 1969 /* Disable the DMA transfer for the receiver request by resetting the DMAR bit
AnnaBridge 167:e84263d55307 1970 in the SMARTCARD associated USART CR3 register */
AnnaBridge 167:e84263d55307 1971 CLEAR_BIT(hsmartcard->Instance->CR3, USART_CR3_DMAR);
AnnaBridge 167:e84263d55307 1972
AnnaBridge 167:e84263d55307 1973 /* At end of Rx process, restore hsmartcard->RxState to Ready */
AnnaBridge 167:e84263d55307 1974 hsmartcard->RxState = HAL_SMARTCARD_STATE_READY;
AnnaBridge 167:e84263d55307 1975
AnnaBridge 167:e84263d55307 1976 HAL_SMARTCARD_RxCpltCallback(hsmartcard);
AnnaBridge 167:e84263d55307 1977 }
AnnaBridge 167:e84263d55307 1978
AnnaBridge 167:e84263d55307 1979 /**
AnnaBridge 167:e84263d55307 1980 * @brief DMA SMARTCARD communication error callback.
AnnaBridge 167:e84263d55307 1981 * @param hdma Pointer to a DMA_HandleTypeDef structure that contains
AnnaBridge 167:e84263d55307 1982 * the configuration information for the specified DMA module.
AnnaBridge 167:e84263d55307 1983 * @retval None
AnnaBridge 167:e84263d55307 1984 */
AnnaBridge 167:e84263d55307 1985 static void SMARTCARD_DMAError(DMA_HandleTypeDef *hdma)
AnnaBridge 167:e84263d55307 1986 {
AnnaBridge 167:e84263d55307 1987 SMARTCARD_HandleTypeDef* hsmartcard = (SMARTCARD_HandleTypeDef*)(hdma->Parent);
AnnaBridge 167:e84263d55307 1988
AnnaBridge 167:e84263d55307 1989 /* Stop SMARTCARD DMA Tx request if ongoing */
AnnaBridge 167:e84263d55307 1990 if ( (hsmartcard->gState == HAL_SMARTCARD_STATE_BUSY_TX)
AnnaBridge 167:e84263d55307 1991 &&(HAL_IS_BIT_SET(hsmartcard->Instance->CR3, USART_CR3_DMAT)) )
AnnaBridge 167:e84263d55307 1992 {
AnnaBridge 167:e84263d55307 1993 hsmartcard->TxXferCount = 0;
AnnaBridge 167:e84263d55307 1994 SMARTCARD_EndTxTransfer(hsmartcard);
AnnaBridge 167:e84263d55307 1995 }
AnnaBridge 167:e84263d55307 1996
AnnaBridge 167:e84263d55307 1997 /* Stop SMARTCARD DMA Rx request if ongoing */
AnnaBridge 167:e84263d55307 1998 if ( (hsmartcard->RxState == HAL_SMARTCARD_STATE_BUSY_RX)
AnnaBridge 167:e84263d55307 1999 &&(HAL_IS_BIT_SET(hsmartcard->Instance->CR3, USART_CR3_DMAR)) )
AnnaBridge 167:e84263d55307 2000 {
AnnaBridge 167:e84263d55307 2001 hsmartcard->RxXferCount = 0;
AnnaBridge 167:e84263d55307 2002 SMARTCARD_EndRxTransfer(hsmartcard);
AnnaBridge 167:e84263d55307 2003 }
AnnaBridge 167:e84263d55307 2004
AnnaBridge 167:e84263d55307 2005 hsmartcard->ErrorCode |= HAL_SMARTCARD_ERROR_DMA;
AnnaBridge 167:e84263d55307 2006 HAL_SMARTCARD_ErrorCallback(hsmartcard);
AnnaBridge 167:e84263d55307 2007 }
AnnaBridge 167:e84263d55307 2008
AnnaBridge 167:e84263d55307 2009 /**
AnnaBridge 167:e84263d55307 2010 * @brief DMA SMARTCARD communication abort callback, when initiated by HAL services on Error
AnnaBridge 167:e84263d55307 2011 * (To be called at end of DMA Abort procedure following error occurrence).
AnnaBridge 167:e84263d55307 2012 * @param hdma DMA handle.
AnnaBridge 167:e84263d55307 2013 * @retval None
AnnaBridge 167:e84263d55307 2014 */
AnnaBridge 167:e84263d55307 2015 static void SMARTCARD_DMAAbortOnError(DMA_HandleTypeDef *hdma)
AnnaBridge 167:e84263d55307 2016 {
AnnaBridge 167:e84263d55307 2017 SMARTCARD_HandleTypeDef* hsmartcard = (SMARTCARD_HandleTypeDef*)(hdma->Parent);
AnnaBridge 167:e84263d55307 2018 hsmartcard->RxXferCount = 0;
AnnaBridge 167:e84263d55307 2019 hsmartcard->TxXferCount = 0;
AnnaBridge 167:e84263d55307 2020
AnnaBridge 167:e84263d55307 2021 HAL_SMARTCARD_ErrorCallback(hsmartcard);
AnnaBridge 167:e84263d55307 2022 }
AnnaBridge 167:e84263d55307 2023
AnnaBridge 167:e84263d55307 2024 /**
AnnaBridge 167:e84263d55307 2025 * @brief DMA SMARTCARD Tx communication abort callback, when initiated by user
AnnaBridge 167:e84263d55307 2026 * (To be called at end of DMA Tx Abort procedure following user abort request).
AnnaBridge 167:e84263d55307 2027 * @note When this callback is executed, User Abort complete call back is called only if no
AnnaBridge 167:e84263d55307 2028 * Abort still ongoing for Rx DMA Handle.
AnnaBridge 167:e84263d55307 2029 * @param hdma DMA handle.
AnnaBridge 167:e84263d55307 2030 * @retval None
AnnaBridge 167:e84263d55307 2031 */
AnnaBridge 167:e84263d55307 2032 static void SMARTCARD_DMATxAbortCallback(DMA_HandleTypeDef *hdma)
AnnaBridge 167:e84263d55307 2033 {
AnnaBridge 167:e84263d55307 2034 SMARTCARD_HandleTypeDef* hsmartcard = (SMARTCARD_HandleTypeDef* )(hdma->Parent);
AnnaBridge 167:e84263d55307 2035
AnnaBridge 167:e84263d55307 2036 hsmartcard->hdmatx->XferAbortCallback = NULL;
AnnaBridge 167:e84263d55307 2037
AnnaBridge 167:e84263d55307 2038 /* Check if an Abort process is still ongoing */
AnnaBridge 167:e84263d55307 2039 if(hsmartcard->hdmarx != NULL)
AnnaBridge 167:e84263d55307 2040 {
AnnaBridge 167:e84263d55307 2041 if(hsmartcard->hdmarx->XferAbortCallback != NULL)
AnnaBridge 167:e84263d55307 2042 {
AnnaBridge 167:e84263d55307 2043 return;
AnnaBridge 167:e84263d55307 2044 }
AnnaBridge 167:e84263d55307 2045 }
AnnaBridge 167:e84263d55307 2046
AnnaBridge 167:e84263d55307 2047 /* No Abort process still ongoing : All DMA channels are aborted, call user Abort Complete callback */
AnnaBridge 167:e84263d55307 2048 hsmartcard->TxXferCount = 0;
AnnaBridge 167:e84263d55307 2049 hsmartcard->RxXferCount = 0;
AnnaBridge 167:e84263d55307 2050
AnnaBridge 167:e84263d55307 2051 /* Reset errorCode */
AnnaBridge 167:e84263d55307 2052 hsmartcard->ErrorCode = HAL_SMARTCARD_ERROR_NONE;
AnnaBridge 167:e84263d55307 2053
AnnaBridge 167:e84263d55307 2054 /* Clear the Error flags in the ICR register */
AnnaBridge 167:e84263d55307 2055 __HAL_SMARTCARD_CLEAR_FLAG(hsmartcard, SMARTCARD_CLEAR_OREF | SMARTCARD_CLEAR_NEF | SMARTCARD_CLEAR_PEF | SMARTCARD_CLEAR_FEF | SMARTCARD_CLEAR_RTOF | SMARTCARD_CLEAR_EOBF);
AnnaBridge 167:e84263d55307 2056
AnnaBridge 167:e84263d55307 2057 /* Restore hsmartcard->gState and hsmartcard->RxState to Ready */
AnnaBridge 167:e84263d55307 2058 hsmartcard->gState = HAL_SMARTCARD_STATE_READY;
AnnaBridge 167:e84263d55307 2059 hsmartcard->RxState = HAL_SMARTCARD_STATE_READY;
AnnaBridge 167:e84263d55307 2060
AnnaBridge 167:e84263d55307 2061 /* Call user Abort complete callback */
AnnaBridge 167:e84263d55307 2062 HAL_SMARTCARD_AbortCpltCallback(hsmartcard);
AnnaBridge 167:e84263d55307 2063 }
AnnaBridge 167:e84263d55307 2064
AnnaBridge 167:e84263d55307 2065
AnnaBridge 167:e84263d55307 2066 /**
AnnaBridge 167:e84263d55307 2067 * @brief DMA SMARTCARD Rx communication abort callback, when initiated by user
AnnaBridge 167:e84263d55307 2068 * (To be called at end of DMA Rx Abort procedure following user abort request).
AnnaBridge 167:e84263d55307 2069 * @note When this callback is executed, User Abort complete call back is called only if no
AnnaBridge 167:e84263d55307 2070 * Abort still ongoing for Tx DMA Handle.
AnnaBridge 167:e84263d55307 2071 * @param hdma DMA handle.
AnnaBridge 167:e84263d55307 2072 * @retval None
AnnaBridge 167:e84263d55307 2073 */
AnnaBridge 167:e84263d55307 2074 static void SMARTCARD_DMARxAbortCallback(DMA_HandleTypeDef *hdma)
AnnaBridge 167:e84263d55307 2075 {
AnnaBridge 167:e84263d55307 2076 SMARTCARD_HandleTypeDef* hsmartcard = (SMARTCARD_HandleTypeDef* )(hdma->Parent);
AnnaBridge 167:e84263d55307 2077
AnnaBridge 167:e84263d55307 2078 hsmartcard->hdmarx->XferAbortCallback = NULL;
AnnaBridge 167:e84263d55307 2079
AnnaBridge 167:e84263d55307 2080 /* Check if an Abort process is still ongoing */
AnnaBridge 167:e84263d55307 2081 if(hsmartcard->hdmatx != NULL)
AnnaBridge 167:e84263d55307 2082 {
AnnaBridge 167:e84263d55307 2083 if(hsmartcard->hdmatx->XferAbortCallback != NULL)
AnnaBridge 167:e84263d55307 2084 {
AnnaBridge 167:e84263d55307 2085 return;
AnnaBridge 167:e84263d55307 2086 }
AnnaBridge 167:e84263d55307 2087 }
AnnaBridge 167:e84263d55307 2088
AnnaBridge 167:e84263d55307 2089 /* No Abort process still ongoing : All DMA channels are aborted, call user Abort Complete callback */
AnnaBridge 167:e84263d55307 2090 hsmartcard->TxXferCount = 0;
AnnaBridge 167:e84263d55307 2091 hsmartcard->RxXferCount = 0;
AnnaBridge 167:e84263d55307 2092
AnnaBridge 167:e84263d55307 2093 /* Reset errorCode */
AnnaBridge 167:e84263d55307 2094 hsmartcard->ErrorCode = HAL_SMARTCARD_ERROR_NONE;
AnnaBridge 167:e84263d55307 2095
AnnaBridge 167:e84263d55307 2096 /* Clear the Error flags in the ICR register */
AnnaBridge 167:e84263d55307 2097 __HAL_SMARTCARD_CLEAR_FLAG(hsmartcard, SMARTCARD_CLEAR_OREF | SMARTCARD_CLEAR_NEF | SMARTCARD_CLEAR_PEF | SMARTCARD_CLEAR_FEF | SMARTCARD_CLEAR_RTOF | SMARTCARD_CLEAR_EOBF);
AnnaBridge 167:e84263d55307 2098
AnnaBridge 167:e84263d55307 2099 /* Restore hsmartcard->gState and hsmartcard->RxState to Ready */
AnnaBridge 167:e84263d55307 2100 hsmartcard->gState = HAL_SMARTCARD_STATE_READY;
AnnaBridge 167:e84263d55307 2101 hsmartcard->RxState = HAL_SMARTCARD_STATE_READY;
AnnaBridge 167:e84263d55307 2102
AnnaBridge 167:e84263d55307 2103 /* Call user Abort complete callback */
AnnaBridge 167:e84263d55307 2104 HAL_SMARTCARD_AbortCpltCallback(hsmartcard);
AnnaBridge 167:e84263d55307 2105 }
AnnaBridge 167:e84263d55307 2106
AnnaBridge 167:e84263d55307 2107
AnnaBridge 167:e84263d55307 2108 /**
AnnaBridge 167:e84263d55307 2109 * @brief DMA SMARTCARD Tx communication abort callback, when initiated by user by a call to
AnnaBridge 167:e84263d55307 2110 * HAL_SMARTCARD_AbortTransmit_IT API (Abort only Tx transfer)
AnnaBridge 167:e84263d55307 2111 * (This callback is executed at end of DMA Tx Abort procedure following user abort request,
AnnaBridge 167:e84263d55307 2112 * and leads to user Tx Abort Complete callback execution).
AnnaBridge 167:e84263d55307 2113 * @param hdma DMA handle.
AnnaBridge 167:e84263d55307 2114 * @retval None
AnnaBridge 167:e84263d55307 2115 */
AnnaBridge 167:e84263d55307 2116 static void SMARTCARD_DMATxOnlyAbortCallback(DMA_HandleTypeDef *hdma)
AnnaBridge 167:e84263d55307 2117 {
AnnaBridge 167:e84263d55307 2118 SMARTCARD_HandleTypeDef* hsmartcard = (SMARTCARD_HandleTypeDef*)(hdma->Parent);
AnnaBridge 167:e84263d55307 2119
AnnaBridge 167:e84263d55307 2120 hsmartcard->TxXferCount = 0;
AnnaBridge 167:e84263d55307 2121
AnnaBridge 167:e84263d55307 2122 /* Clear the Error flags in the ICR register */
AnnaBridge 167:e84263d55307 2123 __HAL_SMARTCARD_CLEAR_FLAG(hsmartcard, SMARTCARD_CLEAR_FEF);
AnnaBridge 167:e84263d55307 2124
AnnaBridge 167:e84263d55307 2125 /* Restore hsmartcard->gState to Ready */
AnnaBridge 167:e84263d55307 2126 hsmartcard->gState = HAL_SMARTCARD_STATE_READY;
AnnaBridge 167:e84263d55307 2127
AnnaBridge 167:e84263d55307 2128 /* Call user Abort complete callback */
AnnaBridge 167:e84263d55307 2129 HAL_SMARTCARD_AbortTransmitCpltCallback(hsmartcard);
AnnaBridge 167:e84263d55307 2130 }
AnnaBridge 167:e84263d55307 2131
AnnaBridge 167:e84263d55307 2132 /**
AnnaBridge 167:e84263d55307 2133 * @brief DMA SMARTCARD Rx communication abort callback, when initiated by user by a call to
AnnaBridge 167:e84263d55307 2134 * HAL_SMARTCARD_AbortReceive_IT API (Abort only Rx transfer)
AnnaBridge 167:e84263d55307 2135 * (This callback is executed at end of DMA Rx Abort procedure following user abort request,
AnnaBridge 167:e84263d55307 2136 * and leads to user Rx Abort Complete callback execution).
AnnaBridge 167:e84263d55307 2137 * @param hdma DMA handle.
AnnaBridge 167:e84263d55307 2138 * @retval None
AnnaBridge 167:e84263d55307 2139 */
AnnaBridge 167:e84263d55307 2140 static void SMARTCARD_DMARxOnlyAbortCallback(DMA_HandleTypeDef *hdma)
AnnaBridge 167:e84263d55307 2141 {
AnnaBridge 167:e84263d55307 2142 SMARTCARD_HandleTypeDef* hsmartcard = ( SMARTCARD_HandleTypeDef* )(hdma->Parent);
AnnaBridge 167:e84263d55307 2143
AnnaBridge 167:e84263d55307 2144 hsmartcard->RxXferCount = 0;
AnnaBridge 167:e84263d55307 2145
AnnaBridge 167:e84263d55307 2146 /* Clear the Error flags in the ICR register */
AnnaBridge 167:e84263d55307 2147 __HAL_SMARTCARD_CLEAR_FLAG(hsmartcard, SMARTCARD_CLEAR_OREF | SMARTCARD_CLEAR_NEF | SMARTCARD_CLEAR_PEF | SMARTCARD_CLEAR_FEF | SMARTCARD_CLEAR_RTOF | SMARTCARD_CLEAR_EOBF);
AnnaBridge 167:e84263d55307 2148
AnnaBridge 167:e84263d55307 2149 /* Restore hsmartcard->RxState to Ready */
AnnaBridge 167:e84263d55307 2150 hsmartcard->RxState = HAL_SMARTCARD_STATE_READY;
AnnaBridge 167:e84263d55307 2151
AnnaBridge 167:e84263d55307 2152 /* Call user Abort complete callback */
AnnaBridge 167:e84263d55307 2153 HAL_SMARTCARD_AbortReceiveCpltCallback(hsmartcard);
AnnaBridge 167:e84263d55307 2154 }
AnnaBridge 167:e84263d55307 2155
AnnaBridge 167:e84263d55307 2156 /**
AnnaBridge 167:e84263d55307 2157 * @brief Send an amount of data in non-blocking mode.
AnnaBridge 167:e84263d55307 2158 * @param hsmartcard: Pointer to a SMARTCARD_HandleTypeDef structure that contains
AnnaBridge 167:e84263d55307 2159 * the configuration information for the specified SMARTCARD module.
AnnaBridge 167:e84263d55307 2160 * Function called under interruption only, once
AnnaBridge 167:e84263d55307 2161 * interruptions have been enabled by HAL_SMARTCARD_Transmit_IT()
AnnaBridge 167:e84263d55307 2162 * @retval HAL status
AnnaBridge 167:e84263d55307 2163 */
AnnaBridge 167:e84263d55307 2164 static HAL_StatusTypeDef SMARTCARD_Transmit_IT(SMARTCARD_HandleTypeDef *hsmartcard)
AnnaBridge 167:e84263d55307 2165 {
AnnaBridge 167:e84263d55307 2166 /* Check that a Tx process is ongoing */
AnnaBridge 167:e84263d55307 2167 if (hsmartcard->gState == HAL_SMARTCARD_STATE_BUSY_TX)
AnnaBridge 167:e84263d55307 2168 {
AnnaBridge 167:e84263d55307 2169 if(hsmartcard->TxXferCount == 0)
AnnaBridge 167:e84263d55307 2170 {
AnnaBridge 167:e84263d55307 2171 /* Disable the SMARTCARD Transmit Data Register Empty Interrupt */
AnnaBridge 167:e84263d55307 2172 CLEAR_BIT(hsmartcard->Instance->CR1, USART_CR1_TXEIE);
AnnaBridge 167:e84263d55307 2173
AnnaBridge 167:e84263d55307 2174 /* Enable the SMARTCARD Transmit Complete Interrupt */
AnnaBridge 167:e84263d55307 2175 __HAL_SMARTCARD_ENABLE_IT(hsmartcard, hsmartcard->AdvancedInit.TxCompletionIndication);
AnnaBridge 167:e84263d55307 2176
AnnaBridge 167:e84263d55307 2177 return HAL_OK;
AnnaBridge 167:e84263d55307 2178 }
AnnaBridge 167:e84263d55307 2179 else
AnnaBridge 167:e84263d55307 2180 {
AnnaBridge 167:e84263d55307 2181 hsmartcard->Instance->TDR = (*hsmartcard->pTxBuffPtr++ & (uint8_t)0xFF);
AnnaBridge 167:e84263d55307 2182 hsmartcard->TxXferCount--;
AnnaBridge 167:e84263d55307 2183
AnnaBridge 167:e84263d55307 2184 return HAL_OK;
AnnaBridge 167:e84263d55307 2185 }
AnnaBridge 167:e84263d55307 2186 }
AnnaBridge 167:e84263d55307 2187 else
AnnaBridge 167:e84263d55307 2188 {
AnnaBridge 167:e84263d55307 2189 return HAL_BUSY;
AnnaBridge 167:e84263d55307 2190 }
AnnaBridge 167:e84263d55307 2191 }
AnnaBridge 167:e84263d55307 2192
AnnaBridge 167:e84263d55307 2193 /**
AnnaBridge 167:e84263d55307 2194 * @brief Wrap up transmission in non-blocking mode.
AnnaBridge 167:e84263d55307 2195 * @param hsmartcard Pointer to a SMARTCARD_HandleTypeDef structure that contains
AnnaBridge 167:e84263d55307 2196 * the configuration information for the specified SMARTCARD module.
AnnaBridge 167:e84263d55307 2197 * @retval HAL status
AnnaBridge 167:e84263d55307 2198 */
AnnaBridge 167:e84263d55307 2199 static HAL_StatusTypeDef SMARTCARD_EndTransmit_IT(SMARTCARD_HandleTypeDef *hsmartcard)
AnnaBridge 167:e84263d55307 2200 {
AnnaBridge 167:e84263d55307 2201 /* Disable the SMARTCARD Transmit Complete Interrupt */
AnnaBridge 167:e84263d55307 2202 __HAL_SMARTCARD_DISABLE_IT(hsmartcard, hsmartcard->AdvancedInit.TxCompletionIndication);
AnnaBridge 167:e84263d55307 2203
AnnaBridge 167:e84263d55307 2204 /* Check if a receive process is ongoing or not. If not disable ERR IT */
AnnaBridge 167:e84263d55307 2205 if(hsmartcard->RxState == HAL_SMARTCARD_STATE_READY)
AnnaBridge 167:e84263d55307 2206 {
AnnaBridge 167:e84263d55307 2207 /* Disable the SMARTCARD Error Interrupt: (Frame error) */
AnnaBridge 167:e84263d55307 2208 CLEAR_BIT(hsmartcard->Instance->CR3, USART_CR3_EIE);
AnnaBridge 167:e84263d55307 2209 }
AnnaBridge 167:e84263d55307 2210
AnnaBridge 167:e84263d55307 2211 /* Re-enable Rx at end of transmission if initial mode is Rx/Tx */
AnnaBridge 167:e84263d55307 2212 if(hsmartcard->Init.Mode == SMARTCARD_MODE_TX_RX)
AnnaBridge 167:e84263d55307 2213 {
AnnaBridge 167:e84263d55307 2214 /* Disable the Peripheral first to update modes */
AnnaBridge 167:e84263d55307 2215 CLEAR_BIT(hsmartcard->Instance->CR1, USART_CR1_UE);
AnnaBridge 167:e84263d55307 2216 SET_BIT(hsmartcard->Instance->CR1, USART_CR1_RE);
AnnaBridge 167:e84263d55307 2217 /* Enable the Peripheral */
AnnaBridge 167:e84263d55307 2218 SET_BIT(hsmartcard->Instance->CR1, USART_CR1_UE);
AnnaBridge 167:e84263d55307 2219 }
AnnaBridge 167:e84263d55307 2220
AnnaBridge 167:e84263d55307 2221 /* Tx process is ended, restore hsmartcard->gState to Ready */
AnnaBridge 167:e84263d55307 2222 hsmartcard->gState = HAL_SMARTCARD_STATE_READY;
AnnaBridge 167:e84263d55307 2223
AnnaBridge 167:e84263d55307 2224 HAL_SMARTCARD_TxCpltCallback(hsmartcard);
AnnaBridge 167:e84263d55307 2225
AnnaBridge 167:e84263d55307 2226 return HAL_OK;
AnnaBridge 167:e84263d55307 2227 }
AnnaBridge 167:e84263d55307 2228
AnnaBridge 167:e84263d55307 2229 /**
AnnaBridge 167:e84263d55307 2230 * @brief Receive an amount of data in non-blocking mode.
AnnaBridge 167:e84263d55307 2231 * @param hsmartcard: Pointer to a SMARTCARD_HandleTypeDef structure that contains
AnnaBridge 167:e84263d55307 2232 * the configuration information for the specified SMARTCARD module.
AnnaBridge 167:e84263d55307 2233 * Function called under interruption only, once
AnnaBridge 167:e84263d55307 2234 * interruptions have been enabled by HAL_SMARTCARD_Receive_IT().
AnnaBridge 167:e84263d55307 2235 * @retval HAL status
AnnaBridge 167:e84263d55307 2236 */
AnnaBridge 167:e84263d55307 2237 static HAL_StatusTypeDef SMARTCARD_Receive_IT(SMARTCARD_HandleTypeDef *hsmartcard)
AnnaBridge 167:e84263d55307 2238 {
AnnaBridge 167:e84263d55307 2239 /* Check that a Rx process is ongoing */
AnnaBridge 167:e84263d55307 2240 if (hsmartcard->RxState == HAL_SMARTCARD_STATE_BUSY_RX)
AnnaBridge 167:e84263d55307 2241 {
AnnaBridge 167:e84263d55307 2242 *hsmartcard->pRxBuffPtr++ = (uint8_t)(hsmartcard->Instance->RDR & (uint8_t)0xFF);
AnnaBridge 167:e84263d55307 2243
AnnaBridge 167:e84263d55307 2244 if(--hsmartcard->RxXferCount == 0)
AnnaBridge 167:e84263d55307 2245 {
AnnaBridge 167:e84263d55307 2246 CLEAR_BIT(hsmartcard->Instance->CR1, USART_CR1_RXNEIE);
AnnaBridge 167:e84263d55307 2247
AnnaBridge 167:e84263d55307 2248 /* Check if a transmit process is ongoing or not. If not disable ERR IT */
AnnaBridge 167:e84263d55307 2249 if(hsmartcard->gState == HAL_SMARTCARD_STATE_READY)
AnnaBridge 167:e84263d55307 2250 {
AnnaBridge 167:e84263d55307 2251 /* Disable the SMARTCARD Error Interrupt: (Frame error, noise error, overrun error) */
AnnaBridge 167:e84263d55307 2252 CLEAR_BIT(hsmartcard->Instance->CR3, USART_CR3_EIE);
AnnaBridge 167:e84263d55307 2253 }
AnnaBridge 167:e84263d55307 2254
AnnaBridge 167:e84263d55307 2255 /* Disable the SMARTCARD Parity Error Interrupt */
AnnaBridge 167:e84263d55307 2256 CLEAR_BIT(hsmartcard->Instance->CR1, USART_CR1_PEIE);
AnnaBridge 167:e84263d55307 2257
AnnaBridge 167:e84263d55307 2258 hsmartcard->RxState = HAL_SMARTCARD_STATE_READY;
AnnaBridge 167:e84263d55307 2259
AnnaBridge 167:e84263d55307 2260 HAL_SMARTCARD_RxCpltCallback(hsmartcard);
AnnaBridge 167:e84263d55307 2261
AnnaBridge 167:e84263d55307 2262 return HAL_OK;
AnnaBridge 167:e84263d55307 2263 }
AnnaBridge 167:e84263d55307 2264
AnnaBridge 167:e84263d55307 2265 return HAL_OK;
AnnaBridge 167:e84263d55307 2266 }
AnnaBridge 167:e84263d55307 2267 else
AnnaBridge 167:e84263d55307 2268 {
AnnaBridge 167:e84263d55307 2269 /* Clear RXNE interrupt flag */
AnnaBridge 167:e84263d55307 2270 __HAL_SMARTCARD_SEND_REQ(hsmartcard, SMARTCARD_RXDATA_FLUSH_REQUEST);
AnnaBridge 167:e84263d55307 2271
AnnaBridge 167:e84263d55307 2272 return HAL_BUSY;
AnnaBridge 167:e84263d55307 2273 }
AnnaBridge 167:e84263d55307 2274 }
AnnaBridge 167:e84263d55307 2275
AnnaBridge 167:e84263d55307 2276 /**
<> 144:ef7eb2e8f9f7 2277 * @}
<> 144:ef7eb2e8f9f7 2278 */
<> 144:ef7eb2e8f9f7 2279
<> 144:ef7eb2e8f9f7 2280 #endif /* HAL_SMARTCARD_MODULE_ENABLED */
<> 144:ef7eb2e8f9f7 2281 /**
<> 144:ef7eb2e8f9f7 2282 * @}
<> 144:ef7eb2e8f9f7 2283 */
<> 144:ef7eb2e8f9f7 2284
<> 144:ef7eb2e8f9f7 2285 /**
<> 144:ef7eb2e8f9f7 2286 * @}
<> 144:ef7eb2e8f9f7 2287 */
<> 144:ef7eb2e8f9f7 2288
<> 144:ef7eb2e8f9f7 2289 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/