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

Committer:
mbed_official
Date:
Wed Jul 01 09:45:11 2015 +0100
Revision:
579:53297373a894
Parent:
394:83f921546702 
Synchronized with git revision d5b4d2ab9c47edb4dc5776e7177b0c2263459081



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



Initial version of drivers for SAMR21

Who changed what in which revision?

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