Subversion Repositories ScreenTimer

/**

  ******************************************************************************

  * @file    stm32f0xx_hal_smartcard.c

  * @author  MCD Application Team

  * @brief   SMARTCARD HAL module driver.

  *          This file provides firmware functions to manage the following

  *          functionalities of the SMARTCARD peripheral:

  *           + Initialization and de-initialization functions

  *           + IO operation functions

  *           + Peripheral Control functions

  *           + Peripheral State and Error functions

  *

  @verbatim

  ==============================================================================

                        ##### How to use this driver #####

  ==============================================================================

  [..]

    The SMARTCARD HAL driver can be used as follows:

    (#) Declare a SMARTCARD_HandleTypeDef handle structure (eg. SMARTCARD_HandleTypeDef hsmartcard).

    (#) Associate a USART to the SMARTCARD handle hsmartcard.

    (#) Initialize the SMARTCARD low level resources by implementing the HAL_SMARTCARD_MspInit() API:

        (++) Enable the USARTx interface clock.

        (++) USART pins configuration:

             (+++) Enable the clock for the USART GPIOs.

             (+++) Configure the USART pins (TX as alternate function pull-up, RX as alternate function Input).

        (++) NVIC configuration if you need to use interrupt process (HAL_SMARTCARD_Transmit_IT()

             and HAL_SMARTCARD_Receive_IT() APIs):

             (+++) Configure the USARTx interrupt priority.

             (+++) Enable the NVIC USART IRQ handle.

        (++) DMA Configuration if you need to use DMA process (HAL_SMARTCARD_Transmit_DMA()

             and HAL_SMARTCARD_Receive_DMA() APIs):

             (+++) Declare a DMA handle structure for the Tx/Rx channel.

             (+++) Enable the DMAx interface clock.

             (+++) Configure the declared DMA handle structure with the required Tx/Rx parameters.

             (+++) Configure the DMA Tx/Rx channel.

             (+++) Associate the initialized DMA handle to the SMARTCARD DMA Tx/Rx handle.

             (+++) Configure the priority and enable the NVIC for the transfer complete

                   interrupt on the DMA Tx/Rx channel.

    (#) Program the Baud Rate, Parity, Mode(Receiver/Transmitter), clock enabling/disabling and accordingly,

        the clock parameters (parity, phase, last bit), prescaler value, guard time and NACK on transmission

        error enabling or disabling in the hsmartcard handle Init structure.

    (#) If required, program SMARTCARD advanced features (TX/RX pins swap, TimeOut, auto-retry counter,...)

        in the hsmartcard handle AdvancedInit structure.

    (#) Initialize the SMARTCARD registers by calling the HAL_SMARTCARD_Init() API:

        (++) This API configures also the low level Hardware GPIO, CLOCK, CORTEX...etc)

             by calling the customized HAL_SMARTCARD_MspInit() API.

        [..]

        (@) The specific SMARTCARD interrupts (Transmission complete interrupt,

             RXNE interrupt and Error Interrupts) will be managed using the macros

             __HAL_SMARTCARD_ENABLE_IT() and __HAL_SMARTCARD_DISABLE_IT() inside the transmit and receive process.

    [..]

    [..] Three operation modes are available within this driver :

     *** Polling mode IO operation ***

     =================================

     [..]

       (+) Send an amount of data in blocking mode using HAL_SMARTCARD_Transmit()

       (+) Receive an amount of data in blocking mode using HAL_SMARTCARD_Receive()

     *** Interrupt mode IO operation ***

     ===================================

     [..]

       (+) Send an amount of data in non-blocking mode using HAL_SMARTCARD_Transmit_IT()

       (+) At transmission end of transfer HAL_SMARTCARD_TxCpltCallback() is executed and user can

            add his own code by customization of function pointer HAL_SMARTCARD_TxCpltCallback()

       (+) Receive an amount of data in non-blocking mode using HAL_SMARTCARD_Receive_IT()

       (+) At reception end of transfer HAL_SMARTCARD_RxCpltCallback() is executed and user can

            add his own code by customization of function pointer HAL_SMARTCARD_RxCpltCallback()

       (+) In case of transfer Error, HAL_SMARTCARD_ErrorCallback() function is executed and user can

            add his own code by customization of function pointer HAL_SMARTCARD_ErrorCallback()

     *** DMA mode IO operation ***

     ==============================

     [..]

       (+) Send an amount of data in non-blocking mode (DMA) using HAL_SMARTCARD_Transmit_DMA()

       (+) At transmission end of transfer HAL_SMARTCARD_TxCpltCallback() is executed and user can

            add his own code by customization of function pointer HAL_SMARTCARD_TxCpltCallback()

       (+) Receive an amount of data in non-blocking mode (DMA) using HAL_SMARTCARD_Receive_DMA()

       (+) At reception end of transfer HAL_SMARTCARD_RxCpltCallback() is executed and user can

            add his own code by customization of function pointer HAL_SMARTCARD_RxCpltCallback()

       (+) In case of transfer Error, HAL_SMARTCARD_ErrorCallback() function is executed and user can

            add his own code by customization of function pointer HAL_SMARTCARD_ErrorCallback()

     *** SMARTCARD HAL driver macros list ***

     ========================================

     [..]

       Below the list of most used macros in SMARTCARD HAL driver.

       (+) __HAL_SMARTCARD_GET_FLAG : Check whether or not the specified SMARTCARD flag is set

       (+) __HAL_SMARTCARD_CLEAR_FLAG : Clear the specified SMARTCARD pending flag

       (+) __HAL_SMARTCARD_ENABLE_IT: Enable the specified SMARTCARD interrupt

       (+) __HAL_SMARTCARD_DISABLE_IT: Disable the specified SMARTCARD interrupt

       (+) __HAL_SMARTCARD_GET_IT_SOURCE: Check whether or not the specified SMARTCARD interrupt is enabled

     [..]

       (@) You can refer to the SMARTCARD HAL driver header file for more useful macros

    ##### Callback registration #####

    ==================================

    [..]

    The compilation define USE_HAL_SMARTCARD_REGISTER_CALLBACKS when set to 1

    allows the user to configure dynamically the driver callbacks.

    [..]

    Use Function HAL_SMARTCARD_RegisterCallback() to register a user callback.

    Function HAL_SMARTCARD_RegisterCallback() allows to register following callbacks:

    (+) TxCpltCallback            : Tx Complete Callback.

    (+) RxCpltCallback            : Rx Complete Callback.

    (+) ErrorCallback             : Error Callback.

    (+) AbortCpltCallback         : Abort Complete Callback.

    (+) AbortTransmitCpltCallback : Abort Transmit Complete Callback.

    (+) AbortReceiveCpltCallback  : Abort Receive Complete Callback.

    (+) MspInitCallback           : SMARTCARD MspInit.

    (+) MspDeInitCallback         : SMARTCARD MspDeInit.

    This function takes as parameters the HAL peripheral handle, the Callback ID

    and a pointer to the user callback function.

    [..]

    Use function HAL_SMARTCARD_UnRegisterCallback() to reset a callback to the default

    weak (surcharged) function.

    HAL_SMARTCARD_UnRegisterCallback() takes as parameters the HAL peripheral handle,

    and the Callback ID.

    This function allows to reset following callbacks:

    (+) TxCpltCallback            : Tx Complete Callback.

    (+) RxCpltCallback            : Rx Complete Callback.

    (+) ErrorCallback             : Error Callback.

    (+) AbortCpltCallback         : Abort Complete Callback.

    (+) AbortTransmitCpltCallback : Abort Transmit Complete Callback.

    (+) AbortReceiveCpltCallback  : Abort Receive Complete Callback.

    (+) MspInitCallback           : SMARTCARD MspInit.

    (+) MspDeInitCallback         : SMARTCARD MspDeInit.

    [..]

    By default, after the HAL_SMARTCARD_Init() and when the state is HAL_SMARTCARD_STATE_RESET

    all callbacks are set to the corresponding weak (surcharged) functions:

    examples HAL_SMARTCARD_TxCpltCallback(), HAL_SMARTCARD_RxCpltCallback().

    Exception done for MspInit and MspDeInit functions that are respectively

    reset to the legacy weak (surcharged) functions in the HAL_SMARTCARD_Init()

    and HAL_SMARTCARD_DeInit() only when these callbacks are null (not registered beforehand).

    If not, MspInit or MspDeInit are not null, the HAL_SMARTCARD_Init() and HAL_SMARTCARD_DeInit()

    keep and use the user MspInit/MspDeInit callbacks (registered beforehand).

    [..]

    Callbacks can be registered/unregistered in HAL_SMARTCARD_STATE_READY state only.

    Exception done MspInit/MspDeInit that can be registered/unregistered

    in HAL_SMARTCARD_STATE_READY or HAL_SMARTCARD_STATE_RESET state, thus registered (user)

    MspInit/DeInit callbacks can be used during the Init/DeInit.

    In that case first register the MspInit/MspDeInit user callbacks

    using HAL_SMARTCARD_RegisterCallback() before calling HAL_SMARTCARD_DeInit()

    or HAL_SMARTCARD_Init() function.

    [..]

    When The compilation define USE_HAL_SMARTCARD_REGISTER_CALLBACKS is set to 0 or

    not defined, the callback registration feature is not available

    and weak (surcharged) callbacks are used.

  @endverbatim

  ******************************************************************************

  * @attention

  *

  * <h2><center>&copy; Copyright (c) 2016 STMicroelectronics.

  * All rights reserved.</center></h2>

  *

  * This software component is licensed by ST under BSD 3-Clause license,

  * the "License"; You may not use this file except in compliance with the

  * License. You may obtain a copy of the License at:

  *                        opensource.org/licenses/BSD-3-Clause

  *

  ******************************************************************************

  */

#if !defined(STM32F030x6) && !defined(STM32F030x8) && !defined(STM32F070x6) && !defined(STM32F070xB) && !defined(STM32F030xC)

/* Includes ------------------------------------------------------------------*/

#include "stm32f0xx_hal.h"

/** @addtogroup STM32F0xx_HAL_Driver

  * @{

  */

/** @defgroup SMARTCARD SMARTCARD

  * @brief HAL SMARTCARD module driver

  * @{

  */

#ifdef HAL_SMARTCARD_MODULE_ENABLED

/* Private typedef -----------------------------------------------------------*/

/* Private define ------------------------------------------------------------*/

/** @defgroup SMARTCARD_Private_Constants SMARTCARD Private Constants

  * @{

  */

#define SMARTCARD_TEACK_REACK_TIMEOUT  1000U       /*!< SMARTCARD TX or RX enable acknowledge time-out value */

#define USART_CR1_FIELDS  ((uint32_t)(USART_CR1_M | USART_CR1_PCE | USART_CR1_PS | USART_CR1_TE | \

                                        USART_CR1_RE | USART_CR1_OVER8)) /*!< USART CR1 fields of parameters set by SMARTCARD_SetConfig API */

#define USART_CR2_CLK_FIELDS  ((uint32_t)(USART_CR2_CLKEN | USART_CR2_CPOL | \

                                          USART_CR2_CPHA | USART_CR2_LBCL)) /*!< SMARTCARD clock-related USART CR2 fields of parameters */

#define USART_CR2_FIELDS  ((uint32_t)(USART_CR2_RTOEN | USART_CR2_CLK_FIELDS | \

                                      USART_CR2_STOP)) /*!< USART CR2 fields of parameters set by SMARTCARD_SetConfig API */

#define USART_CR3_FIELDS  ((uint32_t)(USART_CR3_ONEBIT | USART_CR3_NACK | \

                                      USART_CR3_SCARCNT)) /*!< USART CR3 fields of parameters set by SMARTCARD_SetConfig API */

#define USART_BRR_MIN  0x10U        /*!< USART BRR minimum authorized value */

#define USART_BRR_MAX  0x0000FFFFU  /*!< USART BRR maximum authorized value */

/**

  * @}

  */

/* Private macros ------------------------------------------------------------*/

/* Private variables ---------------------------------------------------------*/

/* Private function prototypes -----------------------------------------------*/

/** @addtogroup SMARTCARD_Private_Functions

  * @{

  */

#if (USE_HAL_SMARTCARD_REGISTER_CALLBACKS == 1)

void SMARTCARD_InitCallbacksToDefault(SMARTCARD_HandleTypeDef *hsmartcard);

#endif /* USE_HAL_SMARTCARD_REGISTER_CALLBACKS */

static HAL_StatusTypeDef SMARTCARD_SetConfig(SMARTCARD_HandleTypeDef *hsmartcard);

static void SMARTCARD_AdvFeatureConfig(SMARTCARD_HandleTypeDef *hsmartcard);

static HAL_StatusTypeDef SMARTCARD_CheckIdleState(SMARTCARD_HandleTypeDef *hsmartcard);

static HAL_StatusTypeDef SMARTCARD_WaitOnFlagUntilTimeout(SMARTCARD_HandleTypeDef *hsmartcard, uint32_t Flag,

                                                          FlagStatus Status, uint32_t Tickstart, uint32_t Timeout);

static void SMARTCARD_EndTxTransfer(SMARTCARD_HandleTypeDef *hsmartcard);

static void SMARTCARD_EndRxTransfer(SMARTCARD_HandleTypeDef *hsmartcard);

static void SMARTCARD_DMATransmitCplt(DMA_HandleTypeDef *hdma);

static void SMARTCARD_DMAReceiveCplt(DMA_HandleTypeDef *hdma);

static void SMARTCARD_DMAError(DMA_HandleTypeDef *hdma);

static void SMARTCARD_DMAAbortOnError(DMA_HandleTypeDef *hdma);

static void SMARTCARD_DMATxAbortCallback(DMA_HandleTypeDef *hdma);

static void SMARTCARD_DMARxAbortCallback(DMA_HandleTypeDef *hdma);

static void SMARTCARD_DMATxOnlyAbortCallback(DMA_HandleTypeDef *hdma);

static void SMARTCARD_DMARxOnlyAbortCallback(DMA_HandleTypeDef *hdma);

static void SMARTCARD_TxISR(SMARTCARD_HandleTypeDef *hsmartcard);

static void SMARTCARD_EndTransmit_IT(SMARTCARD_HandleTypeDef *hsmartcard);

static void SMARTCARD_RxISR(SMARTCARD_HandleTypeDef *hsmartcard);

/**

  * @}

  */

/* Exported functions --------------------------------------------------------*/

/** @defgroup SMARTCARD_Exported_Functions SMARTCARD Exported Functions

  * @{

  */

/** @defgroup SMARTCARD_Exported_Functions_Group1 Initialization and de-initialization functions

  * @brief    Initialization and Configuration functions

  *

@verbatim

  ==============================================================================

              ##### Initialization and Configuration functions #####

  ==============================================================================

  [..]

  This subsection provides a set of functions allowing to initialize the USARTx

  associated to the SmartCard.

  (+) These parameters can be configured:

      (++) Baud Rate

      (++) Parity: parity should be enabled, frame Length is fixed to 8 bits plus parity

      (++) Receiver/transmitter modes

      (++) Synchronous mode (and if enabled, phase, polarity and last bit parameters)

      (++) Prescaler value

      (++) Guard bit time

      (++) NACK enabling or disabling on transmission error

  (+) The following advanced features can be configured as well:

      (++) TX and/or RX pin level inversion

      (++) data logical level inversion

      (++) RX and TX pins swap

      (++) RX overrun detection disabling

      (++) DMA disabling on RX error

      (++) MSB first on communication line

      (++) Time out enabling (and if activated, timeout value)

      (++) Block length

      (++) Auto-retry counter

  [..]

  The HAL_SMARTCARD_Init() API follows the USART synchronous configuration procedures

  (details for the procedures are available in reference manual).

@endverbatim

  The USART frame format is given in the following table:

    Table 1. USART frame format.

    +---------------------------------------------------------------+

    | M1M0 bits |  PCE bit  |            USART frame                |

    |-----------------------|---------------------------------------|

    |     01    |    1      |    | SB | 8 bit data | PB | STB |     |

    +---------------------------------------------------------------+

  * @{

  */

/**

  * @brief  Initialize the SMARTCARD mode according to the specified

  *         parameters in the SMARTCARD_HandleTypeDef and initialize the associated handle.

  * @param  hsmartcard Pointer to a SMARTCARD_HandleTypeDef structure that contains

  *                    the configuration information for the specified SMARTCARD module.

  * @retval HAL status

  */

HAL_StatusTypeDef HAL_SMARTCARD_Init(SMARTCARD_HandleTypeDef *hsmartcard)

{

  /* Check the SMARTCARD handle allocation */

  if (hsmartcard == NULL)

  {

    return HAL_ERROR;

  }

  /* Check the USART associated to the SMARTCARD handle */

  assert_param(IS_SMARTCARD_INSTANCE(hsmartcard->Instance));

  if (hsmartcard->gState == HAL_SMARTCARD_STATE_RESET)

  {

    /* Allocate lock resource and initialize it */

    hsmartcard->Lock = HAL_UNLOCKED;

#if USE_HAL_SMARTCARD_REGISTER_CALLBACKS == 1

    SMARTCARD_InitCallbacksToDefault(hsmartcard);

    if (hsmartcard->MspInitCallback == NULL)

    {

      hsmartcard->MspInitCallback = HAL_SMARTCARD_MspInit;

    }

    /* Init the low level hardware */

    hsmartcard->MspInitCallback(hsmartcard);

#else

    /* Init the low level hardware : GPIO, CLOCK */

    HAL_SMARTCARD_MspInit(hsmartcard);

#endif /* USE_HAL_SMARTCARD_REGISTER_CALLBACKS */

  }

  hsmartcard->gState = HAL_SMARTCARD_STATE_BUSY;

  /* Disable the Peripheral to set smartcard mode */

  CLEAR_BIT(hsmartcard->Instance->CR1, USART_CR1_UE);

  /* In SmartCard mode, the following bits must be kept cleared:

  - LINEN in the USART_CR2 register,

  - HDSEL and IREN  bits in the USART_CR3 register.*/

  CLEAR_BIT(hsmartcard->Instance->CR2, USART_CR2_LINEN);

  CLEAR_BIT(hsmartcard->Instance->CR3, (USART_CR3_HDSEL | USART_CR3_IREN));

  /* set the USART in SMARTCARD mode */

  SET_BIT(hsmartcard->Instance->CR3, USART_CR3_SCEN);

  /* Set the SMARTCARD Communication parameters */

  if (SMARTCARD_SetConfig(hsmartcard) == HAL_ERROR)

  {

    return HAL_ERROR;

  }

  /* Set the SMARTCARD transmission completion indication */

  SMARTCARD_TRANSMISSION_COMPLETION_SETTING(hsmartcard);

  if (hsmartcard->AdvancedInit.AdvFeatureInit != SMARTCARD_ADVFEATURE_NO_INIT)

  {

    SMARTCARD_AdvFeatureConfig(hsmartcard);

  }

  /* Enable the Peripheral */

  SET_BIT(hsmartcard->Instance->CR1, USART_CR1_UE);

  /* TEACK and/or REACK to check before moving hsmartcard->gState and hsmartcard->RxState to Ready */

  return (SMARTCARD_CheckIdleState(hsmartcard));

}

/**

  * @brief  DeInitialize the SMARTCARD peripheral.

  * @param  hsmartcard Pointer to a SMARTCARD_HandleTypeDef structure that contains

  *                    the configuration information for the specified SMARTCARD module.

  * @retval HAL status

  */

HAL_StatusTypeDef HAL_SMARTCARD_DeInit(SMARTCARD_HandleTypeDef *hsmartcard)

{

  /* Check the SMARTCARD handle allocation */

  if (hsmartcard == NULL)

  {

    return HAL_ERROR;

  }

  /* Check the USART/UART associated to the SMARTCARD handle */

  assert_param(IS_SMARTCARD_INSTANCE(hsmartcard->Instance));

  hsmartcard->gState = HAL_SMARTCARD_STATE_BUSY;

  /* Disable the Peripheral */

  CLEAR_BIT(hsmartcard->Instance->CR1, USART_CR1_UE);

  WRITE_REG(hsmartcard->Instance->CR1, 0x0U);

  WRITE_REG(hsmartcard->Instance->CR2, 0x0U);

  WRITE_REG(hsmartcard->Instance->CR3, 0x0U);

  WRITE_REG(hsmartcard->Instance->RTOR, 0x0U);

  WRITE_REG(hsmartcard->Instance->GTPR, 0x0U);

  /* DeInit the low level hardware */

#if USE_HAL_SMARTCARD_REGISTER_CALLBACKS == 1

  if (hsmartcard->MspDeInitCallback == NULL)

  {

    hsmartcard->MspDeInitCallback = HAL_SMARTCARD_MspDeInit;

  }

  /* DeInit the low level hardware */

  hsmartcard->MspDeInitCallback(hsmartcard);

#else

  HAL_SMARTCARD_MspDeInit(hsmartcard);

#endif /* USE_HAL_SMARTCARD_REGISTER_CALLBACKS */

  hsmartcard->ErrorCode = HAL_SMARTCARD_ERROR_NONE;

  hsmartcard->gState    = HAL_SMARTCARD_STATE_RESET;

  hsmartcard->RxState   = HAL_SMARTCARD_STATE_RESET;

  /* Process Unlock */

  __HAL_UNLOCK(hsmartcard);

  return HAL_OK;

}

/**

  * @brief  Initialize the SMARTCARD MSP.

  * @param  hsmartcard Pointer to a SMARTCARD_HandleTypeDef structure that contains

  *                    the configuration information for the specified SMARTCARD module.

  * @retval None

  */

__weak void HAL_SMARTCARD_MspInit(SMARTCARD_HandleTypeDef *hsmartcard)

{

  /* Prevent unused argument(s) compilation warning */

  UNUSED(hsmartcard);

  /* NOTE : This function should not be modified, when the callback is needed,

            the HAL_SMARTCARD_MspInit can be implemented in the user file

   */

}

/**

  * @brief  DeInitialize the SMARTCARD MSP.

  * @param  hsmartcard Pointer to a SMARTCARD_HandleTypeDef structure that contains

  *                    the configuration information for the specified SMARTCARD module.

  * @retval None

  */

__weak void HAL_SMARTCARD_MspDeInit(SMARTCARD_HandleTypeDef *hsmartcard)

{

  /* Prevent unused argument(s) compilation warning */

  UNUSED(hsmartcard);

  /* NOTE : This function should not be modified, when the callback is needed,

            the HAL_SMARTCARD_MspDeInit can be implemented in the user file

   */

}

#if (USE_HAL_SMARTCARD_REGISTER_CALLBACKS == 1)

/**

  * @brief  Register a User SMARTCARD Callback

  *         To be used instead of the weak predefined callback

  * @param  hsmartcard smartcard handle

  * @param  CallbackID ID of the callback to be registered

  *         This parameter can be one of the following values:

  *           @arg @ref HAL_SMARTCARD_TX_COMPLETE_CB_ID Tx Complete Callback ID

  *           @arg @ref HAL_SMARTCARD_RX_COMPLETE_CB_ID Rx Complete Callback ID

  *           @arg @ref HAL_SMARTCARD_ERROR_CB_ID Error Callback ID

  *           @arg @ref HAL_SMARTCARD_ABORT_COMPLETE_CB_ID Abort Complete Callback ID

  *           @arg @ref HAL_SMARTCARD_ABORT_TRANSMIT_COMPLETE_CB_ID Abort Transmit Complete Callback ID

  *           @arg @ref HAL_SMARTCARD_ABORT_RECEIVE_COMPLETE_CB_ID Abort Receive Complete Callback ID

  *           @arg @ref HAL_SMARTCARD_MSPINIT_CB_ID MspInit Callback ID

  *           @arg @ref HAL_SMARTCARD_MSPDEINIT_CB_ID MspDeInit Callback ID

  * @param  pCallback pointer to the Callback function

  * @retval HAL status

  */

HAL_StatusTypeDef HAL_SMARTCARD_RegisterCallback(SMARTCARD_HandleTypeDef *hsmartcard,

                                                 HAL_SMARTCARD_CallbackIDTypeDef CallbackID,

                                                 pSMARTCARD_CallbackTypeDef pCallback)

{

  HAL_StatusTypeDef status = HAL_OK;

  if (pCallback == NULL)

  {

    /* Update the error code */

    hsmartcard->ErrorCode |= HAL_SMARTCARD_ERROR_INVALID_CALLBACK;

    return HAL_ERROR;

  }

  /* Process locked */

  __HAL_LOCK(hsmartcard);

  if (hsmartcard->gState == HAL_SMARTCARD_STATE_READY)

  {

    switch (CallbackID)

    {

      case HAL_SMARTCARD_TX_COMPLETE_CB_ID :

        hsmartcard->TxCpltCallback = pCallback;

        break;

      case HAL_SMARTCARD_RX_COMPLETE_CB_ID :

        hsmartcard->RxCpltCallback = pCallback;

        break;

      case HAL_SMARTCARD_ERROR_CB_ID :

        hsmartcard->ErrorCallback = pCallback;

        break;

      case HAL_SMARTCARD_ABORT_COMPLETE_CB_ID :

        hsmartcard->AbortCpltCallback = pCallback;

        break;

      case HAL_SMARTCARD_ABORT_TRANSMIT_COMPLETE_CB_ID :

        hsmartcard->AbortTransmitCpltCallback = pCallback;

        break;

      case HAL_SMARTCARD_ABORT_RECEIVE_COMPLETE_CB_ID :

        hsmartcard->AbortReceiveCpltCallback = pCallback;

        break;

      case HAL_SMARTCARD_MSPINIT_CB_ID :

        hsmartcard->MspInitCallback = pCallback;

        break;

      case HAL_SMARTCARD_MSPDEINIT_CB_ID :

        hsmartcard->MspDeInitCallback = pCallback;

        break;

      default :

        /* Update the error code */

        hsmartcard->ErrorCode |= HAL_SMARTCARD_ERROR_INVALID_CALLBACK;

        /* Return error status */

        status =  HAL_ERROR;

        break;

    }

  }

  else if (hsmartcard->gState == HAL_SMARTCARD_STATE_RESET)

  {

    switch (CallbackID)

    {

      case HAL_SMARTCARD_MSPINIT_CB_ID :

        hsmartcard->MspInitCallback = pCallback;

        break;

      case HAL_SMARTCARD_MSPDEINIT_CB_ID :

        hsmartcard->MspDeInitCallback = pCallback;

        break;

      default :

        /* Update the error code */

        hsmartcard->ErrorCode |= HAL_SMARTCARD_ERROR_INVALID_CALLBACK;

        /* Return error status */

        status =  HAL_ERROR;

        break;

    }

  }

  else

  {

    /* Update the error code */

    hsmartcard->ErrorCode |= HAL_SMARTCARD_ERROR_INVALID_CALLBACK;

    /* Return error status */

    status =  HAL_ERROR;

  }

  /* Release Lock */

  __HAL_UNLOCK(hsmartcard);

  return status;

}

/**

  * @brief  Unregister an SMARTCARD callback

  *         SMARTCARD callback is redirected to the weak predefined callback

  * @param  hsmartcard smartcard handle

  * @param  CallbackID ID of the callback to be unregistered

  *         This parameter can be one of the following values:

  *           @arg @ref HAL_SMARTCARD_TX_COMPLETE_CB_ID Tx Complete Callback ID

  *           @arg @ref HAL_SMARTCARD_RX_COMPLETE_CB_ID Rx Complete Callback ID

  *           @arg @ref HAL_SMARTCARD_ERROR_CB_ID Error Callback ID

  *           @arg @ref HAL_SMARTCARD_ABORT_COMPLETE_CB_ID Abort Complete Callback ID

  *           @arg @ref HAL_SMARTCARD_ABORT_TRANSMIT_COMPLETE_CB_ID Abort Transmit Complete Callback ID

  *           @arg @ref HAL_SMARTCARD_ABORT_RECEIVE_COMPLETE_CB_ID Abort Receive Complete Callback ID

  *           @arg @ref HAL_SMARTCARD_MSPINIT_CB_ID MspInit Callback ID

  *           @arg @ref HAL_SMARTCARD_MSPDEINIT_CB_ID MspDeInit Callback ID

  * @retval HAL status

  */

HAL_StatusTypeDef HAL_SMARTCARD_UnRegisterCallback(SMARTCARD_HandleTypeDef *hsmartcard,

                                                   HAL_SMARTCARD_CallbackIDTypeDef CallbackID)

{

  HAL_StatusTypeDef status = HAL_OK;

  /* Process locked */

  __HAL_LOCK(hsmartcard);

  if (HAL_SMARTCARD_STATE_READY == hsmartcard->gState)

  {

    switch (CallbackID)

    {

      case HAL_SMARTCARD_TX_COMPLETE_CB_ID :

        hsmartcard->TxCpltCallback = HAL_SMARTCARD_TxCpltCallback;                 /* Legacy weak TxCpltCallback */

        break;

      case HAL_SMARTCARD_RX_COMPLETE_CB_ID :

        hsmartcard->RxCpltCallback = HAL_SMARTCARD_RxCpltCallback;                 /* Legacy weak RxCpltCallback */

        break;

      case HAL_SMARTCARD_ERROR_CB_ID :

        hsmartcard->ErrorCallback = HAL_SMARTCARD_ErrorCallback;                   /* Legacy weak ErrorCallback  */

        break;

      case HAL_SMARTCARD_ABORT_COMPLETE_CB_ID :

        hsmartcard->AbortCpltCallback = HAL_SMARTCARD_AbortCpltCallback;           /* Legacy weak AbortCpltCallback */

        break;

      case HAL_SMARTCARD_ABORT_TRANSMIT_COMPLETE_CB_ID :

        hsmartcard->AbortTransmitCpltCallback = HAL_SMARTCARD_AbortTransmitCpltCallback; /* Legacy weak

                                                                                            AbortTransmitCpltCallback*/

        break;

      case HAL_SMARTCARD_ABORT_RECEIVE_COMPLETE_CB_ID :

        hsmartcard->AbortReceiveCpltCallback = HAL_SMARTCARD_AbortReceiveCpltCallback;  /* Legacy weak

                                                                                           AbortReceiveCpltCallback */

        break;

      case HAL_SMARTCARD_MSPINIT_CB_ID :

        hsmartcard->MspInitCallback = HAL_SMARTCARD_MspInit;                       /* Legacy weak MspInitCallback  */

        break;

      case HAL_SMARTCARD_MSPDEINIT_CB_ID :

        hsmartcard->MspDeInitCallback = HAL_SMARTCARD_MspDeInit;                   /* Legacy weak MspDeInitCallback */

        break;

      default :

        /* Update the error code */

        hsmartcard->ErrorCode |= HAL_SMARTCARD_ERROR_INVALID_CALLBACK;

        /* Return error status */

        status =  HAL_ERROR;

        break;

    }

  }

  else if (HAL_SMARTCARD_STATE_RESET == hsmartcard->gState)

  {

    switch (CallbackID)

    {

      case HAL_SMARTCARD_MSPINIT_CB_ID :

        hsmartcard->MspInitCallback = HAL_SMARTCARD_MspInit;

        break;

      case HAL_SMARTCARD_MSPDEINIT_CB_ID :

        hsmartcard->MspDeInitCallback = HAL_SMARTCARD_MspDeInit;

        break;

      default :

        /* Update the error code */

        hsmartcard->ErrorCode |= HAL_SMARTCARD_ERROR_INVALID_CALLBACK;

        /* Return error status */

        status =  HAL_ERROR;

        break;

    }

  }

  else

  {

    /* Update the error code */

    hsmartcard->ErrorCode |= HAL_SMARTCARD_ERROR_INVALID_CALLBACK;

    /* Return error status */

    status =  HAL_ERROR;

  }

  /* Release Lock */

  __HAL_UNLOCK(hsmartcard);

  return status;

}

#endif /* USE_HAL_SMARTCARD_REGISTER_CALLBACKS */

/**

  * @}

  */

/** @defgroup SMARTCARD_Exported_Functions_Group2 IO operation functions

  * @brief    SMARTCARD Transmit and Receive functions

  *

@verbatim

  ==============================================================================

                         ##### IO operation functions #####

  ==============================================================================

  [..]

    This subsection provides a set of functions allowing to manage the SMARTCARD data transfers.

  [..]

    Smartcard is a single wire half duplex communication protocol.

    The Smartcard interface is designed to support asynchronous protocol Smartcards as

    defined in the ISO 7816-3 standard. The USART should be configured as:

    (+) 8 bits plus parity: where M=1 and PCE=1 in the USART_CR1 register

    (+) 1.5 stop bits when transmitting and receiving: where STOP=11 in the USART_CR2 register.

  [..]

    (#) There are two modes of transfer:

        (##) Blocking mode: The communication is performed in polling mode.

             The HAL status of all data processing is returned by the same function

             after finishing transfer.

        (##) Non-Blocking mode: The communication is performed using Interrupts

             or DMA, the relevant API's return the HAL status.

             The end of the data processing will be indicated through the

             dedicated SMARTCARD IRQ when using Interrupt mode or the DMA IRQ when

             using DMA mode.

        (##) The HAL_SMARTCARD_TxCpltCallback(), HAL_SMARTCARD_RxCpltCallback() user callbacks

             will be executed respectively at the end of the Transmit or Receive process

             The HAL_SMARTCARD_ErrorCallback() user callback will be executed when a communication

             error is detected.

    (#) Blocking mode APIs are :

        (##) HAL_SMARTCARD_Transmit()

        (##) HAL_SMARTCARD_Receive()

    (#) Non Blocking mode APIs with Interrupt are :

        (##) HAL_SMARTCARD_Transmit_IT()

        (##) HAL_SMARTCARD_Receive_IT()

        (##) HAL_SMARTCARD_IRQHandler()

    (#) Non Blocking mode functions with DMA are :

        (##) HAL_SMARTCARD_Transmit_DMA()

        (##) HAL_SMARTCARD_Receive_DMA()

    (#) A set of Transfer Complete Callbacks are provided in non Blocking mode:

        (##) HAL_SMARTCARD_TxCpltCallback()

        (##) HAL_SMARTCARD_RxCpltCallback()

        (##) HAL_SMARTCARD_ErrorCallback()

  [..]

    (#) Non-Blocking mode transfers could be aborted using Abort API's :

        (##) HAL_SMARTCARD_Abort()

        (##) HAL_SMARTCARD_AbortTransmit()

        (##) HAL_SMARTCARD_AbortReceive()

        (##) HAL_SMARTCARD_Abort_IT()

        (##) HAL_SMARTCARD_AbortTransmit_IT()

        (##) HAL_SMARTCARD_AbortReceive_IT()

    (#) For Abort services based on interrupts (HAL_SMARTCARD_Abortxxx_IT),

        a set of Abort Complete Callbacks are provided:

        (##) HAL_SMARTCARD_AbortCpltCallback()

        (##) HAL_SMARTCARD_AbortTransmitCpltCallback()

        (##) HAL_SMARTCARD_AbortReceiveCpltCallback()

    (#) In Non-Blocking mode transfers, possible errors are split into 2 categories.

        Errors are handled as follows :

       (##) Error is considered as Recoverable and non blocking : Transfer could go till end, but error severity is

           to be evaluated by user : this concerns Frame Error,

           Parity Error or Noise Error in Interrupt mode reception .

           Received character is then retrieved and stored in Rx buffer,

           Error code is set to allow user to identify error type,

           and HAL_SMARTCARD_ErrorCallback() user callback is executed. Transfer is kept ongoing on SMARTCARD side.

           If user wants to abort it, Abort services should be called by user.

       (##) Error is considered as Blocking : Transfer could not be completed properly and is aborted.

           This concerns Frame Error in Interrupt mode transmission, Overrun Error in Interrupt

           mode reception and all errors in DMA mode.

           Error code is set to allow user to identify error type,

           and HAL_SMARTCARD_ErrorCallback() user callback is executed.

@endverbatim

  * @{

  */

/**

  * @brief  Send an amount of data in blocking mode.

  * @param  hsmartcard Pointer to a SMARTCARD_HandleTypeDef structure that contains

  *                    the configuration information for the specified SMARTCARD module.

  * @param  pData pointer to data buffer.

  * @param  Size amount of data to be sent.

  * @param  Timeout  Timeout duration.

  * @retval HAL status

  */

HAL_StatusTypeDef HAL_SMARTCARD_Transmit(SMARTCARD_HandleTypeDef *hsmartcard, uint8_t *pData, uint16_t Size,

                                         uint32_t Timeout)

{

  uint32_t tickstart;

  uint8_t  *ptmpdata = pData;

  /* Check that a Tx process is not already ongoing */

  if (hsmartcard->gState == HAL_SMARTCARD_STATE_READY)

  {

    if ((ptmpdata == NULL) || (Size == 0U))

    {

      return  HAL_ERROR;

    }

    /* Process Locked */

    __HAL_LOCK(hsmartcard);

    hsmartcard->gState = HAL_SMARTCARD_STATE_BUSY_TX;

    /* Init tickstart for timeout management */

    tickstart = HAL_GetTick();

    /* Disable the Peripheral first to update mode for TX master */

    CLEAR_BIT(hsmartcard->Instance->CR1, USART_CR1_UE);

    /* In case of TX only mode, if NACK is enabled, the USART must be able to monitor

       the bidirectional line to detect a NACK signal in case of parity error.

       Therefore, the receiver block must be enabled as well (RE bit must be set). */

    if ((hsmartcard->Init.Mode == SMARTCARD_MODE_TX)

        && (hsmartcard->Init.NACKEnable == SMARTCARD_NACK_ENABLE))

    {

      SET_BIT(hsmartcard->Instance->CR1, USART_CR1_RE);

    }

    /* Enable Tx */

    SET_BIT(hsmartcard->Instance->CR1, USART_CR1_TE);

    /* Enable the Peripheral */

    SET_BIT(hsmartcard->Instance->CR1, USART_CR1_UE);

    /* Perform a TX/RX FIFO Flush */

    __HAL_SMARTCARD_FLUSH_DRREGISTER(hsmartcard);

    hsmartcard->ErrorCode = HAL_SMARTCARD_ERROR_NONE;

    hsmartcard->TxXferSize = Size;

    hsmartcard->TxXferCount = Size;

    while (hsmartcard->TxXferCount > 0U)

    {

      hsmartcard->TxXferCount--;

      if (SMARTCARD_WaitOnFlagUntilTimeout(hsmartcard, SMARTCARD_FLAG_TXE, RESET, tickstart, Timeout) != HAL_OK)

      {

        return HAL_TIMEOUT;

      }

      hsmartcard->Instance->TDR = (uint8_t)(*ptmpdata & 0xFFU);

      ptmpdata++;

    }

    if (SMARTCARD_WaitOnFlagUntilTimeout(hsmartcard, SMARTCARD_TRANSMISSION_COMPLETION_FLAG(hsmartcard), RESET,

                                         tickstart, Timeout) != HAL_OK)

    {

      return HAL_TIMEOUT;

    }

    /* Disable the Peripheral first to update mode */

    CLEAR_BIT(hsmartcard->Instance->CR1, USART_CR1_UE);

    if ((hsmartcard->Init.Mode == SMARTCARD_MODE_TX)

        && (hsmartcard->Init.NACKEnable == SMARTCARD_NACK_ENABLE))

    {

      /* In case of TX only mode, if NACK is enabled, receiver block has been enabled

         for Transmit phase. Disable this receiver block. */

      CLEAR_BIT(hsmartcard->Instance->CR1, USART_CR1_RE);

    }

    if ((hsmartcard->Init.Mode == SMARTCARD_MODE_TX_RX)

        || (hsmartcard->Init.NACKEnable == SMARTCARD_NACK_ENABLE))

    {

      /* Perform a TX FIFO Flush at end of Tx phase, as all sent bytes are appearing in Rx Data register */

      __HAL_SMARTCARD_FLUSH_DRREGISTER(hsmartcard);

    }

    SET_BIT(hsmartcard->Instance->CR1, USART_CR1_UE);

    /* At end of Tx process, restore hsmartcard->gState to Ready */

    hsmartcard->gState = HAL_SMARTCARD_STATE_READY;

    /* Process Unlocked */

    __HAL_UNLOCK(hsmartcard);

    return HAL_OK;

  }

  else

  {

    return HAL_BUSY;

  }

}

/**

  * @brief  Receive an amount of data in blocking mode.

  * @param  hsmartcard Pointer to a SMARTCARD_HandleTypeDef structure that contains

  *                    the configuration information for the specified SMARTCARD module.

  * @param  pData pointer to data buffer.

  * @param  Size amount of data to be received.

  * @param  Timeout Timeout duration.

  * @retval HAL status

  */

HAL_StatusTypeDef HAL_SMARTCARD_Receive(SMARTCARD_HandleTypeDef *hsmartcard, uint8_t *pData, uint16_t Size,

                                        uint32_t Timeout)

{

  uint32_t tickstart;

  uint8_t  *ptmpdata = pData;

  /* Check that a Rx process is not already ongoing */

  if (hsmartcard->RxState == HAL_SMARTCARD_STATE_READY)

  {

    if ((ptmpdata == NULL) || (Size == 0U))

    {

      return  HAL_ERROR;

    }

    /* Process Locked */

    __HAL_LOCK(hsmartcard);

    hsmartcard->ErrorCode = HAL_SMARTCARD_ERROR_NONE;

    hsmartcard->RxState   = HAL_SMARTCARD_STATE_BUSY_RX;

    /* Init tickstart for timeout management */

    tickstart = HAL_GetTick();

    hsmartcard->RxXferSize = Size;

    hsmartcard->RxXferCount = Size;

    /* Check the remain data to be received */

    while (hsmartcard->RxXferCount > 0U)

    {

      hsmartcard->RxXferCount--;

      if (SMARTCARD_WaitOnFlagUntilTimeout(hsmartcard, SMARTCARD_FLAG_RXNE, RESET, tickstart, Timeout) != HAL_OK)

      {

        return HAL_TIMEOUT;

      }

      *ptmpdata = (uint8_t)(hsmartcard->Instance->RDR & (uint8_t)0x00FF);

      ptmpdata++;

    }

    /* At end of Rx process, restore hsmartcard->RxState to Ready */

    hsmartcard->RxState = HAL_SMARTCARD_STATE_READY;