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@579:53297373a894, 2015-07-01 (annotated)

Committer:
mbed_official
Date:
Wed Jul 01 09:45:11 2015 +0100
Revision:
579:53297373a894
Parent:
489:119543c9f674 
Synchronized with git revision d5b4d2ab9c47edb4dc5776e7177b0c2263459081



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



Initial version of drivers for SAMR21

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 489:119543c9f674 5 * @version V1.2.0
mbed_official 489:119543c9f674 6 * @date 06-February-2015
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 489:119543c9f674 63 * <h2><center>&copy; COPYRIGHT(c) 2015 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 489:119543c9f674 97 /** @addtogroup 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 489:119543c9f674 126 /** @addtogroup SMARTCARD_Exported_Functions
mbed_official 376:cb4d9db17537 127 * @{
mbed_official 376:cb4d9db17537 128 */
mbed_official 376:cb4d9db17537 129
mbed_official 489:119543c9f674 130 /** @addtogroup SMARTCARD_Exported_Functions_Group1
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 489:119543c9f674 184 if(hsc == 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 489:119543c9f674 235 if(hsc == 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 489:119543c9f674 285 /** @addtogroup SMARTCARD_Exported_Functions_Group2
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 489:119543c9f674 343 if((pData == 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 489:119543c9f674 409 if((pData == 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 489:119543c9f674 473 if((pData == 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 489:119543c9f674 524 if((pData == 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 489:119543c9f674 580 if((pData == 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 489:119543c9f674 613 /* Clear the TC flag in the SR register by writing 0 to it */
mbed_official 489:119543c9f674 614 __HAL_SMARTCARD_CLEAR_FLAG(hsc, SMARTCARD_FLAG_TC);
mbed_official 489:119543c9f674 615
mbed_official 376:cb4d9db17537 616 /* Enable the DMA transfer for transmit request by setting the DMAT bit
mbed_official 376:cb4d9db17537 617 in the SMARTCARD associated USART CR3 register */
mbed_official 376:cb4d9db17537 618 hsc->Instance->CR3 |= USART_CR3_DMAT;
mbed_official 376:cb4d9db17537 619
mbed_official 376:cb4d9db17537 620 /* Process Unlocked */
mbed_official 376:cb4d9db17537 621 __HAL_UNLOCK(hsc);
mbed_official 376:cb4d9db17537 622
mbed_official 376:cb4d9db17537 623 return HAL_OK;
mbed_official 376:cb4d9db17537 624 }
mbed_official 376:cb4d9db17537 625 else
mbed_official 376:cb4d9db17537 626 {
mbed_official 376:cb4d9db17537 627 return HAL_BUSY;
mbed_official 376:cb4d9db17537 628 }
mbed_official 376:cb4d9db17537 629 }
mbed_official 376:cb4d9db17537 630
mbed_official 376:cb4d9db17537 631 /**
mbed_official 376:cb4d9db17537 632 * @brief Receive an amount of data in DMA mode
mbed_official 376:cb4d9db17537 633 * @param hsc: SMARTCARD handle
mbed_official 376:cb4d9db17537 634 * @param pData: pointer to data buffer
mbed_official 376:cb4d9db17537 635 * @param Size: amount of data to be received
mbed_official 376:cb4d9db17537 636 * @note The SMARTCARD-associated USART parity is enabled (PCE = 1),
mbed_official 376:cb4d9db17537 637 * the received data contain the parity bit (MSB position)
mbed_official 376:cb4d9db17537 638 * @retval HAL status
mbed_official 376:cb4d9db17537 639 */
mbed_official 376:cb4d9db17537 640 HAL_StatusTypeDef HAL_SMARTCARD_Receive_DMA(SMARTCARD_HandleTypeDef *hsc, uint8_t *pData, uint16_t Size)
mbed_official 376:cb4d9db17537 641 {
mbed_official 376:cb4d9db17537 642 uint32_t *tmp;
mbed_official 376:cb4d9db17537 643
mbed_official 376:cb4d9db17537 644 if((hsc->State == HAL_SMARTCARD_STATE_READY) || (hsc->State == HAL_SMARTCARD_STATE_BUSY_TX))
mbed_official 376:cb4d9db17537 645 {
mbed_official 489:119543c9f674 646 if((pData == NULL) || (Size == 0))
mbed_official 376:cb4d9db17537 647 {
mbed_official 376:cb4d9db17537 648 return HAL_ERROR;
mbed_official 376:cb4d9db17537 649 }
mbed_official 376:cb4d9db17537 650
mbed_official 376:cb4d9db17537 651 /* Process Locked */
mbed_official 376:cb4d9db17537 652 __HAL_LOCK(hsc);
mbed_official 376:cb4d9db17537 653
mbed_official 376:cb4d9db17537 654 hsc->pRxBuffPtr = pData;
mbed_official 376:cb4d9db17537 655 hsc->RxXferSize = Size;
mbed_official 376:cb4d9db17537 656
mbed_official 376:cb4d9db17537 657 hsc->ErrorCode = HAL_SMARTCARD_ERROR_NONE;
mbed_official 376:cb4d9db17537 658 /* Check if a transmit rocess is ongoing or not */
mbed_official 376:cb4d9db17537 659 if(hsc->State == HAL_SMARTCARD_STATE_BUSY_TX)
mbed_official 376:cb4d9db17537 660 {
mbed_official 376:cb4d9db17537 661 hsc->State = HAL_SMARTCARD_STATE_BUSY_TX_RX;
mbed_official 376:cb4d9db17537 662 }
mbed_official 376:cb4d9db17537 663 else
mbed_official 376:cb4d9db17537 664 {
mbed_official 376:cb4d9db17537 665 hsc->State = HAL_SMARTCARD_STATE_BUSY_RX;
mbed_official 376:cb4d9db17537 666 }
mbed_official 376:cb4d9db17537 667
mbed_official 376:cb4d9db17537 668 /* Set the SMARTCARD DMA transfert complete callback */
mbed_official 376:cb4d9db17537 669 hsc->hdmarx->XferCpltCallback = SMARTCARD_DMAReceiveCplt;
mbed_official 376:cb4d9db17537 670
mbed_official 376:cb4d9db17537 671 /* Set the SMARTCARD DMA error callback */
mbed_official 376:cb4d9db17537 672 hsc->hdmarx->XferErrorCallback = SMARTCARD_DMAError;
mbed_official 376:cb4d9db17537 673
mbed_official 376:cb4d9db17537 674 /* Enable the DMA Stream */
mbed_official 376:cb4d9db17537 675 tmp = (uint32_t*)&pData;
mbed_official 376:cb4d9db17537 676 HAL_DMA_Start_IT(hsc->hdmarx, (uint32_t)&hsc->Instance->RDR, *(uint32_t*)tmp, Size);
mbed_official 376:cb4d9db17537 677
mbed_official 376:cb4d9db17537 678 /* Enable the DMA transfer for the receiver request by setting the DMAR bit
mbed_official 376:cb4d9db17537 679 in the SMARTCARD associated USART CR3 register */
mbed_official 376:cb4d9db17537 680 hsc->Instance->CR3 |= USART_CR3_DMAR;
mbed_official 376:cb4d9db17537 681
mbed_official 376:cb4d9db17537 682 /* Process Unlocked */
mbed_official 376:cb4d9db17537 683 __HAL_UNLOCK(hsc);
mbed_official 376:cb4d9db17537 684
mbed_official 376:cb4d9db17537 685 return HAL_OK;
mbed_official 376:cb4d9db17537 686 }
mbed_official 376:cb4d9db17537 687 else
mbed_official 376:cb4d9db17537 688 {
mbed_official 376:cb4d9db17537 689 return HAL_BUSY;
mbed_official 376:cb4d9db17537 690 }
mbed_official 376:cb4d9db17537 691 }
mbed_official 376:cb4d9db17537 692
mbed_official 376:cb4d9db17537 693 /**
mbed_official 376:cb4d9db17537 694 * @brief SMARTCARD interrupt requests handling.
mbed_official 376:cb4d9db17537 695 * @param hsc: SMARTCARD handle
mbed_official 376:cb4d9db17537 696 * @retval None
mbed_official 376:cb4d9db17537 697 */
mbed_official 376:cb4d9db17537 698 void HAL_SMARTCARD_IRQHandler(SMARTCARD_HandleTypeDef *hsc)
mbed_official 376:cb4d9db17537 699 {
mbed_official 376:cb4d9db17537 700 /* SMARTCARD parity error interrupt occurred -------------------------------*/
mbed_official 376:cb4d9db17537 701 if((__HAL_SMARTCARD_GET_IT(hsc, SMARTCARD_IT_PE) != RESET) && (__HAL_SMARTCARD_GET_IT_SOURCE(hsc, SMARTCARD_IT_PE) != RESET))
mbed_official 376:cb4d9db17537 702 {
mbed_official 489:119543c9f674 703 __HAL_SMARTCARD_CLEAR_PEFLAG(hsc);
mbed_official 376:cb4d9db17537 704 hsc->ErrorCode |= HAL_SMARTCARD_ERROR_PE;
mbed_official 376:cb4d9db17537 705 /* Set the SMARTCARD state ready to be able to start again the process */
mbed_official 376:cb4d9db17537 706 hsc->State = HAL_SMARTCARD_STATE_READY;
mbed_official 376:cb4d9db17537 707 }
mbed_official 376:cb4d9db17537 708
mbed_official 376:cb4d9db17537 709 /* SMARTCARD frame error interrupt occured ---------------------------------*/
mbed_official 376:cb4d9db17537 710 if((__HAL_SMARTCARD_GET_IT(hsc, SMARTCARD_IT_FE) != RESET) && (__HAL_SMARTCARD_GET_IT_SOURCE(hsc, SMARTCARD_IT_ERR) != RESET))
mbed_official 376:cb4d9db17537 711 {
mbed_official 489:119543c9f674 712 __HAL_SMARTCARD_CLEAR_FEFLAG(hsc);
mbed_official 376:cb4d9db17537 713 hsc->ErrorCode |= HAL_SMARTCARD_ERROR_FE;
mbed_official 376:cb4d9db17537 714 /* Set the SMARTCARD state ready to be able to start again the process */
mbed_official 376:cb4d9db17537 715 hsc->State = HAL_SMARTCARD_STATE_READY;
mbed_official 376:cb4d9db17537 716 }
mbed_official 376:cb4d9db17537 717
mbed_official 376:cb4d9db17537 718 /* SMARTCARD noise error interrupt occured ---------------------------------*/
mbed_official 376:cb4d9db17537 719 if((__HAL_SMARTCARD_GET_IT(hsc, SMARTCARD_IT_NE) != RESET) && (__HAL_SMARTCARD_GET_IT_SOURCE(hsc, SMARTCARD_IT_ERR) != RESET))
mbed_official 376:cb4d9db17537 720 {
mbed_official 489:119543c9f674 721 __HAL_SMARTCARD_CLEAR_NEFLAG(hsc);
mbed_official 376:cb4d9db17537 722 hsc->ErrorCode |= HAL_SMARTCARD_ERROR_NE;
mbed_official 376:cb4d9db17537 723 /* Set the SMARTCARD state ready to be able to start again the process */
mbed_official 376:cb4d9db17537 724 hsc->State = HAL_SMARTCARD_STATE_READY;
mbed_official 376:cb4d9db17537 725 }
mbed_official 376:cb4d9db17537 726
mbed_official 376:cb4d9db17537 727 /* SMARTCARD Over-Run interrupt occured ------------------------------------*/
mbed_official 376:cb4d9db17537 728 if((__HAL_SMARTCARD_GET_IT(hsc, SMARTCARD_IT_ORE) != RESET) && (__HAL_SMARTCARD_GET_IT_SOURCE(hsc, SMARTCARD_IT_ERR) != RESET))
mbed_official 376:cb4d9db17537 729 {
mbed_official 489:119543c9f674 730 __HAL_SMARTCARD_CLEAR_OREFLAG(hsc);
mbed_official 376:cb4d9db17537 731 hsc->ErrorCode |= HAL_SMARTCARD_ERROR_ORE;
mbed_official 376:cb4d9db17537 732 /* Set the SMARTCARD state ready to be able to start again the process */
mbed_official 376:cb4d9db17537 733 hsc->State = HAL_SMARTCARD_STATE_READY;
mbed_official 376:cb4d9db17537 734 }
mbed_official 376:cb4d9db17537 735
mbed_official 376:cb4d9db17537 736 /* SMARTCARD receiver timeout interrupt occured ----------------------------*/
mbed_official 376:cb4d9db17537 737 if((__HAL_SMARTCARD_GET_IT(hsc, SMARTCARD_IT_RTO) != RESET) && (__HAL_SMARTCARD_GET_IT_SOURCE(hsc, SMARTCARD_IT_RTO) != RESET))
mbed_official 376:cb4d9db17537 738 {
mbed_official 376:cb4d9db17537 739 __HAL_SMARTCARD_CLEAR_IT(hsc, SMARTCARD_CLEAR_RTOF);
mbed_official 376:cb4d9db17537 740 hsc->ErrorCode |= HAL_SMARTCARD_ERROR_RTO;
mbed_official 376:cb4d9db17537 741 /* Set the SMARTCARD state ready to be able to start again the process */
mbed_official 376:cb4d9db17537 742 hsc->State = HAL_SMARTCARD_STATE_READY;
mbed_official 376:cb4d9db17537 743 }
mbed_official 376:cb4d9db17537 744
mbed_official 376:cb4d9db17537 745 /* Call SMARTCARD Error Call back function if need be ----------------------*/
mbed_official 376:cb4d9db17537 746 if(hsc->ErrorCode != HAL_SMARTCARD_ERROR_NONE)
mbed_official 376:cb4d9db17537 747 {
mbed_official 376:cb4d9db17537 748 HAL_SMARTCARD_ErrorCallback(hsc);
mbed_official 376:cb4d9db17537 749 }
mbed_official 376:cb4d9db17537 750
mbed_official 376:cb4d9db17537 751 /* SMARTCARD in mode Receiver ----------------------------------------------*/
mbed_official 376:cb4d9db17537 752 if((__HAL_SMARTCARD_GET_IT(hsc, SMARTCARD_IT_RXNE) != RESET) && (__HAL_SMARTCARD_GET_IT_SOURCE(hsc, SMARTCARD_IT_RXNE) != RESET))
mbed_official 376:cb4d9db17537 753 {
mbed_official 376:cb4d9db17537 754 SMARTCARD_Receive_IT(hsc);
mbed_official 376:cb4d9db17537 755 /* Clear RXNE interrupt flag */
mbed_official 376:cb4d9db17537 756 __HAL_SMARTCARD_SEND_REQ(hsc, SMARTCARD_RXDATA_FLUSH_REQUEST);
mbed_official 376:cb4d9db17537 757 }
mbed_official 376:cb4d9db17537 758
mbed_official 376:cb4d9db17537 759 /* SMARTCARD in mode Receiver, end of block interruption -------------------*/
mbed_official 376:cb4d9db17537 760 if((__HAL_SMARTCARD_GET_IT(hsc, SMARTCARD_IT_EOB) != RESET) && (__HAL_SMARTCARD_GET_IT_SOURCE(hsc, SMARTCARD_IT_EOB) != RESET))
mbed_official 376:cb4d9db17537 761 {
mbed_official 376:cb4d9db17537 762 hsc->State = HAL_SMARTCARD_STATE_READY;
mbed_official 376:cb4d9db17537 763 HAL_SMARTCARD_RxCpltCallback(hsc);
mbed_official 376:cb4d9db17537 764 /* Clear EOBF interrupt after HAL_SMARTCARD_RxCpltCallback() call for the End of Block information
mbed_official 376:cb4d9db17537 765 * to be available during HAL_SMARTCARD_RxCpltCallback() processing */
mbed_official 376:cb4d9db17537 766 __HAL_SMARTCARD_CLEAR_IT(hsc, SMARTCARD_CLEAR_EOBF);
mbed_official 376:cb4d9db17537 767 }
mbed_official 376:cb4d9db17537 768
mbed_official 376:cb4d9db17537 769 /* SMARTCARD in mode Transmitter -------------------------------------------*/
mbed_official 376:cb4d9db17537 770 if((__HAL_SMARTCARD_GET_IT(hsc, SMARTCARD_IT_TC) != RESET) && (__HAL_SMARTCARD_GET_IT_SOURCE(hsc, SMARTCARD_IT_TC) != RESET))
mbed_official 376:cb4d9db17537 771 {
mbed_official 376:cb4d9db17537 772 SMARTCARD_Transmit_IT(hsc);
mbed_official 376:cb4d9db17537 773 }
mbed_official 376:cb4d9db17537 774 }
mbed_official 376:cb4d9db17537 775
mbed_official 376:cb4d9db17537 776 /**
mbed_official 376:cb4d9db17537 777 * @brief Tx Transfer completed callbacks
mbed_official 376:cb4d9db17537 778 * @param hsc: SMARTCARD handle
mbed_official 376:cb4d9db17537 779 * @retval None
mbed_official 376:cb4d9db17537 780 */
mbed_official 376:cb4d9db17537 781 __weak void HAL_SMARTCARD_TxCpltCallback(SMARTCARD_HandleTypeDef *hsc)
mbed_official 376:cb4d9db17537 782 {
mbed_official 376:cb4d9db17537 783 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 376:cb4d9db17537 784 the HAL_SMARTCARD_TxCpltCallback could be implemented in the user file
mbed_official 376:cb4d9db17537 785 */
mbed_official 376:cb4d9db17537 786 }
mbed_official 376:cb4d9db17537 787
mbed_official 376:cb4d9db17537 788 /**
mbed_official 376:cb4d9db17537 789 * @brief Rx Transfer completed callbacks
mbed_official 376:cb4d9db17537 790 * @param hsc: SMARTCARD handle
mbed_official 376:cb4d9db17537 791 * @retval None
mbed_official 376:cb4d9db17537 792 */
mbed_official 376:cb4d9db17537 793 __weak void HAL_SMARTCARD_RxCpltCallback(SMARTCARD_HandleTypeDef *hsc)
mbed_official 376:cb4d9db17537 794 {
mbed_official 376:cb4d9db17537 795 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 376:cb4d9db17537 796 the HAL_SMARTCARD_TxCpltCallback could be implemented in the user file
mbed_official 376:cb4d9db17537 797 */
mbed_official 376:cb4d9db17537 798 }
mbed_official 376:cb4d9db17537 799
mbed_official 376:cb4d9db17537 800 /**
mbed_official 376:cb4d9db17537 801 * @brief SMARTCARD error callbacks
mbed_official 376:cb4d9db17537 802 * @param hsc: SMARTCARD handle
mbed_official 376:cb4d9db17537 803 * @retval None
mbed_official 376:cb4d9db17537 804 */
mbed_official 376:cb4d9db17537 805 __weak void HAL_SMARTCARD_ErrorCallback(SMARTCARD_HandleTypeDef *hsc)
mbed_official 376:cb4d9db17537 806 {
mbed_official 376:cb4d9db17537 807 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 376:cb4d9db17537 808 the HAL_SMARTCARD_ErrorCallback could be implemented in the user file
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 * @}
mbed_official 376:cb4d9db17537 814 */
mbed_official 376:cb4d9db17537 815
mbed_official 489:119543c9f674 816 /** @addtogroup SMARTCARD_Exported_Functions_Group3
mbed_official 376:cb4d9db17537 817 * @brief SMARTCARD State functions
mbed_official 376:cb4d9db17537 818 *
mbed_official 376:cb4d9db17537 819 @verbatim
mbed_official 376:cb4d9db17537 820 ===============================================================================
mbed_official 376:cb4d9db17537 821 ##### Peripheral State functions #####
mbed_official 376:cb4d9db17537 822 ===============================================================================
mbed_official 376:cb4d9db17537 823 [..]
mbed_official 376:cb4d9db17537 824 This subsection provides a set of functions allowing to initialize the SMARTCARD.
mbed_official 376:cb4d9db17537 825 (+) HAL_SMARTCARD_GetState() API is helpful to check in run-time the state of the SMARTCARD peripheral
mbed_official 376:cb4d9db17537 826 (+) SMARTCARD_SetConfig() API configures the SMARTCARD peripheral
mbed_official 376:cb4d9db17537 827 (+) SMARTCARD_CheckIdleState() API ensures that TEACK and/or REACK are set after initialization
mbed_official 376:cb4d9db17537 828
mbed_official 376:cb4d9db17537 829 @endverbatim
mbed_official 376:cb4d9db17537 830 * @{
mbed_official 376:cb4d9db17537 831 */
mbed_official 376:cb4d9db17537 832
mbed_official 376:cb4d9db17537 833
mbed_official 376:cb4d9db17537 834 /**
mbed_official 376:cb4d9db17537 835 * @brief return the SMARTCARD state
mbed_official 376:cb4d9db17537 836 * @param hsc: SMARTCARD handle
mbed_official 376:cb4d9db17537 837 * @retval HAL state
mbed_official 376:cb4d9db17537 838 */
mbed_official 376:cb4d9db17537 839 HAL_SMARTCARD_StateTypeDef HAL_SMARTCARD_GetState(SMARTCARD_HandleTypeDef *hsc)
mbed_official 376:cb4d9db17537 840 {
mbed_official 376:cb4d9db17537 841 return hsc->State;
mbed_official 376:cb4d9db17537 842 }
mbed_official 376:cb4d9db17537 843
mbed_official 376:cb4d9db17537 844 /**
mbed_official 376:cb4d9db17537 845 * @brief Return the SMARTCARD error code
mbed_official 376:cb4d9db17537 846 * @param hsc : pointer to a SMARTCARD_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 847 * the configuration information for the specified SMARTCARD.
mbed_official 376:cb4d9db17537 848 * @retval SMARTCARD Error Code
mbed_official 376:cb4d9db17537 849 */
mbed_official 376:cb4d9db17537 850 uint32_t HAL_SMARTCARD_GetError(SMARTCARD_HandleTypeDef *hsc)
mbed_official 376:cb4d9db17537 851 {
mbed_official 376:cb4d9db17537 852 return hsc->ErrorCode;
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 */
mbed_official 376:cb4d9db17537 858
mbed_official 376:cb4d9db17537 859 /**
mbed_official 376:cb4d9db17537 860 * @brief Send an amount of data in non blocking mode
mbed_official 376:cb4d9db17537 861 * @param hsc: SMARTCARD handle.
mbed_official 376:cb4d9db17537 862 * Function called under interruption only, once
mbed_official 376:cb4d9db17537 863 * interruptions have been enabled by HAL_SMARTCARD_Transmit_IT()
mbed_official 376:cb4d9db17537 864 * @retval HAL status
mbed_official 376:cb4d9db17537 865 */
mbed_official 376:cb4d9db17537 866 static HAL_StatusTypeDef SMARTCARD_Transmit_IT(SMARTCARD_HandleTypeDef *hsc)
mbed_official 376:cb4d9db17537 867 {
mbed_official 376:cb4d9db17537 868 if((hsc->State == HAL_SMARTCARD_STATE_BUSY_TX) || (hsc->State == HAL_SMARTCARD_STATE_BUSY_TX_RX))
mbed_official 376:cb4d9db17537 869 {
mbed_official 376:cb4d9db17537 870 if(hsc->TxXferCount == 0)
mbed_official 376:cb4d9db17537 871 {
mbed_official 376:cb4d9db17537 872 /* Disable the SMARTCARD Transmit Complete Interrupt */
mbed_official 376:cb4d9db17537 873 __HAL_SMARTCARD_DISABLE_IT(hsc, SMARTCARD_IT_TC);
mbed_official 376:cb4d9db17537 874
mbed_official 376:cb4d9db17537 875 /* Check if a receive Process is ongoing or not */
mbed_official 376:cb4d9db17537 876 if(hsc->State == HAL_SMARTCARD_STATE_BUSY_TX_RX)
mbed_official 376:cb4d9db17537 877 {
mbed_official 376:cb4d9db17537 878 hsc->State = HAL_SMARTCARD_STATE_BUSY_RX;
mbed_official 376:cb4d9db17537 879 }
mbed_official 376:cb4d9db17537 880 else
mbed_official 376:cb4d9db17537 881 {
mbed_official 376:cb4d9db17537 882 /* Disable the SMARTCARD Error Interrupt: (Frame error, noise error, overrun error) */
mbed_official 376:cb4d9db17537 883 __HAL_SMARTCARD_DISABLE_IT(hsc, SMARTCARD_IT_ERR);
mbed_official 376:cb4d9db17537 884
mbed_official 376:cb4d9db17537 885 hsc->State = HAL_SMARTCARD_STATE_READY;
mbed_official 376:cb4d9db17537 886 }
mbed_official 376:cb4d9db17537 887
mbed_official 376:cb4d9db17537 888 HAL_SMARTCARD_TxCpltCallback(hsc);
mbed_official 376:cb4d9db17537 889
mbed_official 376:cb4d9db17537 890 return HAL_OK;
mbed_official 376:cb4d9db17537 891 }
mbed_official 376:cb4d9db17537 892 else
mbed_official 376:cb4d9db17537 893 {
mbed_official 376:cb4d9db17537 894 hsc->Instance->TDR = (*hsc->pTxBuffPtr++ & (uint8_t)0xFF);
mbed_official 376:cb4d9db17537 895 hsc->TxXferCount--;
mbed_official 376:cb4d9db17537 896
mbed_official 376:cb4d9db17537 897 return HAL_OK;
mbed_official 376:cb4d9db17537 898 }
mbed_official 376:cb4d9db17537 899 }
mbed_official 376:cb4d9db17537 900 else
mbed_official 376:cb4d9db17537 901 {
mbed_official 376:cb4d9db17537 902 return HAL_BUSY;
mbed_official 376:cb4d9db17537 903 }
mbed_official 376:cb4d9db17537 904 }
mbed_official 376:cb4d9db17537 905
mbed_official 376:cb4d9db17537 906 /**
mbed_official 376:cb4d9db17537 907 * @brief Receive an amount of data in non blocking mode
mbed_official 376:cb4d9db17537 908 * @param hsc: SMARTCARD handle.
mbed_official 376:cb4d9db17537 909 * Function called under interruption only, once
mbed_official 376:cb4d9db17537 910 * interruptions have been enabled by HAL_SMARTCARD_Receive_IT()
mbed_official 376:cb4d9db17537 911 * @retval HAL status
mbed_official 376:cb4d9db17537 912 */
mbed_official 376:cb4d9db17537 913 static HAL_StatusTypeDef SMARTCARD_Receive_IT(SMARTCARD_HandleTypeDef *hsc)
mbed_official 376:cb4d9db17537 914 {
mbed_official 376:cb4d9db17537 915 if((hsc->State == HAL_SMARTCARD_STATE_BUSY_RX) || (hsc->State == HAL_SMARTCARD_STATE_BUSY_TX_RX))
mbed_official 376:cb4d9db17537 916 {
mbed_official 376:cb4d9db17537 917 *hsc->pRxBuffPtr++ = (uint8_t)(hsc->Instance->RDR & (uint8_t)0xFF);
mbed_official 376:cb4d9db17537 918
mbed_official 376:cb4d9db17537 919 if(--hsc->RxXferCount == 0)
mbed_official 376:cb4d9db17537 920 {
mbed_official 376:cb4d9db17537 921 while(HAL_IS_BIT_SET(hsc->Instance->ISR, SMARTCARD_FLAG_RXNE))
mbed_official 376:cb4d9db17537 922 {
mbed_official 376:cb4d9db17537 923 }
mbed_official 376:cb4d9db17537 924 __HAL_SMARTCARD_DISABLE_IT(hsc, SMARTCARD_IT_RXNE);
mbed_official 376:cb4d9db17537 925
mbed_official 376:cb4d9db17537 926 /* Check if a transmit Process is ongoing or not */
mbed_official 376:cb4d9db17537 927 if(hsc->State == HAL_SMARTCARD_STATE_BUSY_TX_RX)
mbed_official 376:cb4d9db17537 928 {
mbed_official 376:cb4d9db17537 929 hsc->State = HAL_SMARTCARD_STATE_BUSY_TX;
mbed_official 376:cb4d9db17537 930 }
mbed_official 376:cb4d9db17537 931 else
mbed_official 376:cb4d9db17537 932 {
mbed_official 376:cb4d9db17537 933 /* Disable the SMARTCARD Parity Error Interrupt */
mbed_official 376:cb4d9db17537 934 __HAL_SMARTCARD_DISABLE_IT(hsc, SMARTCARD_IT_PE);
mbed_official 376:cb4d9db17537 935
mbed_official 376:cb4d9db17537 936 /* Disable the SMARTCARD Error Interrupt: (Frame error, noise error, overrun error) */
mbed_official 376:cb4d9db17537 937 __HAL_SMARTCARD_DISABLE_IT(hsc, SMARTCARD_IT_ERR);
mbed_official 376:cb4d9db17537 938
mbed_official 376:cb4d9db17537 939 hsc->State = HAL_SMARTCARD_STATE_READY;
mbed_official 376:cb4d9db17537 940 }
mbed_official 376:cb4d9db17537 941
mbed_official 376:cb4d9db17537 942 HAL_SMARTCARD_RxCpltCallback(hsc);
mbed_official 376:cb4d9db17537 943
mbed_official 376:cb4d9db17537 944 return HAL_OK;
mbed_official 376:cb4d9db17537 945 }
mbed_official 376:cb4d9db17537 946 return HAL_OK;
mbed_official 376:cb4d9db17537 947 }
mbed_official 376:cb4d9db17537 948 else
mbed_official 376:cb4d9db17537 949 {
mbed_official 376:cb4d9db17537 950 return HAL_BUSY;
mbed_official 376:cb4d9db17537 951 }
mbed_official 376:cb4d9db17537 952 }
mbed_official 376:cb4d9db17537 953
mbed_official 376:cb4d9db17537 954 /**
mbed_official 376:cb4d9db17537 955 * @brief Configure the SMARTCARD associated USART peripheral
mbed_official 376:cb4d9db17537 956 * @param hsc: SMARTCARD handle
mbed_official 376:cb4d9db17537 957 * @retval None
mbed_official 376:cb4d9db17537 958 */
mbed_official 376:cb4d9db17537 959 static void SMARTCARD_SetConfig(SMARTCARD_HandleTypeDef *hsc)
mbed_official 376:cb4d9db17537 960 {
mbed_official 376:cb4d9db17537 961 uint32_t tmpreg = 0x00000000;
mbed_official 376:cb4d9db17537 962 uint32_t clocksource = 0x00000000;
mbed_official 376:cb4d9db17537 963
mbed_official 376:cb4d9db17537 964 /* Check the parameters */
mbed_official 376:cb4d9db17537 965 assert_param(IS_SMARTCARD_INSTANCE(hsc->Instance));
mbed_official 376:cb4d9db17537 966 assert_param(IS_SMARTCARD_BAUDRATE(hsc->Init.BaudRate));
mbed_official 376:cb4d9db17537 967 assert_param(IS_SMARTCARD_WORD_LENGTH(hsc->Init.WordLength));
mbed_official 376:cb4d9db17537 968 assert_param(IS_SMARTCARD_STOPBITS(hsc->Init.StopBits));
mbed_official 376:cb4d9db17537 969 assert_param(IS_SMARTCARD_PARITY(hsc->Init.Parity));
mbed_official 376:cb4d9db17537 970 assert_param(IS_SMARTCARD_MODE(hsc->Init.Mode));
mbed_official 376:cb4d9db17537 971 assert_param(IS_SMARTCARD_POLARITY(hsc->Init.CLKPolarity));
mbed_official 376:cb4d9db17537 972 assert_param(IS_SMARTCARD_PHASE(hsc->Init.CLKPhase));
mbed_official 376:cb4d9db17537 973 assert_param(IS_SMARTCARD_LASTBIT(hsc->Init.CLKLastBit));
mbed_official 489:119543c9f674 974 assert_param(IS_SMARTCARD_ONE_BIT_SAMPLE(hsc->Init.OneBitSampling));
mbed_official 376:cb4d9db17537 975 assert_param(IS_SMARTCARD_NACK(hsc->Init.NACKState));
mbed_official 376:cb4d9db17537 976 assert_param(IS_SMARTCARD_TIMEOUT(hsc->Init.TimeOutEnable));
mbed_official 376:cb4d9db17537 977 assert_param(IS_SMARTCARD_AUTORETRY_COUNT(hsc->Init.AutoRetryCount));
mbed_official 376:cb4d9db17537 978
mbed_official 376:cb4d9db17537 979 /*-------------------------- USART CR1 Configuration -----------------------*/
mbed_official 376:cb4d9db17537 980 /* In SmartCard mode, M and PCE are forced to 1 (8 bits + parity).
mbed_official 376:cb4d9db17537 981 * Oversampling is forced to 16 (OVER8 = 0).
mbed_official 376:cb4d9db17537 982 * Configure the Parity and Mode:
mbed_official 376:cb4d9db17537 983 * set PS bit according to hsc->Init.Parity value
mbed_official 376:cb4d9db17537 984 * set TE and RE bits according to hsc->Init.Mode value */
mbed_official 376:cb4d9db17537 985 tmpreg = (uint32_t) hsc->Init.Parity | hsc->Init.Mode;
mbed_official 376:cb4d9db17537 986 /* in case of TX-only mode, if NACK is enabled, the USART must be able to monitor
mbed_official 376:cb4d9db17537 987 the bidirectional line to detect a NACK signal in case of parity error.
mbed_official 376:cb4d9db17537 988 Therefore, the receiver block must be enabled as well (RE bit must be set). */
mbed_official 489:119543c9f674 989 if((hsc->Init.Mode == SMARTCARD_MODE_TX) && (hsc->Init.NACKState == SMARTCARD_NACK_ENABLE))
mbed_official 376:cb4d9db17537 990 {
mbed_official 376:cb4d9db17537 991 tmpreg |= USART_CR1_RE;
mbed_official 376:cb4d9db17537 992 }
mbed_official 376:cb4d9db17537 993 tmpreg |= (uint32_t) hsc->Init.WordLength;
mbed_official 376:cb4d9db17537 994 MODIFY_REG(hsc->Instance->CR1, USART_CR1_FIELDS, tmpreg);
mbed_official 376:cb4d9db17537 995
mbed_official 376:cb4d9db17537 996 /*-------------------------- USART CR2 Configuration -----------------------*/
mbed_official 376:cb4d9db17537 997 /* Stop bits are forced to 1.5 (STOP = 11) */
mbed_official 376:cb4d9db17537 998 tmpreg = hsc->Init.StopBits;
mbed_official 376:cb4d9db17537 999 /* Synchronous mode is activated by default */
mbed_official 376:cb4d9db17537 1000 tmpreg |= (uint32_t) USART_CR2_CLKEN | hsc->Init.CLKPolarity;
mbed_official 376:cb4d9db17537 1001 tmpreg |= (uint32_t) hsc->Init.CLKPhase | hsc->Init.CLKLastBit;
mbed_official 376:cb4d9db17537 1002 tmpreg |= (uint32_t) hsc->Init.TimeOutEnable;
mbed_official 376:cb4d9db17537 1003 MODIFY_REG(hsc->Instance->CR2, USART_CR2_FIELDS, tmpreg);
mbed_official 376:cb4d9db17537 1004
mbed_official 376:cb4d9db17537 1005 /*-------------------------- USART CR3 Configuration -----------------------*/
mbed_official 376:cb4d9db17537 1006 /* Configure
mbed_official 376:cb4d9db17537 1007 * - one-bit sampling method versus three samples' majority rule
mbed_official 376:cb4d9db17537 1008 * according to hsc->Init.OneBitSampling
mbed_official 376:cb4d9db17537 1009 * - NACK transmission in case of parity error according
mbed_official 376:cb4d9db17537 1010 * to hsc->Init.NACKEnable
mbed_official 376:cb4d9db17537 1011 * - autoretry counter according to hsc->Init.AutoRetryCount */
mbed_official 376:cb4d9db17537 1012 tmpreg = (uint32_t) hsc->Init.OneBitSampling | hsc->Init.NACKState;
mbed_official 376:cb4d9db17537 1013 tmpreg |= (uint32_t) (hsc->Init.AutoRetryCount << SMARTCARD_CR3_SCARCNT_LSB_POS);
mbed_official 376:cb4d9db17537 1014 MODIFY_REG(hsc->Instance-> CR3,USART_CR3_FIELDS, tmpreg);
mbed_official 376:cb4d9db17537 1015
mbed_official 376:cb4d9db17537 1016 /*-------------------------- USART GTPR Configuration ----------------------*/
mbed_official 376:cb4d9db17537 1017 tmpreg = (uint32_t) (hsc->Init.Prescaler | (hsc->Init.GuardTime << SMARTCARD_GTPR_GT_LSB_POS));
mbed_official 376:cb4d9db17537 1018 MODIFY_REG(hsc->Instance->GTPR, (uint32_t)(USART_GTPR_GT|USART_GTPR_PSC), tmpreg);
mbed_official 376:cb4d9db17537 1019
mbed_official 376:cb4d9db17537 1020 /*-------------------------- USART RTOR Configuration ----------------------*/
mbed_official 376:cb4d9db17537 1021 tmpreg = (uint32_t) (hsc->Init.BlockLength << SMARTCARD_RTOR_BLEN_LSB_POS);
mbed_official 489:119543c9f674 1022 if(hsc->Init.TimeOutEnable == SMARTCARD_TIMEOUT_ENABLE)
mbed_official 376:cb4d9db17537 1023 {
mbed_official 376:cb4d9db17537 1024 assert_param(IS_SMARTCARD_TIMEOUT_VALUE(hsc->Init.TimeOutValue));
mbed_official 376:cb4d9db17537 1025 tmpreg |= (uint32_t) hsc->Init.TimeOutValue;
mbed_official 376:cb4d9db17537 1026 }
mbed_official 376:cb4d9db17537 1027 MODIFY_REG(hsc->Instance->RTOR, (USART_RTOR_RTO|USART_RTOR_BLEN), tmpreg);
mbed_official 376:cb4d9db17537 1028
mbed_official 376:cb4d9db17537 1029 /*-------------------------- USART BRR Configuration -----------------------*/
mbed_official 489:119543c9f674 1030 SMARTCARD_GETCLOCKSOURCE(hsc, clocksource);
mbed_official 376:cb4d9db17537 1031 switch (clocksource)
mbed_official 376:cb4d9db17537 1032 {
mbed_official 376:cb4d9db17537 1033 case SMARTCARD_CLOCKSOURCE_PCLK1:
mbed_official 376:cb4d9db17537 1034 hsc->Instance->BRR = (uint16_t)(HAL_RCC_GetPCLK1Freq() / hsc->Init.BaudRate);
mbed_official 376:cb4d9db17537 1035 break;
mbed_official 376:cb4d9db17537 1036 case SMARTCARD_CLOCKSOURCE_PCLK2:
mbed_official 376:cb4d9db17537 1037 hsc->Instance->BRR = (uint16_t)(HAL_RCC_GetPCLK2Freq() / hsc->Init.BaudRate);
mbed_official 376:cb4d9db17537 1038 break;
mbed_official 376:cb4d9db17537 1039 case SMARTCARD_CLOCKSOURCE_HSI:
mbed_official 376:cb4d9db17537 1040 hsc->Instance->BRR = (uint16_t)(HSI_VALUE / hsc->Init.BaudRate);
mbed_official 376:cb4d9db17537 1041 break;
mbed_official 376:cb4d9db17537 1042 case SMARTCARD_CLOCKSOURCE_SYSCLK:
mbed_official 376:cb4d9db17537 1043 hsc->Instance->BRR = (uint16_t)(HAL_RCC_GetSysClockFreq() / hsc->Init.BaudRate);
mbed_official 376:cb4d9db17537 1044 break;
mbed_official 376:cb4d9db17537 1045 case SMARTCARD_CLOCKSOURCE_LSE:
mbed_official 376:cb4d9db17537 1046 hsc->Instance->BRR = (uint16_t)(LSE_VALUE / hsc->Init.BaudRate);
mbed_official 376:cb4d9db17537 1047 break;
mbed_official 376:cb4d9db17537 1048 default:
mbed_official 376:cb4d9db17537 1049 break;
mbed_official 376:cb4d9db17537 1050 }
mbed_official 376:cb4d9db17537 1051 }
mbed_official 376:cb4d9db17537 1052
mbed_official 376:cb4d9db17537 1053 /**
mbed_official 376:cb4d9db17537 1054 * @brief Check the SMARTCARD Idle State
mbed_official 376:cb4d9db17537 1055 * @param hsc: SMARTCARD handle
mbed_official 376:cb4d9db17537 1056 * @retval HAL status
mbed_official 376:cb4d9db17537 1057 */
mbed_official 376:cb4d9db17537 1058 static HAL_StatusTypeDef SMARTCARD_CheckIdleState(SMARTCARD_HandleTypeDef *hsc)
mbed_official 376:cb4d9db17537 1059 {
mbed_official 376:cb4d9db17537 1060
mbed_official 376:cb4d9db17537 1061 /* Initialize the SMARTCARD ErrorCode */
mbed_official 376:cb4d9db17537 1062 hsc->ErrorCode = HAL_SMARTCARD_ERROR_NONE;
mbed_official 376:cb4d9db17537 1063
mbed_official 376:cb4d9db17537 1064 /* Check if the Transmitter is enabled */
mbed_official 376:cb4d9db17537 1065 if((hsc->Instance->CR1 & USART_CR1_TE) == USART_CR1_TE)
mbed_official 376:cb4d9db17537 1066 {
mbed_official 376:cb4d9db17537 1067 /* Wait until TEACK flag is set */
mbed_official 376:cb4d9db17537 1068 if(SMARTCARD_WaitOnFlagUntilTimeout(hsc, USART_ISR_TEACK, RESET, TEACK_REACK_TIMEOUT) != HAL_OK)
mbed_official 376:cb4d9db17537 1069 {
mbed_official 376:cb4d9db17537 1070 return HAL_TIMEOUT;
mbed_official 376:cb4d9db17537 1071 }
mbed_official 376:cb4d9db17537 1072 }
mbed_official 376:cb4d9db17537 1073 /* Check if the Receiver is enabled */
mbed_official 376:cb4d9db17537 1074 if((hsc->Instance->CR1 & USART_CR1_RE) == USART_CR1_RE)
mbed_official 376:cb4d9db17537 1075 {
mbed_official 376:cb4d9db17537 1076 /* Wait until REACK flag is set */
mbed_official 376:cb4d9db17537 1077 if(SMARTCARD_WaitOnFlagUntilTimeout(hsc, USART_ISR_REACK, RESET, TEACK_REACK_TIMEOUT) != HAL_OK)
mbed_official 376:cb4d9db17537 1078 {
mbed_official 376:cb4d9db17537 1079 return HAL_TIMEOUT;
mbed_official 376:cb4d9db17537 1080 }
mbed_official 376:cb4d9db17537 1081 }
mbed_official 376:cb4d9db17537 1082
mbed_official 376:cb4d9db17537 1083 /* Process Unlocked */
mbed_official 376:cb4d9db17537 1084 __HAL_UNLOCK(hsc);
mbed_official 376:cb4d9db17537 1085
mbed_official 376:cb4d9db17537 1086 /* Initialize the SMARTCARD state*/
mbed_official 376:cb4d9db17537 1087 hsc->State= HAL_SMARTCARD_STATE_READY;
mbed_official 376:cb4d9db17537 1088
mbed_official 376:cb4d9db17537 1089 return HAL_OK;
mbed_official 376:cb4d9db17537 1090 }
mbed_official 376:cb4d9db17537 1091
mbed_official 376:cb4d9db17537 1092 /**
mbed_official 376:cb4d9db17537 1093 * @brief Configure the SMARTCARD associated USART peripheral advanced feautures
mbed_official 376:cb4d9db17537 1094 * @param hsc: SMARTCARD handle
mbed_official 376:cb4d9db17537 1095 * @retval None
mbed_official 376:cb4d9db17537 1096 */
mbed_official 376:cb4d9db17537 1097 static void SMARTCARD_AdvFeatureConfig(SMARTCARD_HandleTypeDef *hsc)
mbed_official 376:cb4d9db17537 1098 {
mbed_official 376:cb4d9db17537 1099 /* Check whether the set of advanced features to configure is properly set */
mbed_official 376:cb4d9db17537 1100 assert_param(IS_SMARTCARD_ADVFEATURE_INIT(hsc->AdvancedInit.AdvFeatureInit));
mbed_official 376:cb4d9db17537 1101
mbed_official 376:cb4d9db17537 1102 /* if required, configure TX pin active level inversion */
mbed_official 376:cb4d9db17537 1103 if(HAL_IS_BIT_SET(hsc->AdvancedInit.AdvFeatureInit, SMARTCARD_ADVFEATURE_TXINVERT_INIT))
mbed_official 376:cb4d9db17537 1104 {
mbed_official 376:cb4d9db17537 1105 assert_param(IS_SMARTCARD_ADVFEATURE_TXINV(hsc->AdvancedInit.TxPinLevelInvert));
mbed_official 376:cb4d9db17537 1106 MODIFY_REG(hsc->Instance->CR2, USART_CR2_TXINV, hsc->AdvancedInit.TxPinLevelInvert);
mbed_official 376:cb4d9db17537 1107 }
mbed_official 376:cb4d9db17537 1108
mbed_official 376:cb4d9db17537 1109 /* if required, configure RX pin active level inversion */
mbed_official 376:cb4d9db17537 1110 if(HAL_IS_BIT_SET(hsc->AdvancedInit.AdvFeatureInit, SMARTCARD_ADVFEATURE_RXINVERT_INIT))
mbed_official 376:cb4d9db17537 1111 {
mbed_official 376:cb4d9db17537 1112 assert_param(IS_SMARTCARD_ADVFEATURE_RXINV(hsc->AdvancedInit.RxPinLevelInvert));
mbed_official 376:cb4d9db17537 1113 MODIFY_REG(hsc->Instance->CR2, USART_CR2_RXINV, hsc->AdvancedInit.RxPinLevelInvert);
mbed_official 376:cb4d9db17537 1114 }
mbed_official 376:cb4d9db17537 1115
mbed_official 376:cb4d9db17537 1116 /* if required, configure data inversion */
mbed_official 376:cb4d9db17537 1117 if(HAL_IS_BIT_SET(hsc->AdvancedInit.AdvFeatureInit, SMARTCARD_ADVFEATURE_DATAINVERT_INIT))
mbed_official 376:cb4d9db17537 1118 {
mbed_official 376:cb4d9db17537 1119 assert_param(IS_SMARTCARD_ADVFEATURE_DATAINV(hsc->AdvancedInit.DataInvert));
mbed_official 376:cb4d9db17537 1120 MODIFY_REG(hsc->Instance->CR2, USART_CR2_DATAINV, hsc->AdvancedInit.DataInvert);
mbed_official 376:cb4d9db17537 1121 }
mbed_official 376:cb4d9db17537 1122
mbed_official 376:cb4d9db17537 1123 /* if required, configure RX/TX pins swap */
mbed_official 376:cb4d9db17537 1124 if(HAL_IS_BIT_SET(hsc->AdvancedInit.AdvFeatureInit, SMARTCARD_ADVFEATURE_SWAP_INIT))
mbed_official 376:cb4d9db17537 1125 {
mbed_official 376:cb4d9db17537 1126 assert_param(IS_SMARTCARD_ADVFEATURE_SWAP(hsc->AdvancedInit.Swap));
mbed_official 376:cb4d9db17537 1127 MODIFY_REG(hsc->Instance->CR2, USART_CR2_SWAP, hsc->AdvancedInit.Swap);
mbed_official 376:cb4d9db17537 1128 }
mbed_official 376:cb4d9db17537 1129
mbed_official 376:cb4d9db17537 1130 /* if required, configure RX overrun detection disabling */
mbed_official 376:cb4d9db17537 1131 if(HAL_IS_BIT_SET(hsc->AdvancedInit.AdvFeatureInit, SMARTCARD_ADVFEATURE_RXOVERRUNDISABLE_INIT))
mbed_official 376:cb4d9db17537 1132 {
mbed_official 376:cb4d9db17537 1133 assert_param(IS_SMARTCARD_OVERRUN(hsc->AdvancedInit.OverrunDisable));
mbed_official 376:cb4d9db17537 1134 MODIFY_REG(hsc->Instance->CR3, USART_CR3_OVRDIS, hsc->AdvancedInit.OverrunDisable);
mbed_official 376:cb4d9db17537 1135 }
mbed_official 376:cb4d9db17537 1136
mbed_official 376:cb4d9db17537 1137 /* if required, configure DMA disabling on reception error */
mbed_official 376:cb4d9db17537 1138 if(HAL_IS_BIT_SET(hsc->AdvancedInit.AdvFeatureInit, SMARTCARD_ADVFEATURE_DMADISABLEONERROR_INIT))
mbed_official 376:cb4d9db17537 1139 {
mbed_official 376:cb4d9db17537 1140 assert_param(IS_SMARTCARD_ADVFEATURE_DMAONRXERROR(hsc->AdvancedInit.DMADisableonRxError));
mbed_official 376:cb4d9db17537 1141 MODIFY_REG(hsc->Instance->CR3, USART_CR3_DDRE, hsc->AdvancedInit.DMADisableonRxError);
mbed_official 376:cb4d9db17537 1142 }
mbed_official 376:cb4d9db17537 1143
mbed_official 376:cb4d9db17537 1144 /* if required, configure MSB first on communication line */
mbed_official 376:cb4d9db17537 1145 if(HAL_IS_BIT_SET(hsc->AdvancedInit.AdvFeatureInit, SMARTCARD_ADVFEATURE_MSBFIRST_INIT))
mbed_official 376:cb4d9db17537 1146 {
mbed_official 376:cb4d9db17537 1147 assert_param(IS_SMARTCARD_ADVFEATURE_MSBFIRST(hsc->AdvancedInit.MSBFirst));
mbed_official 376:cb4d9db17537 1148 MODIFY_REG(hsc->Instance->CR2, USART_CR2_MSBFIRST, hsc->AdvancedInit.MSBFirst);
mbed_official 376:cb4d9db17537 1149 }
mbed_official 376:cb4d9db17537 1150 }
mbed_official 376:cb4d9db17537 1151
mbed_official 376:cb4d9db17537 1152 /**
mbed_official 376:cb4d9db17537 1153 * @brief This function handles SMARTCARD Communication Timeout.
mbed_official 376:cb4d9db17537 1154 * @param hsc: SMARTCARD handle
mbed_official 376:cb4d9db17537 1155 * @param Flag: specifies the SMARTCARD flag to check.
mbed_official 376:cb4d9db17537 1156 * @param Status: The new Flag status (SET or RESET).
mbed_official 376:cb4d9db17537 1157 * @param Timeout: Timeout duration
mbed_official 376:cb4d9db17537 1158 * @retval HAL status
mbed_official 376:cb4d9db17537 1159 */
mbed_official 376:cb4d9db17537 1160 static HAL_StatusTypeDef SMARTCARD_WaitOnFlagUntilTimeout(SMARTCARD_HandleTypeDef *hsc, uint32_t Flag, FlagStatus Status, uint32_t Timeout)
mbed_official 376:cb4d9db17537 1161 {
mbed_official 376:cb4d9db17537 1162 uint32_t tickstart = 0x00;
mbed_official 376:cb4d9db17537 1163 tickstart = HAL_GetTick();
mbed_official 376:cb4d9db17537 1164
mbed_official 376:cb4d9db17537 1165 /* Wait until flag is set */
mbed_official 376:cb4d9db17537 1166 if(Status == RESET)
mbed_official 376:cb4d9db17537 1167 {
mbed_official 376:cb4d9db17537 1168 while(__HAL_SMARTCARD_GET_FLAG(hsc, Flag) == RESET)
mbed_official 376:cb4d9db17537 1169 {
mbed_official 376:cb4d9db17537 1170 /* Check for the Timeout */
mbed_official 376:cb4d9db17537 1171 if(Timeout != HAL_MAX_DELAY)
mbed_official 376:cb4d9db17537 1172 {
mbed_official 376:cb4d9db17537 1173 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
mbed_official 376:cb4d9db17537 1174 {
mbed_official 376:cb4d9db17537 1175 /* Disable TXE, RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts for the interrupt process */
mbed_official 376:cb4d9db17537 1176 __HAL_SMARTCARD_DISABLE_IT(hsc, SMARTCARD_IT_TXE);
mbed_official 376:cb4d9db17537 1177 __HAL_SMARTCARD_DISABLE_IT(hsc, SMARTCARD_IT_RXNE);
mbed_official 376:cb4d9db17537 1178 __HAL_SMARTCARD_DISABLE_IT(hsc, SMARTCARD_IT_PE);
mbed_official 376:cb4d9db17537 1179 __HAL_SMARTCARD_DISABLE_IT(hsc, SMARTCARD_IT_ERR);
mbed_official 376:cb4d9db17537 1180
mbed_official 376:cb4d9db17537 1181 hsc->State= HAL_SMARTCARD_STATE_READY;
mbed_official 376:cb4d9db17537 1182
mbed_official 376:cb4d9db17537 1183 /* Process Unlocked */
mbed_official 376:cb4d9db17537 1184 __HAL_UNLOCK(hsc);
mbed_official 376:cb4d9db17537 1185
mbed_official 376:cb4d9db17537 1186 return HAL_TIMEOUT;
mbed_official 376:cb4d9db17537 1187 }
mbed_official 376:cb4d9db17537 1188 }
mbed_official 376:cb4d9db17537 1189 }
mbed_official 376:cb4d9db17537 1190 }
mbed_official 376:cb4d9db17537 1191 else
mbed_official 376:cb4d9db17537 1192 {
mbed_official 376:cb4d9db17537 1193 while(__HAL_SMARTCARD_GET_FLAG(hsc, Flag) != RESET)
mbed_official 376:cb4d9db17537 1194 {
mbed_official 376:cb4d9db17537 1195 /* Check for the Timeout */
mbed_official 376:cb4d9db17537 1196 if(Timeout != HAL_MAX_DELAY)
mbed_official 376:cb4d9db17537 1197 {
mbed_official 376:cb4d9db17537 1198 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
mbed_official 376:cb4d9db17537 1199 {
mbed_official 376:cb4d9db17537 1200 /* Disable TXE, RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts for the interrupt process */
mbed_official 376:cb4d9db17537 1201 __HAL_SMARTCARD_DISABLE_IT(hsc, SMARTCARD_IT_TXE);
mbed_official 376:cb4d9db17537 1202 __HAL_SMARTCARD_DISABLE_IT(hsc, SMARTCARD_IT_RXNE);
mbed_official 376:cb4d9db17537 1203 __HAL_SMARTCARD_DISABLE_IT(hsc, SMARTCARD_IT_PE);
mbed_official 376:cb4d9db17537 1204 __HAL_SMARTCARD_DISABLE_IT(hsc, SMARTCARD_IT_ERR);
mbed_official 376:cb4d9db17537 1205
mbed_official 376:cb4d9db17537 1206 hsc->State= HAL_SMARTCARD_STATE_READY;
mbed_official 376:cb4d9db17537 1207
mbed_official 376:cb4d9db17537 1208 /* Process Unlocked */
mbed_official 376:cb4d9db17537 1209 __HAL_UNLOCK(hsc);
mbed_official 376:cb4d9db17537 1210
mbed_official 376:cb4d9db17537 1211 return HAL_TIMEOUT;
mbed_official 376:cb4d9db17537 1212 }
mbed_official 376:cb4d9db17537 1213 }
mbed_official 376:cb4d9db17537 1214 }
mbed_official 376:cb4d9db17537 1215 }
mbed_official 376:cb4d9db17537 1216 return HAL_OK;
mbed_official 376:cb4d9db17537 1217 }
mbed_official 376:cb4d9db17537 1218
mbed_official 376:cb4d9db17537 1219 /**
mbed_official 376:cb4d9db17537 1220 * @brief DMA SMARTCARD transmit process complete callback
mbed_official 376:cb4d9db17537 1221 * @param hdma: DMA handle
mbed_official 376:cb4d9db17537 1222 * @retval None
mbed_official 376:cb4d9db17537 1223 */
mbed_official 376:cb4d9db17537 1224 static void SMARTCARD_DMATransmitCplt(DMA_HandleTypeDef *hdma)
mbed_official 376:cb4d9db17537 1225 {
mbed_official 489:119543c9f674 1226 SMARTCARD_HandleTypeDef* hsmartcard = ( SMARTCARD_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
mbed_official 489:119543c9f674 1227 hsmartcard->TxXferCount = 0;
mbed_official 489:119543c9f674 1228
mbed_official 489:119543c9f674 1229 /* Disable the DMA transfer for transmit request by resetting the DMAT bit
mbed_official 376:cb4d9db17537 1230 in the SMARTCARD associated USART CR3 register */
mbed_official 489:119543c9f674 1231 hsmartcard->Instance->CR3 &= (uint16_t)~((uint16_t)USART_CR3_DMAT);
mbed_official 489:119543c9f674 1232
mbed_official 489:119543c9f674 1233 /* Enable the SMARTCARD Transmit Complete Interrupt */
mbed_official 489:119543c9f674 1234 __HAL_SMARTCARD_ENABLE_IT(hsmartcard, SMARTCARD_IT_TC);
mbed_official 376:cb4d9db17537 1235 }
mbed_official 376:cb4d9db17537 1236
mbed_official 376:cb4d9db17537 1237 /**
mbed_official 376:cb4d9db17537 1238 * @brief DMA SMARTCARD receive process complete callback
mbed_official 376:cb4d9db17537 1239 * @param hdma: DMA handle
mbed_official 376:cb4d9db17537 1240 * @retval None
mbed_official 376:cb4d9db17537 1241 */
mbed_official 376:cb4d9db17537 1242 static void SMARTCARD_DMAReceiveCplt(DMA_HandleTypeDef *hdma)
mbed_official 376:cb4d9db17537 1243 {
mbed_official 376:cb4d9db17537 1244 SMARTCARD_HandleTypeDef* hsc = ( SMARTCARD_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
mbed_official 376:cb4d9db17537 1245 hsc->RxXferCount = 0;
mbed_official 376:cb4d9db17537 1246
mbed_official 376:cb4d9db17537 1247 /* Disable the DMA transfer for the receiver request by setting the DMAR bit
mbed_official 376:cb4d9db17537 1248 in the SMARTCARD associated USART CR3 register */
mbed_official 376:cb4d9db17537 1249 hsc->Instance->CR3 &= (uint16_t)~((uint16_t)USART_CR3_DMAR);
mbed_official 376:cb4d9db17537 1250
mbed_official 376:cb4d9db17537 1251 /* Check if a transmit Process is ongoing or not */
mbed_official 376:cb4d9db17537 1252 if(hsc->State == HAL_SMARTCARD_STATE_BUSY_TX_RX)
mbed_official 376:cb4d9db17537 1253 {
mbed_official 376:cb4d9db17537 1254 hsc->State = HAL_SMARTCARD_STATE_BUSY_TX;
mbed_official 376:cb4d9db17537 1255 }
mbed_official 376:cb4d9db17537 1256 else
mbed_official 376:cb4d9db17537 1257 {
mbed_official 376:cb4d9db17537 1258 hsc->State = HAL_SMARTCARD_STATE_READY;
mbed_official 376:cb4d9db17537 1259 }
mbed_official 376:cb4d9db17537 1260
mbed_official 376:cb4d9db17537 1261 HAL_SMARTCARD_RxCpltCallback(hsc);
mbed_official 376:cb4d9db17537 1262 }
mbed_official 376:cb4d9db17537 1263
mbed_official 376:cb4d9db17537 1264 /**
mbed_official 376:cb4d9db17537 1265 * @brief DMA SMARTCARD communication error callback
mbed_official 376:cb4d9db17537 1266 * @param hdma: DMA handle
mbed_official 376:cb4d9db17537 1267 * @retval None
mbed_official 376:cb4d9db17537 1268 */
mbed_official 376:cb4d9db17537 1269 static void SMARTCARD_DMAError(DMA_HandleTypeDef *hdma)
mbed_official 376:cb4d9db17537 1270 {
mbed_official 376:cb4d9db17537 1271 SMARTCARD_HandleTypeDef* hsc = ( SMARTCARD_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
mbed_official 376:cb4d9db17537 1272 hsc->RxXferCount = 0;
mbed_official 376:cb4d9db17537 1273 hsc->TxXferCount = 0;
mbed_official 376:cb4d9db17537 1274 hsc->State= HAL_SMARTCARD_STATE_READY;
mbed_official 376:cb4d9db17537 1275 hsc->ErrorCode |= HAL_SMARTCARD_ERROR_DMA;
mbed_official 376:cb4d9db17537 1276 HAL_SMARTCARD_ErrorCallback(hsc);
mbed_official 376:cb4d9db17537 1277 }
mbed_official 376:cb4d9db17537 1278 /**
mbed_official 376:cb4d9db17537 1279 * @}
mbed_official 376:cb4d9db17537 1280 */
mbed_official 376:cb4d9db17537 1281
mbed_official 376:cb4d9db17537 1282 #endif /* HAL_SMARTCARD_MODULE_ENABLED */
mbed_official 376:cb4d9db17537 1283 /**
mbed_official 376:cb4d9db17537 1284 * @}
mbed_official 376:cb4d9db17537 1285 */
mbed_official 376:cb4d9db17537 1286
mbed_official 376:cb4d9db17537 1287 /**
mbed_official 376:cb4d9db17537 1288 * @}
mbed_official 376:cb4d9db17537 1289 */
mbed_official 376:cb4d9db17537 1290
mbed_official 376:cb4d9db17537 1291 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
mbed_official 489:119543c9f674 1292