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_STM32F4/stm32f4xx_hal_smartcard.c@581:39197bcd20f2, 2015-07-02 (annotated)

Committer:
mbed_official
Date:
Thu Jul 02 16:30:08 2015 +0100
Revision:
581:39197bcd20f2
Parent:
532:fe11edbda85c
Child:
613:bc40b8d2aec4
Synchronized with git revision ae2d3cdffe70184eb8736d94f76c45c93f4b7724



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



Make it possible to build the core mbed library with yotta

Who changed what in which revision?

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