Joris Aerts / mbed-src

mbed library sources

Dependents:   Marvino mbot

Fork of mbed-src by mbed official

targets/cmsis/TARGET_STM/TARGET_STM32F7/stm32f7xx_hal_smartcard.c@637:ed69428d4850, 2015-12-22 (annotated)

Committer:
jaerts
Date:
Tue Dec 22 13:22:16 2015 +0000
Revision:
637:ed69428d4850
Parent:
610:813dcc80987e 
Add very shady LPC1768 CAN Filter implementation

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****/