mbed official / mbed-src

mbed library sources

Dependents:   Encrypted my_mbed lklk CyaSSL_DTLS_Cellular ... more

Superseded

This library was superseded by mbed-dev - https://os.mbed.com/users/mbed_official/code/mbed-dev/.

Development branch of the mbed library sources. This library is kept in synch with the latest changes from the mbed SDK and it is not guaranteed to work.

If you are looking for a stable and tested release, please import one of the official mbed library releases:

Import librarymbed

The official Mbed 2 C/C++ SDK provides the software platform and libraries to build your applications.

Last commit 20 Feb 2019 by mbed official

targets/cmsis/TARGET_STM/TARGET_STM32L0/stm32l0xx_hal_smartcard.c@387:643a59b3dbac, 2014-11-05 (annotated)

Committer:
mbed_official
Date:
Wed Nov 05 14:30:08 2014 +0000
Revision:
387:643a59b3dbac
Parent:
382:ee426a420dbb
Child:
489:119543c9f674
Synchronized with git revision cfeccf154f8f92c3ea9c0c881c577c154537aecc



Full URL: https://github.com/mbedmicro/mbed/commit/cfeccf154f8f92c3ea9c0c881c577c154537aecc/



Exporters: STM32L053R8 - IAR exporter

Who changed what in which revision?

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