?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Increment eeprom version
[betaflight.git] / lib / main / STM32F1 / Drivers / STM32F1xx_HAL_Driver / Src / stm32f1xx_hal_smartcard.c
blob041cfa309824e6e187b3cc7200a4cdf6696efd11
1 /**
2 ******************************************************************************
3 * @file stm32f1xx_hal_smartcard.c
4 * @author MCD Application Team
5 * @version V1.1.1
6 * @date 12-May-2017
7 * @brief SMARTCARD HAL module driver.
8 * This file provides firmware functions to manage the following
9 * functionalities of the SMARTCARD peripheral:
10 * + Initialization and de-initialization functions
11 * + IO operation functions
12 * + Peripheral Control functions
13 * + Peripheral State and Errors functions
14 @verbatim
15 ==============================================================================
16 ##### How to use this driver #####
17 ==============================================================================
18 [..]
19 The SMARTCARD HAL driver can be used as follows:
20
21 (#) Declare a SMARTCARD_HandleTypeDef handle structure.
22 (#) Initialize the SMARTCARD low level resources by implementing the HAL_SMARTCARD_MspInit() API:
23 (##) Enable the USARTx interface clock.
24 (##) SMARTCARD pins configuration:
25 (+++) Enable the clock for the SMARTCARD GPIOs.
26 (+++) Configure the SMARTCARD pins as alternate function pull-up.
27 (##) NVIC configuration if you need to use interrupt process (HAL_SMARTCARD_Transmit_IT()
28 and HAL_SMARTCARD_Receive_IT() APIs):
29 (+++) Configure the USARTx interrupt priority.
30 (+++) Enable the NVIC USART IRQ handle.
31 (##) DMA Configuration if you need to use DMA process (HAL_SMARTCARD_Transmit_DMA()
32 and HAL_SMARTCARD_Receive_DMA() APIs):
33 (+++) Declare a DMA handle structure for the Tx/Rx channel.
34 (+++) Enable the DMAx interface clock.
35 (+++) Configure the declared DMA handle structure with the required Tx/Rx parameters.
36 (+++) Configure the DMA Tx/Rx channel.
37 (+++) Associate the initialized DMA handle to the SMARTCARD DMA Tx/Rx handle.
38 (+++) Configure the priority and enable the NVIC for the transfer complete interrupt on the DMA Tx/Rx channel.
39 (+++) Configure the USARTx interrupt priority and enable the NVIC USART IRQ handle
40 (used for last byte sending completion detection in DMA non circular mode)
41
42 (#) Program the Baud Rate, Word Length, Stop Bit, Parity, Hardware
43 flow control and Mode(Receiver/Transmitter) in the SMARTCARD Init structure.
44
45 (#) Initialize the SMARTCARD registers by calling the HAL_SMARTCARD_Init() API:
46 (++) These APIs configure also the low level Hardware GPIO, CLOCK, CORTEX...etc)
47 by calling the customized HAL_SMARTCARD_MspInit() API.
48 [..]
49 (@)The specific SMARTCARD interrupts (Transmission complete interrupt,
50 RXNE interrupt and Error Interrupts) will be managed using the macros
51 __HAL_SMARTCARD_ENABLE_IT() and __HAL_SMARTCARD_DISABLE_IT() inside the transmit and receive process.
52
53 [..]
54 Three operation modes are available within this driver:
55
56 *** Polling mode IO operation ***
57 =================================
58 [..]
59 (+) Send an amount of data in blocking mode using HAL_SMARTCARD_Transmit()
60 (+) Receive an amount of data in blocking mode using HAL_SMARTCARD_Receive()
61 *** Interrupt mode IO operation ***
62 ===================================
63 [..]
64 (+) Send an amount of data in non blocking mode using HAL_SMARTCARD_Transmit_IT()
65 (+) At transmission end of transfer HAL_SMARTCARD_TxCpltCallback is executed and user can
66 add his own code by customization of function pointer HAL_SMARTCARD_TxCpltCallback
67 (+) Receive an amount of data in non blocking mode using HAL_SMARTCARD_Receive_IT()
68 (+) At reception end of transfer HAL_SMARTCARD_RxCpltCallback is executed and user can
69 add his own code by customization of function pointer HAL_SMARTCARD_RxCpltCallback
70 (+) In case of transfer Error, HAL_SMARTCARD_ErrorCallback() function is executed and user can
71 add his own code by customization of function pointer HAL_SMARTCARD_ErrorCallback
72
73 *** DMA mode IO operation ***
74 ==============================
75 [..]
76 (+) Send an amount of data in non blocking mode (DMA) using HAL_SMARTCARD_Transmit_DMA()
77 (+) At transmission end of transfer HAL_SMARTCARD_TxCpltCallback is executed and user can
78 add his own code by customization of function pointer HAL_SMARTCARD_TxCpltCallback
79 (+) Receive an amount of data in non blocking mode (DMA) using HAL_SMARTCARD_Receive_DMA()
80 (+) At reception end of transfer HAL_SMARTCARD_RxCpltCallback is executed and user can
81 add his own code by customization of function pointer HAL_SMARTCARD_RxCpltCallback
82 (+) In case of transfer Error, HAL_SMARTCARD_ErrorCallback() function is executed and user can
83 add his own code by customization of function pointer HAL_SMARTCARD_ErrorCallback
84
85 *** SMARTCARD HAL driver macros list ***
86 =============================================
87 [..]
88 Below the list of most used macros in SMARTCARD HAL driver.
89
90 (+) __HAL_SMARTCARD_ENABLE: Enable the SMARTCARD peripheral
91 (+) __HAL_SMARTCARD_DISABLE: Disable the SMARTCARD peripheral
92 (+) __HAL_SMARTCARD_GET_FLAG : Check whether the specified SMARTCARD flag is set or not
93 (+) __HAL_SMARTCARD_CLEAR_FLAG : Clear the specified SMARTCARD pending flag
94 (+) __HAL_SMARTCARD_ENABLE_IT: Enable the specified SMARTCARD interrupt
95 (+) __HAL_SMARTCARD_DISABLE_IT: Disable the specified SMARTCARD interrupt
96
97 [..]
98 (@) You can refer to the SMARTCARD HAL driver header file for more useful macros
99
100 @endverbatim
101 [..]
102 (@) Additionnal remark: If the parity is enabled, then the MSB bit of the data written
103 in the data register is transmitted but is changed by the parity bit.
104 Depending on the frame length defined by the M bit (8-bits or 9-bits),
105 the possible SMARTCARD frame formats are as listed in the following table:
106 +-------------------------------------------------------------+
107 | M bit | PCE bit | SMARTCARD frame |
108 |---------------------|---------------------------------------|
109 | 1 | 1 | | SB | 8 bit data | PB | STB | |
110 +-------------------------------------------------------------+
111 ******************************************************************************
112 * @attention
113 *
114 * <h2><center>&copy; COPYRIGHT(c) 2017 STMicroelectronics</center></h2>
115 *
116 * Redistribution and use in source and binary forms, with or without modification,
117 * are permitted provided that the following conditions are met:
118 * 1. Redistributions of source code must retain the above copyright notice,
119 * this list of conditions and the following disclaimer.
120 * 2. Redistributions in binary form must reproduce the above copyright notice,
121 * this list of conditions and the following disclaimer in the documentation
122 * and/or other materials provided with the distribution.
123 * 3. Neither the name of STMicroelectronics nor the names of its contributors
124 * may be used to endorse or promote products derived from this software
125 * without specific prior written permission.
126 *
127 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
128 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
129 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
130 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
131 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
132 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
133 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
134 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
135 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
136 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
137 *
138 ******************************************************************************
139 */
140
141 /* Includes ------------------------------------------------------------------*/
142 #include "stm32f1xx_hal.h"
143
144 /** @addtogroup STM32F1xx_HAL_Driver
145 * @{
146 */
147
148 /** @defgroup SMARTCARD SMARTCARD
149 * @brief HAL SMARTCARD module driver
150 * @{
151 */
152 #ifdef HAL_SMARTCARD_MODULE_ENABLED
153 /* Private typedef -----------------------------------------------------------*/
154 /* Private define ------------------------------------------------------------*/
155 /** @addtogroup SMARTCARD_Private_Constants
156 * @{
157 */
158 /**
159 * @}
160 */
161 /* Private macro -------------------------------------------------------------*/
162 /* Private variables ---------------------------------------------------------*/
163 /* Private function prototypes -----------------------------------------------*/
164 /** @addtogroup SMARTCARD_Private_Functions
165 * @{
166 */
167 static void SMARTCARD_EndTxTransfer(SMARTCARD_HandleTypeDef *hsc);
168 static void SMARTCARD_EndRxTransfer(SMARTCARD_HandleTypeDef *hsc);
169 static void SMARTCARD_SetConfig (SMARTCARD_HandleTypeDef *hsc);
170 static HAL_StatusTypeDef SMARTCARD_Transmit_IT(SMARTCARD_HandleTypeDef *hsc);
171 static HAL_StatusTypeDef SMARTCARD_EndTransmit_IT(SMARTCARD_HandleTypeDef *hsmartcard);
172 static HAL_StatusTypeDef SMARTCARD_Receive_IT(SMARTCARD_HandleTypeDef *hsc);
173 static void SMARTCARD_DMATransmitCplt(DMA_HandleTypeDef *hdma);
174 static void SMARTCARD_DMAReceiveCplt(DMA_HandleTypeDef *hdma);
175 static void SMARTCARD_DMAError(DMA_HandleTypeDef *hdma);
176 static void SMARTCARD_DMAAbortOnError(DMA_HandleTypeDef *hdma);
177 static void SMARTCARD_DMATxAbortCallback(DMA_HandleTypeDef *hdma);
178 static void SMARTCARD_DMARxAbortCallback(DMA_HandleTypeDef *hdma);
179 static void SMARTCARD_DMATxOnlyAbortCallback(DMA_HandleTypeDef *hdma);
180 static void SMARTCARD_DMARxOnlyAbortCallback(DMA_HandleTypeDef *hdma);
181 static HAL_StatusTypeDef SMARTCARD_WaitOnFlagUntilTimeout(SMARTCARD_HandleTypeDef *hsc, uint32_t Flag, FlagStatus Status, uint32_t Tickstart, uint32_t Timeout);
182 /**
183 * @}
184 */
185 /* Exported functions --------------------------------------------------------*/
186 /** @defgroup SMARTCARD_Exported_Functions SMARTCARD Exported Functions
187 * @{
188 */
189
190 /** @defgroup SMARTCARD_Exported_Functions_Group1 SmartCard Initialization and de-initialization functions
191 * @brief Initialization and Configuration functions
192 *
193 @verbatim
194 ==============================================================================
195 ##### Initialization and Configuration functions #####
196 ==============================================================================
197 [..]
198 This subsection provides a set of functions allowing to initialize the USART
199 in Smartcard mode.
200 [..]
201 The Smartcard interface is designed to support asynchronous protocol Smartcards as
202 defined in the ISO 7816-3 standard.
203 [..]
204 The USART can provide a clock to the smartcard through the SCLK output.
205 In smartcard mode, SCLK is not associated to the communication but is simply derived
206 from the internal peripheral input clock through a 5-bit prescaler.
207 [..]
208 (+) For the Smartcard mode only these parameters can be configured:
209 (++) Baud Rate
210 (++) Word Length => Should be 9 bits (8 bits + parity)
211 (++) Stop Bit
212 (++) Parity: => Should be enabled
213 (++) USART polarity
214 (++) USART phase
215 (++) USART LastBit
216 (++) Receiver/transmitter modes
217 (++) Prescaler
218 (++) GuardTime
219 (++) NACKState: The Smartcard NACK state
220
221 (+) Recommended SmartCard interface configuration to get the Answer to Reset from the Card:
222 (++) Word Length = 9 Bits
223 (++) 1.5 Stop Bit
224 (++) Even parity
225 (++) BaudRate = 12096 baud
226 (++) Tx and Rx enabled
227 [..]
228 Please refer to the ISO 7816-3 specification for more details.
229
230 [..]
231 (@) It is also possible to choose 0.5 stop bit for receiving but it is recommended
232 to use 1.5 stop bits for both transmitting and receiving to avoid switching
233 between the two configurations.
234 [..]
235 The HAL_SMARTCARD_Init() function follows the USART SmartCard configuration
236 procedure (details for the procedure are available in reference manual (RM0329)).
237
238 @endverbatim
239 * @{
240 */
241
242 /**
243 * @brief Initializes the SmartCard mode according to the specified
244 * parameters in the SMARTCARD_InitTypeDef and create the associated handle.
245 * @param hsc: pointer to a SMARTCARD_HandleTypeDef structure that contains
246 * the configuration information for SMARTCARD module.
247 * @retval HAL status
248 */
249 HAL_StatusTypeDef HAL_SMARTCARD_Init(SMARTCARD_HandleTypeDef *hsc)
250 {
251 /* Check the SMARTCARD handle allocation */
252 if(hsc == NULL)
253 {
254 return HAL_ERROR;
255 }
256
257 /* Check the parameters */
258 assert_param(IS_SMARTCARD_INSTANCE(hsc->Instance));
259
260
261 if(hsc->gState == HAL_SMARTCARD_STATE_RESET)
262 {
263 /* Allocate lock resource and initialize it */
264 hsc->Lock = HAL_UNLOCKED;
265
266 /* Init the low level hardware : GPIO, CLOCK, CORTEX...etc */
267 HAL_SMARTCARD_MspInit(hsc);
268 }
269
270 hsc->gState = HAL_SMARTCARD_STATE_BUSY;
271
272 /* Set the Prescaler */
273 MODIFY_REG(hsc->Instance->GTPR, USART_GTPR_PSC, hsc->Init.Prescaler);
274
275 /* Set the Guard Time */
276 MODIFY_REG(hsc->Instance->GTPR, USART_GTPR_GT, ((hsc->Init.GuardTime)<<8U));
277
278 /* Set the Smartcard Communication parameters */
279 SMARTCARD_SetConfig(hsc);
280
281 /* In SmartCard mode, the following bits must be kept cleared:
282 - LINEN bit in the USART_CR2 register
283 - HDSEL and IREN bits in the USART_CR3 register.*/
284 CLEAR_BIT(hsc->Instance->CR2, USART_CR2_LINEN);
285 CLEAR_BIT(hsc->Instance->CR3, (USART_CR3_IREN | USART_CR3_HDSEL));
286
287 /* Enable the SMARTCARD Parity Error Interrupt */
288 SET_BIT(hsc->Instance->CR1, USART_CR1_PEIE);
289
290 /* Enable the SMARTCARD Framing Error Interrupt */
291 SET_BIT(hsc->Instance->CR3, USART_CR3_EIE);
292
293 /* Enable the Peripheral */
294 __HAL_SMARTCARD_ENABLE(hsc);
295
296 /* Configure the Smartcard NACK state */
297 MODIFY_REG(hsc->Instance->CR3, USART_CR3_NACK, hsc->Init.NACKState);
298
299 /* Enable the SC mode by setting the SCEN bit in the CR3 register */
300 hsc->Instance->CR3 |= (USART_CR3_SCEN);
301
302 /* Initialize the SMARTCARD state*/
303 hsc->ErrorCode = HAL_SMARTCARD_ERROR_NONE;
304 hsc->gState= HAL_SMARTCARD_STATE_READY;
305 hsc->RxState= HAL_SMARTCARD_STATE_READY;
306
307 return HAL_OK;
308 }
309
310 /**
311 * @brief DeInitializes the USART SmartCard peripheral
312 * @param hsc: pointer to a SMARTCARD_HandleTypeDef structure that contains
313 * the configuration information for SMARTCARD module.
314 * @retval HAL status
315 */
316 HAL_StatusTypeDef HAL_SMARTCARD_DeInit(SMARTCARD_HandleTypeDef *hsc)
317 {
318 /* Check the SMARTCARD handle allocation */
319 if(hsc == NULL)
320 {
321 return HAL_ERROR;
322 }
323
324 /* Check the parameters */
325 assert_param(IS_SMARTCARD_INSTANCE(hsc->Instance));
326
327 hsc->gState = HAL_SMARTCARD_STATE_BUSY;
328
329 /* DeInit the low level hardware */
330 HAL_SMARTCARD_MspDeInit(hsc);
331
332 hsc->ErrorCode = HAL_SMARTCARD_ERROR_NONE;
333 hsc->gState = HAL_SMARTCARD_STATE_RESET;
334 hsc->RxState = HAL_SMARTCARD_STATE_RESET;
335
336 /* Release Lock */
337 __HAL_UNLOCK(hsc);
338
339 return HAL_OK;
340 }
341
342 /**
343 * @brief SMARTCARD MSP Init.
344 * @param hsc: pointer to a SMARTCARD_HandleTypeDef structure that contains
345 * the configuration information for SMARTCARD module.
346 * @retval None
347 */
348 __weak void HAL_SMARTCARD_MspInit(SMARTCARD_HandleTypeDef *hsc)
349 {
350 /* Prevent unused argument(s) compilation warning */
351 UNUSED(hsc);
352 /* NOTE: This function should not be modified, when the callback is needed,
353 the HAL_SMARTCARD_MspInit could be implemented in the user file
354 */
355 }
356
357 /**
358 * @brief SMARTCARD MSP DeInit
359 * @param hsc: pointer to a SMARTCARD_HandleTypeDef structure that contains
360 * the configuration information for SMARTCARD module.
361 * @retval None
362 */
363 __weak void HAL_SMARTCARD_MspDeInit(SMARTCARD_HandleTypeDef *hsc)
364 {
365 /* Prevent unused argument(s) compilation warning */
366 UNUSED(hsc);
367 /* NOTE: This function should not be modified, when the callback is needed,
368 the HAL_SMARTCARD_MspDeInit could be implemented in the user file
369 */
370 }
371
372 /**
373 * @}
374 */
375
376 /** @defgroup SMARTCARD_Exported_Functions_Group2 IO operation functions
377 * @brief SMARTCARD Transmit and Receive functions
378 *
379 @verbatim
380 ===============================================================================
381 ##### IO operation functions #####
382 ===============================================================================
383 [..]
384 This subsection provides a set of functions allowing to manage the SMARTCARD data transfers.
385
386 [..]
387 (#) Smartcard is a single wire half duplex communication protocol.
388 The Smartcard interface is designed to support asynchronous protocol Smartcards as
389 defined in the ISO 7816-3 standard.
390 (#) The USART should be configured as:
391 (++) 8 bits plus parity: where M=1 and PCE=1 in the USART_CR1 register
392 (++) 1.5 stop bits when transmitting and receiving: where STOP=11 in the USART_CR2 register.
393
394 (#) There are two modes of transfer:
395 (++) Blocking mode: The communication is performed in polling mode.
396 The HAL status of all data processing is returned by the same function
397 after finishing transfer.
398 (++) Non Blocking mode: The communication is performed using Interrupts
399 or DMA, These APIs return the HAL status.
400 The end of the data processing will be indicated through the
401 dedicated SMARTCARD IRQ when using Interrupt mode or the DMA IRQ when
402 using DMA mode.
403 The HAL_SMARTCARD_TxCpltCallback(), HAL_SMARTCARD_RxCpltCallback() user callbacks
404 will be executed respectively at the end of the Transmit or Receive process
405 The HAL_SMARTCARD_ErrorCallback() user callback will be executed when a communication error is detected
406
407 (#) Blocking mode APIs are :
408 (++) HAL_SMARTCARD_Transmit()
409 (++) HAL_SMARTCARD_Receive()
410
411 (#) Non Blocking mode APIs with Interrupt are :
412 (++) HAL_SMARTCARD_Transmit_IT()
413 (++) HAL_SMARTCARD_Receive_IT()
414 (++) HAL_SMARTCARD_IRQHandler()
415
416 (#) Non Blocking mode functions with DMA are :
417 (++) HAL_SMARTCARD_Transmit_DMA()
418 (++) HAL_SMARTCARD_Receive_DMA()
419
420 (#) A set of Transfer Complete Callbacks are provided in non Blocking mode:
421 (++) HAL_SMARTCARD_TxCpltCallback()
422 (++) HAL_SMARTCARD_RxCpltCallback()
423 (++) HAL_SMARTCARD_ErrorCallback()
424
425 @endverbatim
426 * @{
427 */
428
429 /**
430 * @brief Send an amount of data in blocking mode
431 * @param hsc: pointer to a SMARTCARD_HandleTypeDef structure that contains
432 * the configuration information for SMARTCARD module.
433 * @param pData: pointer to data buffer
434 * @param Size: amount of data to be sent
435 * @param Timeout: Timeout duration
436 * @retval HAL status
437 */
438 HAL_StatusTypeDef HAL_SMARTCARD_Transmit(SMARTCARD_HandleTypeDef *hsc, uint8_t *pData, uint16_t Size, uint32_t Timeout)
439 {
440 uint16_t* tmp;
441 uint32_t tickstart = 0U;
442
443 if(hsc->gState == HAL_SMARTCARD_STATE_READY)
444 {
445 if((pData == NULL) || (Size == 0U))
446 {
447 return HAL_ERROR;
448 }
449
450 /* Process Locked */
451 __HAL_LOCK(hsc);
452
453 hsc->ErrorCode = HAL_SMARTCARD_ERROR_NONE;
454 hsc->gState = HAL_SMARTCARD_STATE_BUSY_TX;
455
456 /* Init tickstart for timeout managment */
457 tickstart = HAL_GetTick();
458
459 hsc->TxXferSize = Size;
460 hsc->TxXferCount = Size;
461 while(hsc->TxXferCount > 0U)
462 {
463 hsc->TxXferCount--;
464 if(SMARTCARD_WaitOnFlagUntilTimeout(hsc, SMARTCARD_FLAG_TXE, RESET, tickstart, Timeout) != HAL_OK)
465 {
466 return HAL_TIMEOUT;
467 }
468 tmp = (uint16_t*) pData;
469 hsc->Instance->DR = (*tmp & (uint16_t)0x01FF);
470 pData +=1U;
471 }
472
473 if(SMARTCARD_WaitOnFlagUntilTimeout(hsc, SMARTCARD_FLAG_TC, RESET, tickstart, Timeout) != HAL_OK)
474 {
475 return HAL_TIMEOUT;
476 }
477
478 /* At end of Tx process, restore hsc->gState to Ready */
479 hsc->gState = HAL_SMARTCARD_STATE_READY;
480
481 /* Process Unlocked */
482 __HAL_UNLOCK(hsc);
483
484 return HAL_OK;
485 }
486 else
487 {
488 return HAL_BUSY;
489 }
490 }
491
492 /**
493 * @brief Receive an amount of data in blocking mode
494 * @param hsc: pointer to a SMARTCARD_HandleTypeDef structure that contains
495 * the configuration information for SMARTCARD module.
496 * @param pData: pointer to data buffer
497 * @param Size: amount of data to be received
498 * @param Timeout: Timeout duration
499 * @retval HAL status
500 */
501 HAL_StatusTypeDef HAL_SMARTCARD_Receive(SMARTCARD_HandleTypeDef *hsc, uint8_t *pData, uint16_t Size, uint32_t Timeout)
502 {
503 uint16_t* tmp;
504 uint32_t tickstart = 0U;
505
506 if(hsc->RxState == HAL_SMARTCARD_STATE_READY)
507 {
508 if((pData == NULL) || (Size == 0U))
509 {
510 return HAL_ERROR;
511 }
512
513 /* Process Locked */
514 __HAL_LOCK(hsc);
515
516 hsc->ErrorCode = HAL_SMARTCARD_ERROR_NONE;
517 hsc->RxState = HAL_SMARTCARD_STATE_BUSY_RX;
518
519 /* Init tickstart for timeout managment */
520 tickstart = HAL_GetTick();
521
522 hsc->RxXferSize = Size;
523 hsc->RxXferCount = Size;
524
525 /* Check the remain data to be received */
526 while(hsc->RxXferCount > 0U)
527 {
528 hsc->RxXferCount--;
529 if(SMARTCARD_WaitOnFlagUntilTimeout(hsc, SMARTCARD_FLAG_RXNE, RESET, tickstart, Timeout) != HAL_OK)
530 {
531 return HAL_TIMEOUT;
532 }
533 tmp = (uint16_t*) pData;
534 *tmp = (uint8_t)(hsc->Instance->DR & (uint8_t)0xFF);
535 pData +=1U;
536 }
537
538 /* At end of Rx process, restore hsc->RxState to Ready */
539 hsc->RxState = HAL_SMARTCARD_STATE_READY;
540
541 /* Process Unlocked */
542 __HAL_UNLOCK(hsc);
543
544 return HAL_OK;
545 }
546 else
547 {
548 return HAL_BUSY;
549 }
550 }
551
552 /**
553 * @brief Send an amount of data in non blocking mode
554 * @param hsc: pointer to a SMARTCARD_HandleTypeDef structure that contains
555 * the configuration information for SMARTCARD module.
556 * @param pData: pointer to data buffer
557 * @param Size: amount of data to be sent
558 * @retval HAL status
559 */
560 HAL_StatusTypeDef HAL_SMARTCARD_Transmit_IT(SMARTCARD_HandleTypeDef *hsc, uint8_t *pData, uint16_t Size)
561 {
562 /* Check that a Tx process is not already ongoing */
563 if(hsc->gState == HAL_SMARTCARD_STATE_READY)
564 {
565 if((pData == NULL) || (Size == 0U))
566 {
567 return HAL_ERROR;
568 }
569 /* Process Locked */
570 __HAL_LOCK(hsc);
571
572 hsc->pTxBuffPtr = pData;
573 hsc->TxXferSize = Size;
574 hsc->TxXferCount = Size;
575
576 hsc->ErrorCode = HAL_SMARTCARD_ERROR_NONE;
577 hsc->gState = HAL_SMARTCARD_STATE_BUSY_TX;
578
579 /* Process Unlocked */
580 __HAL_UNLOCK(hsc);
581
582 /* Enable the SMARTCARD Parity Error Interrupt */
583 SET_BIT(hsc->Instance->CR1, USART_CR1_PEIE);
584
585 /* Disable the SMARTCARD Error Interrupt: (Frame error, noise error, overrun error) */
586 CLEAR_BIT(hsc->Instance->CR3, USART_CR3_EIE);
587
588 /* Enable the SMARTCARD Transmit data register empty Interrupt */
589 SET_BIT(hsc->Instance->CR1, USART_CR1_TXEIE);
590
591 return HAL_OK;
592 }
593 else
594 {
595 return HAL_BUSY;
596 }
597 }
598
599 /**
600 * @brief Receive an amount of data in non blocking mode
601 * @param hsc: pointer to a SMARTCARD_HandleTypeDef structure that contains
602 * the configuration information for SMARTCARD module.
603 * @param pData: pointer to data buffer
604 * @param Size: amount of data to be received
605 * @retval HAL status
606 */
607 HAL_StatusTypeDef HAL_SMARTCARD_Receive_IT(SMARTCARD_HandleTypeDef *hsc, uint8_t *pData, uint16_t Size)
608 {
609 /* Check that a Rx process is not already ongoing */
610 if(hsc->RxState == HAL_SMARTCARD_STATE_READY)
611 {
612 if((pData == NULL) || (Size == 0U))
613 {
614 return HAL_ERROR;
615 }
616
617 /* Process Locked */
618 __HAL_LOCK(hsc);
619
620 hsc->pRxBuffPtr = pData;
621 hsc->RxXferSize = Size;
622 hsc->RxXferCount = Size;
623
624 hsc->ErrorCode = HAL_SMARTCARD_ERROR_NONE;
625 hsc->RxState = HAL_SMARTCARD_STATE_BUSY_RX;
626
627 /* Process Unlocked */
628 __HAL_UNLOCK(hsc);
629
630 /* Enable the SMARTCARD Parity Error and Data Register not empty Interrupts */
631 SET_BIT(hsc->Instance->CR1, USART_CR1_PEIE| USART_CR1_RXNEIE);
632
633 /* Enable the SMARTCARD Error Interrupt: (Frame error, noise error, overrun error) */
634 SET_BIT(hsc->Instance->CR3, USART_CR3_EIE);
635
636 return HAL_OK;
637 }
638 else
639 {
640 return HAL_BUSY;
641 }
642 }
643
644 /**
645 * @brief Send an amount of data in non blocking mode
646 * @param hsc: pointer to a SMARTCARD_HandleTypeDef structure that contains
647 * the configuration information for SMARTCARD module.
648 * @param pData: pointer to data buffer
649 * @param Size: amount of data to be sent
650 * @retval HAL status
651 */
652 HAL_StatusTypeDef HAL_SMARTCARD_Transmit_DMA(SMARTCARD_HandleTypeDef *hsc, uint8_t *pData, uint16_t Size)
653 {
654 uint32_t *tmp;
655
656 /* Check that a Tx process is not already ongoing */
657 if(hsc->gState == HAL_SMARTCARD_STATE_READY)
658 {
659 if((pData == NULL) || (Size == 0U))
660 {
661 return HAL_ERROR;
662 }
663
664 /* Process Locked */
665 __HAL_LOCK(hsc);
666
667 hsc->pTxBuffPtr = pData;
668 hsc->TxXferSize = Size;
669 hsc->TxXferCount = Size;
670
671 hsc->ErrorCode = HAL_SMARTCARD_ERROR_NONE;
672 hsc->gState = HAL_SMARTCARD_STATE_BUSY_TX;
673
674 /* Set the SMARTCARD DMA transfer complete callback */
675 hsc->hdmatx->XferCpltCallback = SMARTCARD_DMATransmitCplt;
676
677 /* Set the DMA error callback */
678 hsc->hdmatx->XferErrorCallback = SMARTCARD_DMAError;
679
680 /* Set the DMA abort callback */
681 hsc->hdmatx->XferAbortCallback = NULL;
682
683 /* Enable the SMARTCARD transmit DMA Channel */
684 tmp = (uint32_t*)&pData;
685 HAL_DMA_Start_IT(hsc->hdmatx, *(uint32_t*)tmp, (uint32_t)&hsc->Instance->DR, Size);
686
687 /* Clear the TC flag in the SR register by writing 0 to it */
688 __HAL_SMARTCARD_CLEAR_FLAG(hsc, SMARTCARD_FLAG_TC);
689
690 /* Process Unlocked */
691 __HAL_UNLOCK(hsc);
692
693 /* Enable the DMA transfer for transmit request by setting the DMAT bit
694 in the SMARTCARD CR3 register */
695 SET_BIT(hsc->Instance->CR3, USART_CR3_DMAT);
696
697 return HAL_OK;
698 }
699 else
700 {
701 return HAL_BUSY;
702 }
703 }
704
705 /**
706 * @brief Receive an amount of data in non blocking mode
707 * @param hsc: pointer to a SMARTCARD_HandleTypeDef structure that contains
708 * the configuration information for SMARTCARD module.
709 * @param pData: pointer to data buffer
710 * @param Size: amount of data to be received
711 * @note When the SMARTCARD parity is enabled (PCE = 1) the data received contain the parity bit.s
712 * @retval HAL status
713 */
714 HAL_StatusTypeDef HAL_SMARTCARD_Receive_DMA(SMARTCARD_HandleTypeDef *hsc, uint8_t *pData, uint16_t Size)
715 {
716 uint32_t *tmp;
717
718 /* Check that a Rx process is not already ongoing */
719 if(hsc->RxState == HAL_SMARTCARD_STATE_READY)
720 {
721 if((pData == NULL) || (Size == 0U))
722 {
723 return HAL_ERROR;
724 }
725
726 /* Process Locked */
727 __HAL_LOCK(hsc);
728
729 hsc->pRxBuffPtr = pData;
730 hsc->RxXferSize = Size;
731
732 hsc->ErrorCode = HAL_SMARTCARD_ERROR_NONE;
733 hsc->RxState = HAL_SMARTCARD_STATE_BUSY_RX;
734
735 /* Set the SMARTCARD DMA transfer complete callback */
736 hsc->hdmarx->XferCpltCallback = SMARTCARD_DMAReceiveCplt;
737
738 /* Set the DMA error callback */
739 hsc->hdmarx->XferErrorCallback = SMARTCARD_DMAError;
740
741 /* Set the DMA abort callback */
742 hsc->hdmatx->XferAbortCallback = NULL;
743
744 /* Enable the DMA Channel */
745 tmp = (uint32_t*)&pData;
746 HAL_DMA_Start_IT(hsc->hdmarx, (uint32_t)&hsc->Instance->DR, *(uint32_t*)tmp, Size);
747
748 /* Clear the Overrun flag just before enabling the DMA Rx request: can be mandatory for the second transfer */
749 __HAL_SMARTCARD_CLEAR_OREFLAG(hsc);
750
751 /* Process Unlocked */
752 __HAL_UNLOCK(hsc);
753
754 /* Enable the SMARTCARD Parity Error Interrupt */
755 SET_BIT(hsc->Instance->CR1, USART_CR1_PEIE);
756
757 /* Enable the SMARTCARD Error Interrupt: (Frame error, noise error, overrun error) */
758 SET_BIT(hsc->Instance->CR3, USART_CR3_EIE);
759
760 /* Enable the DMA transfer for the receiver request by setting the DMAR bit
761 in the SMARTCARD CR3 register */
762 SET_BIT(hsc->Instance->CR3, USART_CR3_DMAR);
763
764 return HAL_OK;
765 }
766 else
767 {
768 return HAL_BUSY;
769 }
770 }
771
772 /**
773 * @brief Abort ongoing transfers (blocking mode).
774 * @param hsc SMARTCARD handle.
775 * @note This procedure could be used for aborting any ongoing transfer started in Interrupt or DMA mode.
776 * This procedure performs following operations :
777 * - Disable PPP Interrupts
778 * - Disable the DMA transfer in the peripheral register (if enabled)
779 * - Abort DMA transfer by calling HAL_DMA_Abort (in case of transfer in DMA mode)
780 * - Set handle State to READY
781 * @note This procedure is executed in blocking mode : when exiting function, Abort is considered as completed.
782 * @retval HAL status
783 */
784 HAL_StatusTypeDef HAL_SMARTCARD_Abort(SMARTCARD_HandleTypeDef *hsc)
785 {
786 /* Disable TXEIE, TCIE, RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts */
787 CLEAR_BIT(hsc->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE | USART_CR1_TXEIE | USART_CR1_TCIE));
788 CLEAR_BIT(hsc->Instance->CR3, USART_CR3_EIE);
789
790 /* Disable the SMARTCARD DMA Tx request if enabled */
791 if(HAL_IS_BIT_SET(hsc->Instance->CR3, USART_CR3_DMAT))
792 {
793 CLEAR_BIT(hsc->Instance->CR3, USART_CR3_DMAT);
794
795 /* Abort the SMARTCARD DMA Tx channel: use blocking DMA Abort API (no callback) */
796 if(hsc->hdmatx != NULL)
797 {
798 /* Set the SMARTCARD DMA Abort callback to Null.
799 No call back execution at end of DMA abort procedure */
800 hsc->hdmatx->XferAbortCallback = NULL;
801
802 HAL_DMA_Abort(hsc->hdmatx);
803 }
804 }
805
806 /* Disable the SMARTCARD DMA Rx request if enabled */
807 if(HAL_IS_BIT_SET(hsc->Instance->CR3, USART_CR3_DMAR))
808 {
809 CLEAR_BIT(hsc->Instance->CR3, USART_CR3_DMAR);
810
811 /* Abort the SMARTCARD DMA Rx channel: use blocking DMA Abort API (no callback) */
812 if(hsc->hdmarx != NULL)
813 {
814 /* Set the SMARTCARD DMA Abort callback to Null.
815 No call back execution at end of DMA abort procedure */
816 hsc->hdmarx->XferAbortCallback = NULL;
817
818 HAL_DMA_Abort(hsc->hdmarx);
819 }
820 }
821
822 /* Reset Tx and Rx transfer counters */
823 hsc->TxXferCount = 0x00U;
824 hsc->RxXferCount = 0x00U;
825
826 /* Reset ErrorCode */
827 hsc->ErrorCode = HAL_SMARTCARD_ERROR_NONE;
828
829 /* Restore hsc->RxState and hsc->gState to Ready */
830 hsc->RxState = HAL_SMARTCARD_STATE_READY;
831 hsc->gState = HAL_SMARTCARD_STATE_READY;
832
833 return HAL_OK;
834 }
835
836 /**
837 * @brief Abort ongoing Transmit transfer (blocking mode).
838 * @param hsc SMARTCARD handle.
839 * @note This procedure could be used for aborting any ongoing transfer started in Interrupt or DMA mode.
840 * This procedure performs following operations :
841 * - Disable PPP Interrupts
842 * - Disable the DMA transfer in the peripheral register (if enabled)
843 * - Abort DMA transfer by calling HAL_DMA_Abort (in case of transfer in DMA mode)
844 * - Set handle State to READY
845 * @note This procedure is executed in blocking mode : when exiting function, Abort is considered as completed.
846 * @retval HAL status
847 */
848 HAL_StatusTypeDef HAL_SMARTCARD_AbortTransmit(SMARTCARD_HandleTypeDef *hsc)
849 {
850 /* Disable TXEIE and TCIE interrupts */
851 CLEAR_BIT(hsc->Instance->CR1, (USART_CR1_TXEIE | USART_CR1_TCIE));
852
853 /* Disable the SMARTCARD DMA Tx request if enabled */
854 if(HAL_IS_BIT_SET(hsc->Instance->CR3, USART_CR3_DMAT))
855 {
856 CLEAR_BIT(hsc->Instance->CR3, USART_CR3_DMAT);
857
858 /* Abort the SMARTCARD DMA Tx channel: use blocking DMA Abort API (no callback) */
859 if(hsc->hdmatx != NULL)
860 {
861 /* Set the SMARTCARD DMA Abort callback to Null.
862 No call back execution at end of DMA abort procedure */
863 hsc->hdmatx->XferAbortCallback = NULL;
864
865 HAL_DMA_Abort(hsc->hdmatx);
866 }
867 }
868
869 /* Reset Tx transfer counter */
870 hsc->TxXferCount = 0x00U;
871
872 /* Restore hsc->gState to Ready */
873 hsc->gState = HAL_SMARTCARD_STATE_READY;
874
875 return HAL_OK;
876 }
877
878 /**
879 * @brief Abort ongoing Receive transfer (blocking mode).
880 * @param hsc SMARTCARD handle.
881 * @note This procedure could be used for aborting any ongoing transfer started in Interrupt or DMA mode.
882 * This procedure performs following operations :
883 * - Disable PPP Interrupts
884 * - Disable the DMA transfer in the peripheral register (if enabled)
885 * - Abort DMA transfer by calling HAL_DMA_Abort (in case of transfer in DMA mode)
886 * - Set handle State to READY
887 * @note This procedure is executed in blocking mode : when exiting function, Abort is considered as completed.
888 * @retval HAL status
889 */
890 HAL_StatusTypeDef HAL_SMARTCARD_AbortReceive(SMARTCARD_HandleTypeDef *hsc)
891 {
892 /* Disable RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts */
893 CLEAR_BIT(hsc->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE));
894 CLEAR_BIT(hsc->Instance->CR3, USART_CR3_EIE);
895
896 /* Disable the SMARTCARD DMA Rx request if enabled */
897 if(HAL_IS_BIT_SET(hsc->Instance->CR3, USART_CR3_DMAR))
898 {
899 CLEAR_BIT(hsc->Instance->CR3, USART_CR3_DMAR);
900
901 /* Abort the SMARTCARD DMA Rx channel: use blocking DMA Abort API (no callback) */
902 if(hsc->hdmarx != NULL)
903 {
904 /* Set the SMARTCARD DMA Abort callback to Null.
905 No call back execution at end of DMA abort procedure */
906 hsc->hdmarx->XferAbortCallback = NULL;
907
908 HAL_DMA_Abort(hsc->hdmarx);
909 }
910 }
911
912 /* Reset Rx transfer counter */
913 hsc->RxXferCount = 0x00U;
914
915 /* Restore hsc->RxState to Ready */
916 hsc->RxState = HAL_SMARTCARD_STATE_READY;
917
918 return HAL_OK;
919 }
920
921 /**
922 * @brief Abort ongoing transfers (Interrupt mode).
923 * @param hsc SMARTCARD handle.
924 * @note This procedure could be used for aborting any ongoing transfer started in Interrupt or DMA mode.
925 * This procedure performs following operations :
926 * - Disable PPP Interrupts
927 * - Disable the DMA transfer in the peripheral register (if enabled)
928 * - Abort DMA transfer by calling HAL_DMA_Abort_IT (in case of transfer in DMA mode)
929 * - Set handle State to READY
930 * - At abort completion, call user abort complete callback
931 * @note This procedure is executed in Interrupt mode, meaning that abort procedure could be
932 * considered as completed only when user abort complete callback is executed (not when exiting function).
933 * @retval HAL status
934 */
935 HAL_StatusTypeDef HAL_SMARTCARD_Abort_IT(SMARTCARD_HandleTypeDef *hsc)
936 {
937 uint32_t AbortCplt = 0x01U;
938
939 /* Disable TXEIE, TCIE, RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts */
940 CLEAR_BIT(hsc->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE | USART_CR1_TXEIE | USART_CR1_TCIE));
941 CLEAR_BIT(hsc->Instance->CR3, USART_CR3_EIE);
942
943 /* If DMA Tx and/or DMA Rx Handles are associated to SMARTCARD Handle, DMA Abort complete callbacks should be initialised
944 before any call to DMA Abort functions */
945 /* DMA Tx Handle is valid */
946 if(hsc->hdmatx != NULL)
947 {
948 /* Set DMA Abort Complete callback if SMARTCARD DMA Tx request if enabled.
949 Otherwise, set it to NULL */
950 if(HAL_IS_BIT_SET(hsc->Instance->CR3, USART_CR3_DMAT))
951 {
952 hsc->hdmatx->XferAbortCallback = SMARTCARD_DMATxAbortCallback;
953 }
954 else
955 {
956 hsc->hdmatx->XferAbortCallback = NULL;
957 }
958 }
959 /* DMA Rx Handle is valid */
960 if(hsc->hdmarx != NULL)
961 {
962 /* Set DMA Abort Complete callback if SMARTCARD DMA Rx request if enabled.
963 Otherwise, set it to NULL */
964 if(HAL_IS_BIT_SET(hsc->Instance->CR3, USART_CR3_DMAR))
965 {
966 hsc->hdmarx->XferAbortCallback = SMARTCARD_DMARxAbortCallback;
967 }
968 else
969 {
970 hsc->hdmarx->XferAbortCallback = NULL;
971 }
972 }
973
974 /* Disable the SMARTCARD DMA Tx request if enabled */
975 if(HAL_IS_BIT_SET(hsc->Instance->CR3, USART_CR3_DMAT))
976 {
977 /* Disable DMA Tx at SMARTCARD level */
978 CLEAR_BIT(hsc->Instance->CR3, USART_CR3_DMAT);
979
980 /* Abort the SMARTCARD DMA Tx channel : use non blocking DMA Abort API (callback) */
981 if(hsc->hdmatx != NULL)
982 {
983 /* SMARTCARD Tx DMA Abort callback has already been initialised :
984 will lead to call HAL_SMARTCARD_AbortCpltCallback() at end of DMA abort procedure */
985
986 /* Abort DMA TX */
987 if(HAL_DMA_Abort_IT(hsc->hdmatx) != HAL_OK)
988 {
989 hsc->hdmatx->XferAbortCallback = NULL;
990 }
991 else
992 {
993 AbortCplt = 0x00U;
994 }
995 }
996 }
997
998 /* Disable the SMARTCARD DMA Rx request if enabled */
999 if(HAL_IS_BIT_SET(hsc->Instance->CR3, USART_CR3_DMAR))
1000 {
1001 CLEAR_BIT(hsc->Instance->CR3, USART_CR3_DMAR);
1002
1003 /* Abort the SMARTCARD DMA Rx channel : use non blocking DMA Abort API (callback) */
1004 if(hsc->hdmarx != NULL)
1005 {
1006 /* SMARTCARD Rx DMA Abort callback has already been initialised :
1007 will lead to call HAL_SMARTCARD_AbortCpltCallback() at end of DMA abort procedure */
1008
1009 /* Abort DMA RX */
1010 if(HAL_DMA_Abort_IT(hsc->hdmarx) != HAL_OK)
1011 {
1012 hsc->hdmarx->XferAbortCallback = NULL;
1013 AbortCplt = 0x01U;
1014 }
1015 else
1016 {
1017 AbortCplt = 0x00U;
1018 }
1019 }
1020 }
1021
1022 /* if no DMA abort complete callback execution is required => call user Abort Complete callback */
1023 if(AbortCplt == 0x01U)
1024 {
1025 /* Reset Tx and Rx transfer counters */
1026 hsc->TxXferCount = 0x00U;
1027 hsc->RxXferCount = 0x00U;
1028
1029 /* Reset ErrorCode */
1030 hsc->ErrorCode = HAL_SMARTCARD_ERROR_NONE;
1031
1032 /* Restore hsc->gState and hsc->RxState to Ready */
1033 hsc->gState = HAL_SMARTCARD_STATE_READY;
1034 hsc->RxState = HAL_SMARTCARD_STATE_READY;
1035
1036 /* As no DMA to be aborted, call directly user Abort complete callback */
1037 HAL_SMARTCARD_AbortCpltCallback(hsc);
1038 }
1039 return HAL_OK;
1040 }
1041
1042 /**
1043 * @brief Abort ongoing Transmit transfer (Interrupt mode).
1044 * @param hsc SMARTCARD handle.
1045 * @note This procedure could be used for aborting any ongoing transfer started in Interrupt or DMA mode.
1046 * This procedure performs following operations :
1047 * - Disable PPP Interrupts
1048 * - Disable the DMA transfer in the peripheral register (if enabled)
1049 * - Abort DMA transfer by calling HAL_DMA_Abort_IT (in case of transfer in DMA mode)
1050 * - Set handle State to READY
1051 * - At abort completion, call user abort complete callback
1052 * @note This procedure is executed in Interrupt mode, meaning that abort procedure could be
1053 * considered as completed only when user abort complete callback is executed (not when exiting function).
1054 * @retval HAL status
1055 */
1056 HAL_StatusTypeDef HAL_SMARTCARD_AbortTransmit_IT(SMARTCARD_HandleTypeDef *hsc)
1057 {
1058 /* Disable TXEIE and TCIE interrupts */
1059 CLEAR_BIT(hsc->Instance->CR1, (USART_CR1_TXEIE | USART_CR1_TCIE));
1060
1061 /* Disable the SMARTCARD DMA Tx request if enabled */
1062 if(HAL_IS_BIT_SET(hsc->Instance->CR3, USART_CR3_DMAT))
1063 {
1064 CLEAR_BIT(hsc->Instance->CR3, USART_CR3_DMAT);
1065
1066 /* Abort the SMARTCARD DMA Tx channel : use blocking DMA Abort API (no callback) */
1067 if(hsc->hdmatx != NULL)
1068 {
1069 /* Set the SMARTCARD DMA Abort callback :
1070 will lead to call HAL_SMARTCARD_AbortCpltCallback() at end of DMA abort procedure */
1071 hsc->hdmatx->XferAbortCallback = SMARTCARD_DMATxOnlyAbortCallback;
1072
1073 /* Abort DMA TX */
1074 if(HAL_DMA_Abort_IT(hsc->hdmatx) != HAL_OK)
1075 {
1076 /* Call Directly hsc->hdmatx->XferAbortCallback function in case of error */
1077 hsc->hdmatx->XferAbortCallback(hsc->hdmatx);
1078 }
1079 }
1080 else
1081 {
1082 /* Reset Tx transfer counter */
1083 hsc->TxXferCount = 0x00U;
1084
1085 /* Restore hsc->gState to Ready */
1086 hsc->gState = HAL_SMARTCARD_STATE_READY;
1087
1088 /* As no DMA to be aborted, call directly user Abort complete callback */
1089 HAL_SMARTCARD_AbortTransmitCpltCallback(hsc);
1090 }
1091 }
1092 else
1093 {
1094 /* Reset Tx transfer counter */
1095 hsc->TxXferCount = 0x00U;
1096
1097 /* Restore hsc->gState to Ready */
1098 hsc->gState = HAL_SMARTCARD_STATE_READY;
1099
1100 /* As no DMA to be aborted, call directly user Abort complete callback */
1101 HAL_SMARTCARD_AbortTransmitCpltCallback(hsc);
1102 }
1103
1104 return HAL_OK;
1105 }
1106
1107 /**
1108 * @brief Abort ongoing Receive transfer (Interrupt mode).
1109 * @param hsc SMARTCARD handle.
1110 * @note This procedure could be used for aborting any ongoing transfer started in Interrupt or DMA mode.
1111 * This procedure performs following operations :
1112 * - Disable PPP Interrupts
1113 * - Disable the DMA transfer in the peripheral register (if enabled)
1114 * - Abort DMA transfer by calling HAL_DMA_Abort_IT (in case of transfer in DMA mode)
1115 * - Set handle State to READY
1116 * - At abort completion, call user abort complete callback
1117 * @note This procedure is executed in Interrupt mode, meaning that abort procedure could be
1118 * considered as completed only when user abort complete callback is executed (not when exiting function).
1119 * @retval HAL status
1120 */
1121 HAL_StatusTypeDef HAL_SMARTCARD_AbortReceive_IT(SMARTCARD_HandleTypeDef *hsc)
1122 {
1123 /* Disable RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts */
1124 CLEAR_BIT(hsc->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE));
1125 CLEAR_BIT(hsc->Instance->CR3, USART_CR3_EIE);
1126
1127 /* Disable the SMARTCARD DMA Rx request if enabled */
1128 if(HAL_IS_BIT_SET(hsc->Instance->CR3, USART_CR3_DMAR))
1129 {
1130 CLEAR_BIT(hsc->Instance->CR3, USART_CR3_DMAR);
1131
1132 /* Abort the SMARTCARD DMA Rx channel : use blocking DMA Abort API (no callback) */
1133 if(hsc->hdmarx != NULL)
1134 {
1135 /* Set the SMARTCARD DMA Abort callback :
1136 will lead to call HAL_SMARTCARD_AbortCpltCallback() at end of DMA abort procedure */
1137 hsc->hdmarx->XferAbortCallback = SMARTCARD_DMARxOnlyAbortCallback;
1138
1139 /* Abort DMA RX */
1140 if(HAL_DMA_Abort_IT(hsc->hdmarx) != HAL_OK)
1141 {
1142 /* Call Directly hsc->hdmarx->XferAbortCallback function in case of error */
1143 hsc->hdmarx->XferAbortCallback(hsc->hdmarx);
1144 }
1145 }
1146 else
1147 {
1148 /* Reset Rx transfer counter */
1149 hsc->RxXferCount = 0x00U;
1150
1151 /* Restore hsc->RxState to Ready */
1152 hsc->RxState = HAL_SMARTCARD_STATE_READY;
1153
1154 /* As no DMA to be aborted, call directly user Abort complete callback */
1155 HAL_SMARTCARD_AbortReceiveCpltCallback(hsc);
1156 }
1157 }
1158 else
1159 {
1160 /* Reset Rx transfer counter */
1161 hsc->RxXferCount = 0x00U;
1162
1163 /* Restore hsc->RxState to Ready */
1164 hsc->RxState = HAL_SMARTCARD_STATE_READY;
1165
1166 /* As no DMA to be aborted, call directly user Abort complete callback */
1167 HAL_SMARTCARD_AbortReceiveCpltCallback(hsc);
1168 }
1169
1170 return HAL_OK;
1171 }
1172
1173 /**
1174 * @brief This function handles SMARTCARD interrupt request.
1175 * @param hsc: pointer to a SMARTCARD_HandleTypeDef structure that contains
1176 * the configuration information for SMARTCARD module.
1177 * @retval None
1178 */
1179 void HAL_SMARTCARD_IRQHandler(SMARTCARD_HandleTypeDef *hsc)
1180 {
1181 uint32_t isrflags = READ_REG(hsc->Instance->SR);
1182 uint32_t cr1its = READ_REG(hsc->Instance->CR1);
1183 uint32_t cr3its = READ_REG(hsc->Instance->CR3);
1184 uint32_t dmarequest = 0x00U;
1185 uint32_t errorflags = 0x00U;
1186
1187 /* If no error occurs */
1188 errorflags = (isrflags & (uint32_t)(USART_SR_PE | USART_SR_FE | USART_SR_ORE | USART_SR_NE));
1189 if(errorflags == RESET)
1190 {
1191 /* SMARTCARD in mode Receiver -------------------------------------------------*/
1192 if(((isrflags & USART_SR_RXNE) != RESET) && ((cr1its & USART_CR1_RXNEIE) != RESET))
1193 {
1194 SMARTCARD_Receive_IT(hsc);
1195 return;
1196 }
1197 }
1198
1199 /* If some errors occur */
1200 if((errorflags != RESET) && (((cr3its & USART_CR3_EIE) != RESET) || ((cr1its & (USART_CR1_RXNEIE | USART_CR1_PEIE)) != RESET)))
1201 {
1202 /* SMARTCARD parity error interrupt occurred ---------------------------*/
1203 if(((isrflags & SMARTCARD_FLAG_PE) != RESET) && ((cr1its & USART_CR1_PEIE) != RESET))
1204 {
1205 hsc->ErrorCode |= HAL_SMARTCARD_ERROR_PE;
1206 }
1207
1208 /* SMARTCARD noise error interrupt occurred ----------------------------*/
1209 if(((isrflags & SMARTCARD_FLAG_NE) != RESET) && ((cr3its & USART_CR3_EIE) != RESET))
1210 {
1211 hsc->ErrorCode |= HAL_SMARTCARD_ERROR_NE;
1212 }
1213
1214 /* SMARTCARD frame error interrupt occurred ----------------------------*/
1215 if(((isrflags & SMARTCARD_FLAG_FE) != RESET) && ((cr3its & USART_CR3_EIE) != RESET))
1216 {
1217 hsc->ErrorCode |= HAL_SMARTCARD_ERROR_FE;
1218 }
1219
1220 /* SMARTCARD Over-Run interrupt occurred -------------------------------*/
1221 if(((isrflags & SMARTCARD_FLAG_ORE) != RESET) && ((cr3its & USART_CR3_EIE) != RESET))
1222 {
1223 hsc->ErrorCode |= HAL_SMARTCARD_ERROR_ORE;
1224 }
1225
1226 /* Call SMARTCARD Error Call back function if need be ------------------*/
1227 if(hsc->ErrorCode != HAL_SMARTCARD_ERROR_NONE)
1228 {
1229 /* SMARTCARD in mode Receiver ----------------------------------------*/
1230 if(((isrflags & USART_SR_RXNE) != RESET) && ((cr1its & USART_CR1_RXNEIE) != RESET))
1231 {
1232 SMARTCARD_Receive_IT(hsc);
1233 }
1234
1235 /* If Overrun error occurs, or if any error occurs in DMA mode reception,
1236 consider error as blocking */
1237 dmarequest = HAL_IS_BIT_SET(hsc->Instance->CR3, USART_CR3_DMAR);
1238 if(((hsc->ErrorCode & HAL_SMARTCARD_ERROR_ORE) != RESET) || dmarequest)
1239 {
1240 /* Blocking error : transfer is aborted
1241 Set the SMARTCARD state ready to be able to start again the process,
1242 Disable Rx Interrupts, and disable Rx DMA request, if ongoing */
1243 SMARTCARD_EndRxTransfer(hsc);
1244
1245 /* Disable the SMARTCARD DMA Rx request if enabled */
1246 if(HAL_IS_BIT_SET(hsc->Instance->CR3, USART_CR3_DMAR))
1247 {
1248 CLEAR_BIT(hsc->Instance->CR3, USART_CR3_DMAR);
1249
1250 /* Abort the SMARTCARD DMA Rx channel */
1251 if(hsc->hdmarx != NULL)
1252 {
1253 /* Set the SMARTCARD DMA Abort callback :
1254 will lead to call HAL_SMARTCARD_ErrorCallback() at end of DMA abort procedure */
1255 hsc->hdmarx->XferAbortCallback = SMARTCARD_DMAAbortOnError;
1256 if(HAL_DMA_Abort_IT(hsc->hdmarx) != HAL_OK)
1257 {
1258 /* Call Directly XferAbortCallback function in case of error */
1259 hsc->hdmarx->XferAbortCallback(hsc->hdmarx);
1260 }
1261 }
1262 else
1263 {
1264 /* Call user error callback */
1265 HAL_SMARTCARD_ErrorCallback(hsc);
1266 }
1267 }
1268 else
1269 {
1270 /* Call user error callback */
1271 HAL_SMARTCARD_ErrorCallback(hsc);
1272 }
1273 }
1274 else
1275 {
1276 /* Non Blocking error : transfer could go on.
1277 Error is notified to user through user error callback */
1278 HAL_SMARTCARD_ErrorCallback(hsc);
1279 hsc->ErrorCode = HAL_SMARTCARD_ERROR_NONE;
1280 }
1281 }
1282 return;
1283 } /* End if some error occurs */
1284
1285 /* SMARTCARD in mode Transmitter -------------------------------------------*/
1286 if(((isrflags & SMARTCARD_FLAG_TXE) != RESET) && ((cr1its & USART_CR1_TXEIE) != RESET))
1287 {
1288 SMARTCARD_Transmit_IT(hsc);
1289 return;
1290 }
1291
1292 /* SMARTCARD in mode Transmitter (transmission end) ------------------------*/
1293 if(((isrflags & SMARTCARD_FLAG_TC) != RESET) && ((cr1its & USART_CR1_TCIE) != RESET))
1294 {
1295 SMARTCARD_EndTransmit_IT(hsc);
1296 return;
1297 }
1298 }
1299
1300 /**
1301 * @brief Tx Transfer completed callbacks
1302 * @param hsc: pointer to a SMARTCARD_HandleTypeDef structure that contains
1303 * the configuration information for SMARTCARD module.
1304 * @retval None
1305 */
1306 __weak void HAL_SMARTCARD_TxCpltCallback(SMARTCARD_HandleTypeDef *hsc)
1307 {
1308 /* Prevent unused argument(s) compilation warning */
1309 UNUSED(hsc);
1310 /* NOTE : This function Should not be modified, when the callback is needed,
1311 the HAL_SMARTCARD_TxCpltCallback could be implemented in the user file
1312 */
1313 }
1314
1315 /**
1316 * @brief Rx Transfer completed callbacks
1317 * @param hsc: pointer to a SMARTCARD_HandleTypeDef structure that contains
1318 * the configuration information for SMARTCARD module.
1319 * @retval None
1320 */
1321 __weak void HAL_SMARTCARD_RxCpltCallback(SMARTCARD_HandleTypeDef *hsc)
1322 {
1323 /* Prevent unused argument(s) compilation warning */
1324 UNUSED(hsc);
1325 /* NOTE : This function Should not be modified, when the callback is needed,
1326 the HAL_SMARTCARD_RxCpltCallback could be implemented in the user file
1327 */
1328 }
1329
1330 /**
1331 * @brief SMARTCARD error callbacks
1332 * @param hsc: pointer to a SMARTCARD_HandleTypeDef structure that contains
1333 * the configuration information for SMARTCARD module.
1334 * @retval None
1335 */
1336 __weak void HAL_SMARTCARD_ErrorCallback(SMARTCARD_HandleTypeDef *hsc)
1337 {
1338 /* Prevent unused argument(s) compilation warning */
1339 UNUSED(hsc);
1340 /* NOTE : This function Should not be modified, when the callback is needed,
1341 the HAL_SMARTCARD_ErrorCallback could be implemented in the user file
1342 */
1343 }
1344
1345 /**
1346 * @brief SMARTCARD Abort Complete callback.
1347 * @param hsc SMARTCARD handle.
1348 * @retval None
1349 */
1350 __weak void HAL_SMARTCARD_AbortCpltCallback (SMARTCARD_HandleTypeDef *hsc)
1351 {
1352 /* Prevent unused argument(s) compilation warning */
1353 UNUSED(hsc);
1354
1355 /* NOTE : This function should not be modified, when the callback is needed,
1356 the HAL_SMARTCARD_AbortCpltCallback can be implemented in the user file.
1357 */
1358 }
1359
1360 /**
1361 * @brief SMARTCARD Abort Transmit Complete callback.
1362 * @param hsc SMARTCARD handle.
1363 * @retval None
1364 */
1365 __weak void HAL_SMARTCARD_AbortTransmitCpltCallback (SMARTCARD_HandleTypeDef *hsc)
1366 {
1367 /* Prevent unused argument(s) compilation warning */
1368 UNUSED(hsc);
1369
1370 /* NOTE : This function should not be modified, when the callback is needed,
1371 the HAL_SMARTCARD_AbortTransmitCpltCallback can be implemented in the user file.
1372 */
1373 }
1374
1375 /**
1376 * @brief SMARTCARD Abort ReceiveComplete callback.
1377 * @param hsc SMARTCARD handle.
1378 * @retval None
1379 */
1380 __weak void HAL_SMARTCARD_AbortReceiveCpltCallback (SMARTCARD_HandleTypeDef *hsc)
1381 {
1382 /* Prevent unused argument(s) compilation warning */
1383 UNUSED(hsc);
1384
1385 /* NOTE : This function should not be modified, when the callback is needed,
1386 the HAL_SMARTCARD_AbortReceiveCpltCallback can be implemented in the user file.
1387 */
1388 }
1389
1390 /**
1391 * @}
1392 */
1393
1394 /** @defgroup SMARTCARD_Exported_Functions_Group3 Peripheral State and Errors functions
1395 * @brief SMARTCARD State and Errors functions
1396 *
1397 @verbatim
1398 ===============================================================================
1399 ##### Peripheral State and Errors functions #####
1400 ===============================================================================
1401 [..]
1402 This subsection provides a set of functions allowing to control the SmartCard.
1403 (+) HAL_SMARTCARD_GetState() API can be helpful to check in run-time the state of the SmartCard peripheral.
1404 (+) HAL_SMARTCARD_GetError() check in run-time errors that could be occurred during communication.
1405 @endverbatim
1406 * @{
1407 */
1408
1409 /**
1410 * @brief return the SMARTCARD state
1411 * @param hsc: pointer to a SMARTCARD_HandleTypeDef structure that contains
1412 * the configuration information for SMARTCARD module.
1413 * @retval HAL state
1414 */
1415 HAL_SMARTCARD_StateTypeDef HAL_SMARTCARD_GetState(SMARTCARD_HandleTypeDef *hsc)
1416 {
1417 uint32_t temp1= 0x00U, temp2 = 0x00U;
1418 temp1 = hsc->gState;
1419 temp2 = hsc->RxState;
1420
1421 return (HAL_SMARTCARD_StateTypeDef)(temp1 | temp2);
1422 }
1423
1424 /**
1425 * @brief Return the SMARTCARD error code
1426 * @param hsc : pointer to a SMARTCARD_HandleTypeDef structure that contains
1427 * the configuration information for the specified SMARTCARD.
1428 * @retval SMARTCARD Error Code
1429 */
1430 uint32_t HAL_SMARTCARD_GetError(SMARTCARD_HandleTypeDef *hsc)
1431 {
1432 return hsc->ErrorCode;
1433 }
1434
1435 /**
1436 * @}
1437 */
1438
1439 /**
1440 * @brief DMA SMARTCARD transmit process complete callback
1441 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
1442 * the configuration information for the specified DMA module.
1443 * @retval None
1444 */
1445 static void SMARTCARD_DMATransmitCplt(DMA_HandleTypeDef *hdma)
1446 {
1447 SMARTCARD_HandleTypeDef* hsc = ( SMARTCARD_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
1448
1449 hsc->TxXferCount = 0U;
1450
1451 /* Disable the DMA transfer for transmit request by setting the DMAT bit
1452 in the USART CR3 register */
1453 CLEAR_BIT(hsc->Instance->CR3, USART_CR3_DMAT);
1454
1455 /* Enable the SMARTCARD Transmit Complete Interrupt */
1456 SET_BIT(hsc->Instance->CR1, USART_CR1_TCIE);
1457 }
1458
1459 /**
1460 * @brief DMA SMARTCARD receive process complete callback
1461 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
1462 * the configuration information for the specified DMA module.
1463 * @retval None
1464 */
1465 static void SMARTCARD_DMAReceiveCplt(DMA_HandleTypeDef *hdma)
1466 {
1467 SMARTCARD_HandleTypeDef* hsc = ( SMARTCARD_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
1468
1469 hsc->RxXferCount = 0U;
1470
1471 /* Disable RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts */
1472 CLEAR_BIT(hsc->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE));
1473 CLEAR_BIT(hsc->Instance->CR3, USART_CR3_EIE);
1474
1475 /* Disable the DMA transfer for the receiver request by setting the DMAR bit
1476 in the USART CR3 register */
1477 CLEAR_BIT(hsc->Instance->CR3, USART_CR3_DMAR);
1478
1479 /* At end of Rx process, restore hsc->RxState to Ready */
1480 hsc->RxState = HAL_SMARTCARD_STATE_READY;
1481
1482 HAL_SMARTCARD_RxCpltCallback(hsc);
1483 }
1484
1485 /**
1486 * @brief DMA SMARTCARD communication error callback
1487 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
1488 * the configuration information for the specified DMA module.
1489 * @retval None
1490 */
1491 static void SMARTCARD_DMAError(DMA_HandleTypeDef *hdma)
1492 {
1493 uint32_t dmarequest = 0x00U;
1494 SMARTCARD_HandleTypeDef* hsc = ( SMARTCARD_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
1495 hsc->RxXferCount = 0U;
1496 hsc->TxXferCount = 0U;
1497 hsc->ErrorCode = HAL_SMARTCARD_ERROR_DMA;
1498
1499 /* Stop SMARTCARD DMA Tx request if ongoing */
1500 dmarequest = HAL_IS_BIT_SET(hsc->Instance->CR3, USART_CR3_DMAT);
1501 if((hsc->gState == HAL_SMARTCARD_STATE_BUSY_TX) && dmarequest)
1502 {
1503 SMARTCARD_EndTxTransfer(hsc);
1504 }
1505
1506 /* Stop SMARTCARD DMA Rx request if ongoing */
1507 dmarequest = HAL_IS_BIT_SET(hsc->Instance->CR3, USART_CR3_DMAR);
1508 if((hsc->RxState == HAL_SMARTCARD_STATE_BUSY_RX) && dmarequest)
1509 {
1510 SMARTCARD_EndRxTransfer(hsc);
1511 }
1512
1513 HAL_SMARTCARD_ErrorCallback(hsc);
1514 }
1515
1516 /**
1517 * @brief This function handles SMARTCARD Communication Timeout.
1518 * @param hsc: SMARTCARD handle
1519 * @param Flag: specifies the SMARTCARD flag to check.
1520 * @param Status: The new Flag status (SET or RESET).
1521 * @param Timeout: Timeout duration
1522 * @param Tickstart: tick start value
1523 * @retval HAL status
1524 */
1525 static HAL_StatusTypeDef SMARTCARD_WaitOnFlagUntilTimeout(SMARTCARD_HandleTypeDef *hsc, uint32_t Flag, FlagStatus Status, uint32_t Tickstart, uint32_t Timeout)
1526 {
1527 /* Wait until flag is set */
1528 while((__HAL_SMARTCARD_GET_FLAG(hsc, Flag) ? SET : RESET) == Status)
1529 {
1530 /* Check for the Timeout */
1531 if(Timeout != HAL_MAX_DELAY)
1532 {
1533 if((Timeout == 0U)||((HAL_GetTick() - Tickstart ) > Timeout))
1534 {
1535 /* Disable TXE and RXNE interrupts for the interrupt process */
1536 CLEAR_BIT(hsc->Instance->CR1, USART_CR1_TXEIE);
1537 CLEAR_BIT(hsc->Instance->CR1, USART_CR1_RXNEIE);
1538
1539 hsc->gState= HAL_SMARTCARD_STATE_READY;
1540 hsc->RxState= HAL_SMARTCARD_STATE_READY;
1541
1542 /* Process Unlocked */
1543 __HAL_UNLOCK(hsc);
1544
1545 return HAL_TIMEOUT;
1546 }
1547 }
1548 }
1549 return HAL_OK;
1550 }
1551
1552 /**
1553 * @brief End ongoing Tx transfer on SMARTCARD peripheral (following error detection or Transmit completion).
1554 * @param hsc: SMARTCARD handle.
1555 * @retval None
1556 */
1557 static void SMARTCARD_EndTxTransfer(SMARTCARD_HandleTypeDef *hsc)
1558 {
1559 /* At end of Tx process, restore hsc->gState to Ready */
1560 hsc->gState = HAL_SMARTCARD_STATE_READY;
1561
1562 /* Disable TXEIE and TCIE interrupts */
1563 CLEAR_BIT(hsc->Instance->CR1, (USART_CR1_TXEIE | USART_CR1_TCIE));
1564 }
1565
1566
1567 /**
1568 * @brief End ongoing Rx transfer on SMARTCARD peripheral (following error detection or Reception completion).
1569 * @param hsc: SMARTCARD handle.
1570 * @retval None
1571 */
1572 static void SMARTCARD_EndRxTransfer(SMARTCARD_HandleTypeDef *hsc)
1573 {
1574 /* At end of Rx process, restore hsc->RxState to Ready */
1575 hsc->RxState = HAL_SMARTCARD_STATE_READY;
1576
1577 /* Disable RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts */
1578 CLEAR_BIT(hsc->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE));
1579 CLEAR_BIT(hsc->Instance->CR3, USART_CR3_EIE);
1580 }
1581
1582
1583
1584 /**
1585 * @brief DMA SMARTCARD communication abort callback, when initiated by HAL services on Error
1586 * (To be called at end of DMA Abort procedure following error occurrence).
1587 * @param hdma DMA handle.
1588 * @retval None
1589 */
1590 static void SMARTCARD_DMAAbortOnError(DMA_HandleTypeDef *hdma)
1591 {
1592 SMARTCARD_HandleTypeDef* hsc = (SMARTCARD_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
1593 hsc->RxXferCount = 0x00U;
1594 hsc->TxXferCount = 0x00U;
1595
1596 HAL_SMARTCARD_ErrorCallback(hsc);
1597 }
1598
1599 /**
1600 * @brief DMA SMARTCARD Tx communication abort callback, when initiated by user
1601 * (To be called at end of DMA Tx Abort procedure following user abort request).
1602 * @note When this callback is executed, User Abort complete call back is called only if no
1603 * Abort still ongoing for Rx DMA Handle.
1604 * @param hdma DMA handle.
1605 * @retval None
1606 */
1607 static void SMARTCARD_DMATxAbortCallback(DMA_HandleTypeDef *hdma)
1608 {
1609 SMARTCARD_HandleTypeDef* hsc = ( SMARTCARD_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
1610
1611 hsc->hdmatx->XferAbortCallback = NULL;
1612
1613 /* Check if an Abort process is still ongoing */
1614 if(hsc->hdmarx != NULL)
1615 {
1616 if(hsc->hdmarx->XferAbortCallback != NULL)
1617 {
1618 return;
1619 }
1620 }
1621
1622 /* No Abort process still ongoing : All DMA channels are aborted, call user Abort Complete callback */
1623 hsc->TxXferCount = 0x00U;
1624 hsc->RxXferCount = 0x00U;
1625
1626 /* Reset ErrorCode */
1627 hsc->ErrorCode = HAL_SMARTCARD_ERROR_NONE;
1628
1629 /* Restore hsc->gState and hsc->RxState to Ready */
1630 hsc->gState = HAL_SMARTCARD_STATE_READY;
1631 hsc->RxState = HAL_SMARTCARD_STATE_READY;
1632
1633 /* Call user Abort complete callback */
1634 HAL_SMARTCARD_AbortCpltCallback(hsc);
1635 }
1636
1637 /**
1638 * @brief DMA SMARTCARD Rx communication abort callback, when initiated by user
1639 * (To be called at end of DMA Rx Abort procedure following user abort request).
1640 * @note When this callback is executed, User Abort complete call back is called only if no
1641 * Abort still ongoing for Tx DMA Handle.
1642 * @param hdma DMA handle.
1643 * @retval None
1644 */
1645 static void SMARTCARD_DMARxAbortCallback(DMA_HandleTypeDef *hdma)
1646 {
1647 SMARTCARD_HandleTypeDef* hsc = ( SMARTCARD_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
1648
1649 hsc->hdmarx->XferAbortCallback = NULL;
1650
1651 /* Check if an Abort process is still ongoing */
1652 if(hsc->hdmatx != NULL)
1653 {
1654 if(hsc->hdmatx->XferAbortCallback != NULL)
1655 {
1656 return;
1657 }
1658 }
1659
1660 /* No Abort process still ongoing : All DMA channels are aborted, call user Abort Complete callback */
1661 hsc->TxXferCount = 0x00U;
1662 hsc->RxXferCount = 0x00U;
1663
1664 /* Reset ErrorCode */
1665 hsc->ErrorCode = HAL_SMARTCARD_ERROR_NONE;
1666
1667 /* Restore hsc->gState and hsc->RxState to Ready */
1668 hsc->gState = HAL_SMARTCARD_STATE_READY;
1669 hsc->RxState = HAL_SMARTCARD_STATE_READY;
1670
1671 /* Call user Abort complete callback */
1672 HAL_SMARTCARD_AbortCpltCallback(hsc);
1673 }
1674
1675 /**
1676 * @brief DMA SMARTCARD Tx communication abort callback, when initiated by user by a call to
1677 * HAL_SMARTCARD_AbortTransmit_IT API (Abort only Tx transfer)
1678 * (This callback is executed at end of DMA Tx Abort procedure following user abort request,
1679 * and leads to user Tx Abort Complete callback execution).
1680 * @param hdma DMA handle.
1681 * @retval None
1682 */
1683 static void SMARTCARD_DMATxOnlyAbortCallback(DMA_HandleTypeDef *hdma)
1684 {
1685 SMARTCARD_HandleTypeDef* hsc = ( SMARTCARD_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
1686
1687 hsc->TxXferCount = 0x00U;
1688
1689 /* Restore hsc->gState to Ready */
1690 hsc->gState = HAL_SMARTCARD_STATE_READY;
1691
1692 /* Call user Abort complete callback */
1693 HAL_SMARTCARD_AbortTransmitCpltCallback(hsc);
1694 }
1695
1696 /**
1697 * @brief DMA SMARTCARD Rx communication abort callback, when initiated by user by a call to
1698 * HAL_SMARTCARD_AbortReceive_IT API (Abort only Rx transfer)
1699 * (This callback is executed at end of DMA Rx Abort procedure following user abort request,
1700 * and leads to user Rx Abort Complete callback execution).
1701 * @param hdma DMA handle.
1702 * @retval None
1703 */
1704 static void SMARTCARD_DMARxOnlyAbortCallback(DMA_HandleTypeDef *hdma)
1705 {
1706 SMARTCARD_HandleTypeDef* hsc = ( SMARTCARD_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
1707
1708 hsc->RxXferCount = 0x00U;
1709
1710 /* Restore hsc->RxState to Ready */
1711 hsc->RxState = HAL_SMARTCARD_STATE_READY;
1712
1713 /* Call user Abort complete callback */
1714 HAL_SMARTCARD_AbortReceiveCpltCallback(hsc);
1715 }
1716
1717 /**
1718 * @brief Send an amount of data in non blocking mode
1719 * @param hsc: pointer to a SMARTCARD_HandleTypeDef structure that contains
1720 * the configuration information for SMARTCARD module.
1721 * @retval HAL status
1722 */
1723 static HAL_StatusTypeDef SMARTCARD_Transmit_IT(SMARTCARD_HandleTypeDef *hsc)
1724 {
1725 uint16_t* tmp;
1726
1727 /* Check that a Tx process is ongoing */
1728 if(hsc->gState == HAL_SMARTCARD_STATE_BUSY_TX)
1729 {
1730 tmp = (uint16_t*) hsc->pTxBuffPtr;
1731 hsc->Instance->DR = (uint16_t)(*tmp & (uint16_t)0x01FF);
1732 hsc->pTxBuffPtr += 1U;
1733
1734 if(--hsc->TxXferCount == 0U)
1735 {
1736 /* Disable the SMARTCARD Transmit data register empty Interrupt */
1737 CLEAR_BIT(hsc->Instance->CR1, USART_CR1_TXEIE);
1738
1739 /* Enable the SMARTCARD Transmit Complete Interrupt */
1740 SET_BIT(hsc->Instance->CR1, USART_CR1_TCIE);
1741 }
1742
1743 return HAL_OK;
1744 }
1745 else
1746 {
1747 return HAL_BUSY;
1748 }
1749 }
1750
1751 /**
1752 * @brief Wraps up transmission in non blocking mode.
1753 * @param hsmartcard: pointer to a SMARTCARD_HandleTypeDef structure that contains
1754 * the configuration information for the specified SMARTCARD module.
1755 * @retval HAL status
1756 */
1757 static HAL_StatusTypeDef SMARTCARD_EndTransmit_IT(SMARTCARD_HandleTypeDef *hsmartcard)
1758 {
1759 /* Disable the SMARTCARD Transmit Complete Interrupt */
1760 CLEAR_BIT(hsmartcard->Instance->CR1, USART_CR1_TCIE);
1761
1762 /* Disable the SMARTCARD Error Interrupt: (Frame error, noise error, overrun error) */
1763 CLEAR_BIT(hsmartcard->Instance->CR3, USART_CR3_EIE);
1764
1765 /* Tx process is ended, restore hsmartcard->gState to Ready */
1766 hsmartcard->gState = HAL_SMARTCARD_STATE_READY;
1767
1768 HAL_SMARTCARD_TxCpltCallback(hsmartcard);
1769
1770 return HAL_OK;
1771 }
1772
1773 /**
1774 * @brief Receive an amount of data in non blocking mode
1775 * @param hsc: pointer to a SMARTCARD_HandleTypeDef structure that contains
1776 * the configuration information for SMARTCARD module.
1777 * @retval HAL status
1778 */
1779 static HAL_StatusTypeDef SMARTCARD_Receive_IT(SMARTCARD_HandleTypeDef *hsc)
1780 {
1781 uint16_t* tmp;
1782
1783 /* Check that a Rx process is ongoing */
1784 if(hsc->RxState == HAL_SMARTCARD_STATE_BUSY_RX)
1785 {
1786 tmp = (uint16_t*) hsc->pRxBuffPtr;
1787 *tmp = (uint8_t)(hsc->Instance->DR & (uint8_t)0x00FF);
1788 hsc->pRxBuffPtr += 1U;
1789
1790 if(--hsc->RxXferCount == 0U)
1791 {
1792 CLEAR_BIT(hsc->Instance->CR1, USART_CR1_RXNEIE);
1793
1794 /* Disable the SMARTCARD Parity Error Interrupt */
1795 CLEAR_BIT(hsc->Instance->CR1, USART_CR1_PEIE);
1796
1797 /* Disable the SMARTCARD Error Interrupt: (Frame error, noise error, overrun error) */
1798 CLEAR_BIT(hsc->Instance->CR3, USART_CR3_EIE);
1799
1800 /* Rx process is completed, restore hsc->RxState to Ready */
1801 hsc->RxState = HAL_SMARTCARD_STATE_READY;
1802
1803 HAL_SMARTCARD_RxCpltCallback(hsc);
1804
1805 return HAL_OK;
1806 }
1807 return HAL_OK;
1808 }
1809 else
1810 {
1811 return HAL_BUSY;
1812 }
1813 }
1814
1815 /**
1816 * @brief Configure the SMARTCARD peripheral
1817 * @param hsc: pointer to a SMARTCARD_HandleTypeDef structure that contains
1818 * the configuration information for SMARTCARD module.
1819 * @retval None
1820 */
1821 static void SMARTCARD_SetConfig(SMARTCARD_HandleTypeDef *hsc)
1822 {
1823 uint32_t tmpreg = 0x00U;
1824
1825 /* Check the parameters */
1826 assert_param(IS_SMARTCARD_INSTANCE(hsc->Instance));
1827 assert_param(IS_SMARTCARD_POLARITY(hsc->Init.CLKPolarity));
1828 assert_param(IS_SMARTCARD_PHASE(hsc->Init.CLKPhase));
1829 assert_param(IS_SMARTCARD_LASTBIT(hsc->Init.CLKLastBit));
1830 assert_param(IS_SMARTCARD_BAUDRATE(hsc->Init.BaudRate));
1831 assert_param(IS_SMARTCARD_WORD_LENGTH(hsc->Init.WordLength));
1832 assert_param(IS_SMARTCARD_STOPBITS(hsc->Init.StopBits));
1833 assert_param(IS_SMARTCARD_PARITY(hsc->Init.Parity));
1834 assert_param(IS_SMARTCARD_MODE(hsc->Init.Mode));
1835 assert_param(IS_SMARTCARD_NACK_STATE(hsc->Init.NACKState));
1836
1837
1838 /* The LBCL, CPOL and CPHA bits have to be selected when both the transmitter and the
1839 receiver are disabled (TE=RE=0) to ensure that the clock pulses function correctly. */
1840 CLEAR_BIT(hsc->Instance->CR1, (USART_CR1_TE | USART_CR1_RE));
1841
1842 /*---------------------------- USART CR2 Configuration ---------------------*/
1843 tmpreg = hsc->Instance->CR2;
1844 /* Clear CLKEN, CPOL, CPHA and LBCL bits */
1845 tmpreg &= (uint32_t)~((uint32_t)(USART_CR2_CPHA | USART_CR2_CPOL | USART_CR2_CLKEN | USART_CR2_LBCL));
1846 /* Configure the SMARTCARD Clock, CPOL, CPHA and LastBit -----------------------*/
1847 /* Set CPOL bit according to hsc->Init.CLKPolarity value */
1848 /* Set CPHA bit according to hsc->Init.CLKPhase value */
1849 /* Set LBCL bit according to hsc->Init.CLKLastBit value */
1850 /* Set Stop Bits: Set STOP[13:12] bits according to hsc->Init.StopBits value */
1851 tmpreg |= (uint32_t)(USART_CR2_CLKEN | hsc->Init.CLKPolarity |
1852 hsc->Init.CLKPhase| hsc->Init.CLKLastBit | hsc->Init.StopBits);
1853 /* Write to USART CR2 */
1854 WRITE_REG(hsc->Instance->CR2, (uint32_t)tmpreg);
1855
1856 tmpreg = hsc->Instance->CR2;
1857
1858 /* Clear STOP[13:12] bits */
1859 tmpreg &= (uint32_t)~((uint32_t)USART_CR2_STOP);
1860
1861 /* Set Stop Bits: Set STOP[13:12] bits according to hsc->Init.StopBits value */
1862 tmpreg |= (uint32_t)(hsc->Init.StopBits);
1863
1864 /* Write to USART CR2 */
1865 WRITE_REG(hsc->Instance->CR2, (uint32_t)tmpreg);
1866
1867 /*-------------------------- USART CR1 Configuration -----------------------*/
1868 tmpreg = hsc->Instance->CR1;
1869
1870 /* Clear M, PCE, PS, TE and RE bits */
1871 tmpreg &= (uint32_t)~((uint32_t)(USART_CR1_M | USART_CR1_PCE | USART_CR1_PS | USART_CR1_TE | \
1872 USART_CR1_RE));
1873
1874 /* Configure the SMARTCARD Word Length, Parity and mode:
1875 Set the M bits according to hsc->Init.WordLength value
1876 Set PCE and PS bits according to hsc->Init.Parity value
1877 Set TE and RE bits according to hsc->Init.Mode value */
1878 tmpreg |= (uint32_t)hsc->Init.WordLength | hsc->Init.Parity | hsc->Init.Mode;
1879
1880 /* Write to USART CR1 */
1881 WRITE_REG(hsc->Instance->CR1, (uint32_t)tmpreg);
1882
1883 /*-------------------------- USART CR3 Configuration -----------------------*/
1884 /* Clear CTSE and RTSE bits */
1885 CLEAR_BIT(hsc->Instance->CR3, (USART_CR3_RTSE | USART_CR3_CTSE));
1886
1887 /*-------------------------- USART BRR Configuration -----------------------*/
1888
1889 if(hsc->Instance == USART1)
1890 {
1891 hsc->Instance->BRR = SMARTCARD_BRR(HAL_RCC_GetPCLK2Freq(), hsc->Init.BaudRate);
1892 }
1893 else
1894 {
1895 hsc->Instance->BRR = SMARTCARD_BRR(HAL_RCC_GetPCLK1Freq(), hsc->Init.BaudRate);
1896 }
1897 }
1898
1899 /**
1900 * @}
1901 */
1902
1903 #endif /* HAL_SMARTCARD_MODULE_ENABLED */
1904 /**
1905 * @}
1906 */
1907
1908 /**
1909 * @}
1910 */
1911
1912 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/