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

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