Emil Johnsen / mbed-src-STM32F030K6

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-src by Ermanno Brusadin

targets/cmsis/TARGET_STM/TARGET_NUCLEO_L053R8/stm32l0xx_hal_smartcard.c@0:0a673c671a56, 2016-07-27 (annotated)

Committer:
ebrus
Date:
Wed Jul 27 18:35:32 2016 +0000
Revision:
0:0a673c671a56
4

Who changed what in which revision?

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