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@610:813dcc80987e, 2015-08-14 (annotated)

Committer:
mbed_official
Date:
Fri Aug 14 13:15:17 2015 +0100
Revision:
610:813dcc80987e
Parent:
573:ad23fe03a082 
Synchronized with git revision 6d84db41c6833e0b9b024741eb0616a5f62d5599



Full URL: https://github.com/mbedmicro/mbed/commit/6d84db41c6833e0b9b024741eb0616a5f62d5599/



DISCO_F746NG - Improvements

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