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_STM32F7/stm32f7xx_hal_smartcard.c@573:ad23fe03a082, 2015-06-19 (annotated)

Committer:
mbed_official
Date:
Fri Jun 19 09:15:11 2015 +0100
Revision:
573:ad23fe03a082
Child:
610:813dcc80987e
Synchronized with git revision d47834cd4d729e5b36b4c1ad4650f8b8f6a9ab86



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



DISCO_F746NG - Add new target

Who changed what in which revision?

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