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_STM32F1/device/stm32f1xx_hal_smartcard.c@189:f392fc9709a3, 2019-02-20 (annotated)

Committer:
AnnaBridge
Date:
Wed Feb 20 22:31:08 2019 +0000
Revision:
189:f392fc9709a3
Parent:
187:0387e8f68319 
mbed library release version 165

Who changed what in which revision?

UserRevisionLine numberNew contents of line
<> 144:ef7eb2e8f9f7 1 /**
<> 144:ef7eb2e8f9f7 2 ******************************************************************************
<> 144:ef7eb2e8f9f7 3 * @file stm32f1xx_hal_smartcard.c
<> 144:ef7eb2e8f9f7 4 * @author MCD Application Team
<> 144:ef7eb2e8f9f7 5 * @brief SMARTCARD HAL module driver.
AnnaBridge 187:0387e8f68319 6 * This file provides firmware functions to manage the following
<> 144:ef7eb2e8f9f7 7 * functionalities of the SMARTCARD peripheral:
<> 144:ef7eb2e8f9f7 8 * + Initialization and de-initialization functions
<> 144:ef7eb2e8f9f7 9 * + IO operation functions
AnnaBridge 165:e614a9f1c9e2 10 * + Peripheral Control functions
<> 144:ef7eb2e8f9f7 11 * + Peripheral State and Errors functions
<> 144:ef7eb2e8f9f7 12 @verbatim
<> 144:ef7eb2e8f9f7 13 ==============================================================================
<> 144:ef7eb2e8f9f7 14 ##### How to use this driver #####
<> 144:ef7eb2e8f9f7 15 ==============================================================================
<> 144:ef7eb2e8f9f7 16 [..]
<> 144:ef7eb2e8f9f7 17 The SMARTCARD HAL driver can be used as follows:
<> 144:ef7eb2e8f9f7 18
<> 144:ef7eb2e8f9f7 19 (#) Declare a SMARTCARD_HandleTypeDef handle structure.
<> 144:ef7eb2e8f9f7 20 (#) Initialize the SMARTCARD low level resources by implementing the HAL_SMARTCARD_MspInit() API:
AnnaBridge 165:e614a9f1c9e2 21 (##) Enable the USARTx interface clock.
<> 144:ef7eb2e8f9f7 22 (##) SMARTCARD pins configuration:
<> 144:ef7eb2e8f9f7 23 (+++) Enable the clock for the SMARTCARD GPIOs.
AnnaBridge 165:e614a9f1c9e2 24 (+++) Configure the SMARTCARD pins as alternate function pull-up.
<> 144:ef7eb2e8f9f7 25 (##) NVIC configuration if you need to use interrupt process (HAL_SMARTCARD_Transmit_IT()
<> 144:ef7eb2e8f9f7 26 and HAL_SMARTCARD_Receive_IT() APIs):
<> 144:ef7eb2e8f9f7 27 (+++) Configure the USARTx interrupt priority.
<> 144:ef7eb2e8f9f7 28 (+++) Enable the NVIC USART IRQ handle.
<> 144:ef7eb2e8f9f7 29 (##) DMA Configuration if you need to use DMA process (HAL_SMARTCARD_Transmit_DMA()
<> 144:ef7eb2e8f9f7 30 and HAL_SMARTCARD_Receive_DMA() APIs):
<> 144:ef7eb2e8f9f7 31 (+++) Declare a DMA handle structure for the Tx/Rx channel.
<> 144:ef7eb2e8f9f7 32 (+++) Enable the DMAx interface clock.
<> 144:ef7eb2e8f9f7 33 (+++) Configure the declared DMA handle structure with the required Tx/Rx parameters.
<> 144:ef7eb2e8f9f7 34 (+++) Configure the DMA Tx/Rx channel.
AnnaBridge 165:e614a9f1c9e2 35 (+++) Associate the initialized DMA handle to the SMARTCARD DMA Tx/Rx handle.
<> 144:ef7eb2e8f9f7 36 (+++) Configure the priority and enable the NVIC for the transfer complete interrupt on the DMA Tx/Rx channel.
<> 144:ef7eb2e8f9f7 37 (+++) Configure the USARTx interrupt priority and enable the NVIC USART IRQ handle
<> 144:ef7eb2e8f9f7 38 (used for last byte sending completion detection in DMA non circular mode)
<> 144:ef7eb2e8f9f7 39
AnnaBridge 187:0387e8f68319 40 (#) Program the Baud Rate, Word Length, Stop Bit, Parity, Hardware
<> 144:ef7eb2e8f9f7 41 flow control and Mode(Receiver/Transmitter) in the SMARTCARD Init structure.
<> 144:ef7eb2e8f9f7 42
<> 144:ef7eb2e8f9f7 43 (#) Initialize the SMARTCARD registers by calling the HAL_SMARTCARD_Init() API:
AnnaBridge 165:e614a9f1c9e2 44 (++) These APIs configure also the low level Hardware GPIO, CLOCK, CORTEX...etc)
AnnaBridge 165:e614a9f1c9e2 45 by calling the customized HAL_SMARTCARD_MspInit() API.
AnnaBridge 187:0387e8f68319 46 [..]
AnnaBridge 187:0387e8f68319 47 (@)The specific SMARTCARD interrupts (Transmission complete interrupt,
AnnaBridge 165:e614a9f1c9e2 48 RXNE interrupt and Error Interrupts) will be managed using the macros
AnnaBridge 165:e614a9f1c9e2 49 __HAL_SMARTCARD_ENABLE_IT() and __HAL_SMARTCARD_DISABLE_IT() inside the transmit and receive process.
AnnaBridge 165:e614a9f1c9e2 50
AnnaBridge 165:e614a9f1c9e2 51 [..]
AnnaBridge 165:e614a9f1c9e2 52 Three operation modes are available within this driver:
<> 144:ef7eb2e8f9f7 53
AnnaBridge 165:e614a9f1c9e2 54 *** Polling mode IO operation ***
AnnaBridge 165:e614a9f1c9e2 55 =================================
AnnaBridge 165:e614a9f1c9e2 56 [..]
AnnaBridge 165:e614a9f1c9e2 57 (+) Send an amount of data in blocking mode using HAL_SMARTCARD_Transmit()
AnnaBridge 165:e614a9f1c9e2 58 (+) Receive an amount of data in blocking mode using HAL_SMARTCARD_Receive()
AnnaBridge 165:e614a9f1c9e2 59 *** Interrupt mode IO operation ***
AnnaBridge 165:e614a9f1c9e2 60 ===================================
AnnaBridge 165:e614a9f1c9e2 61 [..]
AnnaBridge 165:e614a9f1c9e2 62 (+) Send an amount of data in non blocking mode using HAL_SMARTCARD_Transmit_IT()
AnnaBridge 165:e614a9f1c9e2 63 (+) At transmission end of transfer HAL_SMARTCARD_TxCpltCallback is executed and user can
AnnaBridge 165:e614a9f1c9e2 64 add his own code by customization of function pointer HAL_SMARTCARD_TxCpltCallback
AnnaBridge 165:e614a9f1c9e2 65 (+) Receive an amount of data in non blocking mode using HAL_SMARTCARD_Receive_IT()
AnnaBridge 165:e614a9f1c9e2 66 (+) At reception end of transfer HAL_SMARTCARD_RxCpltCallback is executed and user can
AnnaBridge 165:e614a9f1c9e2 67 add his own code by customization of function pointer HAL_SMARTCARD_RxCpltCallback
AnnaBridge 187:0387e8f68319 68 (+) In case of transfer Error, HAL_SMARTCARD_ErrorCallback() function is executed and user can
AnnaBridge 165:e614a9f1c9e2 69 add his own code by customization of function pointer HAL_SMARTCARD_ErrorCallback
<> 144:ef7eb2e8f9f7 70
AnnaBridge 187:0387e8f68319 71 *** DMA mode IO operation ***
AnnaBridge 165:e614a9f1c9e2 72 ==============================
AnnaBridge 187:0387e8f68319 73 [..]
AnnaBridge 165:e614a9f1c9e2 74 (+) Send an amount of data in non blocking mode (DMA) using HAL_SMARTCARD_Transmit_DMA()
AnnaBridge 165:e614a9f1c9e2 75 (+) At transmission end of transfer HAL_SMARTCARD_TxCpltCallback is executed and user can
AnnaBridge 165:e614a9f1c9e2 76 add his own code by customization of function pointer HAL_SMARTCARD_TxCpltCallback
AnnaBridge 165:e614a9f1c9e2 77 (+) Receive an amount of data in non blocking mode (DMA) using HAL_SMARTCARD_Receive_DMA()
AnnaBridge 165:e614a9f1c9e2 78 (+) At reception end of transfer HAL_SMARTCARD_RxCpltCallback is executed and user can
AnnaBridge 165:e614a9f1c9e2 79 add his own code by customization of function pointer HAL_SMARTCARD_RxCpltCallback
AnnaBridge 165:e614a9f1c9e2 80 (+) In case of transfer Error, HAL_SMARTCARD_ErrorCallback() function is executed and user can
AnnaBridge 165:e614a9f1c9e2 81 add his own code by customization of function pointer HAL_SMARTCARD_ErrorCallback
<> 144:ef7eb2e8f9f7 82
AnnaBridge 165:e614a9f1c9e2 83 *** SMARTCARD HAL driver macros list ***
AnnaBridge 165:e614a9f1c9e2 84 =============================================
AnnaBridge 165:e614a9f1c9e2 85 [..]
AnnaBridge 165:e614a9f1c9e2 86 Below the list of most used macros in SMARTCARD HAL driver.
AnnaBridge 165:e614a9f1c9e2 87
AnnaBridge 165:e614a9f1c9e2 88 (+) __HAL_SMARTCARD_ENABLE: Enable the SMARTCARD peripheral
AnnaBridge 165:e614a9f1c9e2 89 (+) __HAL_SMARTCARD_DISABLE: Disable the SMARTCARD peripheral
AnnaBridge 165:e614a9f1c9e2 90 (+) __HAL_SMARTCARD_GET_FLAG : Check whether the specified SMARTCARD flag is set or not
AnnaBridge 165:e614a9f1c9e2 91 (+) __HAL_SMARTCARD_CLEAR_FLAG : Clear the specified SMARTCARD pending flag
AnnaBridge 165:e614a9f1c9e2 92 (+) __HAL_SMARTCARD_ENABLE_IT: Enable the specified SMARTCARD interrupt
AnnaBridge 165:e614a9f1c9e2 93 (+) __HAL_SMARTCARD_DISABLE_IT: Disable the specified SMARTCARD interrupt
AnnaBridge 187:0387e8f68319 94
AnnaBridge 187:0387e8f68319 95 [..]
AnnaBridge 165:e614a9f1c9e2 96 (@) You can refer to the SMARTCARD HAL driver header file for more useful macros
AnnaBridge 187:0387e8f68319 97
AnnaBridge 165:e614a9f1c9e2 98 @endverbatim
<> 144:ef7eb2e8f9f7 99 [..]
AnnaBridge 165:e614a9f1c9e2 100 (@) Additionnal remark: If the parity is enabled, then the MSB bit of the data written
AnnaBridge 165:e614a9f1c9e2 101 in the data register is transmitted but is changed by the parity bit.
AnnaBridge 165:e614a9f1c9e2 102 Depending on the frame length defined by the M bit (8-bits or 9-bits),
AnnaBridge 165:e614a9f1c9e2 103 the possible SMARTCARD frame formats are as listed in the following table:
AnnaBridge 165:e614a9f1c9e2 104 +-------------------------------------------------------------+
AnnaBridge 165:e614a9f1c9e2 105 | M bit | PCE bit | SMARTCARD frame |
AnnaBridge 165:e614a9f1c9e2 106 |---------------------|---------------------------------------|
AnnaBridge 165:e614a9f1c9e2 107 | 1 | 1 | | SB | 8 bit data | PB | STB | |
AnnaBridge 165:e614a9f1c9e2 108 +-------------------------------------------------------------+
<> 144:ef7eb2e8f9f7 109 ******************************************************************************
<> 144:ef7eb2e8f9f7 110 * @attention
<> 144:ef7eb2e8f9f7 111 *
AnnaBridge 165:e614a9f1c9e2 112 * <h2><center>&copy; COPYRIGHT(c) 2017 STMicroelectronics</center></h2>
<> 144:ef7eb2e8f9f7 113 *
<> 144:ef7eb2e8f9f7 114 * Redistribution and use in source and binary forms, with or without modification,
<> 144:ef7eb2e8f9f7 115 * are permitted provided that the following conditions are met:
<> 144:ef7eb2e8f9f7 116 * 1. Redistributions of source code must retain the above copyright notice,
<> 144:ef7eb2e8f9f7 117 * this list of conditions and the following disclaimer.
<> 144:ef7eb2e8f9f7 118 * 2. Redistributions in binary form must reproduce the above copyright notice,
<> 144:ef7eb2e8f9f7 119 * this list of conditions and the following disclaimer in the documentation
<> 144:ef7eb2e8f9f7 120 * and/or other materials provided with the distribution.
<> 144:ef7eb2e8f9f7 121 * 3. Neither the name of STMicroelectronics nor the names of its contributors
<> 144:ef7eb2e8f9f7 122 * may be used to endorse or promote products derived from this software
<> 144:ef7eb2e8f9f7 123 * without specific prior written permission.
<> 144:ef7eb2e8f9f7 124 *
<> 144:ef7eb2e8f9f7 125 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
<> 144:ef7eb2e8f9f7 126 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
<> 144:ef7eb2e8f9f7 127 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
<> 144:ef7eb2e8f9f7 128 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
<> 144:ef7eb2e8f9f7 129 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
<> 144:ef7eb2e8f9f7 130 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
<> 144:ef7eb2e8f9f7 131 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
<> 144:ef7eb2e8f9f7 132 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
<> 144:ef7eb2e8f9f7 133 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
<> 144:ef7eb2e8f9f7 134 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
<> 144:ef7eb2e8f9f7 135 *
<> 144:ef7eb2e8f9f7 136 ******************************************************************************
<> 144:ef7eb2e8f9f7 137 */
<> 144:ef7eb2e8f9f7 138
<> 144:ef7eb2e8f9f7 139 /* Includes ------------------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 140 #include "stm32f1xx_hal.h"
<> 144:ef7eb2e8f9f7 141
<> 144:ef7eb2e8f9f7 142 /** @addtogroup STM32F1xx_HAL_Driver
<> 144:ef7eb2e8f9f7 143 * @{
<> 144:ef7eb2e8f9f7 144 */
<> 144:ef7eb2e8f9f7 145
<> 144:ef7eb2e8f9f7 146 /** @defgroup SMARTCARD SMARTCARD
<> 144:ef7eb2e8f9f7 147 * @brief HAL SMARTCARD module driver
<> 144:ef7eb2e8f9f7 148 * @{
<> 144:ef7eb2e8f9f7 149 */
<> 144:ef7eb2e8f9f7 150 #ifdef HAL_SMARTCARD_MODULE_ENABLED
<> 144:ef7eb2e8f9f7 151 /* Private typedef -----------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 152 /* Private define ------------------------------------------------------------*/
AnnaBridge 165:e614a9f1c9e2 153 /** @addtogroup SMARTCARD_Private_Constants
AnnaBridge 165:e614a9f1c9e2 154 * @{
AnnaBridge 165:e614a9f1c9e2 155 */
AnnaBridge 165:e614a9f1c9e2 156 /**
AnnaBridge 165:e614a9f1c9e2 157 * @}
AnnaBridge 165:e614a9f1c9e2 158 */
AnnaBridge 165:e614a9f1c9e2 159 /* Private macro -------------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 160 /* Private variables ---------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 161 /* Private function prototypes -----------------------------------------------*/
AnnaBridge 165:e614a9f1c9e2 162 /** @addtogroup SMARTCARD_Private_Functions
<> 144:ef7eb2e8f9f7 163 * @{
<> 144:ef7eb2e8f9f7 164 */
AnnaBridge 165:e614a9f1c9e2 165 static void SMARTCARD_EndTxTransfer(SMARTCARD_HandleTypeDef *hsc);
AnnaBridge 165:e614a9f1c9e2 166 static void SMARTCARD_EndRxTransfer(SMARTCARD_HandleTypeDef *hsc);
AnnaBridge 187:0387e8f68319 167 static void SMARTCARD_SetConfig(SMARTCARD_HandleTypeDef *hsc);
<> 144:ef7eb2e8f9f7 168 static HAL_StatusTypeDef SMARTCARD_Transmit_IT(SMARTCARD_HandleTypeDef *hsc);
<> 144:ef7eb2e8f9f7 169 static HAL_StatusTypeDef SMARTCARD_EndTransmit_IT(SMARTCARD_HandleTypeDef *hsmartcard);
<> 144:ef7eb2e8f9f7 170 static HAL_StatusTypeDef SMARTCARD_Receive_IT(SMARTCARD_HandleTypeDef *hsc);
<> 144:ef7eb2e8f9f7 171 static void SMARTCARD_DMATransmitCplt(DMA_HandleTypeDef *hdma);
<> 144:ef7eb2e8f9f7 172 static void SMARTCARD_DMAReceiveCplt(DMA_HandleTypeDef *hdma);
<> 144:ef7eb2e8f9f7 173 static void SMARTCARD_DMAError(DMA_HandleTypeDef *hdma);
AnnaBridge 165:e614a9f1c9e2 174 static void SMARTCARD_DMAAbortOnError(DMA_HandleTypeDef *hdma);
AnnaBridge 165:e614a9f1c9e2 175 static void SMARTCARD_DMATxAbortCallback(DMA_HandleTypeDef *hdma);
AnnaBridge 165:e614a9f1c9e2 176 static void SMARTCARD_DMARxAbortCallback(DMA_HandleTypeDef *hdma);
AnnaBridge 165:e614a9f1c9e2 177 static void SMARTCARD_DMATxOnlyAbortCallback(DMA_HandleTypeDef *hdma);
AnnaBridge 165:e614a9f1c9e2 178 static void SMARTCARD_DMARxOnlyAbortCallback(DMA_HandleTypeDef *hdma);
AnnaBridge 165:e614a9f1c9e2 179 static HAL_StatusTypeDef SMARTCARD_WaitOnFlagUntilTimeout(SMARTCARD_HandleTypeDef *hsc, uint32_t Flag, FlagStatus Status, uint32_t Tickstart, uint32_t Timeout);
<> 144:ef7eb2e8f9f7 180 /**
<> 144:ef7eb2e8f9f7 181 * @}
<> 144:ef7eb2e8f9f7 182 */
AnnaBridge 165:e614a9f1c9e2 183 /* Exported functions --------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 184 /** @defgroup SMARTCARD_Exported_Functions SMARTCARD Exported Functions
<> 144:ef7eb2e8f9f7 185 * @{
<> 144:ef7eb2e8f9f7 186 */
<> 144:ef7eb2e8f9f7 187
AnnaBridge 187:0387e8f68319 188 /** @defgroup SMARTCARD_Exported_Functions_Group1 SmartCard Initialization and de-initialization functions
AnnaBridge 187:0387e8f68319 189 * @brief Initialization and Configuration functions
<> 144:ef7eb2e8f9f7 190 *
<> 144:ef7eb2e8f9f7 191 @verbatim
<> 144:ef7eb2e8f9f7 192 ==============================================================================
AnnaBridge 165:e614a9f1c9e2 193 ##### Initialization and Configuration functions #####
<> 144:ef7eb2e8f9f7 194 ==============================================================================
<> 144:ef7eb2e8f9f7 195 [..]
AnnaBridge 187:0387e8f68319 196 This subsection provides a set of functions allowing to initialize the USART
<> 144:ef7eb2e8f9f7 197 in Smartcard mode.
<> 144:ef7eb2e8f9f7 198 [..]
<> 144:ef7eb2e8f9f7 199 The Smartcard interface is designed to support asynchronous protocol Smartcards as
<> 144:ef7eb2e8f9f7 200 defined in the ISO 7816-3 standard.
<> 144:ef7eb2e8f9f7 201 [..]
<> 144:ef7eb2e8f9f7 202 The USART can provide a clock to the smartcard through the SCLK output.
AnnaBridge 187:0387e8f68319 203 In smartcard mode, SCLK is not associated to the communication but is simply derived
<> 144:ef7eb2e8f9f7 204 from the internal peripheral input clock through a 5-bit prescaler.
<> 144:ef7eb2e8f9f7 205 [..]
<> 144:ef7eb2e8f9f7 206 (+) For the Smartcard mode only these parameters can be configured:
<> 144:ef7eb2e8f9f7 207 (++) Baud Rate
<> 144:ef7eb2e8f9f7 208 (++) Word Length => Should be 9 bits (8 bits + parity)
<> 144:ef7eb2e8f9f7 209 (++) Stop Bit
AnnaBridge 165:e614a9f1c9e2 210 (++) Parity: => Should be enabled
<> 144:ef7eb2e8f9f7 211 (++) USART polarity
<> 144:ef7eb2e8f9f7 212 (++) USART phase
<> 144:ef7eb2e8f9f7 213 (++) USART LastBit
<> 144:ef7eb2e8f9f7 214 (++) Receiver/transmitter modes
<> 144:ef7eb2e8f9f7 215 (++) Prescaler
<> 144:ef7eb2e8f9f7 216 (++) GuardTime
<> 144:ef7eb2e8f9f7 217 (++) NACKState: The Smartcard NACK state
<> 144:ef7eb2e8f9f7 218
<> 144:ef7eb2e8f9f7 219 (+) Recommended SmartCard interface configuration to get the Answer to Reset from the Card:
<> 144:ef7eb2e8f9f7 220 (++) Word Length = 9 Bits
<> 144:ef7eb2e8f9f7 221 (++) 1.5 Stop Bit
<> 144:ef7eb2e8f9f7 222 (++) Even parity
<> 144:ef7eb2e8f9f7 223 (++) BaudRate = 12096 baud
<> 144:ef7eb2e8f9f7 224 (++) Tx and Rx enabled
<> 144:ef7eb2e8f9f7 225 [..]
<> 144:ef7eb2e8f9f7 226 Please refer to the ISO 7816-3 specification for more details.
<> 144:ef7eb2e8f9f7 227
<> 144:ef7eb2e8f9f7 228 [..]
AnnaBridge 187:0387e8f68319 229 (@) It is also possible to choose 0.5 stop bit for receiving but it is recommended
AnnaBridge 187:0387e8f68319 230 to use 1.5 stop bits for both transmitting and receiving to avoid switching
AnnaBridge 165:e614a9f1c9e2 231 between the two configurations.
AnnaBridge 165:e614a9f1c9e2 232 [..]
AnnaBridge 187:0387e8f68319 233 The HAL_SMARTCARD_Init() function follows the USART SmartCard configuration
AnnaBridge 165:e614a9f1c9e2 234 procedure (details for the procedure are available in reference manual (RM0329)).
<> 144:ef7eb2e8f9f7 235
<> 144:ef7eb2e8f9f7 236 @endverbatim
<> 144:ef7eb2e8f9f7 237 * @{
<> 144:ef7eb2e8f9f7 238 */
<> 144:ef7eb2e8f9f7 239
<> 144:ef7eb2e8f9f7 240 /**
AnnaBridge 165:e614a9f1c9e2 241 * @brief Initializes the SmartCard mode according to the specified
AnnaBridge 165:e614a9f1c9e2 242 * parameters in the SMARTCARD_InitTypeDef and create the associated handle.
AnnaBridge 165:e614a9f1c9e2 243 * @param hsc: pointer to a SMARTCARD_HandleTypeDef structure that contains
AnnaBridge 165:e614a9f1c9e2 244 * the configuration information for SMARTCARD module.
<> 144:ef7eb2e8f9f7 245 * @retval HAL status
<> 144:ef7eb2e8f9f7 246 */
<> 144:ef7eb2e8f9f7 247 HAL_StatusTypeDef HAL_SMARTCARD_Init(SMARTCARD_HandleTypeDef *hsc)
<> 144:ef7eb2e8f9f7 248 {
<> 144:ef7eb2e8f9f7 249 /* Check the SMARTCARD handle allocation */
AnnaBridge 187:0387e8f68319 250 if (hsc == NULL)
<> 144:ef7eb2e8f9f7 251 {
<> 144:ef7eb2e8f9f7 252 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 253 }
<> 144:ef7eb2e8f9f7 254
<> 144:ef7eb2e8f9f7 255 /* Check the parameters */
<> 144:ef7eb2e8f9f7 256 assert_param(IS_SMARTCARD_INSTANCE(hsc->Instance));
AnnaBridge 165:e614a9f1c9e2 257
<> 144:ef7eb2e8f9f7 258
AnnaBridge 187:0387e8f68319 259 if (hsc->gState == HAL_SMARTCARD_STATE_RESET)
AnnaBridge 187:0387e8f68319 260 {
<> 144:ef7eb2e8f9f7 261 /* Allocate lock resource and initialize it */
<> 144:ef7eb2e8f9f7 262 hsc->Lock = HAL_UNLOCKED;
AnnaBridge 165:e614a9f1c9e2 263
AnnaBridge 165:e614a9f1c9e2 264 /* Init the low level hardware : GPIO, CLOCK, CORTEX...etc */
<> 144:ef7eb2e8f9f7 265 HAL_SMARTCARD_MspInit(hsc);
<> 144:ef7eb2e8f9f7 266 }
<> 144:ef7eb2e8f9f7 267
AnnaBridge 165:e614a9f1c9e2 268 hsc->gState = HAL_SMARTCARD_STATE_BUSY;
AnnaBridge 165:e614a9f1c9e2 269
<> 144:ef7eb2e8f9f7 270 /* Set the Prescaler */
<> 144:ef7eb2e8f9f7 271 MODIFY_REG(hsc->Instance->GTPR, USART_GTPR_PSC, hsc->Init.Prescaler);
<> 144:ef7eb2e8f9f7 272
<> 144:ef7eb2e8f9f7 273 /* Set the Guard Time */
AnnaBridge 187:0387e8f68319 274 MODIFY_REG(hsc->Instance->GTPR, USART_GTPR_GT, ((hsc->Init.GuardTime) << 8U));
<> 144:ef7eb2e8f9f7 275
<> 144:ef7eb2e8f9f7 276 /* Set the Smartcard Communication parameters */
<> 144:ef7eb2e8f9f7 277 SMARTCARD_SetConfig(hsc);
<> 144:ef7eb2e8f9f7 278
AnnaBridge 187:0387e8f68319 279 /* In SmartCard mode, the following bits must be kept cleared:
<> 144:ef7eb2e8f9f7 280 - LINEN bit in the USART_CR2 register
<> 144:ef7eb2e8f9f7 281 - HDSEL and IREN bits in the USART_CR3 register.*/
<> 144:ef7eb2e8f9f7 282 CLEAR_BIT(hsc->Instance->CR2, USART_CR2_LINEN);
<> 144:ef7eb2e8f9f7 283 CLEAR_BIT(hsc->Instance->CR3, (USART_CR3_IREN | USART_CR3_HDSEL));
<> 144:ef7eb2e8f9f7 284
AnnaBridge 165:e614a9f1c9e2 285 /* Enable the SMARTCARD Parity Error Interrupt */
AnnaBridge 165:e614a9f1c9e2 286 SET_BIT(hsc->Instance->CR1, USART_CR1_PEIE);
AnnaBridge 165:e614a9f1c9e2 287
AnnaBridge 165:e614a9f1c9e2 288 /* Enable the SMARTCARD Framing Error Interrupt */
AnnaBridge 165:e614a9f1c9e2 289 SET_BIT(hsc->Instance->CR3, USART_CR3_EIE);
AnnaBridge 165:e614a9f1c9e2 290
AnnaBridge 165:e614a9f1c9e2 291 /* Enable the Peripheral */
<> 144:ef7eb2e8f9f7 292 __HAL_SMARTCARD_ENABLE(hsc);
<> 144:ef7eb2e8f9f7 293
<> 144:ef7eb2e8f9f7 294 /* Configure the Smartcard NACK state */
<> 144:ef7eb2e8f9f7 295 MODIFY_REG(hsc->Instance->CR3, USART_CR3_NACK, hsc->Init.NACKState);
<> 144:ef7eb2e8f9f7 296
<> 144:ef7eb2e8f9f7 297 /* Enable the SC mode by setting the SCEN bit in the CR3 register */
AnnaBridge 165:e614a9f1c9e2 298 hsc->Instance->CR3 |= (USART_CR3_SCEN);
<> 144:ef7eb2e8f9f7 299
<> 144:ef7eb2e8f9f7 300 /* Initialize the SMARTCARD state*/
<> 144:ef7eb2e8f9f7 301 hsc->ErrorCode = HAL_SMARTCARD_ERROR_NONE;
AnnaBridge 187:0387e8f68319 302 hsc->gState = HAL_SMARTCARD_STATE_READY;
AnnaBridge 187:0387e8f68319 303 hsc->RxState = HAL_SMARTCARD_STATE_READY;
<> 144:ef7eb2e8f9f7 304
<> 144:ef7eb2e8f9f7 305 return HAL_OK;
<> 144:ef7eb2e8f9f7 306 }
<> 144:ef7eb2e8f9f7 307
<> 144:ef7eb2e8f9f7 308 /**
AnnaBridge 165:e614a9f1c9e2 309 * @brief DeInitializes the USART SmartCard peripheral
AnnaBridge 165:e614a9f1c9e2 310 * @param hsc: pointer to a SMARTCARD_HandleTypeDef structure that contains
AnnaBridge 165:e614a9f1c9e2 311 * the configuration information for SMARTCARD module.
<> 144:ef7eb2e8f9f7 312 * @retval HAL status
<> 144:ef7eb2e8f9f7 313 */
<> 144:ef7eb2e8f9f7 314 HAL_StatusTypeDef HAL_SMARTCARD_DeInit(SMARTCARD_HandleTypeDef *hsc)
<> 144:ef7eb2e8f9f7 315 {
<> 144:ef7eb2e8f9f7 316 /* Check the SMARTCARD handle allocation */
AnnaBridge 187:0387e8f68319 317 if (hsc == NULL)
<> 144:ef7eb2e8f9f7 318 {
<> 144:ef7eb2e8f9f7 319 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 320 }
<> 144:ef7eb2e8f9f7 321
<> 144:ef7eb2e8f9f7 322 /* Check the parameters */
<> 144:ef7eb2e8f9f7 323 assert_param(IS_SMARTCARD_INSTANCE(hsc->Instance));
<> 144:ef7eb2e8f9f7 324
AnnaBridge 165:e614a9f1c9e2 325 hsc->gState = HAL_SMARTCARD_STATE_BUSY;
<> 144:ef7eb2e8f9f7 326
<> 144:ef7eb2e8f9f7 327 /* DeInit the low level hardware */
<> 144:ef7eb2e8f9f7 328 HAL_SMARTCARD_MspDeInit(hsc);
<> 144:ef7eb2e8f9f7 329
<> 144:ef7eb2e8f9f7 330 hsc->ErrorCode = HAL_SMARTCARD_ERROR_NONE;
AnnaBridge 165:e614a9f1c9e2 331 hsc->gState = HAL_SMARTCARD_STATE_RESET;
AnnaBridge 165:e614a9f1c9e2 332 hsc->RxState = HAL_SMARTCARD_STATE_RESET;
<> 144:ef7eb2e8f9f7 333
<> 144:ef7eb2e8f9f7 334 /* Release Lock */
<> 144:ef7eb2e8f9f7 335 __HAL_UNLOCK(hsc);
<> 144:ef7eb2e8f9f7 336
<> 144:ef7eb2e8f9f7 337 return HAL_OK;
<> 144:ef7eb2e8f9f7 338 }
<> 144:ef7eb2e8f9f7 339
<> 144:ef7eb2e8f9f7 340 /**
AnnaBridge 165:e614a9f1c9e2 341 * @brief SMARTCARD MSP Init.
AnnaBridge 165:e614a9f1c9e2 342 * @param hsc: pointer to a SMARTCARD_HandleTypeDef structure that contains
AnnaBridge 165:e614a9f1c9e2 343 * the configuration information for SMARTCARD module.
<> 144:ef7eb2e8f9f7 344 * @retval None
<> 144:ef7eb2e8f9f7 345 */
AnnaBridge 165:e614a9f1c9e2 346 __weak void HAL_SMARTCARD_MspInit(SMARTCARD_HandleTypeDef *hsc)
<> 144:ef7eb2e8f9f7 347 {
<> 144:ef7eb2e8f9f7 348 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 349 UNUSED(hsc);
<> 144:ef7eb2e8f9f7 350 /* NOTE: This function should not be modified, when the callback is needed,
AnnaBridge 165:e614a9f1c9e2 351 the HAL_SMARTCARD_MspInit could be implemented in the user file
AnnaBridge 165:e614a9f1c9e2 352 */
<> 144:ef7eb2e8f9f7 353 }
<> 144:ef7eb2e8f9f7 354
<> 144:ef7eb2e8f9f7 355 /**
AnnaBridge 165:e614a9f1c9e2 356 * @brief SMARTCARD MSP DeInit
AnnaBridge 165:e614a9f1c9e2 357 * @param hsc: pointer to a SMARTCARD_HandleTypeDef structure that contains
AnnaBridge 165:e614a9f1c9e2 358 * the configuration information for SMARTCARD module.
<> 144:ef7eb2e8f9f7 359 * @retval None
<> 144:ef7eb2e8f9f7 360 */
AnnaBridge 165:e614a9f1c9e2 361 __weak void HAL_SMARTCARD_MspDeInit(SMARTCARD_HandleTypeDef *hsc)
<> 144:ef7eb2e8f9f7 362 {
<> 144:ef7eb2e8f9f7 363 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 364 UNUSED(hsc);
<> 144:ef7eb2e8f9f7 365 /* NOTE: This function should not be modified, when the callback is needed,
AnnaBridge 165:e614a9f1c9e2 366 the HAL_SMARTCARD_MspDeInit could be implemented in the user file
AnnaBridge 165:e614a9f1c9e2 367 */
<> 144:ef7eb2e8f9f7 368 }
<> 144:ef7eb2e8f9f7 369
<> 144:ef7eb2e8f9f7 370 /**
<> 144:ef7eb2e8f9f7 371 * @}
<> 144:ef7eb2e8f9f7 372 */
<> 144:ef7eb2e8f9f7 373
AnnaBridge 187:0387e8f68319 374 /** @defgroup SMARTCARD_Exported_Functions_Group2 IO operation functions
AnnaBridge 187:0387e8f68319 375 * @brief SMARTCARD Transmit and Receive functions
<> 144:ef7eb2e8f9f7 376 *
<> 144:ef7eb2e8f9f7 377 @verbatim
AnnaBridge 165:e614a9f1c9e2 378 ===============================================================================
AnnaBridge 165:e614a9f1c9e2 379 ##### IO operation functions #####
AnnaBridge 165:e614a9f1c9e2 380 ===============================================================================
AnnaBridge 165:e614a9f1c9e2 381 [..]
AnnaBridge 165:e614a9f1c9e2 382 This subsection provides a set of functions allowing to manage the SMARTCARD data transfers.
<> 144:ef7eb2e8f9f7 383
AnnaBridge 165:e614a9f1c9e2 384 [..]
AnnaBridge 187:0387e8f68319 385 (#) Smartcard is a single wire half duplex communication protocol.
<> 144:ef7eb2e8f9f7 386 The Smartcard interface is designed to support asynchronous protocol Smartcards as
AnnaBridge 187:0387e8f68319 387 defined in the ISO 7816-3 standard.
<> 144:ef7eb2e8f9f7 388 (#) The USART should be configured as:
AnnaBridge 165:e614a9f1c9e2 389 (++) 8 bits plus parity: where M=1 and PCE=1 in the USART_CR1 register
AnnaBridge 165:e614a9f1c9e2 390 (++) 1.5 stop bits when transmitting and receiving: where STOP=11 in the USART_CR2 register.
<> 144:ef7eb2e8f9f7 391
<> 144:ef7eb2e8f9f7 392 (#) There are two modes of transfer:
AnnaBridge 187:0387e8f68319 393 (++) Blocking mode: The communication is performed in polling mode.
AnnaBridge 187:0387e8f68319 394 The HAL status of all data processing is returned by the same function
AnnaBridge 187:0387e8f68319 395 after finishing transfer.
AnnaBridge 187:0387e8f68319 396 (++) Non Blocking mode: The communication is performed using Interrupts
AnnaBridge 165:e614a9f1c9e2 397 or DMA, These APIs return the HAL status.
AnnaBridge 187:0387e8f68319 398 The end of the data processing will be indicated through the
AnnaBridge 187:0387e8f68319 399 dedicated SMARTCARD IRQ when using Interrupt mode or the DMA IRQ when
AnnaBridge 165:e614a9f1c9e2 400 using DMA mode.
AnnaBridge 187:0387e8f68319 401 The HAL_SMARTCARD_TxCpltCallback(), HAL_SMARTCARD_RxCpltCallback() user callbacks
AnnaBridge 165:e614a9f1c9e2 402 will be executed respectively at the end of the Transmit or Receive process
AnnaBridge 165:e614a9f1c9e2 403 The HAL_SMARTCARD_ErrorCallback() user callback will be executed when a communication error is detected
<> 144:ef7eb2e8f9f7 404
<> 144:ef7eb2e8f9f7 405 (#) Blocking mode APIs are :
<> 144:ef7eb2e8f9f7 406 (++) HAL_SMARTCARD_Transmit()
<> 144:ef7eb2e8f9f7 407 (++) HAL_SMARTCARD_Receive()
<> 144:ef7eb2e8f9f7 408
<> 144:ef7eb2e8f9f7 409 (#) Non Blocking mode APIs with Interrupt are :
<> 144:ef7eb2e8f9f7 410 (++) HAL_SMARTCARD_Transmit_IT()
<> 144:ef7eb2e8f9f7 411 (++) HAL_SMARTCARD_Receive_IT()
<> 144:ef7eb2e8f9f7 412 (++) HAL_SMARTCARD_IRQHandler()
<> 144:ef7eb2e8f9f7 413
<> 144:ef7eb2e8f9f7 414 (#) Non Blocking mode functions with DMA are :
<> 144:ef7eb2e8f9f7 415 (++) HAL_SMARTCARD_Transmit_DMA()
<> 144:ef7eb2e8f9f7 416 (++) HAL_SMARTCARD_Receive_DMA()
<> 144:ef7eb2e8f9f7 417
<> 144:ef7eb2e8f9f7 418 (#) A set of Transfer Complete Callbacks are provided in non Blocking mode:
<> 144:ef7eb2e8f9f7 419 (++) HAL_SMARTCARD_TxCpltCallback()
<> 144:ef7eb2e8f9f7 420 (++) HAL_SMARTCARD_RxCpltCallback()
<> 144:ef7eb2e8f9f7 421 (++) HAL_SMARTCARD_ErrorCallback()
<> 144:ef7eb2e8f9f7 422
<> 144:ef7eb2e8f9f7 423 @endverbatim
<> 144:ef7eb2e8f9f7 424 * @{
<> 144:ef7eb2e8f9f7 425 */
<> 144:ef7eb2e8f9f7 426
<> 144:ef7eb2e8f9f7 427 /**
AnnaBridge 165:e614a9f1c9e2 428 * @brief Send an amount of data in blocking mode
AnnaBridge 165:e614a9f1c9e2 429 * @param hsc: pointer to a SMARTCARD_HandleTypeDef structure that contains
AnnaBridge 165:e614a9f1c9e2 430 * the configuration information for SMARTCARD module.
AnnaBridge 165:e614a9f1c9e2 431 * @param pData: pointer to data buffer
AnnaBridge 165:e614a9f1c9e2 432 * @param Size: amount of data to be sent
AnnaBridge 165:e614a9f1c9e2 433 * @param Timeout: Timeout duration
<> 144:ef7eb2e8f9f7 434 * @retval HAL status
<> 144:ef7eb2e8f9f7 435 */
<> 144:ef7eb2e8f9f7 436 HAL_StatusTypeDef HAL_SMARTCARD_Transmit(SMARTCARD_HandleTypeDef *hsc, uint8_t *pData, uint16_t Size, uint32_t Timeout)
<> 144:ef7eb2e8f9f7 437 {
AnnaBridge 165:e614a9f1c9e2 438 uint32_t tickstart = 0U;
AnnaBridge 187:0387e8f68319 439
AnnaBridge 187:0387e8f68319 440 if (hsc->gState == HAL_SMARTCARD_STATE_READY)
<> 144:ef7eb2e8f9f7 441 {
AnnaBridge 187:0387e8f68319 442 if ((pData == NULL) || (Size == 0U))
<> 144:ef7eb2e8f9f7 443 {
<> 144:ef7eb2e8f9f7 444 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 445 }
<> 144:ef7eb2e8f9f7 446
<> 144:ef7eb2e8f9f7 447 /* Process Locked */
<> 144:ef7eb2e8f9f7 448 __HAL_LOCK(hsc);
<> 144:ef7eb2e8f9f7 449
<> 144:ef7eb2e8f9f7 450 hsc->ErrorCode = HAL_SMARTCARD_ERROR_NONE;
AnnaBridge 165:e614a9f1c9e2 451 hsc->gState = HAL_SMARTCARD_STATE_BUSY_TX;
AnnaBridge 165:e614a9f1c9e2 452
AnnaBridge 165:e614a9f1c9e2 453 /* Init tickstart for timeout managment */
AnnaBridge 165:e614a9f1c9e2 454 tickstart = HAL_GetTick();
AnnaBridge 165:e614a9f1c9e2 455
<> 144:ef7eb2e8f9f7 456 hsc->TxXferSize = Size;
<> 144:ef7eb2e8f9f7 457 hsc->TxXferCount = Size;
AnnaBridge 187:0387e8f68319 458 while (hsc->TxXferCount > 0U)
<> 144:ef7eb2e8f9f7 459 {
AnnaBridge 165:e614a9f1c9e2 460 hsc->TxXferCount--;
AnnaBridge 187:0387e8f68319 461 if (SMARTCARD_WaitOnFlagUntilTimeout(hsc, SMARTCARD_FLAG_TXE, RESET, tickstart, Timeout) != HAL_OK)
<> 144:ef7eb2e8f9f7 462 {
<> 144:ef7eb2e8f9f7 463 return HAL_TIMEOUT;
<> 144:ef7eb2e8f9f7 464 }
AnnaBridge 187:0387e8f68319 465 hsc->Instance->DR = *(uint8_t *) pData;
AnnaBridge 187:0387e8f68319 466 pData += 1U;
<> 144:ef7eb2e8f9f7 467 }
AnnaBridge 187:0387e8f68319 468
AnnaBridge 187:0387e8f68319 469 if (SMARTCARD_WaitOnFlagUntilTimeout(hsc, SMARTCARD_FLAG_TC, RESET, tickstart, Timeout) != HAL_OK)
<> 144:ef7eb2e8f9f7 470 {
<> 144:ef7eb2e8f9f7 471 return HAL_TIMEOUT;
<> 144:ef7eb2e8f9f7 472 }
<> 144:ef7eb2e8f9f7 473
AnnaBridge 187:0387e8f68319 474 /* At end of Tx process, restore hsc->gState to Ready */
AnnaBridge 165:e614a9f1c9e2 475 hsc->gState = HAL_SMARTCARD_STATE_READY;
AnnaBridge 187:0387e8f68319 476
<> 144:ef7eb2e8f9f7 477 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 478 __HAL_UNLOCK(hsc);
<> 144:ef7eb2e8f9f7 479
<> 144:ef7eb2e8f9f7 480 return HAL_OK;
<> 144:ef7eb2e8f9f7 481 }
<> 144:ef7eb2e8f9f7 482 else
<> 144:ef7eb2e8f9f7 483 {
<> 144:ef7eb2e8f9f7 484 return HAL_BUSY;
<> 144:ef7eb2e8f9f7 485 }
<> 144:ef7eb2e8f9f7 486 }
<> 144:ef7eb2e8f9f7 487
<> 144:ef7eb2e8f9f7 488 /**
AnnaBridge 187:0387e8f68319 489 * @brief Receive an amount of data in blocking mode
AnnaBridge 165:e614a9f1c9e2 490 * @param hsc: pointer to a SMARTCARD_HandleTypeDef structure that contains
AnnaBridge 165:e614a9f1c9e2 491 * the configuration information for SMARTCARD module.
AnnaBridge 165:e614a9f1c9e2 492 * @param pData: pointer to data buffer
AnnaBridge 165:e614a9f1c9e2 493 * @param Size: amount of data to be received
AnnaBridge 165:e614a9f1c9e2 494 * @param Timeout: Timeout duration
<> 144:ef7eb2e8f9f7 495 * @retval HAL status
<> 144:ef7eb2e8f9f7 496 */
AnnaBridge 165:e614a9f1c9e2 497 HAL_StatusTypeDef HAL_SMARTCARD_Receive(SMARTCARD_HandleTypeDef *hsc, uint8_t *pData, uint16_t Size, uint32_t Timeout)
<> 144:ef7eb2e8f9f7 498 {
AnnaBridge 165:e614a9f1c9e2 499 uint32_t tickstart = 0U;
AnnaBridge 187:0387e8f68319 500
AnnaBridge 187:0387e8f68319 501 if (hsc->RxState == HAL_SMARTCARD_STATE_READY)
<> 144:ef7eb2e8f9f7 502 {
AnnaBridge 187:0387e8f68319 503 if ((pData == NULL) || (Size == 0U))
<> 144:ef7eb2e8f9f7 504 {
AnnaBridge 165:e614a9f1c9e2 505 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 506 }
<> 144:ef7eb2e8f9f7 507
<> 144:ef7eb2e8f9f7 508 /* Process Locked */
<> 144:ef7eb2e8f9f7 509 __HAL_LOCK(hsc);
AnnaBridge 187:0387e8f68319 510
AnnaBridge 165:e614a9f1c9e2 511 hsc->ErrorCode = HAL_SMARTCARD_ERROR_NONE;
AnnaBridge 165:e614a9f1c9e2 512 hsc->RxState = HAL_SMARTCARD_STATE_BUSY_RX;
<> 144:ef7eb2e8f9f7 513
AnnaBridge 165:e614a9f1c9e2 514 /* Init tickstart for timeout managment */
AnnaBridge 165:e614a9f1c9e2 515 tickstart = HAL_GetTick();
AnnaBridge 165:e614a9f1c9e2 516
<> 144:ef7eb2e8f9f7 517 hsc->RxXferSize = Size;
<> 144:ef7eb2e8f9f7 518 hsc->RxXferCount = Size;
<> 144:ef7eb2e8f9f7 519
AnnaBridge 165:e614a9f1c9e2 520 /* Check the remain data to be received */
AnnaBridge 187:0387e8f68319 521 while (hsc->RxXferCount > 0U)
<> 144:ef7eb2e8f9f7 522 {
AnnaBridge 165:e614a9f1c9e2 523 hsc->RxXferCount--;
AnnaBridge 187:0387e8f68319 524 if (SMARTCARD_WaitOnFlagUntilTimeout(hsc, SMARTCARD_FLAG_RXNE, RESET, tickstart, Timeout) != HAL_OK)
AnnaBridge 165:e614a9f1c9e2 525 {
AnnaBridge 165:e614a9f1c9e2 526 return HAL_TIMEOUT;
AnnaBridge 165:e614a9f1c9e2 527 }
AnnaBridge 187:0387e8f68319 528 *(uint8_t *) pData = (uint8_t)hsc->Instance->DR;
AnnaBridge 187:0387e8f68319 529 pData += 1U;
<> 144:ef7eb2e8f9f7 530 }
<> 144:ef7eb2e8f9f7 531
AnnaBridge 165:e614a9f1c9e2 532 /* At end of Rx process, restore hsc->RxState to Ready */
AnnaBridge 165:e614a9f1c9e2 533 hsc->RxState = HAL_SMARTCARD_STATE_READY;
AnnaBridge 187:0387e8f68319 534
<> 144:ef7eb2e8f9f7 535 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 536 __HAL_UNLOCK(hsc);
<> 144:ef7eb2e8f9f7 537
<> 144:ef7eb2e8f9f7 538 return HAL_OK;
<> 144:ef7eb2e8f9f7 539 }
<> 144:ef7eb2e8f9f7 540 else
<> 144:ef7eb2e8f9f7 541 {
<> 144:ef7eb2e8f9f7 542 return HAL_BUSY;
<> 144:ef7eb2e8f9f7 543 }
<> 144:ef7eb2e8f9f7 544 }
<> 144:ef7eb2e8f9f7 545
<> 144:ef7eb2e8f9f7 546 /**
AnnaBridge 165:e614a9f1c9e2 547 * @brief Send an amount of data in non blocking mode
AnnaBridge 165:e614a9f1c9e2 548 * @param hsc: pointer to a SMARTCARD_HandleTypeDef structure that contains
AnnaBridge 165:e614a9f1c9e2 549 * the configuration information for SMARTCARD module.
AnnaBridge 165:e614a9f1c9e2 550 * @param pData: pointer to data buffer
AnnaBridge 165:e614a9f1c9e2 551 * @param Size: amount of data to be sent
AnnaBridge 165:e614a9f1c9e2 552 * @retval HAL status
AnnaBridge 165:e614a9f1c9e2 553 */
AnnaBridge 165:e614a9f1c9e2 554 HAL_StatusTypeDef HAL_SMARTCARD_Transmit_IT(SMARTCARD_HandleTypeDef *hsc, uint8_t *pData, uint16_t Size)
AnnaBridge 165:e614a9f1c9e2 555 {
AnnaBridge 165:e614a9f1c9e2 556 /* Check that a Tx process is not already ongoing */
AnnaBridge 187:0387e8f68319 557 if (hsc->gState == HAL_SMARTCARD_STATE_READY)
AnnaBridge 165:e614a9f1c9e2 558 {
AnnaBridge 187:0387e8f68319 559 if ((pData == NULL) || (Size == 0U))
AnnaBridge 165:e614a9f1c9e2 560 {
AnnaBridge 165:e614a9f1c9e2 561 return HAL_ERROR;
AnnaBridge 165:e614a9f1c9e2 562 }
AnnaBridge 165:e614a9f1c9e2 563 /* Process Locked */
AnnaBridge 165:e614a9f1c9e2 564 __HAL_LOCK(hsc);
AnnaBridge 165:e614a9f1c9e2 565
AnnaBridge 165:e614a9f1c9e2 566 hsc->pTxBuffPtr = pData;
AnnaBridge 165:e614a9f1c9e2 567 hsc->TxXferSize = Size;
AnnaBridge 165:e614a9f1c9e2 568 hsc->TxXferCount = Size;
AnnaBridge 165:e614a9f1c9e2 569
AnnaBridge 165:e614a9f1c9e2 570 hsc->ErrorCode = HAL_SMARTCARD_ERROR_NONE;
AnnaBridge 165:e614a9f1c9e2 571 hsc->gState = HAL_SMARTCARD_STATE_BUSY_TX;
AnnaBridge 165:e614a9f1c9e2 572
AnnaBridge 165:e614a9f1c9e2 573 /* Process Unlocked */
AnnaBridge 165:e614a9f1c9e2 574 __HAL_UNLOCK(hsc);
AnnaBridge 187:0387e8f68319 575
AnnaBridge 165:e614a9f1c9e2 576 /* Enable the SMARTCARD Parity Error Interrupt */
AnnaBridge 165:e614a9f1c9e2 577 SET_BIT(hsc->Instance->CR1, USART_CR1_PEIE);
AnnaBridge 165:e614a9f1c9e2 578
AnnaBridge 165:e614a9f1c9e2 579 /* Disable the SMARTCARD Error Interrupt: (Frame error, noise error, overrun error) */
AnnaBridge 165:e614a9f1c9e2 580 CLEAR_BIT(hsc->Instance->CR3, USART_CR3_EIE);
AnnaBridge 165:e614a9f1c9e2 581
AnnaBridge 165:e614a9f1c9e2 582 /* Enable the SMARTCARD Transmit data register empty Interrupt */
AnnaBridge 165:e614a9f1c9e2 583 SET_BIT(hsc->Instance->CR1, USART_CR1_TXEIE);
AnnaBridge 165:e614a9f1c9e2 584
AnnaBridge 165:e614a9f1c9e2 585 return HAL_OK;
AnnaBridge 165:e614a9f1c9e2 586 }
AnnaBridge 165:e614a9f1c9e2 587 else
AnnaBridge 165:e614a9f1c9e2 588 {
AnnaBridge 165:e614a9f1c9e2 589 return HAL_BUSY;
AnnaBridge 165:e614a9f1c9e2 590 }
AnnaBridge 165:e614a9f1c9e2 591 }
AnnaBridge 165:e614a9f1c9e2 592
AnnaBridge 165:e614a9f1c9e2 593 /**
AnnaBridge 187:0387e8f68319 594 * @brief Receive an amount of data in non blocking mode
AnnaBridge 165:e614a9f1c9e2 595 * @param hsc: pointer to a SMARTCARD_HandleTypeDef structure that contains
AnnaBridge 165:e614a9f1c9e2 596 * the configuration information for SMARTCARD module.
AnnaBridge 165:e614a9f1c9e2 597 * @param pData: pointer to data buffer
AnnaBridge 165:e614a9f1c9e2 598 * @param Size: amount of data to be received
AnnaBridge 165:e614a9f1c9e2 599 * @retval HAL status
AnnaBridge 165:e614a9f1c9e2 600 */
AnnaBridge 165:e614a9f1c9e2 601 HAL_StatusTypeDef HAL_SMARTCARD_Receive_IT(SMARTCARD_HandleTypeDef *hsc, uint8_t *pData, uint16_t Size)
AnnaBridge 165:e614a9f1c9e2 602 {
AnnaBridge 165:e614a9f1c9e2 603 /* Check that a Rx process is not already ongoing */
AnnaBridge 187:0387e8f68319 604 if (hsc->RxState == HAL_SMARTCARD_STATE_READY)
AnnaBridge 165:e614a9f1c9e2 605 {
AnnaBridge 187:0387e8f68319 606 if ((pData == NULL) || (Size == 0U))
AnnaBridge 165:e614a9f1c9e2 607 {
AnnaBridge 165:e614a9f1c9e2 608 return HAL_ERROR;
AnnaBridge 165:e614a9f1c9e2 609 }
AnnaBridge 165:e614a9f1c9e2 610
AnnaBridge 165:e614a9f1c9e2 611 /* Process Locked */
AnnaBridge 165:e614a9f1c9e2 612 __HAL_LOCK(hsc);
AnnaBridge 165:e614a9f1c9e2 613
AnnaBridge 165:e614a9f1c9e2 614 hsc->pRxBuffPtr = pData;
AnnaBridge 165:e614a9f1c9e2 615 hsc->RxXferSize = Size;
AnnaBridge 165:e614a9f1c9e2 616 hsc->RxXferCount = Size;
AnnaBridge 165:e614a9f1c9e2 617
AnnaBridge 165:e614a9f1c9e2 618 hsc->ErrorCode = HAL_SMARTCARD_ERROR_NONE;
AnnaBridge 165:e614a9f1c9e2 619 hsc->RxState = HAL_SMARTCARD_STATE_BUSY_RX;
AnnaBridge 187:0387e8f68319 620
AnnaBridge 165:e614a9f1c9e2 621 /* Process Unlocked */
AnnaBridge 165:e614a9f1c9e2 622 __HAL_UNLOCK(hsc);
AnnaBridge 165:e614a9f1c9e2 623
AnnaBridge 165:e614a9f1c9e2 624 /* Enable the SMARTCARD Parity Error and Data Register not empty Interrupts */
AnnaBridge 187:0387e8f68319 625 SET_BIT(hsc->Instance->CR1, USART_CR1_PEIE | USART_CR1_RXNEIE);
AnnaBridge 165:e614a9f1c9e2 626
AnnaBridge 165:e614a9f1c9e2 627 /* Enable the SMARTCARD Error Interrupt: (Frame error, noise error, overrun error) */
AnnaBridge 165:e614a9f1c9e2 628 SET_BIT(hsc->Instance->CR3, USART_CR3_EIE);
AnnaBridge 165:e614a9f1c9e2 629
AnnaBridge 165:e614a9f1c9e2 630 return HAL_OK;
AnnaBridge 165:e614a9f1c9e2 631 }
AnnaBridge 165:e614a9f1c9e2 632 else
AnnaBridge 165:e614a9f1c9e2 633 {
AnnaBridge 165:e614a9f1c9e2 634 return HAL_BUSY;
AnnaBridge 165:e614a9f1c9e2 635 }
AnnaBridge 165:e614a9f1c9e2 636 }
AnnaBridge 165:e614a9f1c9e2 637
AnnaBridge 165:e614a9f1c9e2 638 /**
AnnaBridge 187:0387e8f68319 639 * @brief Send an amount of data in non blocking mode
AnnaBridge 165:e614a9f1c9e2 640 * @param hsc: pointer to a SMARTCARD_HandleTypeDef structure that contains
AnnaBridge 165:e614a9f1c9e2 641 * the configuration information for SMARTCARD module.
AnnaBridge 165:e614a9f1c9e2 642 * @param pData: pointer to data buffer
AnnaBridge 165:e614a9f1c9e2 643 * @param Size: amount of data to be sent
AnnaBridge 165:e614a9f1c9e2 644 * @retval HAL status
AnnaBridge 165:e614a9f1c9e2 645 */
AnnaBridge 165:e614a9f1c9e2 646 HAL_StatusTypeDef HAL_SMARTCARD_Transmit_DMA(SMARTCARD_HandleTypeDef *hsc, uint8_t *pData, uint16_t Size)
AnnaBridge 165:e614a9f1c9e2 647 {
AnnaBridge 165:e614a9f1c9e2 648 uint32_t *tmp;
AnnaBridge 187:0387e8f68319 649
AnnaBridge 165:e614a9f1c9e2 650 /* Check that a Tx process is not already ongoing */
AnnaBridge 187:0387e8f68319 651 if (hsc->gState == HAL_SMARTCARD_STATE_READY)
AnnaBridge 165:e614a9f1c9e2 652 {
AnnaBridge 187:0387e8f68319 653 if ((pData == NULL) || (Size == 0U))
AnnaBridge 165:e614a9f1c9e2 654 {
AnnaBridge 165:e614a9f1c9e2 655 return HAL_ERROR;
AnnaBridge 165:e614a9f1c9e2 656 }
AnnaBridge 165:e614a9f1c9e2 657
AnnaBridge 165:e614a9f1c9e2 658 /* Process Locked */
AnnaBridge 165:e614a9f1c9e2 659 __HAL_LOCK(hsc);
AnnaBridge 165:e614a9f1c9e2 660
AnnaBridge 165:e614a9f1c9e2 661 hsc->pTxBuffPtr = pData;
AnnaBridge 165:e614a9f1c9e2 662 hsc->TxXferSize = Size;
AnnaBridge 165:e614a9f1c9e2 663 hsc->TxXferCount = Size;
AnnaBridge 165:e614a9f1c9e2 664
AnnaBridge 165:e614a9f1c9e2 665 hsc->ErrorCode = HAL_SMARTCARD_ERROR_NONE;
AnnaBridge 165:e614a9f1c9e2 666 hsc->gState = HAL_SMARTCARD_STATE_BUSY_TX;
AnnaBridge 165:e614a9f1c9e2 667
AnnaBridge 165:e614a9f1c9e2 668 /* Set the SMARTCARD DMA transfer complete callback */
AnnaBridge 165:e614a9f1c9e2 669 hsc->hdmatx->XferCpltCallback = SMARTCARD_DMATransmitCplt;
AnnaBridge 165:e614a9f1c9e2 670
AnnaBridge 165:e614a9f1c9e2 671 /* Set the DMA error callback */
AnnaBridge 165:e614a9f1c9e2 672 hsc->hdmatx->XferErrorCallback = SMARTCARD_DMAError;
AnnaBridge 165:e614a9f1c9e2 673
AnnaBridge 165:e614a9f1c9e2 674 /* Set the DMA abort callback */
AnnaBridge 165:e614a9f1c9e2 675 hsc->hdmatx->XferAbortCallback = NULL;
AnnaBridge 165:e614a9f1c9e2 676
AnnaBridge 165:e614a9f1c9e2 677 /* Enable the SMARTCARD transmit DMA Channel */
AnnaBridge 187:0387e8f68319 678 tmp = (uint32_t *)&pData;
AnnaBridge 187:0387e8f68319 679 HAL_DMA_Start_IT(hsc->hdmatx, *(uint32_t *)tmp, (uint32_t)&hsc->Instance->DR, Size);
AnnaBridge 165:e614a9f1c9e2 680
AnnaBridge 165:e614a9f1c9e2 681 /* Clear the TC flag in the SR register by writing 0 to it */
AnnaBridge 165:e614a9f1c9e2 682 __HAL_SMARTCARD_CLEAR_FLAG(hsc, SMARTCARD_FLAG_TC);
AnnaBridge 165:e614a9f1c9e2 683
AnnaBridge 165:e614a9f1c9e2 684 /* Process Unlocked */
AnnaBridge 165:e614a9f1c9e2 685 __HAL_UNLOCK(hsc);
AnnaBridge 165:e614a9f1c9e2 686
AnnaBridge 165:e614a9f1c9e2 687 /* Enable the DMA transfer for transmit request by setting the DMAT bit
AnnaBridge 165:e614a9f1c9e2 688 in the SMARTCARD CR3 register */
AnnaBridge 165:e614a9f1c9e2 689 SET_BIT(hsc->Instance->CR3, USART_CR3_DMAT);
AnnaBridge 165:e614a9f1c9e2 690
AnnaBridge 165:e614a9f1c9e2 691 return HAL_OK;
AnnaBridge 165:e614a9f1c9e2 692 }
AnnaBridge 165:e614a9f1c9e2 693 else
AnnaBridge 165:e614a9f1c9e2 694 {
AnnaBridge 165:e614a9f1c9e2 695 return HAL_BUSY;
AnnaBridge 165:e614a9f1c9e2 696 }
AnnaBridge 165:e614a9f1c9e2 697 }
AnnaBridge 165:e614a9f1c9e2 698
AnnaBridge 165:e614a9f1c9e2 699 /**
AnnaBridge 187:0387e8f68319 700 * @brief Receive an amount of data in non blocking mode
AnnaBridge 165:e614a9f1c9e2 701 * @param hsc: pointer to a SMARTCARD_HandleTypeDef structure that contains
AnnaBridge 165:e614a9f1c9e2 702 * the configuration information for SMARTCARD module.
AnnaBridge 165:e614a9f1c9e2 703 * @param pData: pointer to data buffer
AnnaBridge 165:e614a9f1c9e2 704 * @param Size: amount of data to be received
AnnaBridge 165:e614a9f1c9e2 705 * @note When the SMARTCARD parity is enabled (PCE = 1) the data received contain the parity bit.s
AnnaBridge 165:e614a9f1c9e2 706 * @retval HAL status
AnnaBridge 165:e614a9f1c9e2 707 */
AnnaBridge 165:e614a9f1c9e2 708 HAL_StatusTypeDef HAL_SMARTCARD_Receive_DMA(SMARTCARD_HandleTypeDef *hsc, uint8_t *pData, uint16_t Size)
AnnaBridge 165:e614a9f1c9e2 709 {
AnnaBridge 165:e614a9f1c9e2 710 uint32_t *tmp;
AnnaBridge 187:0387e8f68319 711
AnnaBridge 165:e614a9f1c9e2 712 /* Check that a Rx process is not already ongoing */
AnnaBridge 187:0387e8f68319 713 if (hsc->RxState == HAL_SMARTCARD_STATE_READY)
AnnaBridge 165:e614a9f1c9e2 714 {
AnnaBridge 187:0387e8f68319 715 if ((pData == NULL) || (Size == 0U))
AnnaBridge 165:e614a9f1c9e2 716 {
AnnaBridge 165:e614a9f1c9e2 717 return HAL_ERROR;
AnnaBridge 165:e614a9f1c9e2 718 }
AnnaBridge 165:e614a9f1c9e2 719
AnnaBridge 165:e614a9f1c9e2 720 /* Process Locked */
AnnaBridge 165:e614a9f1c9e2 721 __HAL_LOCK(hsc);
AnnaBridge 165:e614a9f1c9e2 722
AnnaBridge 165:e614a9f1c9e2 723 hsc->pRxBuffPtr = pData;
AnnaBridge 165:e614a9f1c9e2 724 hsc->RxXferSize = Size;
AnnaBridge 165:e614a9f1c9e2 725
AnnaBridge 165:e614a9f1c9e2 726 hsc->ErrorCode = HAL_SMARTCARD_ERROR_NONE;
AnnaBridge 165:e614a9f1c9e2 727 hsc->RxState = HAL_SMARTCARD_STATE_BUSY_RX;
AnnaBridge 165:e614a9f1c9e2 728
AnnaBridge 165:e614a9f1c9e2 729 /* Set the SMARTCARD DMA transfer complete callback */
AnnaBridge 165:e614a9f1c9e2 730 hsc->hdmarx->XferCpltCallback = SMARTCARD_DMAReceiveCplt;
AnnaBridge 165:e614a9f1c9e2 731
AnnaBridge 165:e614a9f1c9e2 732 /* Set the DMA error callback */
AnnaBridge 165:e614a9f1c9e2 733 hsc->hdmarx->XferErrorCallback = SMARTCARD_DMAError;
AnnaBridge 165:e614a9f1c9e2 734
AnnaBridge 165:e614a9f1c9e2 735 /* Set the DMA abort callback */
AnnaBridge 165:e614a9f1c9e2 736 hsc->hdmatx->XferAbortCallback = NULL;
AnnaBridge 165:e614a9f1c9e2 737
AnnaBridge 165:e614a9f1c9e2 738 /* Enable the DMA Channel */
AnnaBridge 187:0387e8f68319 739 tmp = (uint32_t *)&pData;
AnnaBridge 187:0387e8f68319 740 HAL_DMA_Start_IT(hsc->hdmarx, (uint32_t)&hsc->Instance->DR, *(uint32_t *)tmp, Size);
AnnaBridge 165:e614a9f1c9e2 741
AnnaBridge 165:e614a9f1c9e2 742 /* Clear the Overrun flag just before enabling the DMA Rx request: can be mandatory for the second transfer */
AnnaBridge 165:e614a9f1c9e2 743 __HAL_SMARTCARD_CLEAR_OREFLAG(hsc);
AnnaBridge 165:e614a9f1c9e2 744
AnnaBridge 165:e614a9f1c9e2 745 /* Process Unlocked */
AnnaBridge 165:e614a9f1c9e2 746 __HAL_UNLOCK(hsc);
AnnaBridge 165:e614a9f1c9e2 747
AnnaBridge 165:e614a9f1c9e2 748 /* Enable the SMARTCARD Parity Error Interrupt */
AnnaBridge 165:e614a9f1c9e2 749 SET_BIT(hsc->Instance->CR1, USART_CR1_PEIE);
AnnaBridge 165:e614a9f1c9e2 750
AnnaBridge 165:e614a9f1c9e2 751 /* Enable the SMARTCARD Error Interrupt: (Frame error, noise error, overrun error) */
AnnaBridge 165:e614a9f1c9e2 752 SET_BIT(hsc->Instance->CR3, USART_CR3_EIE);
AnnaBridge 165:e614a9f1c9e2 753
AnnaBridge 187:0387e8f68319 754 /* Enable the DMA transfer for the receiver request by setting the DMAR bit
AnnaBridge 165:e614a9f1c9e2 755 in the SMARTCARD CR3 register */
AnnaBridge 165:e614a9f1c9e2 756 SET_BIT(hsc->Instance->CR3, USART_CR3_DMAR);
AnnaBridge 165:e614a9f1c9e2 757
AnnaBridge 165:e614a9f1c9e2 758 return HAL_OK;
AnnaBridge 165:e614a9f1c9e2 759 }
AnnaBridge 165:e614a9f1c9e2 760 else
AnnaBridge 165:e614a9f1c9e2 761 {
AnnaBridge 165:e614a9f1c9e2 762 return HAL_BUSY;
AnnaBridge 165:e614a9f1c9e2 763 }
AnnaBridge 165:e614a9f1c9e2 764 }
AnnaBridge 165:e614a9f1c9e2 765
AnnaBridge 165:e614a9f1c9e2 766 /**
AnnaBridge 165:e614a9f1c9e2 767 * @brief Abort ongoing transfers (blocking mode).
AnnaBridge 165:e614a9f1c9e2 768 * @param hsc SMARTCARD handle.
AnnaBridge 187:0387e8f68319 769 * @note This procedure could be used for aborting any ongoing transfer started in Interrupt or DMA mode.
AnnaBridge 165:e614a9f1c9e2 770 * This procedure performs following operations :
AnnaBridge 165:e614a9f1c9e2 771 * - Disable PPP Interrupts
AnnaBridge 165:e614a9f1c9e2 772 * - Disable the DMA transfer in the peripheral register (if enabled)
AnnaBridge 165:e614a9f1c9e2 773 * - Abort DMA transfer by calling HAL_DMA_Abort (in case of transfer in DMA mode)
AnnaBridge 165:e614a9f1c9e2 774 * - Set handle State to READY
AnnaBridge 165:e614a9f1c9e2 775 * @note This procedure is executed in blocking mode : when exiting function, Abort is considered as completed.
AnnaBridge 165:e614a9f1c9e2 776 * @retval HAL status
AnnaBridge 165:e614a9f1c9e2 777 */
AnnaBridge 165:e614a9f1c9e2 778 HAL_StatusTypeDef HAL_SMARTCARD_Abort(SMARTCARD_HandleTypeDef *hsc)
AnnaBridge 165:e614a9f1c9e2 779 {
AnnaBridge 165:e614a9f1c9e2 780 /* Disable TXEIE, TCIE, RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts */
AnnaBridge 165:e614a9f1c9e2 781 CLEAR_BIT(hsc->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE | USART_CR1_TXEIE | USART_CR1_TCIE));
AnnaBridge 165:e614a9f1c9e2 782 CLEAR_BIT(hsc->Instance->CR3, USART_CR3_EIE);
AnnaBridge 187:0387e8f68319 783
AnnaBridge 165:e614a9f1c9e2 784 /* Disable the SMARTCARD DMA Tx request if enabled */
AnnaBridge 187:0387e8f68319 785 if (HAL_IS_BIT_SET(hsc->Instance->CR3, USART_CR3_DMAT))
AnnaBridge 165:e614a9f1c9e2 786 {
AnnaBridge 165:e614a9f1c9e2 787 CLEAR_BIT(hsc->Instance->CR3, USART_CR3_DMAT);
AnnaBridge 165:e614a9f1c9e2 788
AnnaBridge 165:e614a9f1c9e2 789 /* Abort the SMARTCARD DMA Tx channel: use blocking DMA Abort API (no callback) */
AnnaBridge 187:0387e8f68319 790 if (hsc->hdmatx != NULL)
AnnaBridge 165:e614a9f1c9e2 791 {
AnnaBridge 187:0387e8f68319 792 /* Set the SMARTCARD DMA Abort callback to Null.
AnnaBridge 165:e614a9f1c9e2 793 No call back execution at end of DMA abort procedure */
AnnaBridge 165:e614a9f1c9e2 794 hsc->hdmatx->XferAbortCallback = NULL;
AnnaBridge 165:e614a9f1c9e2 795
AnnaBridge 165:e614a9f1c9e2 796 HAL_DMA_Abort(hsc->hdmatx);
AnnaBridge 165:e614a9f1c9e2 797 }
AnnaBridge 165:e614a9f1c9e2 798 }
AnnaBridge 165:e614a9f1c9e2 799
AnnaBridge 165:e614a9f1c9e2 800 /* Disable the SMARTCARD DMA Rx request if enabled */
AnnaBridge 187:0387e8f68319 801 if (HAL_IS_BIT_SET(hsc->Instance->CR3, USART_CR3_DMAR))
AnnaBridge 165:e614a9f1c9e2 802 {
AnnaBridge 165:e614a9f1c9e2 803 CLEAR_BIT(hsc->Instance->CR3, USART_CR3_DMAR);
AnnaBridge 165:e614a9f1c9e2 804
AnnaBridge 165:e614a9f1c9e2 805 /* Abort the SMARTCARD DMA Rx channel: use blocking DMA Abort API (no callback) */
AnnaBridge 187:0387e8f68319 806 if (hsc->hdmarx != NULL)
AnnaBridge 165:e614a9f1c9e2 807 {
AnnaBridge 187:0387e8f68319 808 /* Set the SMARTCARD DMA Abort callback to Null.
AnnaBridge 165:e614a9f1c9e2 809 No call back execution at end of DMA abort procedure */
AnnaBridge 165:e614a9f1c9e2 810 hsc->hdmarx->XferAbortCallback = NULL;
AnnaBridge 165:e614a9f1c9e2 811
AnnaBridge 165:e614a9f1c9e2 812 HAL_DMA_Abort(hsc->hdmarx);
AnnaBridge 165:e614a9f1c9e2 813 }
AnnaBridge 165:e614a9f1c9e2 814 }
AnnaBridge 165:e614a9f1c9e2 815
AnnaBridge 165:e614a9f1c9e2 816 /* Reset Tx and Rx transfer counters */
AnnaBridge 165:e614a9f1c9e2 817 hsc->TxXferCount = 0x00U;
AnnaBridge 165:e614a9f1c9e2 818 hsc->RxXferCount = 0x00U;
AnnaBridge 165:e614a9f1c9e2 819
AnnaBridge 165:e614a9f1c9e2 820 /* Reset ErrorCode */
AnnaBridge 165:e614a9f1c9e2 821 hsc->ErrorCode = HAL_SMARTCARD_ERROR_NONE;
AnnaBridge 165:e614a9f1c9e2 822
AnnaBridge 165:e614a9f1c9e2 823 /* Restore hsc->RxState and hsc->gState to Ready */
AnnaBridge 165:e614a9f1c9e2 824 hsc->RxState = HAL_SMARTCARD_STATE_READY;
AnnaBridge 165:e614a9f1c9e2 825 hsc->gState = HAL_SMARTCARD_STATE_READY;
AnnaBridge 165:e614a9f1c9e2 826
AnnaBridge 165:e614a9f1c9e2 827 return HAL_OK;
AnnaBridge 165:e614a9f1c9e2 828 }
AnnaBridge 165:e614a9f1c9e2 829
AnnaBridge 165:e614a9f1c9e2 830 /**
AnnaBridge 165:e614a9f1c9e2 831 * @brief Abort ongoing Transmit transfer (blocking mode).
AnnaBridge 165:e614a9f1c9e2 832 * @param hsc SMARTCARD handle.
AnnaBridge 187:0387e8f68319 833 * @note This procedure could be used for aborting any ongoing transfer started in Interrupt or DMA mode.
AnnaBridge 165:e614a9f1c9e2 834 * This procedure performs following operations :
AnnaBridge 165:e614a9f1c9e2 835 * - Disable PPP Interrupts
AnnaBridge 165:e614a9f1c9e2 836 * - Disable the DMA transfer in the peripheral register (if enabled)
AnnaBridge 165:e614a9f1c9e2 837 * - Abort DMA transfer by calling HAL_DMA_Abort (in case of transfer in DMA mode)
AnnaBridge 165:e614a9f1c9e2 838 * - Set handle State to READY
AnnaBridge 165:e614a9f1c9e2 839 * @note This procedure is executed in blocking mode : when exiting function, Abort is considered as completed.
AnnaBridge 165:e614a9f1c9e2 840 * @retval HAL status
AnnaBridge 165:e614a9f1c9e2 841 */
AnnaBridge 165:e614a9f1c9e2 842 HAL_StatusTypeDef HAL_SMARTCARD_AbortTransmit(SMARTCARD_HandleTypeDef *hsc)
AnnaBridge 165:e614a9f1c9e2 843 {
AnnaBridge 165:e614a9f1c9e2 844 /* Disable TXEIE and TCIE interrupts */
AnnaBridge 165:e614a9f1c9e2 845 CLEAR_BIT(hsc->Instance->CR1, (USART_CR1_TXEIE | USART_CR1_TCIE));
AnnaBridge 165:e614a9f1c9e2 846
AnnaBridge 165:e614a9f1c9e2 847 /* Disable the SMARTCARD DMA Tx request if enabled */
AnnaBridge 187:0387e8f68319 848 if (HAL_IS_BIT_SET(hsc->Instance->CR3, USART_CR3_DMAT))
AnnaBridge 165:e614a9f1c9e2 849 {
AnnaBridge 165:e614a9f1c9e2 850 CLEAR_BIT(hsc->Instance->CR3, USART_CR3_DMAT);
AnnaBridge 165:e614a9f1c9e2 851
AnnaBridge 165:e614a9f1c9e2 852 /* Abort the SMARTCARD DMA Tx channel: use blocking DMA Abort API (no callback) */
AnnaBridge 187:0387e8f68319 853 if (hsc->hdmatx != NULL)
AnnaBridge 165:e614a9f1c9e2 854 {
AnnaBridge 187:0387e8f68319 855 /* Set the SMARTCARD DMA Abort callback to Null.
AnnaBridge 165:e614a9f1c9e2 856 No call back execution at end of DMA abort procedure */
AnnaBridge 165:e614a9f1c9e2 857 hsc->hdmatx->XferAbortCallback = NULL;
AnnaBridge 165:e614a9f1c9e2 858
AnnaBridge 165:e614a9f1c9e2 859 HAL_DMA_Abort(hsc->hdmatx);
AnnaBridge 165:e614a9f1c9e2 860 }
AnnaBridge 165:e614a9f1c9e2 861 }
AnnaBridge 165:e614a9f1c9e2 862
AnnaBridge 165:e614a9f1c9e2 863 /* Reset Tx transfer counter */
AnnaBridge 165:e614a9f1c9e2 864 hsc->TxXferCount = 0x00U;
AnnaBridge 165:e614a9f1c9e2 865
AnnaBridge 165:e614a9f1c9e2 866 /* Restore hsc->gState to Ready */
AnnaBridge 165:e614a9f1c9e2 867 hsc->gState = HAL_SMARTCARD_STATE_READY;
AnnaBridge 165:e614a9f1c9e2 868
AnnaBridge 165:e614a9f1c9e2 869 return HAL_OK;
AnnaBridge 165:e614a9f1c9e2 870 }
AnnaBridge 165:e614a9f1c9e2 871
AnnaBridge 165:e614a9f1c9e2 872 /**
AnnaBridge 165:e614a9f1c9e2 873 * @brief Abort ongoing Receive transfer (blocking mode).
AnnaBridge 165:e614a9f1c9e2 874 * @param hsc SMARTCARD handle.
AnnaBridge 187:0387e8f68319 875 * @note This procedure could be used for aborting any ongoing transfer started in Interrupt or DMA mode.
AnnaBridge 165:e614a9f1c9e2 876 * This procedure performs following operations :
AnnaBridge 165:e614a9f1c9e2 877 * - Disable PPP Interrupts
AnnaBridge 165:e614a9f1c9e2 878 * - Disable the DMA transfer in the peripheral register (if enabled)
AnnaBridge 165:e614a9f1c9e2 879 * - Abort DMA transfer by calling HAL_DMA_Abort (in case of transfer in DMA mode)
AnnaBridge 165:e614a9f1c9e2 880 * - Set handle State to READY
AnnaBridge 165:e614a9f1c9e2 881 * @note This procedure is executed in blocking mode : when exiting function, Abort is considered as completed.
AnnaBridge 165:e614a9f1c9e2 882 * @retval HAL status
AnnaBridge 165:e614a9f1c9e2 883 */
AnnaBridge 165:e614a9f1c9e2 884 HAL_StatusTypeDef HAL_SMARTCARD_AbortReceive(SMARTCARD_HandleTypeDef *hsc)
AnnaBridge 165:e614a9f1c9e2 885 {
AnnaBridge 165:e614a9f1c9e2 886 /* Disable RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts */
AnnaBridge 165:e614a9f1c9e2 887 CLEAR_BIT(hsc->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE));
AnnaBridge 165:e614a9f1c9e2 888 CLEAR_BIT(hsc->Instance->CR3, USART_CR3_EIE);
AnnaBridge 165:e614a9f1c9e2 889
AnnaBridge 165:e614a9f1c9e2 890 /* Disable the SMARTCARD DMA Rx request if enabled */
AnnaBridge 187:0387e8f68319 891 if (HAL_IS_BIT_SET(hsc->Instance->CR3, USART_CR3_DMAR))
AnnaBridge 165:e614a9f1c9e2 892 {
AnnaBridge 165:e614a9f1c9e2 893 CLEAR_BIT(hsc->Instance->CR3, USART_CR3_DMAR);
AnnaBridge 165:e614a9f1c9e2 894
AnnaBridge 165:e614a9f1c9e2 895 /* Abort the SMARTCARD DMA Rx channel: use blocking DMA Abort API (no callback) */
AnnaBridge 187:0387e8f68319 896 if (hsc->hdmarx != NULL)
AnnaBridge 165:e614a9f1c9e2 897 {
AnnaBridge 187:0387e8f68319 898 /* Set the SMARTCARD DMA Abort callback to Null.
AnnaBridge 165:e614a9f1c9e2 899 No call back execution at end of DMA abort procedure */
AnnaBridge 165:e614a9f1c9e2 900 hsc->hdmarx->XferAbortCallback = NULL;
AnnaBridge 165:e614a9f1c9e2 901
AnnaBridge 165:e614a9f1c9e2 902 HAL_DMA_Abort(hsc->hdmarx);
AnnaBridge 165:e614a9f1c9e2 903 }
AnnaBridge 165:e614a9f1c9e2 904 }
AnnaBridge 165:e614a9f1c9e2 905
AnnaBridge 165:e614a9f1c9e2 906 /* Reset Rx transfer counter */
AnnaBridge 165:e614a9f1c9e2 907 hsc->RxXferCount = 0x00U;
AnnaBridge 165:e614a9f1c9e2 908
AnnaBridge 165:e614a9f1c9e2 909 /* Restore hsc->RxState to Ready */
AnnaBridge 165:e614a9f1c9e2 910 hsc->RxState = HAL_SMARTCARD_STATE_READY;
AnnaBridge 165:e614a9f1c9e2 911
AnnaBridge 165:e614a9f1c9e2 912 return HAL_OK;
AnnaBridge 165:e614a9f1c9e2 913 }
AnnaBridge 165:e614a9f1c9e2 914
AnnaBridge 165:e614a9f1c9e2 915 /**
AnnaBridge 165:e614a9f1c9e2 916 * @brief Abort ongoing transfers (Interrupt mode).
AnnaBridge 165:e614a9f1c9e2 917 * @param hsc SMARTCARD handle.
AnnaBridge 187:0387e8f68319 918 * @note This procedure could be used for aborting any ongoing transfer started in Interrupt or DMA mode.
AnnaBridge 165:e614a9f1c9e2 919 * This procedure performs following operations :
AnnaBridge 165:e614a9f1c9e2 920 * - Disable PPP Interrupts
AnnaBridge 165:e614a9f1c9e2 921 * - Disable the DMA transfer in the peripheral register (if enabled)
AnnaBridge 165:e614a9f1c9e2 922 * - Abort DMA transfer by calling HAL_DMA_Abort_IT (in case of transfer in DMA mode)
AnnaBridge 165:e614a9f1c9e2 923 * - Set handle State to READY
AnnaBridge 165:e614a9f1c9e2 924 * - At abort completion, call user abort complete callback
AnnaBridge 165:e614a9f1c9e2 925 * @note This procedure is executed in Interrupt mode, meaning that abort procedure could be
AnnaBridge 165:e614a9f1c9e2 926 * considered as completed only when user abort complete callback is executed (not when exiting function).
AnnaBridge 165:e614a9f1c9e2 927 * @retval HAL status
AnnaBridge 165:e614a9f1c9e2 928 */
AnnaBridge 165:e614a9f1c9e2 929 HAL_StatusTypeDef HAL_SMARTCARD_Abort_IT(SMARTCARD_HandleTypeDef *hsc)
AnnaBridge 165:e614a9f1c9e2 930 {
AnnaBridge 165:e614a9f1c9e2 931 uint32_t AbortCplt = 0x01U;
AnnaBridge 165:e614a9f1c9e2 932
AnnaBridge 165:e614a9f1c9e2 933 /* Disable TXEIE, TCIE, RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts */
AnnaBridge 165:e614a9f1c9e2 934 CLEAR_BIT(hsc->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE | USART_CR1_TXEIE | USART_CR1_TCIE));
AnnaBridge 165:e614a9f1c9e2 935 CLEAR_BIT(hsc->Instance->CR3, USART_CR3_EIE);
AnnaBridge 165:e614a9f1c9e2 936
AnnaBridge 165:e614a9f1c9e2 937 /* If DMA Tx and/or DMA Rx Handles are associated to SMARTCARD Handle, DMA Abort complete callbacks should be initialised
AnnaBridge 165:e614a9f1c9e2 938 before any call to DMA Abort functions */
AnnaBridge 165:e614a9f1c9e2 939 /* DMA Tx Handle is valid */
AnnaBridge 187:0387e8f68319 940 if (hsc->hdmatx != NULL)
AnnaBridge 165:e614a9f1c9e2 941 {
AnnaBridge 165:e614a9f1c9e2 942 /* Set DMA Abort Complete callback if SMARTCARD DMA Tx request if enabled.
AnnaBridge 165:e614a9f1c9e2 943 Otherwise, set it to NULL */
AnnaBridge 187:0387e8f68319 944 if (HAL_IS_BIT_SET(hsc->Instance->CR3, USART_CR3_DMAT))
AnnaBridge 165:e614a9f1c9e2 945 {
AnnaBridge 165:e614a9f1c9e2 946 hsc->hdmatx->XferAbortCallback = SMARTCARD_DMATxAbortCallback;
AnnaBridge 165:e614a9f1c9e2 947 }
AnnaBridge 165:e614a9f1c9e2 948 else
AnnaBridge 165:e614a9f1c9e2 949 {
AnnaBridge 165:e614a9f1c9e2 950 hsc->hdmatx->XferAbortCallback = NULL;
AnnaBridge 165:e614a9f1c9e2 951 }
AnnaBridge 165:e614a9f1c9e2 952 }
AnnaBridge 165:e614a9f1c9e2 953 /* DMA Rx Handle is valid */
AnnaBridge 187:0387e8f68319 954 if (hsc->hdmarx != NULL)
AnnaBridge 165:e614a9f1c9e2 955 {
AnnaBridge 165:e614a9f1c9e2 956 /* Set DMA Abort Complete callback if SMARTCARD DMA Rx request if enabled.
AnnaBridge 165:e614a9f1c9e2 957 Otherwise, set it to NULL */
AnnaBridge 187:0387e8f68319 958 if (HAL_IS_BIT_SET(hsc->Instance->CR3, USART_CR3_DMAR))
AnnaBridge 165:e614a9f1c9e2 959 {
AnnaBridge 165:e614a9f1c9e2 960 hsc->hdmarx->XferAbortCallback = SMARTCARD_DMARxAbortCallback;
AnnaBridge 165:e614a9f1c9e2 961 }
AnnaBridge 165:e614a9f1c9e2 962 else
AnnaBridge 165:e614a9f1c9e2 963 {
AnnaBridge 165:e614a9f1c9e2 964 hsc->hdmarx->XferAbortCallback = NULL;
AnnaBridge 165:e614a9f1c9e2 965 }
AnnaBridge 165:e614a9f1c9e2 966 }
AnnaBridge 165:e614a9f1c9e2 967
AnnaBridge 165:e614a9f1c9e2 968 /* Disable the SMARTCARD DMA Tx request if enabled */
AnnaBridge 187:0387e8f68319 969 if (HAL_IS_BIT_SET(hsc->Instance->CR3, USART_CR3_DMAT))
AnnaBridge 165:e614a9f1c9e2 970 {
AnnaBridge 165:e614a9f1c9e2 971 /* Disable DMA Tx at SMARTCARD level */
AnnaBridge 165:e614a9f1c9e2 972 CLEAR_BIT(hsc->Instance->CR3, USART_CR3_DMAT);
AnnaBridge 165:e614a9f1c9e2 973
AnnaBridge 165:e614a9f1c9e2 974 /* Abort the SMARTCARD DMA Tx channel : use non blocking DMA Abort API (callback) */
AnnaBridge 187:0387e8f68319 975 if (hsc->hdmatx != NULL)
AnnaBridge 165:e614a9f1c9e2 976 {
AnnaBridge 187:0387e8f68319 977 /* SMARTCARD Tx DMA Abort callback has already been initialised :
AnnaBridge 165:e614a9f1c9e2 978 will lead to call HAL_SMARTCARD_AbortCpltCallback() at end of DMA abort procedure */
AnnaBridge 165:e614a9f1c9e2 979
AnnaBridge 165:e614a9f1c9e2 980 /* Abort DMA TX */
AnnaBridge 187:0387e8f68319 981 if (HAL_DMA_Abort_IT(hsc->hdmatx) != HAL_OK)
AnnaBridge 165:e614a9f1c9e2 982 {
AnnaBridge 165:e614a9f1c9e2 983 hsc->hdmatx->XferAbortCallback = NULL;
AnnaBridge 165:e614a9f1c9e2 984 }
AnnaBridge 165:e614a9f1c9e2 985 else
AnnaBridge 165:e614a9f1c9e2 986 {
AnnaBridge 165:e614a9f1c9e2 987 AbortCplt = 0x00U;
AnnaBridge 165:e614a9f1c9e2 988 }
AnnaBridge 165:e614a9f1c9e2 989 }
AnnaBridge 165:e614a9f1c9e2 990 }
AnnaBridge 165:e614a9f1c9e2 991
AnnaBridge 165:e614a9f1c9e2 992 /* Disable the SMARTCARD DMA Rx request if enabled */
AnnaBridge 187:0387e8f68319 993 if (HAL_IS_BIT_SET(hsc->Instance->CR3, USART_CR3_DMAR))
AnnaBridge 165:e614a9f1c9e2 994 {
AnnaBridge 165:e614a9f1c9e2 995 CLEAR_BIT(hsc->Instance->CR3, USART_CR3_DMAR);
AnnaBridge 165:e614a9f1c9e2 996
AnnaBridge 165:e614a9f1c9e2 997 /* Abort the SMARTCARD DMA Rx channel : use non blocking DMA Abort API (callback) */
AnnaBridge 187:0387e8f68319 998 if (hsc->hdmarx != NULL)
AnnaBridge 165:e614a9f1c9e2 999 {
AnnaBridge 187:0387e8f68319 1000 /* SMARTCARD Rx DMA Abort callback has already been initialised :
AnnaBridge 165:e614a9f1c9e2 1001 will lead to call HAL_SMARTCARD_AbortCpltCallback() at end of DMA abort procedure */
AnnaBridge 165:e614a9f1c9e2 1002
AnnaBridge 165:e614a9f1c9e2 1003 /* Abort DMA RX */
AnnaBridge 187:0387e8f68319 1004 if (HAL_DMA_Abort_IT(hsc->hdmarx) != HAL_OK)
AnnaBridge 165:e614a9f1c9e2 1005 {
AnnaBridge 165:e614a9f1c9e2 1006 hsc->hdmarx->XferAbortCallback = NULL;
AnnaBridge 165:e614a9f1c9e2 1007 AbortCplt = 0x01U;
AnnaBridge 165:e614a9f1c9e2 1008 }
AnnaBridge 165:e614a9f1c9e2 1009 else
AnnaBridge 165:e614a9f1c9e2 1010 {
AnnaBridge 165:e614a9f1c9e2 1011 AbortCplt = 0x00U;
AnnaBridge 165:e614a9f1c9e2 1012 }
AnnaBridge 165:e614a9f1c9e2 1013 }
AnnaBridge 165:e614a9f1c9e2 1014 }
AnnaBridge 165:e614a9f1c9e2 1015
AnnaBridge 165:e614a9f1c9e2 1016 /* if no DMA abort complete callback execution is required => call user Abort Complete callback */
AnnaBridge 187:0387e8f68319 1017 if (AbortCplt == 0x01U)
AnnaBridge 165:e614a9f1c9e2 1018 {
AnnaBridge 165:e614a9f1c9e2 1019 /* Reset Tx and Rx transfer counters */
AnnaBridge 187:0387e8f68319 1020 hsc->TxXferCount = 0x00U;
AnnaBridge 165:e614a9f1c9e2 1021 hsc->RxXferCount = 0x00U;
AnnaBridge 165:e614a9f1c9e2 1022
AnnaBridge 165:e614a9f1c9e2 1023 /* Reset ErrorCode */
AnnaBridge 165:e614a9f1c9e2 1024 hsc->ErrorCode = HAL_SMARTCARD_ERROR_NONE;
AnnaBridge 165:e614a9f1c9e2 1025
AnnaBridge 165:e614a9f1c9e2 1026 /* Restore hsc->gState and hsc->RxState to Ready */
AnnaBridge 165:e614a9f1c9e2 1027 hsc->gState = HAL_SMARTCARD_STATE_READY;
AnnaBridge 165:e614a9f1c9e2 1028 hsc->RxState = HAL_SMARTCARD_STATE_READY;
AnnaBridge 165:e614a9f1c9e2 1029
AnnaBridge 165:e614a9f1c9e2 1030 /* As no DMA to be aborted, call directly user Abort complete callback */
AnnaBridge 165:e614a9f1c9e2 1031 HAL_SMARTCARD_AbortCpltCallback(hsc);
AnnaBridge 165:e614a9f1c9e2 1032 }
AnnaBridge 165:e614a9f1c9e2 1033 return HAL_OK;
AnnaBridge 165:e614a9f1c9e2 1034 }
AnnaBridge 165:e614a9f1c9e2 1035
AnnaBridge 165:e614a9f1c9e2 1036 /**
AnnaBridge 165:e614a9f1c9e2 1037 * @brief Abort ongoing Transmit transfer (Interrupt mode).
AnnaBridge 165:e614a9f1c9e2 1038 * @param hsc SMARTCARD handle.
AnnaBridge 187:0387e8f68319 1039 * @note This procedure could be used for aborting any ongoing transfer started in Interrupt or DMA mode.
AnnaBridge 165:e614a9f1c9e2 1040 * This procedure performs following operations :
AnnaBridge 165:e614a9f1c9e2 1041 * - Disable PPP Interrupts
AnnaBridge 165:e614a9f1c9e2 1042 * - Disable the DMA transfer in the peripheral register (if enabled)
AnnaBridge 165:e614a9f1c9e2 1043 * - Abort DMA transfer by calling HAL_DMA_Abort_IT (in case of transfer in DMA mode)
AnnaBridge 165:e614a9f1c9e2 1044 * - Set handle State to READY
AnnaBridge 165:e614a9f1c9e2 1045 * - At abort completion, call user abort complete callback
AnnaBridge 165:e614a9f1c9e2 1046 * @note This procedure is executed in Interrupt mode, meaning that abort procedure could be
AnnaBridge 165:e614a9f1c9e2 1047 * considered as completed only when user abort complete callback is executed (not when exiting function).
AnnaBridge 165:e614a9f1c9e2 1048 * @retval HAL status
AnnaBridge 165:e614a9f1c9e2 1049 */
AnnaBridge 165:e614a9f1c9e2 1050 HAL_StatusTypeDef HAL_SMARTCARD_AbortTransmit_IT(SMARTCARD_HandleTypeDef *hsc)
AnnaBridge 165:e614a9f1c9e2 1051 {
AnnaBridge 165:e614a9f1c9e2 1052 /* Disable TXEIE and TCIE interrupts */
AnnaBridge 165:e614a9f1c9e2 1053 CLEAR_BIT(hsc->Instance->CR1, (USART_CR1_TXEIE | USART_CR1_TCIE));
AnnaBridge 165:e614a9f1c9e2 1054
AnnaBridge 165:e614a9f1c9e2 1055 /* Disable the SMARTCARD DMA Tx request if enabled */
AnnaBridge 187:0387e8f68319 1056 if (HAL_IS_BIT_SET(hsc->Instance->CR3, USART_CR3_DMAT))
AnnaBridge 165:e614a9f1c9e2 1057 {
AnnaBridge 165:e614a9f1c9e2 1058 CLEAR_BIT(hsc->Instance->CR3, USART_CR3_DMAT);
AnnaBridge 165:e614a9f1c9e2 1059
AnnaBridge 165:e614a9f1c9e2 1060 /* Abort the SMARTCARD DMA Tx channel : use blocking DMA Abort API (no callback) */
AnnaBridge 187:0387e8f68319 1061 if (hsc->hdmatx != NULL)
AnnaBridge 165:e614a9f1c9e2 1062 {
AnnaBridge 187:0387e8f68319 1063 /* Set the SMARTCARD DMA Abort callback :
AnnaBridge 165:e614a9f1c9e2 1064 will lead to call HAL_SMARTCARD_AbortCpltCallback() at end of DMA abort procedure */
AnnaBridge 165:e614a9f1c9e2 1065 hsc->hdmatx->XferAbortCallback = SMARTCARD_DMATxOnlyAbortCallback;
AnnaBridge 165:e614a9f1c9e2 1066
AnnaBridge 165:e614a9f1c9e2 1067 /* Abort DMA TX */
AnnaBridge 187:0387e8f68319 1068 if (HAL_DMA_Abort_IT(hsc->hdmatx) != HAL_OK)
AnnaBridge 165:e614a9f1c9e2 1069 {
AnnaBridge 165:e614a9f1c9e2 1070 /* Call Directly hsc->hdmatx->XferAbortCallback function in case of error */
AnnaBridge 165:e614a9f1c9e2 1071 hsc->hdmatx->XferAbortCallback(hsc->hdmatx);
AnnaBridge 165:e614a9f1c9e2 1072 }
AnnaBridge 165:e614a9f1c9e2 1073 }
AnnaBridge 165:e614a9f1c9e2 1074 else
AnnaBridge 165:e614a9f1c9e2 1075 {
AnnaBridge 165:e614a9f1c9e2 1076 /* Reset Tx transfer counter */
AnnaBridge 165:e614a9f1c9e2 1077 hsc->TxXferCount = 0x00U;
AnnaBridge 165:e614a9f1c9e2 1078
AnnaBridge 165:e614a9f1c9e2 1079 /* Restore hsc->gState to Ready */
AnnaBridge 165:e614a9f1c9e2 1080 hsc->gState = HAL_SMARTCARD_STATE_READY;
AnnaBridge 165:e614a9f1c9e2 1081
AnnaBridge 165:e614a9f1c9e2 1082 /* As no DMA to be aborted, call directly user Abort complete callback */
AnnaBridge 165:e614a9f1c9e2 1083 HAL_SMARTCARD_AbortTransmitCpltCallback(hsc);
AnnaBridge 165:e614a9f1c9e2 1084 }
AnnaBridge 165:e614a9f1c9e2 1085 }
AnnaBridge 165:e614a9f1c9e2 1086 else
AnnaBridge 165:e614a9f1c9e2 1087 {
AnnaBridge 165:e614a9f1c9e2 1088 /* Reset Tx transfer counter */
AnnaBridge 165:e614a9f1c9e2 1089 hsc->TxXferCount = 0x00U;
AnnaBridge 165:e614a9f1c9e2 1090
AnnaBridge 165:e614a9f1c9e2 1091 /* Restore hsc->gState to Ready */
AnnaBridge 165:e614a9f1c9e2 1092 hsc->gState = HAL_SMARTCARD_STATE_READY;
AnnaBridge 165:e614a9f1c9e2 1093
AnnaBridge 165:e614a9f1c9e2 1094 /* As no DMA to be aborted, call directly user Abort complete callback */
AnnaBridge 165:e614a9f1c9e2 1095 HAL_SMARTCARD_AbortTransmitCpltCallback(hsc);
AnnaBridge 165:e614a9f1c9e2 1096 }
AnnaBridge 165:e614a9f1c9e2 1097
AnnaBridge 165:e614a9f1c9e2 1098 return HAL_OK;
AnnaBridge 165:e614a9f1c9e2 1099 }
AnnaBridge 165:e614a9f1c9e2 1100
AnnaBridge 165:e614a9f1c9e2 1101 /**
AnnaBridge 165:e614a9f1c9e2 1102 * @brief Abort ongoing Receive transfer (Interrupt mode).
AnnaBridge 165:e614a9f1c9e2 1103 * @param hsc SMARTCARD handle.
AnnaBridge 187:0387e8f68319 1104 * @note This procedure could be used for aborting any ongoing transfer started in Interrupt or DMA mode.
AnnaBridge 165:e614a9f1c9e2 1105 * This procedure performs following operations :
AnnaBridge 165:e614a9f1c9e2 1106 * - Disable PPP Interrupts
AnnaBridge 165:e614a9f1c9e2 1107 * - Disable the DMA transfer in the peripheral register (if enabled)
AnnaBridge 165:e614a9f1c9e2 1108 * - Abort DMA transfer by calling HAL_DMA_Abort_IT (in case of transfer in DMA mode)
AnnaBridge 165:e614a9f1c9e2 1109 * - Set handle State to READY
AnnaBridge 165:e614a9f1c9e2 1110 * - At abort completion, call user abort complete callback
AnnaBridge 165:e614a9f1c9e2 1111 * @note This procedure is executed in Interrupt mode, meaning that abort procedure could be
AnnaBridge 165:e614a9f1c9e2 1112 * considered as completed only when user abort complete callback is executed (not when exiting function).
AnnaBridge 165:e614a9f1c9e2 1113 * @retval HAL status
AnnaBridge 165:e614a9f1c9e2 1114 */
AnnaBridge 165:e614a9f1c9e2 1115 HAL_StatusTypeDef HAL_SMARTCARD_AbortReceive_IT(SMARTCARD_HandleTypeDef *hsc)
AnnaBridge 165:e614a9f1c9e2 1116 {
AnnaBridge 165:e614a9f1c9e2 1117 /* Disable RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts */
AnnaBridge 165:e614a9f1c9e2 1118 CLEAR_BIT(hsc->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE));
AnnaBridge 165:e614a9f1c9e2 1119 CLEAR_BIT(hsc->Instance->CR3, USART_CR3_EIE);
AnnaBridge 165:e614a9f1c9e2 1120
AnnaBridge 165:e614a9f1c9e2 1121 /* Disable the SMARTCARD DMA Rx request if enabled */
AnnaBridge 187:0387e8f68319 1122 if (HAL_IS_BIT_SET(hsc->Instance->CR3, USART_CR3_DMAR))
AnnaBridge 165:e614a9f1c9e2 1123 {
AnnaBridge 165:e614a9f1c9e2 1124 CLEAR_BIT(hsc->Instance->CR3, USART_CR3_DMAR);
AnnaBridge 165:e614a9f1c9e2 1125
AnnaBridge 165:e614a9f1c9e2 1126 /* Abort the SMARTCARD DMA Rx channel : use blocking DMA Abort API (no callback) */
AnnaBridge 187:0387e8f68319 1127 if (hsc->hdmarx != NULL)
AnnaBridge 165:e614a9f1c9e2 1128 {
AnnaBridge 187:0387e8f68319 1129 /* Set the SMARTCARD DMA Abort callback :
AnnaBridge 165:e614a9f1c9e2 1130 will lead to call HAL_SMARTCARD_AbortCpltCallback() at end of DMA abort procedure */
AnnaBridge 165:e614a9f1c9e2 1131 hsc->hdmarx->XferAbortCallback = SMARTCARD_DMARxOnlyAbortCallback;
AnnaBridge 165:e614a9f1c9e2 1132
AnnaBridge 165:e614a9f1c9e2 1133 /* Abort DMA RX */
AnnaBridge 187:0387e8f68319 1134 if (HAL_DMA_Abort_IT(hsc->hdmarx) != HAL_OK)
AnnaBridge 165:e614a9f1c9e2 1135 {
AnnaBridge 165:e614a9f1c9e2 1136 /* Call Directly hsc->hdmarx->XferAbortCallback function in case of error */
AnnaBridge 165:e614a9f1c9e2 1137 hsc->hdmarx->XferAbortCallback(hsc->hdmarx);
AnnaBridge 165:e614a9f1c9e2 1138 }
AnnaBridge 165:e614a9f1c9e2 1139 }
AnnaBridge 165:e614a9f1c9e2 1140 else
AnnaBridge 165:e614a9f1c9e2 1141 {
AnnaBridge 165:e614a9f1c9e2 1142 /* Reset Rx transfer counter */
AnnaBridge 165:e614a9f1c9e2 1143 hsc->RxXferCount = 0x00U;
AnnaBridge 165:e614a9f1c9e2 1144
AnnaBridge 165:e614a9f1c9e2 1145 /* Restore hsc->RxState to Ready */
AnnaBridge 165:e614a9f1c9e2 1146 hsc->RxState = HAL_SMARTCARD_STATE_READY;
AnnaBridge 165:e614a9f1c9e2 1147
AnnaBridge 165:e614a9f1c9e2 1148 /* As no DMA to be aborted, call directly user Abort complete callback */
AnnaBridge 165:e614a9f1c9e2 1149 HAL_SMARTCARD_AbortReceiveCpltCallback(hsc);
AnnaBridge 165:e614a9f1c9e2 1150 }
AnnaBridge 165:e614a9f1c9e2 1151 }
AnnaBridge 165:e614a9f1c9e2 1152 else
AnnaBridge 165:e614a9f1c9e2 1153 {
AnnaBridge 165:e614a9f1c9e2 1154 /* Reset Rx transfer counter */
AnnaBridge 165:e614a9f1c9e2 1155 hsc->RxXferCount = 0x00U;
AnnaBridge 165:e614a9f1c9e2 1156
AnnaBridge 165:e614a9f1c9e2 1157 /* Restore hsc->RxState to Ready */
AnnaBridge 165:e614a9f1c9e2 1158 hsc->RxState = HAL_SMARTCARD_STATE_READY;
AnnaBridge 165:e614a9f1c9e2 1159
AnnaBridge 165:e614a9f1c9e2 1160 /* As no DMA to be aborted, call directly user Abort complete callback */
AnnaBridge 165:e614a9f1c9e2 1161 HAL_SMARTCARD_AbortReceiveCpltCallback(hsc);
AnnaBridge 165:e614a9f1c9e2 1162 }
AnnaBridge 165:e614a9f1c9e2 1163
AnnaBridge 165:e614a9f1c9e2 1164 return HAL_OK;
AnnaBridge 165:e614a9f1c9e2 1165 }
AnnaBridge 165:e614a9f1c9e2 1166
AnnaBridge 165:e614a9f1c9e2 1167 /**
AnnaBridge 165:e614a9f1c9e2 1168 * @brief This function handles SMARTCARD interrupt request.
AnnaBridge 165:e614a9f1c9e2 1169 * @param hsc: pointer to a SMARTCARD_HandleTypeDef structure that contains
AnnaBridge 165:e614a9f1c9e2 1170 * the configuration information for SMARTCARD module.
<> 144:ef7eb2e8f9f7 1171 * @retval None
<> 144:ef7eb2e8f9f7 1172 */
<> 144:ef7eb2e8f9f7 1173 void HAL_SMARTCARD_IRQHandler(SMARTCARD_HandleTypeDef *hsc)
<> 144:ef7eb2e8f9f7 1174 {
AnnaBridge 165:e614a9f1c9e2 1175 uint32_t isrflags = READ_REG(hsc->Instance->SR);
AnnaBridge 165:e614a9f1c9e2 1176 uint32_t cr1its = READ_REG(hsc->Instance->CR1);
AnnaBridge 165:e614a9f1c9e2 1177 uint32_t cr3its = READ_REG(hsc->Instance->CR3);
AnnaBridge 165:e614a9f1c9e2 1178 uint32_t dmarequest = 0x00U;
AnnaBridge 165:e614a9f1c9e2 1179 uint32_t errorflags = 0x00U;
AnnaBridge 165:e614a9f1c9e2 1180
AnnaBridge 165:e614a9f1c9e2 1181 /* If no error occurs */
AnnaBridge 165:e614a9f1c9e2 1182 errorflags = (isrflags & (uint32_t)(USART_SR_PE | USART_SR_FE | USART_SR_ORE | USART_SR_NE));
AnnaBridge 187:0387e8f68319 1183 if (errorflags == RESET)
<> 144:ef7eb2e8f9f7 1184 {
AnnaBridge 165:e614a9f1c9e2 1185 /* SMARTCARD in mode Receiver -------------------------------------------------*/
AnnaBridge 187:0387e8f68319 1186 if (((isrflags & USART_SR_RXNE) != RESET) && ((cr1its & USART_CR1_RXNEIE) != RESET))
AnnaBridge 165:e614a9f1c9e2 1187 {
AnnaBridge 165:e614a9f1c9e2 1188 SMARTCARD_Receive_IT(hsc);
AnnaBridge 165:e614a9f1c9e2 1189 return;
AnnaBridge 165:e614a9f1c9e2 1190 }
<> 144:ef7eb2e8f9f7 1191 }
<> 144:ef7eb2e8f9f7 1192
AnnaBridge 165:e614a9f1c9e2 1193 /* If some errors occur */
AnnaBridge 187:0387e8f68319 1194 if ((errorflags != RESET) && (((cr3its & USART_CR3_EIE) != RESET) || ((cr1its & (USART_CR1_RXNEIE | USART_CR1_PEIE)) != RESET)))
<> 144:ef7eb2e8f9f7 1195 {
AnnaBridge 165:e614a9f1c9e2 1196 /* SMARTCARD parity error interrupt occurred ---------------------------*/
AnnaBridge 187:0387e8f68319 1197 if (((isrflags & SMARTCARD_FLAG_PE) != RESET) && ((cr1its & USART_CR1_PEIE) != RESET))
AnnaBridge 165:e614a9f1c9e2 1198 {
AnnaBridge 165:e614a9f1c9e2 1199 hsc->ErrorCode |= HAL_SMARTCARD_ERROR_PE;
AnnaBridge 165:e614a9f1c9e2 1200 }
AnnaBridge 165:e614a9f1c9e2 1201
AnnaBridge 165:e614a9f1c9e2 1202 /* SMARTCARD noise error interrupt occurred ----------------------------*/
AnnaBridge 187:0387e8f68319 1203 if (((isrflags & SMARTCARD_FLAG_NE) != RESET) && ((cr3its & USART_CR3_EIE) != RESET))
AnnaBridge 165:e614a9f1c9e2 1204 {
AnnaBridge 165:e614a9f1c9e2 1205 hsc->ErrorCode |= HAL_SMARTCARD_ERROR_NE;
AnnaBridge 165:e614a9f1c9e2 1206 }
AnnaBridge 165:e614a9f1c9e2 1207
AnnaBridge 165:e614a9f1c9e2 1208 /* SMARTCARD frame error interrupt occurred ----------------------------*/
AnnaBridge 187:0387e8f68319 1209 if (((isrflags & SMARTCARD_FLAG_FE) != RESET) && ((cr3its & USART_CR3_EIE) != RESET))
AnnaBridge 165:e614a9f1c9e2 1210 {
AnnaBridge 165:e614a9f1c9e2 1211 hsc->ErrorCode |= HAL_SMARTCARD_ERROR_FE;
AnnaBridge 165:e614a9f1c9e2 1212 }
AnnaBridge 165:e614a9f1c9e2 1213
AnnaBridge 165:e614a9f1c9e2 1214 /* SMARTCARD Over-Run interrupt occurred -------------------------------*/
AnnaBridge 187:0387e8f68319 1215 if (((isrflags & SMARTCARD_FLAG_ORE) != RESET) && ((cr3its & USART_CR3_EIE) != RESET))
AnnaBridge 187:0387e8f68319 1216 {
AnnaBridge 165:e614a9f1c9e2 1217 hsc->ErrorCode |= HAL_SMARTCARD_ERROR_ORE;
AnnaBridge 165:e614a9f1c9e2 1218 }
AnnaBridge 165:e614a9f1c9e2 1219
AnnaBridge 165:e614a9f1c9e2 1220 /* Call SMARTCARD Error Call back function if need be ------------------*/
AnnaBridge 187:0387e8f68319 1221 if (hsc->ErrorCode != HAL_SMARTCARD_ERROR_NONE)
AnnaBridge 165:e614a9f1c9e2 1222 {
AnnaBridge 165:e614a9f1c9e2 1223 /* SMARTCARD in mode Receiver ----------------------------------------*/
AnnaBridge 187:0387e8f68319 1224 if (((isrflags & USART_SR_RXNE) != RESET) && ((cr1its & USART_CR1_RXNEIE) != RESET))
AnnaBridge 165:e614a9f1c9e2 1225 {
AnnaBridge 165:e614a9f1c9e2 1226 SMARTCARD_Receive_IT(hsc);
AnnaBridge 165:e614a9f1c9e2 1227 }
AnnaBridge 165:e614a9f1c9e2 1228
AnnaBridge 165:e614a9f1c9e2 1229 /* If Overrun error occurs, or if any error occurs in DMA mode reception,
AnnaBridge 165:e614a9f1c9e2 1230 consider error as blocking */
AnnaBridge 165:e614a9f1c9e2 1231 dmarequest = HAL_IS_BIT_SET(hsc->Instance->CR3, USART_CR3_DMAR);
AnnaBridge 187:0387e8f68319 1232 if (((hsc->ErrorCode & HAL_SMARTCARD_ERROR_ORE) != RESET) || dmarequest)
AnnaBridge 165:e614a9f1c9e2 1233 {
AnnaBridge 165:e614a9f1c9e2 1234 /* Blocking error : transfer is aborted
AnnaBridge 165:e614a9f1c9e2 1235 Set the SMARTCARD state ready to be able to start again the process,
AnnaBridge 165:e614a9f1c9e2 1236 Disable Rx Interrupts, and disable Rx DMA request, if ongoing */
AnnaBridge 165:e614a9f1c9e2 1237 SMARTCARD_EndRxTransfer(hsc);
<> 144:ef7eb2e8f9f7 1238
AnnaBridge 165:e614a9f1c9e2 1239 /* Disable the SMARTCARD DMA Rx request if enabled */
AnnaBridge 187:0387e8f68319 1240 if (HAL_IS_BIT_SET(hsc->Instance->CR3, USART_CR3_DMAR))
AnnaBridge 165:e614a9f1c9e2 1241 {
AnnaBridge 165:e614a9f1c9e2 1242 CLEAR_BIT(hsc->Instance->CR3, USART_CR3_DMAR);
AnnaBridge 165:e614a9f1c9e2 1243
AnnaBridge 165:e614a9f1c9e2 1244 /* Abort the SMARTCARD DMA Rx channel */
AnnaBridge 187:0387e8f68319 1245 if (hsc->hdmarx != NULL)
AnnaBridge 165:e614a9f1c9e2 1246 {
AnnaBridge 187:0387e8f68319 1247 /* Set the SMARTCARD DMA Abort callback :
AnnaBridge 165:e614a9f1c9e2 1248 will lead to call HAL_SMARTCARD_ErrorCallback() at end of DMA abort procedure */
AnnaBridge 165:e614a9f1c9e2 1249 hsc->hdmarx->XferAbortCallback = SMARTCARD_DMAAbortOnError;
AnnaBridge 187:0387e8f68319 1250 if (HAL_DMA_Abort_IT(hsc->hdmarx) != HAL_OK)
AnnaBridge 165:e614a9f1c9e2 1251 {
AnnaBridge 165:e614a9f1c9e2 1252 /* Call Directly XferAbortCallback function in case of error */
AnnaBridge 165:e614a9f1c9e2 1253 hsc->hdmarx->XferAbortCallback(hsc->hdmarx);
AnnaBridge 165:e614a9f1c9e2 1254 }
AnnaBridge 165:e614a9f1c9e2 1255 }
AnnaBridge 165:e614a9f1c9e2 1256 else
AnnaBridge 165:e614a9f1c9e2 1257 {
AnnaBridge 165:e614a9f1c9e2 1258 /* Call user error callback */
AnnaBridge 165:e614a9f1c9e2 1259 HAL_SMARTCARD_ErrorCallback(hsc);
AnnaBridge 165:e614a9f1c9e2 1260 }
AnnaBridge 165:e614a9f1c9e2 1261 }
AnnaBridge 165:e614a9f1c9e2 1262 else
AnnaBridge 165:e614a9f1c9e2 1263 {
AnnaBridge 165:e614a9f1c9e2 1264 /* Call user error callback */
AnnaBridge 165:e614a9f1c9e2 1265 HAL_SMARTCARD_ErrorCallback(hsc);
AnnaBridge 165:e614a9f1c9e2 1266 }
AnnaBridge 165:e614a9f1c9e2 1267 }
AnnaBridge 165:e614a9f1c9e2 1268 else
AnnaBridge 165:e614a9f1c9e2 1269 {
AnnaBridge 187:0387e8f68319 1270 /* Non Blocking error : transfer could go on.
AnnaBridge 165:e614a9f1c9e2 1271 Error is notified to user through user error callback */
AnnaBridge 165:e614a9f1c9e2 1272 HAL_SMARTCARD_ErrorCallback(hsc);
AnnaBridge 165:e614a9f1c9e2 1273 hsc->ErrorCode = HAL_SMARTCARD_ERROR_NONE;
AnnaBridge 165:e614a9f1c9e2 1274 }
AnnaBridge 165:e614a9f1c9e2 1275 }
AnnaBridge 165:e614a9f1c9e2 1276 return;
AnnaBridge 165:e614a9f1c9e2 1277 } /* End if some error occurs */
AnnaBridge 187:0387e8f68319 1278
AnnaBridge 165:e614a9f1c9e2 1279 /* SMARTCARD in mode Transmitter -------------------------------------------*/
AnnaBridge 187:0387e8f68319 1280 if (((isrflags & SMARTCARD_FLAG_TXE) != RESET) && ((cr1its & USART_CR1_TXEIE) != RESET))
<> 144:ef7eb2e8f9f7 1281 {
AnnaBridge 165:e614a9f1c9e2 1282 SMARTCARD_Transmit_IT(hsc);
AnnaBridge 165:e614a9f1c9e2 1283 return;
<> 144:ef7eb2e8f9f7 1284 }
AnnaBridge 187:0387e8f68319 1285
<> 144:ef7eb2e8f9f7 1286 /* SMARTCARD in mode Transmitter (transmission end) ------------------------*/
AnnaBridge 187:0387e8f68319 1287 if (((isrflags & SMARTCARD_FLAG_TC) != RESET) && ((cr1its & USART_CR1_TCIE) != RESET))
<> 144:ef7eb2e8f9f7 1288 {
<> 144:ef7eb2e8f9f7 1289 SMARTCARD_EndTransmit_IT(hsc);
AnnaBridge 165:e614a9f1c9e2 1290 return;
<> 144:ef7eb2e8f9f7 1291 }
<> 144:ef7eb2e8f9f7 1292 }
<> 144:ef7eb2e8f9f7 1293
<> 144:ef7eb2e8f9f7 1294 /**
AnnaBridge 165:e614a9f1c9e2 1295 * @brief Tx Transfer completed callbacks
AnnaBridge 165:e614a9f1c9e2 1296 * @param hsc: pointer to a SMARTCARD_HandleTypeDef structure that contains
AnnaBridge 165:e614a9f1c9e2 1297 * the configuration information for SMARTCARD module.
<> 144:ef7eb2e8f9f7 1298 * @retval None
<> 144:ef7eb2e8f9f7 1299 */
AnnaBridge 165:e614a9f1c9e2 1300 __weak void HAL_SMARTCARD_TxCpltCallback(SMARTCARD_HandleTypeDef *hsc)
<> 144:ef7eb2e8f9f7 1301 {
<> 144:ef7eb2e8f9f7 1302 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 1303 UNUSED(hsc);
AnnaBridge 165:e614a9f1c9e2 1304 /* NOTE : This function Should not be modified, when the callback is needed,
AnnaBridge 165:e614a9f1c9e2 1305 the HAL_SMARTCARD_TxCpltCallback could be implemented in the user file
AnnaBridge 187:0387e8f68319 1306 */
<> 144:ef7eb2e8f9f7 1307 }
<> 144:ef7eb2e8f9f7 1308
<> 144:ef7eb2e8f9f7 1309 /**
AnnaBridge 165:e614a9f1c9e2 1310 * @brief Rx Transfer completed callbacks
AnnaBridge 165:e614a9f1c9e2 1311 * @param hsc: pointer to a SMARTCARD_HandleTypeDef structure that contains
AnnaBridge 165:e614a9f1c9e2 1312 * the configuration information for SMARTCARD module.
<> 144:ef7eb2e8f9f7 1313 * @retval None
<> 144:ef7eb2e8f9f7 1314 */
<> 144:ef7eb2e8f9f7 1315 __weak void HAL_SMARTCARD_RxCpltCallback(SMARTCARD_HandleTypeDef *hsc)
<> 144:ef7eb2e8f9f7 1316 {
<> 144:ef7eb2e8f9f7 1317 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 1318 UNUSED(hsc);
AnnaBridge 165:e614a9f1c9e2 1319 /* NOTE : This function Should not be modified, when the callback is needed,
AnnaBridge 165:e614a9f1c9e2 1320 the HAL_SMARTCARD_RxCpltCallback could be implemented in the user file
AnnaBridge 165:e614a9f1c9e2 1321 */
AnnaBridge 165:e614a9f1c9e2 1322 }
AnnaBridge 165:e614a9f1c9e2 1323
AnnaBridge 165:e614a9f1c9e2 1324 /**
AnnaBridge 165:e614a9f1c9e2 1325 * @brief SMARTCARD error callbacks
AnnaBridge 165:e614a9f1c9e2 1326 * @param hsc: pointer to a SMARTCARD_HandleTypeDef structure that contains
AnnaBridge 165:e614a9f1c9e2 1327 * the configuration information for SMARTCARD module.
AnnaBridge 165:e614a9f1c9e2 1328 * @retval None
AnnaBridge 165:e614a9f1c9e2 1329 */
AnnaBridge 165:e614a9f1c9e2 1330 __weak void HAL_SMARTCARD_ErrorCallback(SMARTCARD_HandleTypeDef *hsc)
AnnaBridge 165:e614a9f1c9e2 1331 {
AnnaBridge 165:e614a9f1c9e2 1332 /* Prevent unused argument(s) compilation warning */
AnnaBridge 165:e614a9f1c9e2 1333 UNUSED(hsc);
AnnaBridge 165:e614a9f1c9e2 1334 /* NOTE : This function Should not be modified, when the callback is needed,
AnnaBridge 165:e614a9f1c9e2 1335 the HAL_SMARTCARD_ErrorCallback could be implemented in the user file
<> 144:ef7eb2e8f9f7 1336 */
<> 144:ef7eb2e8f9f7 1337 }
<> 144:ef7eb2e8f9f7 1338
<> 144:ef7eb2e8f9f7 1339 /**
AnnaBridge 165:e614a9f1c9e2 1340 * @brief SMARTCARD Abort Complete callback.
AnnaBridge 165:e614a9f1c9e2 1341 * @param hsc SMARTCARD handle.
<> 144:ef7eb2e8f9f7 1342 * @retval None
<> 144:ef7eb2e8f9f7 1343 */
AnnaBridge 187:0387e8f68319 1344 __weak void HAL_SMARTCARD_AbortCpltCallback(SMARTCARD_HandleTypeDef *hsc)
<> 144:ef7eb2e8f9f7 1345 {
<> 144:ef7eb2e8f9f7 1346 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 1347 UNUSED(hsc);
AnnaBridge 165:e614a9f1c9e2 1348
AnnaBridge 165:e614a9f1c9e2 1349 /* NOTE : This function should not be modified, when the callback is needed,
AnnaBridge 165:e614a9f1c9e2 1350 the HAL_SMARTCARD_AbortCpltCallback can be implemented in the user file.
AnnaBridge 165:e614a9f1c9e2 1351 */
AnnaBridge 165:e614a9f1c9e2 1352 }
AnnaBridge 165:e614a9f1c9e2 1353
AnnaBridge 165:e614a9f1c9e2 1354 /**
AnnaBridge 165:e614a9f1c9e2 1355 * @brief SMARTCARD Abort Transmit Complete callback.
AnnaBridge 165:e614a9f1c9e2 1356 * @param hsc SMARTCARD handle.
AnnaBridge 165:e614a9f1c9e2 1357 * @retval None
AnnaBridge 165:e614a9f1c9e2 1358 */
AnnaBridge 187:0387e8f68319 1359 __weak void HAL_SMARTCARD_AbortTransmitCpltCallback(SMARTCARD_HandleTypeDef *hsc)
AnnaBridge 165:e614a9f1c9e2 1360 {
AnnaBridge 187:0387e8f68319 1361 /* Prevent unused argument(s) compilation warning */
AnnaBridge 187:0387e8f68319 1362 UNUSED(hsc);
AnnaBridge 165:e614a9f1c9e2 1363
AnnaBridge 187:0387e8f68319 1364 /* NOTE : This function should not be modified, when the callback is needed,
AnnaBridge 187:0387e8f68319 1365 the HAL_SMARTCARD_AbortTransmitCpltCallback can be implemented in the user file.
AnnaBridge 187:0387e8f68319 1366 */
AnnaBridge 165:e614a9f1c9e2 1367 }
AnnaBridge 165:e614a9f1c9e2 1368
AnnaBridge 165:e614a9f1c9e2 1369 /**
AnnaBridge 165:e614a9f1c9e2 1370 * @brief SMARTCARD Abort ReceiveComplete callback.
AnnaBridge 165:e614a9f1c9e2 1371 * @param hsc SMARTCARD handle.
AnnaBridge 165:e614a9f1c9e2 1372 * @retval None
AnnaBridge 165:e614a9f1c9e2 1373 */
AnnaBridge 187:0387e8f68319 1374 __weak void HAL_SMARTCARD_AbortReceiveCpltCallback(SMARTCARD_HandleTypeDef *hsc)
AnnaBridge 165:e614a9f1c9e2 1375 {
AnnaBridge 187:0387e8f68319 1376 /* Prevent unused argument(s) compilation warning */
AnnaBridge 187:0387e8f68319 1377 UNUSED(hsc);
AnnaBridge 165:e614a9f1c9e2 1378
AnnaBridge 187:0387e8f68319 1379 /* NOTE : This function should not be modified, when the callback is needed,
AnnaBridge 187:0387e8f68319 1380 the HAL_SMARTCARD_AbortReceiveCpltCallback can be implemented in the user file.
AnnaBridge 187:0387e8f68319 1381 */
<> 144:ef7eb2e8f9f7 1382 }
<> 144:ef7eb2e8f9f7 1383
<> 144:ef7eb2e8f9f7 1384 /**
<> 144:ef7eb2e8f9f7 1385 * @}
<> 144:ef7eb2e8f9f7 1386 */
<> 144:ef7eb2e8f9f7 1387
AnnaBridge 187:0387e8f68319 1388 /** @defgroup SMARTCARD_Exported_Functions_Group3 Peripheral State and Errors functions
AnnaBridge 187:0387e8f68319 1389 * @brief SMARTCARD State and Errors functions
<> 144:ef7eb2e8f9f7 1390 *
AnnaBridge 187:0387e8f68319 1391 @verbatim
AnnaBridge 165:e614a9f1c9e2 1392 ===============================================================================
AnnaBridge 165:e614a9f1c9e2 1393 ##### Peripheral State and Errors functions #####
AnnaBridge 187:0387e8f68319 1394 ===============================================================================
AnnaBridge 165:e614a9f1c9e2 1395 [..]
AnnaBridge 165:e614a9f1c9e2 1396 This subsection provides a set of functions allowing to control the SmartCard.
AnnaBridge 165:e614a9f1c9e2 1397 (+) HAL_SMARTCARD_GetState() API can be helpful to check in run-time the state of the SmartCard peripheral.
AnnaBridge 187:0387e8f68319 1398 (+) HAL_SMARTCARD_GetError() check in run-time errors that could be occurred during communication.
<> 144:ef7eb2e8f9f7 1399 @endverbatim
<> 144:ef7eb2e8f9f7 1400 * @{
<> 144:ef7eb2e8f9f7 1401 */
<> 144:ef7eb2e8f9f7 1402
<> 144:ef7eb2e8f9f7 1403 /**
AnnaBridge 165:e614a9f1c9e2 1404 * @brief return the SMARTCARD state
AnnaBridge 165:e614a9f1c9e2 1405 * @param hsc: pointer to a SMARTCARD_HandleTypeDef structure that contains
AnnaBridge 165:e614a9f1c9e2 1406 * the configuration information for SMARTCARD module.
<> 144:ef7eb2e8f9f7 1407 * @retval HAL state
<> 144:ef7eb2e8f9f7 1408 */
<> 144:ef7eb2e8f9f7 1409 HAL_SMARTCARD_StateTypeDef HAL_SMARTCARD_GetState(SMARTCARD_HandleTypeDef *hsc)
<> 144:ef7eb2e8f9f7 1410 {
AnnaBridge 187:0387e8f68319 1411 uint32_t temp1 = 0x00U, temp2 = 0x00U;
AnnaBridge 165:e614a9f1c9e2 1412 temp1 = hsc->gState;
AnnaBridge 165:e614a9f1c9e2 1413 temp2 = hsc->RxState;
AnnaBridge 187:0387e8f68319 1414
AnnaBridge 165:e614a9f1c9e2 1415 return (HAL_SMARTCARD_StateTypeDef)(temp1 | temp2);
<> 144:ef7eb2e8f9f7 1416 }
<> 144:ef7eb2e8f9f7 1417
<> 144:ef7eb2e8f9f7 1418 /**
<> 144:ef7eb2e8f9f7 1419 * @brief Return the SMARTCARD error code
AnnaBridge 165:e614a9f1c9e2 1420 * @param hsc : pointer to a SMARTCARD_HandleTypeDef structure that contains
AnnaBridge 165:e614a9f1c9e2 1421 * the configuration information for the specified SMARTCARD.
<> 144:ef7eb2e8f9f7 1422 * @retval SMARTCARD Error Code
<> 144:ef7eb2e8f9f7 1423 */
<> 144:ef7eb2e8f9f7 1424 uint32_t HAL_SMARTCARD_GetError(SMARTCARD_HandleTypeDef *hsc)
<> 144:ef7eb2e8f9f7 1425 {
<> 144:ef7eb2e8f9f7 1426 return hsc->ErrorCode;
<> 144:ef7eb2e8f9f7 1427 }
<> 144:ef7eb2e8f9f7 1428
<> 144:ef7eb2e8f9f7 1429 /**
<> 144:ef7eb2e8f9f7 1430 * @}
<> 144:ef7eb2e8f9f7 1431 */
AnnaBridge 165:e614a9f1c9e2 1432
<> 144:ef7eb2e8f9f7 1433 /**
AnnaBridge 187:0387e8f68319 1434 * @brief DMA SMARTCARD transmit process complete callback
AnnaBridge 165:e614a9f1c9e2 1435 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
AnnaBridge 165:e614a9f1c9e2 1436 * the configuration information for the specified DMA module.
<> 144:ef7eb2e8f9f7 1437 * @retval None
<> 144:ef7eb2e8f9f7 1438 */
<> 144:ef7eb2e8f9f7 1439 static void SMARTCARD_DMATransmitCplt(DMA_HandleTypeDef *hdma)
<> 144:ef7eb2e8f9f7 1440 {
AnnaBridge 187:0387e8f68319 1441 SMARTCARD_HandleTypeDef *hsc = (SMARTCARD_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
AnnaBridge 187:0387e8f68319 1442
AnnaBridge 165:e614a9f1c9e2 1443 hsc->TxXferCount = 0U;
AnnaBridge 187:0387e8f68319 1444
<> 144:ef7eb2e8f9f7 1445 /* Disable the DMA transfer for transmit request by setting the DMAT bit
AnnaBridge 165:e614a9f1c9e2 1446 in the USART CR3 register */
<> 144:ef7eb2e8f9f7 1447 CLEAR_BIT(hsc->Instance->CR3, USART_CR3_DMAT);
<> 144:ef7eb2e8f9f7 1448
AnnaBridge 165:e614a9f1c9e2 1449 /* Enable the SMARTCARD Transmit Complete Interrupt */
AnnaBridge 165:e614a9f1c9e2 1450 SET_BIT(hsc->Instance->CR1, USART_CR1_TCIE);
<> 144:ef7eb2e8f9f7 1451 }
<> 144:ef7eb2e8f9f7 1452
<> 144:ef7eb2e8f9f7 1453 /**
AnnaBridge 187:0387e8f68319 1454 * @brief DMA SMARTCARD receive process complete callback
AnnaBridge 165:e614a9f1c9e2 1455 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
AnnaBridge 165:e614a9f1c9e2 1456 * the configuration information for the specified DMA module.
<> 144:ef7eb2e8f9f7 1457 * @retval None
<> 144:ef7eb2e8f9f7 1458 */
AnnaBridge 187:0387e8f68319 1459 static void SMARTCARD_DMAReceiveCplt(DMA_HandleTypeDef *hdma)
<> 144:ef7eb2e8f9f7 1460 {
AnnaBridge 187:0387e8f68319 1461 SMARTCARD_HandleTypeDef *hsc = (SMARTCARD_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
<> 144:ef7eb2e8f9f7 1462
AnnaBridge 165:e614a9f1c9e2 1463 hsc->RxXferCount = 0U;
AnnaBridge 187:0387e8f68319 1464
AnnaBridge 165:e614a9f1c9e2 1465 /* Disable RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts */
AnnaBridge 165:e614a9f1c9e2 1466 CLEAR_BIT(hsc->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE));
AnnaBridge 165:e614a9f1c9e2 1467 CLEAR_BIT(hsc->Instance->CR3, USART_CR3_EIE);
AnnaBridge 187:0387e8f68319 1468
AnnaBridge 187:0387e8f68319 1469 /* Disable the DMA transfer for the receiver request by setting the DMAR bit
AnnaBridge 165:e614a9f1c9e2 1470 in the USART CR3 register */
<> 144:ef7eb2e8f9f7 1471 CLEAR_BIT(hsc->Instance->CR3, USART_CR3_DMAR);
<> 144:ef7eb2e8f9f7 1472
AnnaBridge 165:e614a9f1c9e2 1473 /* At end of Rx process, restore hsc->RxState to Ready */
AnnaBridge 165:e614a9f1c9e2 1474 hsc->RxState = HAL_SMARTCARD_STATE_READY;
AnnaBridge 187:0387e8f68319 1475
<> 144:ef7eb2e8f9f7 1476 HAL_SMARTCARD_RxCpltCallback(hsc);
<> 144:ef7eb2e8f9f7 1477 }
<> 144:ef7eb2e8f9f7 1478
<> 144:ef7eb2e8f9f7 1479 /**
AnnaBridge 187:0387e8f68319 1480 * @brief DMA SMARTCARD communication error callback
AnnaBridge 165:e614a9f1c9e2 1481 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
AnnaBridge 165:e614a9f1c9e2 1482 * the configuration information for the specified DMA module.
<> 144:ef7eb2e8f9f7 1483 * @retval None
<> 144:ef7eb2e8f9f7 1484 */
AnnaBridge 187:0387e8f68319 1485 static void SMARTCARD_DMAError(DMA_HandleTypeDef *hdma)
<> 144:ef7eb2e8f9f7 1486 {
AnnaBridge 165:e614a9f1c9e2 1487 uint32_t dmarequest = 0x00U;
AnnaBridge 187:0387e8f68319 1488 SMARTCARD_HandleTypeDef *hsc = (SMARTCARD_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
AnnaBridge 165:e614a9f1c9e2 1489 hsc->RxXferCount = 0U;
AnnaBridge 165:e614a9f1c9e2 1490 hsc->TxXferCount = 0U;
AnnaBridge 165:e614a9f1c9e2 1491 hsc->ErrorCode = HAL_SMARTCARD_ERROR_DMA;
AnnaBridge 187:0387e8f68319 1492
AnnaBridge 165:e614a9f1c9e2 1493 /* Stop SMARTCARD DMA Tx request if ongoing */
AnnaBridge 165:e614a9f1c9e2 1494 dmarequest = HAL_IS_BIT_SET(hsc->Instance->CR3, USART_CR3_DMAT);
AnnaBridge 187:0387e8f68319 1495 if ((hsc->gState == HAL_SMARTCARD_STATE_BUSY_TX) && dmarequest)
AnnaBridge 165:e614a9f1c9e2 1496 {
AnnaBridge 165:e614a9f1c9e2 1497 SMARTCARD_EndTxTransfer(hsc);
AnnaBridge 165:e614a9f1c9e2 1498 }
AnnaBridge 165:e614a9f1c9e2 1499
AnnaBridge 165:e614a9f1c9e2 1500 /* Stop SMARTCARD DMA Rx request if ongoing */
AnnaBridge 165:e614a9f1c9e2 1501 dmarequest = HAL_IS_BIT_SET(hsc->Instance->CR3, USART_CR3_DMAR);
AnnaBridge 187:0387e8f68319 1502 if ((hsc->RxState == HAL_SMARTCARD_STATE_BUSY_RX) && dmarequest)
AnnaBridge 165:e614a9f1c9e2 1503 {
AnnaBridge 165:e614a9f1c9e2 1504 SMARTCARD_EndRxTransfer(hsc);
AnnaBridge 165:e614a9f1c9e2 1505 }
AnnaBridge 165:e614a9f1c9e2 1506
<> 144:ef7eb2e8f9f7 1507 HAL_SMARTCARD_ErrorCallback(hsc);
<> 144:ef7eb2e8f9f7 1508 }
<> 144:ef7eb2e8f9f7 1509
<> 144:ef7eb2e8f9f7 1510 /**
<> 144:ef7eb2e8f9f7 1511 * @brief This function handles SMARTCARD Communication Timeout.
AnnaBridge 165:e614a9f1c9e2 1512 * @param hsc: SMARTCARD handle
<> 144:ef7eb2e8f9f7 1513 * @param Flag: specifies the SMARTCARD flag to check.
<> 144:ef7eb2e8f9f7 1514 * @param Status: The new Flag status (SET or RESET).
<> 144:ef7eb2e8f9f7 1515 * @param Timeout: Timeout duration
AnnaBridge 165:e614a9f1c9e2 1516 * @param Tickstart: tick start value
<> 144:ef7eb2e8f9f7 1517 * @retval HAL status
<> 144:ef7eb2e8f9f7 1518 */
AnnaBridge 165:e614a9f1c9e2 1519 static HAL_StatusTypeDef SMARTCARD_WaitOnFlagUntilTimeout(SMARTCARD_HandleTypeDef *hsc, uint32_t Flag, FlagStatus Status, uint32_t Tickstart, uint32_t Timeout)
<> 144:ef7eb2e8f9f7 1520 {
<> 144:ef7eb2e8f9f7 1521 /* Wait until flag is set */
AnnaBridge 187:0387e8f68319 1522 while ((__HAL_SMARTCARD_GET_FLAG(hsc, Flag) ? SET : RESET) == Status)
<> 144:ef7eb2e8f9f7 1523 {
AnnaBridge 165:e614a9f1c9e2 1524 /* Check for the Timeout */
AnnaBridge 187:0387e8f68319 1525 if (Timeout != HAL_MAX_DELAY)
<> 144:ef7eb2e8f9f7 1526 {
AnnaBridge 187:0387e8f68319 1527 if ((Timeout == 0U) || ((HAL_GetTick() - Tickstart) > Timeout))
<> 144:ef7eb2e8f9f7 1528 {
AnnaBridge 165:e614a9f1c9e2 1529 /* Disable TXE and RXNE interrupts for the interrupt process */
AnnaBridge 165:e614a9f1c9e2 1530 CLEAR_BIT(hsc->Instance->CR1, USART_CR1_TXEIE);
AnnaBridge 165:e614a9f1c9e2 1531 CLEAR_BIT(hsc->Instance->CR1, USART_CR1_RXNEIE);
AnnaBridge 187:0387e8f68319 1532
AnnaBridge 187:0387e8f68319 1533 hsc->gState = HAL_SMARTCARD_STATE_READY;
AnnaBridge 187:0387e8f68319 1534 hsc->RxState = HAL_SMARTCARD_STATE_READY;
AnnaBridge 187:0387e8f68319 1535
AnnaBridge 165:e614a9f1c9e2 1536 /* Process Unlocked */
AnnaBridge 165:e614a9f1c9e2 1537 __HAL_UNLOCK(hsc);
AnnaBridge 187:0387e8f68319 1538
AnnaBridge 165:e614a9f1c9e2 1539 return HAL_TIMEOUT;
<> 144:ef7eb2e8f9f7 1540 }
<> 144:ef7eb2e8f9f7 1541 }
<> 144:ef7eb2e8f9f7 1542 }
<> 144:ef7eb2e8f9f7 1543 return HAL_OK;
<> 144:ef7eb2e8f9f7 1544 }
<> 144:ef7eb2e8f9f7 1545
<> 144:ef7eb2e8f9f7 1546 /**
AnnaBridge 165:e614a9f1c9e2 1547 * @brief End ongoing Tx transfer on SMARTCARD peripheral (following error detection or Transmit completion).
AnnaBridge 165:e614a9f1c9e2 1548 * @param hsc: SMARTCARD handle.
AnnaBridge 165:e614a9f1c9e2 1549 * @retval None
AnnaBridge 165:e614a9f1c9e2 1550 */
AnnaBridge 165:e614a9f1c9e2 1551 static void SMARTCARD_EndTxTransfer(SMARTCARD_HandleTypeDef *hsc)
AnnaBridge 165:e614a9f1c9e2 1552 {
AnnaBridge 165:e614a9f1c9e2 1553 /* At end of Tx process, restore hsc->gState to Ready */
AnnaBridge 165:e614a9f1c9e2 1554 hsc->gState = HAL_SMARTCARD_STATE_READY;
AnnaBridge 165:e614a9f1c9e2 1555
AnnaBridge 165:e614a9f1c9e2 1556 /* Disable TXEIE and TCIE interrupts */
AnnaBridge 165:e614a9f1c9e2 1557 CLEAR_BIT(hsc->Instance->CR1, (USART_CR1_TXEIE | USART_CR1_TCIE));
AnnaBridge 165:e614a9f1c9e2 1558 }
AnnaBridge 165:e614a9f1c9e2 1559
AnnaBridge 165:e614a9f1c9e2 1560
AnnaBridge 165:e614a9f1c9e2 1561 /**
AnnaBridge 165:e614a9f1c9e2 1562 * @brief End ongoing Rx transfer on SMARTCARD peripheral (following error detection or Reception completion).
AnnaBridge 165:e614a9f1c9e2 1563 * @param hsc: SMARTCARD handle.
AnnaBridge 165:e614a9f1c9e2 1564 * @retval None
AnnaBridge 165:e614a9f1c9e2 1565 */
AnnaBridge 165:e614a9f1c9e2 1566 static void SMARTCARD_EndRxTransfer(SMARTCARD_HandleTypeDef *hsc)
AnnaBridge 165:e614a9f1c9e2 1567 {
AnnaBridge 165:e614a9f1c9e2 1568 /* At end of Rx process, restore hsc->RxState to Ready */
AnnaBridge 165:e614a9f1c9e2 1569 hsc->RxState = HAL_SMARTCARD_STATE_READY;
AnnaBridge 165:e614a9f1c9e2 1570
AnnaBridge 165:e614a9f1c9e2 1571 /* Disable RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts */
AnnaBridge 165:e614a9f1c9e2 1572 CLEAR_BIT(hsc->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE));
AnnaBridge 165:e614a9f1c9e2 1573 CLEAR_BIT(hsc->Instance->CR3, USART_CR3_EIE);
AnnaBridge 165:e614a9f1c9e2 1574 }
AnnaBridge 165:e614a9f1c9e2 1575
AnnaBridge 165:e614a9f1c9e2 1576
AnnaBridge 165:e614a9f1c9e2 1577
AnnaBridge 165:e614a9f1c9e2 1578 /**
AnnaBridge 165:e614a9f1c9e2 1579 * @brief DMA SMARTCARD communication abort callback, when initiated by HAL services on Error
AnnaBridge 165:e614a9f1c9e2 1580 * (To be called at end of DMA Abort procedure following error occurrence).
AnnaBridge 165:e614a9f1c9e2 1581 * @param hdma DMA handle.
AnnaBridge 165:e614a9f1c9e2 1582 * @retval None
AnnaBridge 165:e614a9f1c9e2 1583 */
AnnaBridge 165:e614a9f1c9e2 1584 static void SMARTCARD_DMAAbortOnError(DMA_HandleTypeDef *hdma)
AnnaBridge 165:e614a9f1c9e2 1585 {
AnnaBridge 187:0387e8f68319 1586 SMARTCARD_HandleTypeDef *hsc = (SMARTCARD_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
AnnaBridge 165:e614a9f1c9e2 1587 hsc->RxXferCount = 0x00U;
AnnaBridge 165:e614a9f1c9e2 1588 hsc->TxXferCount = 0x00U;
AnnaBridge 165:e614a9f1c9e2 1589
AnnaBridge 165:e614a9f1c9e2 1590 HAL_SMARTCARD_ErrorCallback(hsc);
AnnaBridge 165:e614a9f1c9e2 1591 }
AnnaBridge 165:e614a9f1c9e2 1592
AnnaBridge 165:e614a9f1c9e2 1593 /**
AnnaBridge 165:e614a9f1c9e2 1594 * @brief DMA SMARTCARD Tx communication abort callback, when initiated by user
AnnaBridge 165:e614a9f1c9e2 1595 * (To be called at end of DMA Tx Abort procedure following user abort request).
AnnaBridge 165:e614a9f1c9e2 1596 * @note When this callback is executed, User Abort complete call back is called only if no
AnnaBridge 165:e614a9f1c9e2 1597 * Abort still ongoing for Rx DMA Handle.
AnnaBridge 165:e614a9f1c9e2 1598 * @param hdma DMA handle.
AnnaBridge 165:e614a9f1c9e2 1599 * @retval None
AnnaBridge 165:e614a9f1c9e2 1600 */
AnnaBridge 165:e614a9f1c9e2 1601 static void SMARTCARD_DMATxAbortCallback(DMA_HandleTypeDef *hdma)
AnnaBridge 165:e614a9f1c9e2 1602 {
AnnaBridge 187:0387e8f68319 1603 SMARTCARD_HandleTypeDef *hsc = (SMARTCARD_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
AnnaBridge 187:0387e8f68319 1604
AnnaBridge 165:e614a9f1c9e2 1605 hsc->hdmatx->XferAbortCallback = NULL;
AnnaBridge 165:e614a9f1c9e2 1606
AnnaBridge 165:e614a9f1c9e2 1607 /* Check if an Abort process is still ongoing */
AnnaBridge 187:0387e8f68319 1608 if (hsc->hdmarx != NULL)
AnnaBridge 165:e614a9f1c9e2 1609 {
AnnaBridge 187:0387e8f68319 1610 if (hsc->hdmarx->XferAbortCallback != NULL)
AnnaBridge 165:e614a9f1c9e2 1611 {
AnnaBridge 165:e614a9f1c9e2 1612 return;
AnnaBridge 165:e614a9f1c9e2 1613 }
AnnaBridge 165:e614a9f1c9e2 1614 }
AnnaBridge 187:0387e8f68319 1615
AnnaBridge 165:e614a9f1c9e2 1616 /* No Abort process still ongoing : All DMA channels are aborted, call user Abort Complete callback */
AnnaBridge 165:e614a9f1c9e2 1617 hsc->TxXferCount = 0x00U;
AnnaBridge 165:e614a9f1c9e2 1618 hsc->RxXferCount = 0x00U;
AnnaBridge 165:e614a9f1c9e2 1619
AnnaBridge 165:e614a9f1c9e2 1620 /* Reset ErrorCode */
AnnaBridge 165:e614a9f1c9e2 1621 hsc->ErrorCode = HAL_SMARTCARD_ERROR_NONE;
AnnaBridge 165:e614a9f1c9e2 1622
AnnaBridge 165:e614a9f1c9e2 1623 /* Restore hsc->gState and hsc->RxState to Ready */
AnnaBridge 165:e614a9f1c9e2 1624 hsc->gState = HAL_SMARTCARD_STATE_READY;
AnnaBridge 165:e614a9f1c9e2 1625 hsc->RxState = HAL_SMARTCARD_STATE_READY;
AnnaBridge 165:e614a9f1c9e2 1626
AnnaBridge 165:e614a9f1c9e2 1627 /* Call user Abort complete callback */
AnnaBridge 165:e614a9f1c9e2 1628 HAL_SMARTCARD_AbortCpltCallback(hsc);
AnnaBridge 165:e614a9f1c9e2 1629 }
AnnaBridge 165:e614a9f1c9e2 1630
AnnaBridge 165:e614a9f1c9e2 1631 /**
AnnaBridge 165:e614a9f1c9e2 1632 * @brief DMA SMARTCARD Rx communication abort callback, when initiated by user
AnnaBridge 165:e614a9f1c9e2 1633 * (To be called at end of DMA Rx Abort procedure following user abort request).
AnnaBridge 165:e614a9f1c9e2 1634 * @note When this callback is executed, User Abort complete call back is called only if no
AnnaBridge 165:e614a9f1c9e2 1635 * Abort still ongoing for Tx DMA Handle.
AnnaBridge 165:e614a9f1c9e2 1636 * @param hdma DMA handle.
AnnaBridge 165:e614a9f1c9e2 1637 * @retval None
AnnaBridge 165:e614a9f1c9e2 1638 */
AnnaBridge 165:e614a9f1c9e2 1639 static void SMARTCARD_DMARxAbortCallback(DMA_HandleTypeDef *hdma)
AnnaBridge 165:e614a9f1c9e2 1640 {
AnnaBridge 187:0387e8f68319 1641 SMARTCARD_HandleTypeDef *hsc = (SMARTCARD_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
AnnaBridge 187:0387e8f68319 1642
AnnaBridge 165:e614a9f1c9e2 1643 hsc->hdmarx->XferAbortCallback = NULL;
AnnaBridge 165:e614a9f1c9e2 1644
AnnaBridge 165:e614a9f1c9e2 1645 /* Check if an Abort process is still ongoing */
AnnaBridge 187:0387e8f68319 1646 if (hsc->hdmatx != NULL)
AnnaBridge 165:e614a9f1c9e2 1647 {
AnnaBridge 187:0387e8f68319 1648 if (hsc->hdmatx->XferAbortCallback != NULL)
AnnaBridge 165:e614a9f1c9e2 1649 {
AnnaBridge 165:e614a9f1c9e2 1650 return;
AnnaBridge 165:e614a9f1c9e2 1651 }
AnnaBridge 165:e614a9f1c9e2 1652 }
AnnaBridge 187:0387e8f68319 1653
AnnaBridge 165:e614a9f1c9e2 1654 /* No Abort process still ongoing : All DMA channels are aborted, call user Abort Complete callback */
AnnaBridge 165:e614a9f1c9e2 1655 hsc->TxXferCount = 0x00U;
AnnaBridge 165:e614a9f1c9e2 1656 hsc->RxXferCount = 0x00U;
AnnaBridge 165:e614a9f1c9e2 1657
AnnaBridge 165:e614a9f1c9e2 1658 /* Reset ErrorCode */
AnnaBridge 165:e614a9f1c9e2 1659 hsc->ErrorCode = HAL_SMARTCARD_ERROR_NONE;
AnnaBridge 165:e614a9f1c9e2 1660
AnnaBridge 165:e614a9f1c9e2 1661 /* Restore hsc->gState and hsc->RxState to Ready */
AnnaBridge 165:e614a9f1c9e2 1662 hsc->gState = HAL_SMARTCARD_STATE_READY;
AnnaBridge 165:e614a9f1c9e2 1663 hsc->RxState = HAL_SMARTCARD_STATE_READY;
AnnaBridge 165:e614a9f1c9e2 1664
AnnaBridge 165:e614a9f1c9e2 1665 /* Call user Abort complete callback */
AnnaBridge 165:e614a9f1c9e2 1666 HAL_SMARTCARD_AbortCpltCallback(hsc);
AnnaBridge 165:e614a9f1c9e2 1667 }
AnnaBridge 165:e614a9f1c9e2 1668
AnnaBridge 165:e614a9f1c9e2 1669 /**
AnnaBridge 165:e614a9f1c9e2 1670 * @brief DMA SMARTCARD Tx communication abort callback, when initiated by user by a call to
AnnaBridge 165:e614a9f1c9e2 1671 * HAL_SMARTCARD_AbortTransmit_IT API (Abort only Tx transfer)
AnnaBridge 165:e614a9f1c9e2 1672 * (This callback is executed at end of DMA Tx Abort procedure following user abort request,
AnnaBridge 165:e614a9f1c9e2 1673 * and leads to user Tx Abort Complete callback execution).
AnnaBridge 165:e614a9f1c9e2 1674 * @param hdma DMA handle.
AnnaBridge 165:e614a9f1c9e2 1675 * @retval None
AnnaBridge 165:e614a9f1c9e2 1676 */
AnnaBridge 165:e614a9f1c9e2 1677 static void SMARTCARD_DMATxOnlyAbortCallback(DMA_HandleTypeDef *hdma)
AnnaBridge 165:e614a9f1c9e2 1678 {
AnnaBridge 187:0387e8f68319 1679 SMARTCARD_HandleTypeDef *hsc = (SMARTCARD_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
AnnaBridge 165:e614a9f1c9e2 1680
AnnaBridge 165:e614a9f1c9e2 1681 hsc->TxXferCount = 0x00U;
AnnaBridge 165:e614a9f1c9e2 1682
AnnaBridge 165:e614a9f1c9e2 1683 /* Restore hsc->gState to Ready */
AnnaBridge 165:e614a9f1c9e2 1684 hsc->gState = HAL_SMARTCARD_STATE_READY;
AnnaBridge 165:e614a9f1c9e2 1685
AnnaBridge 165:e614a9f1c9e2 1686 /* Call user Abort complete callback */
AnnaBridge 165:e614a9f1c9e2 1687 HAL_SMARTCARD_AbortTransmitCpltCallback(hsc);
AnnaBridge 165:e614a9f1c9e2 1688 }
AnnaBridge 165:e614a9f1c9e2 1689
AnnaBridge 165:e614a9f1c9e2 1690 /**
AnnaBridge 165:e614a9f1c9e2 1691 * @brief DMA SMARTCARD Rx communication abort callback, when initiated by user by a call to
AnnaBridge 165:e614a9f1c9e2 1692 * HAL_SMARTCARD_AbortReceive_IT API (Abort only Rx transfer)
AnnaBridge 165:e614a9f1c9e2 1693 * (This callback is executed at end of DMA Rx Abort procedure following user abort request,
AnnaBridge 165:e614a9f1c9e2 1694 * and leads to user Rx Abort Complete callback execution).
AnnaBridge 165:e614a9f1c9e2 1695 * @param hdma DMA handle.
AnnaBridge 165:e614a9f1c9e2 1696 * @retval None
AnnaBridge 165:e614a9f1c9e2 1697 */
AnnaBridge 165:e614a9f1c9e2 1698 static void SMARTCARD_DMARxOnlyAbortCallback(DMA_HandleTypeDef *hdma)
AnnaBridge 165:e614a9f1c9e2 1699 {
AnnaBridge 187:0387e8f68319 1700 SMARTCARD_HandleTypeDef *hsc = (SMARTCARD_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
AnnaBridge 165:e614a9f1c9e2 1701
AnnaBridge 165:e614a9f1c9e2 1702 hsc->RxXferCount = 0x00U;
AnnaBridge 165:e614a9f1c9e2 1703
AnnaBridge 165:e614a9f1c9e2 1704 /* Restore hsc->RxState to Ready */
AnnaBridge 165:e614a9f1c9e2 1705 hsc->RxState = HAL_SMARTCARD_STATE_READY;
AnnaBridge 165:e614a9f1c9e2 1706
AnnaBridge 165:e614a9f1c9e2 1707 /* Call user Abort complete callback */
AnnaBridge 165:e614a9f1c9e2 1708 HAL_SMARTCARD_AbortReceiveCpltCallback(hsc);
AnnaBridge 165:e614a9f1c9e2 1709 }
AnnaBridge 165:e614a9f1c9e2 1710
AnnaBridge 165:e614a9f1c9e2 1711 /**
AnnaBridge 187:0387e8f68319 1712 * @brief Send an amount of data in non blocking mode
AnnaBridge 165:e614a9f1c9e2 1713 * @param hsc: pointer to a SMARTCARD_HandleTypeDef structure that contains
AnnaBridge 165:e614a9f1c9e2 1714 * the configuration information for SMARTCARD module.
<> 144:ef7eb2e8f9f7 1715 * @retval HAL status
<> 144:ef7eb2e8f9f7 1716 */
<> 144:ef7eb2e8f9f7 1717 static HAL_StatusTypeDef SMARTCARD_Transmit_IT(SMARTCARD_HandleTypeDef *hsc)
<> 144:ef7eb2e8f9f7 1718 {
AnnaBridge 165:e614a9f1c9e2 1719 /* Check that a Tx process is ongoing */
AnnaBridge 187:0387e8f68319 1720 if (hsc->gState == HAL_SMARTCARD_STATE_BUSY_TX)
<> 144:ef7eb2e8f9f7 1721 {
AnnaBridge 187:0387e8f68319 1722 hsc->Instance->DR = *(uint8_t *) hsc->pTxBuffPtr;
AnnaBridge 165:e614a9f1c9e2 1723 hsc->pTxBuffPtr += 1U;
AnnaBridge 187:0387e8f68319 1724
AnnaBridge 187:0387e8f68319 1725 if (--hsc->TxXferCount == 0U)
<> 144:ef7eb2e8f9f7 1726 {
AnnaBridge 165:e614a9f1c9e2 1727 /* Disable the SMARTCARD Transmit data register empty Interrupt */
AnnaBridge 165:e614a9f1c9e2 1728 CLEAR_BIT(hsc->Instance->CR1, USART_CR1_TXEIE);
<> 144:ef7eb2e8f9f7 1729
AnnaBridge 165:e614a9f1c9e2 1730 /* Enable the SMARTCARD Transmit Complete Interrupt */
AnnaBridge 165:e614a9f1c9e2 1731 SET_BIT(hsc->Instance->CR1, USART_CR1_TCIE);
<> 144:ef7eb2e8f9f7 1732 }
AnnaBridge 165:e614a9f1c9e2 1733
<> 144:ef7eb2e8f9f7 1734 return HAL_OK;
<> 144:ef7eb2e8f9f7 1735 }
<> 144:ef7eb2e8f9f7 1736 else
<> 144:ef7eb2e8f9f7 1737 {
<> 144:ef7eb2e8f9f7 1738 return HAL_BUSY;
<> 144:ef7eb2e8f9f7 1739 }
<> 144:ef7eb2e8f9f7 1740 }
<> 144:ef7eb2e8f9f7 1741
<> 144:ef7eb2e8f9f7 1742 /**
<> 144:ef7eb2e8f9f7 1743 * @brief Wraps up transmission in non blocking mode.
<> 144:ef7eb2e8f9f7 1744 * @param hsmartcard: pointer to a SMARTCARD_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1745 * the configuration information for the specified SMARTCARD module.
<> 144:ef7eb2e8f9f7 1746 * @retval HAL status
<> 144:ef7eb2e8f9f7 1747 */
<> 144:ef7eb2e8f9f7 1748 static HAL_StatusTypeDef SMARTCARD_EndTransmit_IT(SMARTCARD_HandleTypeDef *hsmartcard)
<> 144:ef7eb2e8f9f7 1749 {
AnnaBridge 187:0387e8f68319 1750 /* Disable the SMARTCARD Transmit Complete Interrupt */
AnnaBridge 165:e614a9f1c9e2 1751 CLEAR_BIT(hsmartcard->Instance->CR1, USART_CR1_TCIE);
AnnaBridge 187:0387e8f68319 1752
AnnaBridge 165:e614a9f1c9e2 1753 /* Disable the SMARTCARD Error Interrupt: (Frame error, noise error, overrun error) */
AnnaBridge 165:e614a9f1c9e2 1754 CLEAR_BIT(hsmartcard->Instance->CR3, USART_CR3_EIE);
AnnaBridge 165:e614a9f1c9e2 1755
AnnaBridge 165:e614a9f1c9e2 1756 /* Tx process is ended, restore hsmartcard->gState to Ready */
AnnaBridge 165:e614a9f1c9e2 1757 hsmartcard->gState = HAL_SMARTCARD_STATE_READY;
AnnaBridge 165:e614a9f1c9e2 1758
<> 144:ef7eb2e8f9f7 1759 HAL_SMARTCARD_TxCpltCallback(hsmartcard);
AnnaBridge 187:0387e8f68319 1760
<> 144:ef7eb2e8f9f7 1761 return HAL_OK;
<> 144:ef7eb2e8f9f7 1762 }
<> 144:ef7eb2e8f9f7 1763
<> 144:ef7eb2e8f9f7 1764 /**
AnnaBridge 187:0387e8f68319 1765 * @brief Receive an amount of data in non blocking mode
AnnaBridge 165:e614a9f1c9e2 1766 * @param hsc: pointer to a SMARTCARD_HandleTypeDef structure that contains
AnnaBridge 165:e614a9f1c9e2 1767 * the configuration information for SMARTCARD module.
<> 144:ef7eb2e8f9f7 1768 * @retval HAL status
<> 144:ef7eb2e8f9f7 1769 */
<> 144:ef7eb2e8f9f7 1770 static HAL_StatusTypeDef SMARTCARD_Receive_IT(SMARTCARD_HandleTypeDef *hsc)
<> 144:ef7eb2e8f9f7 1771 {
AnnaBridge 165:e614a9f1c9e2 1772 /* Check that a Rx process is ongoing */
AnnaBridge 187:0387e8f68319 1773 if (hsc->RxState == HAL_SMARTCARD_STATE_BUSY_RX)
<> 144:ef7eb2e8f9f7 1774 {
AnnaBridge 187:0387e8f68319 1775 *(uint8_t *) hsc->pRxBuffPtr = (uint8_t)hsc->Instance->DR;
AnnaBridge 165:e614a9f1c9e2 1776 hsc->pRxBuffPtr += 1U;
AnnaBridge 187:0387e8f68319 1777
AnnaBridge 187:0387e8f68319 1778 if (--hsc->RxXferCount == 0U)
<> 144:ef7eb2e8f9f7 1779 {
AnnaBridge 165:e614a9f1c9e2 1780 CLEAR_BIT(hsc->Instance->CR1, USART_CR1_RXNEIE);
AnnaBridge 187:0387e8f68319 1781
<> 144:ef7eb2e8f9f7 1782 /* Disable the SMARTCARD Parity Error Interrupt */
AnnaBridge 165:e614a9f1c9e2 1783 CLEAR_BIT(hsc->Instance->CR1, USART_CR1_PEIE);
AnnaBridge 187:0387e8f68319 1784
<> 144:ef7eb2e8f9f7 1785 /* Disable the SMARTCARD Error Interrupt: (Frame error, noise error, overrun error) */
AnnaBridge 165:e614a9f1c9e2 1786 CLEAR_BIT(hsc->Instance->CR3, USART_CR3_EIE);
<> 144:ef7eb2e8f9f7 1787
AnnaBridge 187:0387e8f68319 1788 /* Rx process is completed, restore hsc->RxState to Ready */
AnnaBridge 165:e614a9f1c9e2 1789 hsc->RxState = HAL_SMARTCARD_STATE_READY;
<> 144:ef7eb2e8f9f7 1790
<> 144:ef7eb2e8f9f7 1791 HAL_SMARTCARD_RxCpltCallback(hsc);
<> 144:ef7eb2e8f9f7 1792
<> 144:ef7eb2e8f9f7 1793 return HAL_OK;
<> 144:ef7eb2e8f9f7 1794 }
<> 144:ef7eb2e8f9f7 1795 return HAL_OK;
<> 144:ef7eb2e8f9f7 1796 }
<> 144:ef7eb2e8f9f7 1797 else
<> 144:ef7eb2e8f9f7 1798 {
AnnaBridge 165:e614a9f1c9e2 1799 return HAL_BUSY;
<> 144:ef7eb2e8f9f7 1800 }
<> 144:ef7eb2e8f9f7 1801 }
<> 144:ef7eb2e8f9f7 1802
<> 144:ef7eb2e8f9f7 1803 /**
AnnaBridge 187:0387e8f68319 1804 * @brief Configure the SMARTCARD peripheral
AnnaBridge 165:e614a9f1c9e2 1805 * @param hsc: pointer to a SMARTCARD_HandleTypeDef structure that contains
AnnaBridge 165:e614a9f1c9e2 1806 * the configuration information for SMARTCARD module.
<> 144:ef7eb2e8f9f7 1807 * @retval None
<> 144:ef7eb2e8f9f7 1808 */
<> 144:ef7eb2e8f9f7 1809 static void SMARTCARD_SetConfig(SMARTCARD_HandleTypeDef *hsc)
<> 144:ef7eb2e8f9f7 1810 {
AnnaBridge 165:e614a9f1c9e2 1811 uint32_t tmpreg = 0x00U;
AnnaBridge 165:e614a9f1c9e2 1812
<> 144:ef7eb2e8f9f7 1813 /* Check the parameters */
AnnaBridge 165:e614a9f1c9e2 1814 assert_param(IS_SMARTCARD_INSTANCE(hsc->Instance));
<> 144:ef7eb2e8f9f7 1815 assert_param(IS_SMARTCARD_POLARITY(hsc->Init.CLKPolarity));
<> 144:ef7eb2e8f9f7 1816 assert_param(IS_SMARTCARD_PHASE(hsc->Init.CLKPhase));
<> 144:ef7eb2e8f9f7 1817 assert_param(IS_SMARTCARD_LASTBIT(hsc->Init.CLKLastBit));
AnnaBridge 187:0387e8f68319 1818 assert_param(IS_SMARTCARD_BAUDRATE(hsc->Init.BaudRate));
<> 144:ef7eb2e8f9f7 1819 assert_param(IS_SMARTCARD_WORD_LENGTH(hsc->Init.WordLength));
<> 144:ef7eb2e8f9f7 1820 assert_param(IS_SMARTCARD_STOPBITS(hsc->Init.StopBits));
<> 144:ef7eb2e8f9f7 1821 assert_param(IS_SMARTCARD_PARITY(hsc->Init.Parity));
<> 144:ef7eb2e8f9f7 1822 assert_param(IS_SMARTCARD_MODE(hsc->Init.Mode));
<> 144:ef7eb2e8f9f7 1823 assert_param(IS_SMARTCARD_NACK_STATE(hsc->Init.NACKState));
<> 144:ef7eb2e8f9f7 1824
AnnaBridge 165:e614a9f1c9e2 1825
<> 144:ef7eb2e8f9f7 1826 /* The LBCL, CPOL and CPHA bits have to be selected when both the transmitter and the
<> 144:ef7eb2e8f9f7 1827 receiver are disabled (TE=RE=0) to ensure that the clock pulses function correctly. */
AnnaBridge 165:e614a9f1c9e2 1828 CLEAR_BIT(hsc->Instance->CR1, (USART_CR1_TE | USART_CR1_RE));
AnnaBridge 187:0387e8f68319 1829
AnnaBridge 165:e614a9f1c9e2 1830 /*---------------------------- USART CR2 Configuration ---------------------*/
AnnaBridge 165:e614a9f1c9e2 1831 tmpreg = hsc->Instance->CR2;
<> 144:ef7eb2e8f9f7 1832 /* Clear CLKEN, CPOL, CPHA and LBCL bits */
AnnaBridge 165:e614a9f1c9e2 1833 tmpreg &= (uint32_t)~((uint32_t)(USART_CR2_CPHA | USART_CR2_CPOL | USART_CR2_CLKEN | USART_CR2_LBCL));
<> 144:ef7eb2e8f9f7 1834 /* Configure the SMARTCARD Clock, CPOL, CPHA and LastBit -----------------------*/
<> 144:ef7eb2e8f9f7 1835 /* Set CPOL bit according to hsc->Init.CLKPolarity value */
<> 144:ef7eb2e8f9f7 1836 /* Set CPHA bit according to hsc->Init.CLKPhase value */
<> 144:ef7eb2e8f9f7 1837 /* Set LBCL bit according to hsc->Init.CLKLastBit value */
AnnaBridge 165:e614a9f1c9e2 1838 /* Set Stop Bits: Set STOP[13:12] bits according to hsc->Init.StopBits value */
AnnaBridge 187:0387e8f68319 1839 tmpreg |= (uint32_t)(USART_CR2_CLKEN | hsc->Init.CLKPolarity |
AnnaBridge 187:0387e8f68319 1840 hsc->Init.CLKPhase | hsc->Init.CLKLastBit | hsc->Init.StopBits);
AnnaBridge 165:e614a9f1c9e2 1841 /* Write to USART CR2 */
AnnaBridge 165:e614a9f1c9e2 1842 WRITE_REG(hsc->Instance->CR2, (uint32_t)tmpreg);
AnnaBridge 187:0387e8f68319 1843
AnnaBridge 165:e614a9f1c9e2 1844 tmpreg = hsc->Instance->CR2;
AnnaBridge 165:e614a9f1c9e2 1845
AnnaBridge 165:e614a9f1c9e2 1846 /* Clear STOP[13:12] bits */
AnnaBridge 165:e614a9f1c9e2 1847 tmpreg &= (uint32_t)~((uint32_t)USART_CR2_STOP);
AnnaBridge 165:e614a9f1c9e2 1848
<> 144:ef7eb2e8f9f7 1849 /* Set Stop Bits: Set STOP[13:12] bits according to hsc->Init.StopBits value */
AnnaBridge 165:e614a9f1c9e2 1850 tmpreg |= (uint32_t)(hsc->Init.StopBits);
AnnaBridge 187:0387e8f68319 1851
AnnaBridge 165:e614a9f1c9e2 1852 /* Write to USART CR2 */
AnnaBridge 165:e614a9f1c9e2 1853 WRITE_REG(hsc->Instance->CR2, (uint32_t)tmpreg);
<> 144:ef7eb2e8f9f7 1854
AnnaBridge 165:e614a9f1c9e2 1855 /*-------------------------- USART CR1 Configuration -----------------------*/
AnnaBridge 165:e614a9f1c9e2 1856 tmpreg = hsc->Instance->CR1;
AnnaBridge 165:e614a9f1c9e2 1857
<> 144:ef7eb2e8f9f7 1858 /* Clear M, PCE, PS, TE and RE bits */
AnnaBridge 165:e614a9f1c9e2 1859 tmpreg &= (uint32_t)~((uint32_t)(USART_CR1_M | USART_CR1_PCE | USART_CR1_PS | USART_CR1_TE | \
AnnaBridge 165:e614a9f1c9e2 1860 USART_CR1_RE));
AnnaBridge 165:e614a9f1c9e2 1861
AnnaBridge 187:0387e8f68319 1862 /* Configure the SMARTCARD Word Length, Parity and mode:
AnnaBridge 187:0387e8f68319 1863 Set the M bits according to hsc->Init.WordLength value
AnnaBridge 165:e614a9f1c9e2 1864 Set PCE and PS bits according to hsc->Init.Parity value
<> 144:ef7eb2e8f9f7 1865 Set TE and RE bits according to hsc->Init.Mode value */
AnnaBridge 165:e614a9f1c9e2 1866 tmpreg |= (uint32_t)hsc->Init.WordLength | hsc->Init.Parity | hsc->Init.Mode;
<> 144:ef7eb2e8f9f7 1867
AnnaBridge 165:e614a9f1c9e2 1868 /* Write to USART CR1 */
AnnaBridge 187:0387e8f68319 1869 WRITE_REG(hsc->Instance->CR1, (uint32_t)tmpreg);
AnnaBridge 165:e614a9f1c9e2 1870
AnnaBridge 187:0387e8f68319 1871 /*-------------------------- USART CR3 Configuration -----------------------*/
<> 144:ef7eb2e8f9f7 1872 /* Clear CTSE and RTSE bits */
<> 144:ef7eb2e8f9f7 1873 CLEAR_BIT(hsc->Instance->CR3, (USART_CR3_RTSE | USART_CR3_CTSE));
<> 144:ef7eb2e8f9f7 1874
AnnaBridge 165:e614a9f1c9e2 1875 /*-------------------------- USART BRR Configuration -----------------------*/
AnnaBridge 165:e614a9f1c9e2 1876
AnnaBridge 187:0387e8f68319 1877 if (hsc->Instance == USART1)
<> 144:ef7eb2e8f9f7 1878 {
<> 144:ef7eb2e8f9f7 1879 hsc->Instance->BRR = SMARTCARD_BRR(HAL_RCC_GetPCLK2Freq(), hsc->Init.BaudRate);
<> 144:ef7eb2e8f9f7 1880 }
<> 144:ef7eb2e8f9f7 1881 else
<> 144:ef7eb2e8f9f7 1882 {
<> 144:ef7eb2e8f9f7 1883 hsc->Instance->BRR = SMARTCARD_BRR(HAL_RCC_GetPCLK1Freq(), hsc->Init.BaudRate);
<> 144:ef7eb2e8f9f7 1884 }
<> 144:ef7eb2e8f9f7 1885 }
<> 144:ef7eb2e8f9f7 1886
<> 144:ef7eb2e8f9f7 1887 /**
<> 144:ef7eb2e8f9f7 1888 * @}
<> 144:ef7eb2e8f9f7 1889 */
<> 144:ef7eb2e8f9f7 1890
<> 144:ef7eb2e8f9f7 1891 #endif /* HAL_SMARTCARD_MODULE_ENABLED */
<> 144:ef7eb2e8f9f7 1892 /**
<> 144:ef7eb2e8f9f7 1893 * @}
<> 144:ef7eb2e8f9f7 1894 */
<> 144:ef7eb2e8f9f7 1895
<> 144:ef7eb2e8f9f7 1896 /**
<> 144:ef7eb2e8f9f7 1897 * @}
<> 144:ef7eb2e8f9f7 1898 */
<> 144:ef7eb2e8f9f7 1899
<> 144:ef7eb2e8f9f7 1900 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/