Jolyon Hill / mbed-dev

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Fork of mbed-dev by mbed official

targets/cmsis/TARGET_STM/TARGET_STM32L0/stm32l0xx_hal_smartcard.c@144:ef7eb2e8f9f7, 2016-09-02 (annotated)

Committer:
<>
Date:
Fri Sep 02 15:07:44 2016 +0100
Revision:
144:ef7eb2e8f9f7
Parent:
113:b3775bf36a83 
This updates the lib to the mbed lib v125

Who changed what in which revision?

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