LXR 6.1/​bsps/​arm/​stm32h7/​hal/​stm32h7xx_hal_swpmi.c	Source navigation Diff markup Identifier search General search
	Version: 6.1 Revert   Change

File indexing completed on 2025-05-11 08:23:09

 /**
   ******************************************************************************
   * @file    stm32h7xx_hal_swpmi.c
   * @author  MCD Application Team
   * @brief   SWPMI HAL module driver.
   *          This file provides firmware functions to manage the following
   *          functionalities of the Single Wire Protocol Master Interface (SWPMI).
   *           + Initialization and Configuration
   *           + Data transfers functions
   *           + DMA transfers management
   *           + Interrupts and flags management
   ******************************************************************************
   * @attention
   *
   * Copyright (c) 2017 STMicroelectronics.
   * All rights reserved.
   *
   * This software is licensed under terms that can be found in the LICENSE file
   * in the root directory of this software component.
   * If no LICENSE file comes with this software, it is provided AS-IS.
   *
   ******************************************************************************
   @verbatim
  ===============================================================================
                         ##### How to use this driver #####
  ===============================================================================
   [..]
      The SWPMI HAL driver can be used as follows:
 
     (#) Declare a SWPMI_HandleTypeDef handle structure (eg. SWPMI_HandleTypeDef hswpmi).
 
     (#) Initialize the SWPMI low level resources by implementing the HAL_SWPMI_MspInit() API:
         (##) Enable the SWPMIx interface clock with __HAL_RCC_SWPMIx_CLK_ENABLE().
         (##) SWPMI IO configuration:
             (+++) Enable the clock for the SWPMI GPIO.
             (+++) Configure these SWPMI pins as alternate function pull-up.
         (##) NVIC configuration if you need to use interrupt process (HAL_SWPMI_Transmit_IT()
              and HAL_SWPMI_Receive_IT() APIs):
             (+++) Configure the SWPMIx interrupt priority with HAL_NVIC_SetPriority().
             (+++) Enable the NVIC SWPMI IRQ handle with HAL_NVIC_EnableIRQ().
 
         (##) DMA Configuration if you need to use DMA process (HAL_SWPMI_Transmit_DMA()
              and HAL_SWPMI_Receive_DMA() APIs):
             (+++) Declare a DMA handle structure for the Tx/Rx streams.
             (+++) Enable the DMAx interface clock.
             (+++) Configure the declared DMA handle structure with the required
                   Tx/Rx parameters.
             (+++) Configure the DMA Tx/Rx streams and requests.
             (+++) Associate the initialized DMA handle to the SWPMI DMA Tx/Rx handle.
             (+++) Configure the priority and enable the NVIC for the transfer complete
                   interrupt on the DMA Tx/Rx streams.
 
     (#) Program the Bite Rate, Tx Buffering mode, Rx Buffering mode in the Init structure.
 
     (#) Enable the SWPMI peripheral by calling the HAL_SWPMI_Init() function.
 
   [..]
     Three operation modes are available within this driver :
 
     *** Polling mode IO operation ***
     =================================
     [..]
       (+) Send an amount of data in blocking mode using HAL_SWPMI_Transmit()
       (+) Receive an amount of data in blocking mode using HAL_SWPMI_Receive()
 
     *** Interrupt mode IO operation ***
     ===================================
     [..]
       (+) Send an amount of data in non-blocking mode using HAL_SWPMI_Transmit_IT()
       (+) At transmission end of transfer HAL_SWPMI_TxCpltCallback() is executed and user can
           add his own code by customization of function pointer HAL_SWPMI_TxCpltCallback()
       (+) Receive an amount of data in non-blocking mode using HAL_SWPMI_Receive_IT()
       (+) At reception end of transfer HAL_SWPMI_RxCpltCallback() is executed and user can
           add his own code by customization of function pointer HAL_SWPMI_RxCpltCallback()
       (+) In case of flag error, HAL_SWPMI_ErrorCallback() function is executed and user can
           add his own code by customization of function pointer HAL_SWPMI_ErrorCallback()
 
     *** DMA mode IO operation ***
     =============================
     [..]
       (+) Send an amount of data in non-blocking mode (DMA) using HAL_SWPMI_Transmit_DMA()
       (+) At transmission end of transfer HAL_SWPMI_TxCpltCallback() is executed and user can
           add his own code by customization of function pointer HAL_SWPMI_TxCpltCallback()
       (+) Receive an amount of data in non-blocking mode (DMA) using HAL_SWPMI_Receive_DMA()
       (+) At reception end of transfer HAL_SWPMI_RxCpltCallback() is executed and user can
           add his own code by customization of function pointer HAL_SWPMI_RxCpltCallback()
       (+) In case of flag error, HAL_SWPMI_ErrorCallback() function is executed and user can
           add his own code by customization of function pointer HAL_SWPMI_ErrorCallback()
       (+) Stop the DMA Transfer using HAL_SWPMI_DMAStop()
 
     *** SWPMI HAL driver additional function list ***
     ===============================================
     [..]
       Below the list the others API available SWPMI HAL driver :
 
       (+) HAL_SWPMI_EnableLoopback(): Enable the loopback mode for test purpose only
       (+) HAL_SWPMI_DisableLoopback(): Disable the loopback mode
 
     *** SWPMI HAL driver macros list ***
     ==================================
     [..]
       Below the list of most used macros in SWPMI HAL driver :
 
       (+) __HAL_SWPMI_ENABLE(): Enable the SWPMI peripheral
       (+) __HAL_SWPMI_DISABLE(): Disable the SWPMI peripheral
       (+) __HAL_SWPMI_TRANSCEIVER_ENABLE(): Enable the SWPMI peripheral transceiver
       (+) __HAL_SWPMI_TRANSCEIVER_DISABLE(): Disable the SWPMI peripheral transceiver
       (+) __HAL_SWPMI_ENABLE_IT(): Enable the specified SWPMI interrupts
       (+) __HAL_SWPMI_DISABLE_IT(): Disable the specified SWPMI interrupts
       (+) __HAL_SWPMI_GET_IT_SOURCE(): Check if the specified SWPMI interrupt source is
           enabled or disabled
       (+) __HAL_SWPMI_GET_FLAG(): Check whether the specified SWPMI flag is set or not
 
     *** Callback registration ***
     =============================
     [..]
       The compilation define USE_HAL_SWPMI_REGISTER_CALLBACKS when set to 1
       allows the user to configure dynamically the driver callbacks.
     [..]
       Use function HAL_SWPMI_RegisterCallback() to register a user callback. It allows
       to register the following callbacks:
       (+) RxCpltCallback     : SWPMI receive complete.
       (+) RxHalfCpltCallback : SWPMI receive half complete.
       (+) TxCpltCallback     : SWPMI transmit complete.
       (+) TxHalfCpltCallback : SWPMI transmit half complete.
       (+) ErrorCallback      : SWPMI error.
       (+) MspInitCallback    : SWPMI MspInit.
       (+) MspDeInitCallback  : SWPMI MspDeInit.
     [..]
     This function takes as parameters the HAL peripheral handle, the callback ID
     and a pointer to the user callback function.
     [..]
     Use function HAL_SWPMI_UnRegisterCallback() to reset a callback to the default
     weak (surcharged) function.
     HAL_SWPMI_UnRegisterCallback() takes as parameters the HAL peripheral handle,
     and the callback ID.
     This function allows to reset following callbacks:
       (+) RxCpltCallback     : SWPMI receive complete.
       (+) RxHalfCpltCallback : SWPMI receive half complete.
       (+) TxCpltCallback     : SWPMI transmit complete.
       (+) TxHalfCpltCallback : SWPMI transmit half complete.
       (+) ErrorCallback      : SWPMI error.
       (+) MspInitCallback    : SWPMI MspInit.
       (+) MspDeInitCallback  : SWPMI MspDeInit.
     [..]
     By default, after the HAL_SWPMI_Init and if the state is HAL_SWPMI_STATE_RESET
     all callbacks are reset to the corresponding legacy weak (surcharged) functions:
     examples HAL_SWPMI_RxCpltCallback(), HAL_SWPMI_ErrorCallback().
     Exception done for MspInit and MspDeInit callbacks that are respectively
     reset to the legacy weak (surcharged) functions in the HAL_SWPMI_Init
     and HAL_SWPMI_DeInit only when these callbacks are null (not registered beforehand).
     If not, MspInit or MspDeInit are not null, the HAL_SWPMI_Init and HAL_SWPMI_DeInit
     keep and use the user MspInit/MspDeInit callbacks (registered beforehand).
     [..]
     Callbacks can be registered/unregistered in READY state only.
     Exception done for MspInit/MspDeInit callbacks that can be registered/unregistered
     in READY or 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_SWPMI_RegisterCallback before calling HAL_SWPMI_DeInit
     or HAL_SWPMI_Init function.
     [..]
     When the compilation define USE_HAL_SWPMI_REGISTER_CALLBACKS is set to 0 or
     not defined, the callback registering feature is not available
     and weak (surcharged) callbacks are used.
 
   @endverbatim
   */
 
 /* Includes ------------------------------------------------------------------*/
 #include "stm32h7xx_hal.h"
 
 /** @addtogroup STM32H7xx_HAL_Driver
   * @{
   */
 
 
 /** @defgroup SWPMI SWPMI
   * @ingroup RTEMSBSPsARMSTM32H7
   * @brief HAL SWPMI module driver
   * @{
   */
 #ifdef HAL_SWPMI_MODULE_ENABLED
 
 /* Private typedef -----------------------------------------------------------*/
 /* Private define ------------------------------------------------------------*/
 /* Private constants ---------------------------------------------------------*/
 /** @addtogroup SWPMI_Private_Constants SWPMI Private Constants
   * @{
   */
 #define SWPMI_TIMEOUT_VALUE                   22000U   /* End of transmission timeout */
 #define SWPMI_TRANSCEIVER_RDY_TIMEOUT_VALUE    2000U   /* Transceiver ready timeout */
 
 /**
   * @}
   */
 
 /* Private macros ------------------------------------------------------------*/
 /* Private variables ---------------------------------------------------------*/
 /* Private function prototypes -----------------------------------------------*/
 static void SWPMI_DMATransmitCplt(DMA_HandleTypeDef *hdma);
 static void SWPMI_DMATxHalfCplt(DMA_HandleTypeDef *hdma);
 static void SWPMI_DMAReceiveCplt(DMA_HandleTypeDef *hdma);
 static void SWPMI_DMARxHalfCplt(DMA_HandleTypeDef *hdma);
 static void SWPMI_DMAError(DMA_HandleTypeDef *hdma);
 static void SWPMI_DMAAbortOnError(DMA_HandleTypeDef *hdma);
 static void SWPMI_Transmit_IT(SWPMI_HandleTypeDef *hswpmi);
 static void SWPMI_EndTransmit_IT(SWPMI_HandleTypeDef *hswpmi);
 static void SWPMI_Receive_IT(SWPMI_HandleTypeDef *hswpmi);
 static void SWPMI_EndReceive_IT(SWPMI_HandleTypeDef *hswpmi);
 static void SWPMI_EndTransmitReceive_IT(SWPMI_HandleTypeDef *hswpmi);
 static HAL_StatusTypeDef SWPMI_WaitOnFlagSetUntilTimeout(SWPMI_HandleTypeDef *hswpmi, uint32_t Flag, uint32_t Tickstart, uint32_t Timeout);
 
 /* Exported functions --------------------------------------------------------*/
 
 /** @defgroup SWPMI_Exported_Functions SWPMI Exported Functions
   * @ingroup RTEMSBSPsARMSTM32H7
   * @{
   */
 
 /** @defgroup SWPMI_Exported_Group1 Initialization/de-initialization methods
   * @ingroup RTEMSBSPsARMSTM32H7
   *  @brief    Initialization and Configuration functions
   *
 @verbatim
  ===============================================================================
             ##### Initialization and Configuration functions #####
  ===============================================================================
     [..]  This section provides functions allowing to:
       (+) Initialize and configure the SWPMI peripheral.
       (+) De-initialize the SWPMI peripheral.
 
 @endverbatim
   * @{
   */
 
 /**
   * @brief Initialize the SWPMI peripheral according to the specified parameters in the SWPMI_InitTypeDef.
   * @param hswpmi SWPMI handle
   * @retval HAL status
   */
 HAL_StatusTypeDef HAL_SWPMI_Init(SWPMI_HandleTypeDef *hswpmi)
 {
   HAL_StatusTypeDef status = HAL_OK;
   uint32_t tickstart = HAL_GetTick();
 
   /* Check the SWPMI handle allocation */
   if (hswpmi == NULL)
   {
     status = HAL_ERROR;
   }
   else
   {
     /* Check the parameters */
     assert_param(IS_SWPMI_VOLTAGE_CLASS(hswpmi->Init.VoltageClass));
     assert_param(IS_SWPMI_BITRATE_VALUE(hswpmi->Init.BitRate));
     assert_param(IS_SWPMI_TX_BUFFERING_MODE(hswpmi->Init.TxBufferingMode));
     assert_param(IS_SWPMI_RX_BUFFERING_MODE(hswpmi->Init.RxBufferingMode));
 
     if (hswpmi->State == HAL_SWPMI_STATE_RESET)
     {
       /* Allocate lock resource and initialize it */
       hswpmi->Lock = HAL_UNLOCKED;
 
 #if (USE_HAL_SWPMI_REGISTER_CALLBACKS == 1)
       /* Reset callback pointers to the weak predefined callbacks */
       hswpmi->RxCpltCallback     = HAL_SWPMI_RxCpltCallback;
       hswpmi->RxHalfCpltCallback = HAL_SWPMI_RxHalfCpltCallback;
       hswpmi->TxCpltCallback     = HAL_SWPMI_TxCpltCallback;
       hswpmi->TxHalfCpltCallback = HAL_SWPMI_TxHalfCpltCallback;
       hswpmi->ErrorCallback      = HAL_SWPMI_ErrorCallback;
 
       /* Init the low level hardware : GPIO, CLOCK, NVIC and DMA */
       if (hswpmi->MspInitCallback == NULL)
       {
         hswpmi->MspInitCallback = HAL_SWPMI_MspInit;
       }
       hswpmi->MspInitCallback(hswpmi);
 #else
       /* Init the low level hardware : GPIO, CLOCK, NVIC and DMA */
       HAL_SWPMI_MspInit(hswpmi);
 #endif
     }
 
     hswpmi->State = HAL_SWPMI_STATE_BUSY;
 
     /* Disable SWPMI interface */
     CLEAR_BIT(hswpmi->Instance->CR, SWPMI_CR_SWPACT);
 
     /* Clear all SWPMI interface flags */
     WRITE_REG(hswpmi->Instance->ICR, 0x099F);
 
     /* Apply Voltage class selection */
     MODIFY_REG(hswpmi->Instance->OR, SWPMI_OR_CLASS, hswpmi->Init.VoltageClass);
 
 
     /* Configure the BRR register (Bitrate) */
     WRITE_REG(hswpmi->Instance->BRR, hswpmi->Init.BitRate);
 
     /* Apply SWPMI CR configuration */
     MODIFY_REG(hswpmi->Instance->CR, \
                SWPMI_CR_RXDMA | SWPMI_CR_TXDMA  | SWPMI_CR_RXMODE | SWPMI_CR_TXMODE, \
                hswpmi->Init.TxBufferingMode | hswpmi->Init.RxBufferingMode);
 
     /* Enable the SWPMI transceiver */
     SET_BIT(hswpmi->Instance->CR, SWPMI_CR_SWPEN);
     /* Wait on RDYF flag to activate SWPMI */
     if (SWPMI_WaitOnFlagSetUntilTimeout(hswpmi, SWPMI_FLAG_RDYF, tickstart, SWPMI_TRANSCEIVER_RDY_TIMEOUT_VALUE) != HAL_OK)
     {
       status = HAL_TIMEOUT;
     }
 
     if (status == HAL_OK)
     {
       hswpmi->ErrorCode = HAL_SWPMI_ERROR_NONE;
       hswpmi->State = HAL_SWPMI_STATE_READY;
 
       /* Enable SWPMI peripheral */
       SET_BIT(hswpmi->Instance->CR, SWPMI_CR_SWPACT);
     }
     else
     {
       hswpmi->ErrorCode = HAL_SWPMI_ERROR_TRANSCEIVER_NOT_READY;
       hswpmi->State = HAL_SWPMI_STATE_ERROR;
     }
   }
 
   return status;
 }
 
 /**
   * @brief De-initialize the SWPMI peripheral.
   * @param hswpmi SWPMI handle
   * @retval HAL status
   */
 HAL_StatusTypeDef HAL_SWPMI_DeInit(SWPMI_HandleTypeDef *hswpmi)
 {
   HAL_StatusTypeDef status = HAL_OK;
 
   /* Check the SWPMI handle allocation */
   if (hswpmi == NULL)
   {
     status = HAL_ERROR;
   }
   else
   {
     /* Check the parameters */
     assert_param(IS_SWPMI_INSTANCE(hswpmi->Instance));
 
     hswpmi->State = HAL_SWPMI_STATE_BUSY;
 
     /* Disable SWPMI interface */
     CLEAR_BIT(hswpmi->Instance->CR, SWPMI_CR_SWPACT);
 
     /* Disable Loopback mode */
     CLEAR_BIT(hswpmi->Instance->CR, SWPMI_CR_LPBK);
 
     /* Disable SWPMI transceiver */
     CLEAR_BIT(hswpmi->Instance->CR, SWPMI_CR_SWPEN);
 
 
     /* DeInit the low level hardware: GPIO, CLOCK, NVIC and DMA */
 #if (USE_HAL_SWPMI_REGISTER_CALLBACKS == 1)
     if (hswpmi->MspDeInitCallback == NULL)
     {
       hswpmi->MspDeInitCallback = HAL_SWPMI_MspDeInit;
     }
     hswpmi->MspDeInitCallback(hswpmi);
 #else
     HAL_SWPMI_MspDeInit(hswpmi);
 #endif
 
     hswpmi->ErrorCode = HAL_SWPMI_ERROR_NONE;
     hswpmi->State = HAL_SWPMI_STATE_RESET;
 
     /* Release Lock */
     __HAL_UNLOCK(hswpmi);
   }
 
   return status;
 }
 
 /**
   * @brief Initialize the SWPMI MSP.
   * @param hswpmi SWPMI handle
   * @retval None
   */
 __weak void HAL_SWPMI_MspInit(SWPMI_HandleTypeDef *hswpmi)
 {
   /* Prevent unused argument(s) compilation warning */
   UNUSED(hswpmi);
 
   /* NOTE : This function should not be modified, when the callback is needed,
             the HAL_SWPMI_MspInit can be implemented in the user file
    */
 }
 
 /**
   * @brief DeInitialize the SWPMI MSP.
   * @param hswpmi SWPMI handle
   * @retval None
   */
 __weak void HAL_SWPMI_MspDeInit(SWPMI_HandleTypeDef *hswpmi)
 {
   /* Prevent unused argument(s) compilation warning */
   UNUSED(hswpmi);
 
   /* NOTE : This function should not be modified, when the callback is needed,
             the HAL_SWPMI_MspDeInit can be implemented in the user file
    */
 }
 
 #if (USE_HAL_SWPMI_REGISTER_CALLBACKS == 1)
 /**
   * @brief  Register a user SWPMI callback
   *         to be used instead of the weak predefined callback.
   * @param  hswpmi SWPMI handle.
   * @param  CallbackID ID of the callback to be registered.
   *         This parameter can be one of the following values:
   *           @arg @ref HAL_SWPMI_RX_COMPLETE_CB_ID receive complete callback ID.
   *           @arg @ref HAL_SWPMI_RX_HALFCOMPLETE_CB_ID receive half complete callback ID.
   *           @arg @ref HAL_SWPMI_TX_COMPLETE_CB_ID transmit complete callback ID.
   *           @arg @ref HAL_SWPMI_TX_HALFCOMPLETE_CB_ID transmit half complete callback ID.
   *           @arg @ref HAL_SWPMI_ERROR_CB_ID error callback ID.
   *           @arg @ref HAL_SWPMI_MSPINIT_CB_ID MSP init callback ID.
   *           @arg @ref HAL_SWPMI_MSPDEINIT_CB_ID MSP de-init callback ID.
   * @param  pCallback pointer to the callback function.
   * @retval HAL status.
   */
 HAL_StatusTypeDef HAL_SWPMI_RegisterCallback(SWPMI_HandleTypeDef        *hswpmi,
                                              HAL_SWPMI_CallbackIDTypeDef CallbackID,
                                              pSWPMI_CallbackTypeDef      pCallback)
 {
   HAL_StatusTypeDef status = HAL_OK;
 
   if (pCallback == NULL)
   {
     /* update the error code */
     hswpmi->ErrorCode |= HAL_SWPMI_ERROR_INVALID_CALLBACK;
     /* update return status */
     status = HAL_ERROR;
   }
   else
   {
     if (hswpmi->State == HAL_SWPMI_STATE_READY)
     {
       switch (CallbackID)
       {
         case HAL_SWPMI_RX_COMPLETE_CB_ID :
           hswpmi->RxCpltCallback = pCallback;
           break;
         case HAL_SWPMI_RX_HALFCOMPLETE_CB_ID :
           hswpmi->RxHalfCpltCallback = pCallback;
           break;
         case HAL_SWPMI_TX_COMPLETE_CB_ID :
           hswpmi->TxCpltCallback = pCallback;
           break;
         case HAL_SWPMI_TX_HALFCOMPLETE_CB_ID :
           hswpmi->TxHalfCpltCallback = pCallback;
           break;
         case HAL_SWPMI_ERROR_CB_ID :
           hswpmi->ErrorCallback = pCallback;
           break;
         case HAL_SWPMI_MSPINIT_CB_ID :
           hswpmi->MspInitCallback = pCallback;
           break;
         case HAL_SWPMI_MSPDEINIT_CB_ID :
           hswpmi->MspDeInitCallback = pCallback;
           break;
         default :
           /* update the error code */
           hswpmi->ErrorCode |= HAL_SWPMI_ERROR_INVALID_CALLBACK;
           /* update return status */
           status = HAL_ERROR;
           break;
       }
     }
     else if (hswpmi->State == HAL_SWPMI_STATE_RESET)
     {
       switch (CallbackID)
       {
         case HAL_SWPMI_MSPINIT_CB_ID :
           hswpmi->MspInitCallback = pCallback;
           break;
         case HAL_SWPMI_MSPDEINIT_CB_ID :
           hswpmi->MspDeInitCallback = pCallback;
           break;
         default :
           /* update the error code */
           hswpmi->ErrorCode |= HAL_SWPMI_ERROR_INVALID_CALLBACK;
           /* update return status */
           status = HAL_ERROR;
           break;
       }
     }
     else
     {
       /* update the error code */
       hswpmi->ErrorCode |= HAL_SWPMI_ERROR_INVALID_CALLBACK;
       /* update return status */
       status = HAL_ERROR;
     }
   }
   return status;
 }
 
 /**
   * @brief  Unregister a user SWPMI callback.
   *         SWPMI callback is redirected to the weak predefined callback.
   * @param  hswpmi SWPMI handle.
   * @param  CallbackID ID of the callback to be unregistered.
   *         This parameter can be one of the following values:
   *           @arg @ref HAL_SWPMI_RX_COMPLETE_CB_ID receive complete callback ID.
   *           @arg @ref HAL_SWPMI_RX_HALFCOMPLETE_CB_ID receive half complete callback ID.
   *           @arg @ref HAL_SWPMI_TX_COMPLETE_CB_ID transmit complete callback ID.
   *           @arg @ref HAL_SWPMI_TX_HALFCOMPLETE_CB_ID transmit half complete callback ID.
   *           @arg @ref HAL_SWPMI_ERROR_CB_ID error callback ID.
   *           @arg @ref HAL_SWPMI_MSPINIT_CB_ID MSP init callback ID.
   *           @arg @ref HAL_SWPMI_MSPDEINIT_CB_ID MSP de-init callback ID.
   * @retval HAL status.
   */
 HAL_StatusTypeDef HAL_SWPMI_UnRegisterCallback(SWPMI_HandleTypeDef        *hswpmi,
                                                HAL_SWPMI_CallbackIDTypeDef CallbackID)
 {
   HAL_StatusTypeDef status = HAL_OK;
 
   if (hswpmi->State == HAL_SWPMI_STATE_READY)
   {
     switch (CallbackID)
     {
       case HAL_SWPMI_RX_COMPLETE_CB_ID :
         hswpmi->RxCpltCallback = HAL_SWPMI_RxCpltCallback;
         break;
       case HAL_SWPMI_RX_HALFCOMPLETE_CB_ID :
         hswpmi->RxHalfCpltCallback = HAL_SWPMI_RxHalfCpltCallback;
         break;
       case HAL_SWPMI_TX_COMPLETE_CB_ID :
         hswpmi->TxCpltCallback = HAL_SWPMI_TxCpltCallback;
         break;
       case HAL_SWPMI_TX_HALFCOMPLETE_CB_ID :
         hswpmi->TxHalfCpltCallback = HAL_SWPMI_TxHalfCpltCallback;
         break;
       case HAL_SWPMI_ERROR_CB_ID :
         hswpmi->ErrorCallback = HAL_SWPMI_ErrorCallback;
         break;
       case HAL_SWPMI_MSPINIT_CB_ID :
         hswpmi->MspInitCallback = HAL_SWPMI_MspInit;
         break;
       case HAL_SWPMI_MSPDEINIT_CB_ID :
         hswpmi->MspDeInitCallback = HAL_SWPMI_MspDeInit;
         break;
       default :
         /* update the error code */
         hswpmi->ErrorCode |= HAL_SWPMI_ERROR_INVALID_CALLBACK;
         /* update return status */
         status = HAL_ERROR;
         break;
     }
   }
   else if (hswpmi->State == HAL_SWPMI_STATE_RESET)
   {
     switch (CallbackID)
     {
       case HAL_SWPMI_MSPINIT_CB_ID :
         hswpmi->MspInitCallback = HAL_SWPMI_MspInit;
         break;
       case HAL_SWPMI_MSPDEINIT_CB_ID :
         hswpmi->MspDeInitCallback = HAL_SWPMI_MspDeInit;
         break;
       default :
         /* update the error code */
         hswpmi->ErrorCode |= HAL_SWPMI_ERROR_INVALID_CALLBACK;
         /* update return status */
         status = HAL_ERROR;
         break;
     }
   }
   else
   {
     /* update the error code */
     hswpmi->ErrorCode |= HAL_SWPMI_ERROR_INVALID_CALLBACK;
     /* update return status */
     status = HAL_ERROR;
   }
   return status;
 }
 #endif /* USE_HAL_SWPMI_REGISTER_CALLBACKS */
 
 /**
   * @}
   */
 
 /** @defgroup SWPMI_Exported_Group2 IO operation methods
   * @ingroup RTEMSBSPsARMSTM32H7
   *  @brief SWPMI Transmit/Receive functions
   *
 @verbatim
  ===============================================================================
                       ##### IO operation methods #####
  ===============================================================================
  [..]
     This subsection provides a set of functions allowing to manage the SWPMI
      data transfers.
 
     (#) 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 end of the data processing will be indicated through the
            dedicated SWPMI Interrupt handler (HAL_SWPMI_IRQHandler()) when using Interrupt mode or
            the selected DMA stream interrupt handler when using DMA mode.
            The HAL_SWPMI_TxCpltCallback(), HAL_SWPMI_RxCpltCallback() user callbacks
            will be executed respectively at the end of the transmit or receive process.
            The HAL_SWPMI_ErrorCallback() user callback will be executed when a communication error is detected.
 
     (#) Blocking mode API's are:
         (++) HAL_SWPMI_Transmit()
         (++) HAL_SWPMI_Receive()
 
     (#) Non-Blocking mode API's with Interrupt are:
         (++) HAL_SWPMI_Transmit_IT()
         (++) HAL_SWPMI_Receive_IT()
         (++) HAL_SWPMI_IRQHandler()
 
     (#) Non-Blocking mode API's with DMA are:
         (++) HAL_SWPMI_Transmit_DMA()
         (++) HAL_SWPMI_Receive_DMA()
         (++) HAL_SWPMI_DMAPause()
         (++) HAL_SWPMI_DMAResume()
         (++) HAL_SWPMI_DMAStop()
 
     (#) A set of Transfer Complete Callbacks are provided in Non-Blocking mode:
         (++) HAL_SWPMI_TxHalfCpltCallback()
         (++) HAL_SWPMI_TxCpltCallback()
         (++) HAL_SWPMI_RxHalfCpltCallback()
         (++) HAL_SWPMI_RxCpltCallback()
         (++) HAL_SWPMI_ErrorCallback()
 
     (#) The capability to launch the above IO operations in loopback mode for
         user application verification:
         (++) HAL_SWPMI_EnableLoopback()
         (++) HAL_SWPMI_DisableLoopback()
 
 @endverbatim
   * @{
   */
 
 /**
   * @brief  Transmit an amount of data in blocking mode.
   * @param  hswpmi pointer to a SWPMI_HandleTypeDef structure that contains
   *                the configuration information for SWPMI 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_SWPMI_Transmit(SWPMI_HandleTypeDef *hswpmi, uint32_t *pData, uint16_t Size, uint32_t Timeout)
 {
   uint32_t tickstart = HAL_GetTick();
   HAL_StatusTypeDef status = HAL_OK;
   HAL_SWPMI_StateTypeDef tmp_state;
   uint32_t *ptmp_data;
   uint32_t tmp_size;
 
   if ((pData == NULL) || (Size == 0U))
   {
     status = HAL_ERROR;
   }
   else
   {
     /* Process Locked */
     __HAL_LOCK(hswpmi);
 
     tmp_state = hswpmi->State;
     if ((tmp_state == HAL_SWPMI_STATE_READY) || (tmp_state == HAL_SWPMI_STATE_BUSY_RX))
     {
       /* Check if a non-blocking receive process is ongoing or not */
       if (tmp_state == HAL_SWPMI_STATE_READY)
       {
         hswpmi->State = HAL_SWPMI_STATE_BUSY_TX;
 
         /* Disable any transmitter interrupts */
         __HAL_SWPMI_DISABLE_IT(hswpmi, SWPMI_IT_TCIE | SWPMI_IT_TIE | SWPMI_IT_TXUNRIE | SWPMI_IT_TXBEIE);
 
         /* Disable any transmitter flags */
         __HAL_SWPMI_CLEAR_FLAG(hswpmi, SWPMI_FLAG_TXBEF | SWPMI_FLAG_TXUNRF | SWPMI_FLAG_TCF);
 
         /* Enable SWPMI peripheral if not */
         SET_BIT(hswpmi->Instance->CR, SWPMI_CR_SWPACT);
       }
       else
       {
         hswpmi->State = HAL_SWPMI_STATE_BUSY_TX_RX;
       }
 
       ptmp_data = pData;
       tmp_size = Size;
       do
       {
         /* Wait the TXE to write data */
         if (HAL_IS_BIT_SET(hswpmi->Instance->ISR, SWPMI_FLAG_TXE))
         {
           hswpmi->Instance->TDR = *ptmp_data;
           ptmp_data++;
           tmp_size--;
         }
         else
         {
           /* Check for the Timeout */
           if (Timeout != HAL_MAX_DELAY)
           {
             if (((HAL_GetTick() - tickstart) > Timeout) || (Timeout == 0U))
             {
               status = HAL_TIMEOUT;
               break;
             }
           }
         }
       }
       while (tmp_size != 0U);
 
       /* Wait on TXBEF flag to be able to start a second transfer */
       if (SWPMI_WaitOnFlagSetUntilTimeout(hswpmi, SWPMI_FLAG_TXBEF, tickstart, Timeout) != HAL_OK)
       {
         /* Timeout occurred */
         hswpmi->ErrorCode |= HAL_SWPMI_ERROR_TXBEF_TIMEOUT;
 
         status = HAL_TIMEOUT;
       }
 
       if (status == HAL_OK)
       {
         /* Check if a non-blocking receive Process is ongoing or not */
         if (hswpmi->State == HAL_SWPMI_STATE_BUSY_TX_RX)
         {
           hswpmi->State = HAL_SWPMI_STATE_BUSY_RX;
         }
         else
         {
           hswpmi->State = HAL_SWPMI_STATE_READY;
         }
       }
     }
     else
     {
       status = HAL_BUSY;
     }
   }
 
   if ((status != HAL_OK) && (status != HAL_BUSY))
   {
     hswpmi->State = HAL_SWPMI_STATE_READY;
   }
   /* Process Unlocked */
   __HAL_UNLOCK(hswpmi);
 
   return status;
 }
 
 /**
   * @brief  Receive an amount of data in blocking mode.
   * @param  hswpmi pointer to a SWPMI_HandleTypeDef structure that contains
   *                the configuration information for SWPMI 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_SWPMI_Receive(SWPMI_HandleTypeDef *hswpmi, uint32_t *pData, uint16_t Size, uint32_t Timeout)
 {
   uint32_t tickstart = HAL_GetTick();
   HAL_StatusTypeDef status = HAL_OK;
   HAL_SWPMI_StateTypeDef tmp_state;
   uint32_t *ptmp_data;
   uint32_t tmp_size;
 
   if ((pData == NULL) || (Size == 0U))
   {
     status = HAL_ERROR;
   }
   else
   {
     /* Process Locked */
     __HAL_LOCK(hswpmi);
 
     tmp_state = hswpmi->State;
     if ((tmp_state == HAL_SWPMI_STATE_READY) || (tmp_state == HAL_SWPMI_STATE_BUSY_TX))
     {
       /* Check if a non-blocking transmit process is ongoing or not */
       if (tmp_state == HAL_SWPMI_STATE_READY)
       {
         hswpmi->State = HAL_SWPMI_STATE_BUSY_RX;
 
         /* Disable any receiver interrupts */
         CLEAR_BIT(hswpmi->Instance->IER, SWPMI_IT_SRIE | SWPMI_IT_RIE | SWPMI_IT_RXBERIE | SWPMI_IT_RXOVRIE | SWPMI_IT_RXBFIE);
 
         /* Enable SWPMI peripheral if not */
         SET_BIT(hswpmi->Instance->CR, SWPMI_CR_SWPACT);
       }
       else
       {
         hswpmi->State = HAL_SWPMI_STATE_BUSY_TX_RX;
       }
 
       ptmp_data = pData;
       tmp_size = Size;
       do
       {
         /* Wait the RXNE to read data */
         if (HAL_IS_BIT_SET(hswpmi->Instance->ISR, SWPMI_FLAG_RXNE))
         {
           *ptmp_data = hswpmi->Instance->RDR;
           ptmp_data++;
           tmp_size--;
         }
         else
         {
           /* Check for the Timeout */
           if (Timeout != HAL_MAX_DELAY)
           {
             if (((HAL_GetTick() - tickstart) > Timeout) || (Timeout == 0U))
             {
               status = HAL_TIMEOUT;
               break;
             }
           }
         }
       }
       while (tmp_size != 0U);
 
       if (status == HAL_OK)
       {
         if (HAL_IS_BIT_SET(hswpmi->Instance->ISR, SWPMI_FLAG_RXBFF))
         {
           /* Clear RXBFF at end of reception */
           WRITE_REG(hswpmi->Instance->ICR, SWPMI_FLAG_RXBFF);
         }
 
         /* Check if a non-blocking transmit Process is ongoing or not */
         if (hswpmi->State == HAL_SWPMI_STATE_BUSY_TX_RX)
         {
           hswpmi->State = HAL_SWPMI_STATE_BUSY_TX;
         }
         else
         {
           hswpmi->State = HAL_SWPMI_STATE_READY;
         }
       }
     }
     else
     {
       status = HAL_BUSY;
     }
   }
 
   if ((status != HAL_OK) && (status != HAL_BUSY))
   {
     hswpmi->State = HAL_SWPMI_STATE_READY;
   }
   /* Process Unlocked */
   __HAL_UNLOCK(hswpmi);
 
   return status;
 }
 
 /**
   * @brief  Transmit an amount of data in non-blocking mode with interrupt.
   * @param  hswpmi pointer to a SWPMI_HandleTypeDef structure that contains
   *                the configuration information for SWPMI module.
   * @param  pData Pointer to data buffer
   * @param  Size Amount of data to be sent
   * @retval HAL status
   */
 HAL_StatusTypeDef HAL_SWPMI_Transmit_IT(SWPMI_HandleTypeDef *hswpmi, uint32_t *pData, uint16_t Size)
 {
   HAL_StatusTypeDef status = HAL_OK;
   HAL_SWPMI_StateTypeDef tmp_state;
 
   if ((pData == NULL) || (Size == 0U))
   {
     status =  HAL_ERROR;
   }
   else
   {
     /* Process Locked */
     __HAL_LOCK(hswpmi);
 
     tmp_state = hswpmi->State;
     if ((tmp_state == HAL_SWPMI_STATE_READY) || (tmp_state == HAL_SWPMI_STATE_BUSY_RX))
     {
       /* Update handle */
       hswpmi->pTxBuffPtr = pData;
       hswpmi->TxXferSize = Size;
       hswpmi->TxXferCount = Size;
       hswpmi->ErrorCode = HAL_SWPMI_ERROR_NONE;
 
       /* Check if a receive process is ongoing or not */
       if (tmp_state == HAL_SWPMI_STATE_READY)
       {
         hswpmi->State = HAL_SWPMI_STATE_BUSY_TX;
 
         /* Enable SWPMI peripheral if not */
         SET_BIT(hswpmi->Instance->CR, SWPMI_CR_SWPACT);
       }
       else
       {
         hswpmi->State = HAL_SWPMI_STATE_BUSY_TX_RX;
       }
 
       /* Enable the SWPMI transmit underrun error */
       __HAL_SWPMI_ENABLE_IT(hswpmi, SWPMI_IT_TXUNRIE);
 
       /* Process Unlocked */
       __HAL_UNLOCK(hswpmi);
 
       /* Enable the SWPMI interrupts:      */
       /* - Transmit data register empty    */
       /* - Transmit buffer empty           */
       /* - Transmit/Reception completion   */
       __HAL_SWPMI_ENABLE_IT(hswpmi, SWPMI_IT_TIE | SWPMI_IT_TXBEIE | SWPMI_IT_TCIE);
     }
     else
     {
       status =  HAL_BUSY;
 
       /* Process Unlocked */
       __HAL_UNLOCK(hswpmi);
     }
   }
 
   return status;
 }
 
 /**
   * @brief  Receive an amount of data in non-blocking mode with interrupt.
   * @param  hswpmi SWPMI handle
   * @param  pData Pointer to data buffer
   * @param  Size Amount of data to be received
   * @retval HAL status
   */
 HAL_StatusTypeDef HAL_SWPMI_Receive_IT(SWPMI_HandleTypeDef *hswpmi, uint32_t *pData, uint16_t Size)
 {
   HAL_StatusTypeDef status = HAL_OK;
   HAL_SWPMI_StateTypeDef tmp_state;
 
   if ((pData == NULL) || (Size == 0U))
   {
     status =  HAL_ERROR;
   }
   else
   {
     /* Process Locked */
     __HAL_LOCK(hswpmi);
 
     tmp_state = hswpmi->State;
     if ((tmp_state == HAL_SWPMI_STATE_READY) || (tmp_state == HAL_SWPMI_STATE_BUSY_TX))
     {
       /* Update handle */
       hswpmi->pRxBuffPtr = pData;
       hswpmi->RxXferSize = Size;
       hswpmi->RxXferCount = Size;
       hswpmi->ErrorCode = HAL_SWPMI_ERROR_NONE;
 
       /* Check if a transmit process is ongoing or not */
       if (tmp_state == HAL_SWPMI_STATE_READY)
       {
         hswpmi->State = HAL_SWPMI_STATE_BUSY_RX;
 
         /* Enable SWPMI peripheral if not */
         SET_BIT(hswpmi->Instance->CR, SWPMI_CR_SWPACT);
       }
       else
       {
         hswpmi->State = HAL_SWPMI_STATE_BUSY_TX_RX;
       }
 
       /* Process Unlocked */
       __HAL_UNLOCK(hswpmi);
 
       /* Enable the SWPMI slave resume */
       /* Enable the SWPMI Data Register not empty Interrupt, receive CRC Error, receive overrun and RxBuf Interrupt */
       /*  Enable the SWPMI Transmit/Reception completion   */
       __HAL_SWPMI_ENABLE_IT(hswpmi, SWPMI_IT_RIE | SWPMI_IT_RXBERIE | SWPMI_IT_RXOVRIE | SWPMI_IT_RXBFIE);
     }
     else
     {
       status = HAL_BUSY;
 
       /* Process Unlocked */
       __HAL_UNLOCK(hswpmi);
     }
   }
 
   return status;
 }
 
 /**
   * @brief  Transmit an amount of data in non-blocking mode with DMA interrupt.
   * @param  hswpmi SWPMI handle
   * @param  pData Pointer to data buffer
   * @param  Size Amount of data to be sent
   * @retval HAL status
   */
 HAL_StatusTypeDef HAL_SWPMI_Transmit_DMA(SWPMI_HandleTypeDef *hswpmi, uint32_t *pData, uint16_t Size)
 {
   HAL_StatusTypeDef status = HAL_OK;
   HAL_SWPMI_StateTypeDef tmp_state;
 
   if ((pData == NULL) || (Size == 0U))
   {
     status =  HAL_ERROR;
   }
   else
   {
     /* Process Locked */
     __HAL_LOCK(hswpmi);
 
     tmp_state = hswpmi->State;
     if ((tmp_state == HAL_SWPMI_STATE_READY) || (tmp_state == HAL_SWPMI_STATE_BUSY_RX))
     {
       /* Update handle */
       hswpmi->pTxBuffPtr = pData;
       hswpmi->TxXferSize = Size;
       hswpmi->TxXferCount = Size;
       hswpmi->ErrorCode = HAL_SWPMI_ERROR_NONE;
 
       /* Check if a receive process is ongoing or not */
       if (tmp_state == HAL_SWPMI_STATE_READY)
       {
         hswpmi->State = HAL_SWPMI_STATE_BUSY_TX;
 
         /* Enable SWPMI peripheral if not */
         SET_BIT(hswpmi->Instance->CR, SWPMI_CR_SWPACT);
       }
       else
       {
         hswpmi->State = HAL_SWPMI_STATE_BUSY_TX_RX;
       }
 
       /* Set the SWPMI DMA transfer complete callback */
       hswpmi->hdmatx->XferCpltCallback = SWPMI_DMATransmitCplt;
 
       /* Set the SWPMI DMA Half transfer complete callback */
       hswpmi->hdmatx->XferHalfCpltCallback = SWPMI_DMATxHalfCplt;
 
       /* Set the DMA error callback */
       hswpmi->hdmatx->XferErrorCallback = SWPMI_DMAError;
 
       /* Enable the SWPMI transmit DMA stream */
       if (HAL_DMA_Start_IT(hswpmi->hdmatx, (uint32_t)hswpmi->pTxBuffPtr, (uint32_t)&hswpmi->Instance->TDR, Size) != HAL_OK)
       {
         hswpmi->State = tmp_state;    /* Back to previous state */
         hswpmi->ErrorCode = HAL_SWPMI_ERROR_DMA;
         status = HAL_ERROR;
 
         /* Process Unlocked */
         __HAL_UNLOCK(hswpmi);
       }
       else
       {
         /* Process Unlocked */
         __HAL_UNLOCK(hswpmi);
 
         /* Enable the SWPMI transmit underrun error */
         __HAL_SWPMI_ENABLE_IT(hswpmi, SWPMI_IT_TXUNRIE);
 
         /* Enable the DMA transfer for transmit request by setting the TXDMA bit
            in the SWPMI CR register */
         SET_BIT(hswpmi->Instance->CR, SWPMI_CR_TXDMA);
       }
     }
     else
     {
       status = HAL_BUSY;
 
       /* Process Unlocked */
       __HAL_UNLOCK(hswpmi);
     }
   }
 
   return status;
 }
 
 /**
   * @brief  Receive an amount of data in non-blocking mode with DMA interrupt.
   * @param  hswpmi SWPMI handle
   * @param  pData Pointer to data buffer
   * @param  Size Amount of data to be received
   * @retval HAL status
   */
 HAL_StatusTypeDef HAL_SWPMI_Receive_DMA(SWPMI_HandleTypeDef *hswpmi, uint32_t *pData, uint16_t Size)
 {
   HAL_StatusTypeDef status = HAL_OK;
   HAL_SWPMI_StateTypeDef tmp_state;
 
   if ((pData == NULL) || (Size == 0U))
   {
     status =  HAL_ERROR;
   }
   else
   {
     /* Process Locked */
     __HAL_LOCK(hswpmi);
 
     tmp_state = hswpmi->State;
     if ((tmp_state == HAL_SWPMI_STATE_READY) || (tmp_state == HAL_SWPMI_STATE_BUSY_TX))
     {
       /* Update handle */
       hswpmi->pRxBuffPtr = pData;
       hswpmi->RxXferSize = Size;
       hswpmi->ErrorCode = HAL_SWPMI_ERROR_NONE;
 
       /* Check if a transmit process is ongoing or not */
       if (tmp_state == HAL_SWPMI_STATE_READY)
       {
         hswpmi->State = HAL_SWPMI_STATE_BUSY_RX;
 
         /* Enable SWPMI peripheral if not */
         SET_BIT(hswpmi->Instance->CR, SWPMI_CR_SWPACT);
       }
       else
       {
         hswpmi->State = HAL_SWPMI_STATE_BUSY_TX_RX;
       }
 
       /* Set the SWPMI DMA transfer complete callback */
       hswpmi->hdmarx->XferCpltCallback = SWPMI_DMAReceiveCplt;
 
       /* Set the SWPMI DMA Half transfer complete callback */
       hswpmi->hdmarx->XferHalfCpltCallback = SWPMI_DMARxHalfCplt;
 
       /* Set the DMA error callback */
       hswpmi->hdmarx->XferErrorCallback = SWPMI_DMAError;
 
       /* Enable the DMA request */
       if (HAL_DMA_Start_IT(hswpmi->hdmarx, (uint32_t)&hswpmi->Instance->RDR, (uint32_t)hswpmi->pRxBuffPtr, Size) != HAL_OK)
       {
         hswpmi->State = tmp_state;    /* Back to previous state */
         hswpmi->ErrorCode = HAL_SWPMI_ERROR_DMA;
         status = HAL_ERROR;
 
         /* Process Unlocked */
         __HAL_UNLOCK(hswpmi);
       }
       else
       {
         /* Process Unlocked */
         __HAL_UNLOCK(hswpmi);
 
         /* Enable the SWPMI receive CRC Error and receive overrun interrupts */
         __HAL_SWPMI_ENABLE_IT(hswpmi, SWPMI_IT_RXBERIE | SWPMI_IT_RXOVRIE);
 
         /* Enable the DMA transfer for the receiver request by setting the RXDMA bit
            in the SWPMI CR register */
         SET_BIT(hswpmi->Instance->CR, SWPMI_CR_RXDMA);
       }
     }
     else
     {
       status = HAL_BUSY;
 
       /* Process Unlocked */
       __HAL_UNLOCK(hswpmi);
     }
   }
 
   return status;
 }
 
 /**
   * @brief Stop all DMA transfers.
   * @param hswpmi SWPMI handle
   * @retval HAL status
   */
 HAL_StatusTypeDef HAL_SWPMI_DMAStop(SWPMI_HandleTypeDef *hswpmi)
 {
   HAL_StatusTypeDef status = HAL_OK;
 
   /* Process Locked */
   __HAL_LOCK(hswpmi);
 
   /* Disable the SWPMI Tx/Rx DMA requests */
   CLEAR_BIT(hswpmi->Instance->CR, (SWPMI_CR_TXDMA | SWPMI_CR_RXDMA));
 
   /* Abort the SWPMI DMA tx stream */
   if (hswpmi->hdmatx != NULL)
   {
     if (HAL_DMA_Abort(hswpmi->hdmatx) != HAL_OK)
     {
       hswpmi->ErrorCode |= HAL_SWPMI_ERROR_DMA;
       status = HAL_ERROR;
     }
   }
   /* Abort the SWPMI DMA rx stream */
   if (hswpmi->hdmarx != NULL)
   {
     if (HAL_DMA_Abort(hswpmi->hdmarx) != HAL_OK)
     {
       hswpmi->ErrorCode |= HAL_SWPMI_ERROR_DMA;
       status = HAL_ERROR;
     }
   }
 
   /* Disable SWPMI interface */
   CLEAR_BIT(hswpmi->Instance->CR, SWPMI_CR_SWPACT);
 
   hswpmi->State = HAL_SWPMI_STATE_READY;
 
   /* Process Unlocked */
   __HAL_UNLOCK(hswpmi);
 
   return status;
 }
 
 
 /**
   * @brief Enable the Loopback mode.
   * @param hswpmi SWPMI handle
   * @note  Loopback mode is to be used only for test purposes
   * @retval HAL_OK / HAL_BUSY
   */
 HAL_StatusTypeDef HAL_SWPMI_EnableLoopback(SWPMI_HandleTypeDef *hswpmi)
 {
   HAL_StatusTypeDef  status = HAL_OK;
 
   /* Process Locked */
   __HAL_LOCK(hswpmi);
 
   /* Make sure the SWPMI interface is not enabled to set the loopback mode */
   CLEAR_BIT(hswpmi->Instance->CR, SWPMI_CR_SWPACT);
 
   /* Set Loopback */
   SET_BIT(hswpmi->Instance->CR, SWPMI_CR_LPBK);
 
   /* Enable SWPMI interface in loopback mode */
   SET_BIT(hswpmi->Instance->CR, SWPMI_CR_SWPACT);
 
   /* Process Unlocked */
   __HAL_UNLOCK(hswpmi);
 
   return status;
 }
 
 /**
   * @brief Disable the Loopback mode.
   * @param hswpmi SWPMI handle
   * @note  Loopback mode is to be used only for test purposes
   * @retval HAL_OK / HAL_BUSY
   */
 HAL_StatusTypeDef HAL_SWPMI_DisableLoopback(SWPMI_HandleTypeDef *hswpmi)
 {
   HAL_StatusTypeDef  status = HAL_OK;
 
   /* Process Locked */
   __HAL_LOCK(hswpmi);
 
   /* Make sure the SWPMI interface is not enabled to reset the loopback mode */
   CLEAR_BIT(hswpmi->Instance->CR, SWPMI_CR_SWPACT);
 
   /* Reset Loopback */
   CLEAR_BIT(hswpmi->Instance->CR, SWPMI_CR_LPBK);
 
   /* Re-enable SWPMI interface in normal mode */
   SET_BIT(hswpmi->Instance->CR, SWPMI_CR_SWPACT);
 
   /* Process Unlocked */
   __HAL_UNLOCK(hswpmi);
 
   return status;
 }
 
 /**
   * @}
   */
 
 /** @defgroup SWPMI_Exported_Group3 SWPMI IRQ handler and callbacks
   * @ingroup RTEMSBSPsARMSTM32H7
  *  @brief  SWPMI  IRQ handler.
  *
 @verbatim
   ==============================================================================
                       ##### SWPMI IRQ handler and callbacks  #####
   ==============================================================================
 [..]  This section provides SWPMI IRQ handler and callback functions called within
       the IRQ handler.
 
 @endverbatim
   * @{
   */
 
 /**
   * @brief Handle SWPMI interrupt request.
   * @param hswpmi SWPMI handle
   * @retval None
   */
 void HAL_SWPMI_IRQHandler(SWPMI_HandleTypeDef *hswpmi)
 {
   uint32_t regisr = READ_REG(hswpmi->Instance->ISR);
   uint32_t regier = READ_REG(hswpmi->Instance->IER);
   uint32_t errcode = HAL_SWPMI_ERROR_NONE;
 
   /* SWPMI CRC error interrupt occurred --------------------------------------*/
   if (((regisr & SWPMI_FLAG_RXBERF) != 0U) && ((regier & SWPMI_IT_RXBERIE) != 0U))
   {
     /* Disable Receive CRC interrupt */
     CLEAR_BIT(hswpmi->Instance->IER, SWPMI_IT_RXBERIE | SWPMI_IT_RXBFIE);
     /* Clear Receive CRC and Receive buffer full flag */
     WRITE_REG(hswpmi->Instance->ICR, SWPMI_FLAG_RXBERF | SWPMI_FLAG_RXBFF);
 
     errcode |= HAL_SWPMI_ERROR_CRC;
   }
 
   /* SWPMI Over-Run interrupt occurred -----------------------------------------*/
   if (((regisr & SWPMI_FLAG_RXOVRF) != 0U) && ((regier & SWPMI_IT_RXOVRIE) != 0U))
   {
     /* Disable Receive overrun interrupt */
     CLEAR_BIT(hswpmi->Instance->IER, SWPMI_IT_RXOVRIE);
     /* Clear Receive overrun flag */
     WRITE_REG(hswpmi->Instance->ICR, SWPMI_FLAG_RXOVRF);
 
     errcode |= HAL_SWPMI_ERROR_OVR;
   }
 
   /* SWPMI Under-Run interrupt occurred -----------------------------------------*/
   if (((regisr & SWPMI_FLAG_TXUNRF) != 0U) && ((regier & SWPMI_IT_TXUNRIE) != 0U))
   {
     /* Disable Transmit under run interrupt */
     CLEAR_BIT(hswpmi->Instance->IER, SWPMI_IT_TXUNRIE);
     /* Clear Transmit under run flag */
     WRITE_REG(hswpmi->Instance->ICR, SWPMI_FLAG_TXUNRF);
 
     errcode |= HAL_SWPMI_ERROR_UDR;
   }
 
   /* Call SWPMI Error Call back function if needed --------------------------*/
   if (errcode != HAL_SWPMI_ERROR_NONE)
   {
     hswpmi->ErrorCode |= errcode;
 
     if ((errcode & HAL_SWPMI_ERROR_UDR) != 0U)
     {
       /* Check TXDMA transfer to abort */
       if (HAL_IS_BIT_SET(hswpmi->Instance->CR, SWPMI_CR_TXDMA))
       {
         /* Disable DMA TX at SWPMI level */
         CLEAR_BIT(hswpmi->Instance->CR, SWPMI_CR_TXDMA);
 
         /* Abort the USART DMA Tx stream */
         if (hswpmi->hdmatx != NULL)
         {
           /* Set the SWPMI Tx DMA Abort callback :
              will lead to call HAL_SWPMI_ErrorCallback() at end of DMA abort procedure */
           hswpmi->hdmatx->XferAbortCallback = SWPMI_DMAAbortOnError;
           /* Abort DMA TX */
           if (HAL_DMA_Abort_IT(hswpmi->hdmatx) != HAL_OK)
           {
             /* Call Directly hswpmi->hdmatx->XferAbortCallback function in case of error */
             hswpmi->hdmatx->XferAbortCallback(hswpmi->hdmatx);
           }
         }
         else
         {
           /* Set the SWPMI state ready to be able to start again the process */
           hswpmi->State = HAL_SWPMI_STATE_READY;
 
 #if (USE_HAL_SWPMI_REGISTER_CALLBACKS == 1)
           hswpmi->ErrorCallback(hswpmi);
 #else
           HAL_SWPMI_ErrorCallback(hswpmi);
 #endif
         }
       }
       else
       {
         /* Set the SWPMI state ready to be able to start again the process */
         hswpmi->State = HAL_SWPMI_STATE_READY;
 
 #if (USE_HAL_SWPMI_REGISTER_CALLBACKS == 1)
         hswpmi->ErrorCallback(hswpmi);
 #else
         HAL_SWPMI_ErrorCallback(hswpmi);
 #endif
       }
     }
     else
     {
       /* Check RXDMA transfer to abort */
       if (HAL_IS_BIT_SET(hswpmi->Instance->CR, SWPMI_CR_RXDMA))
       {
         /* Disable DMA RX at SWPMI level */
         CLEAR_BIT(hswpmi->Instance->CR, SWPMI_CR_RXDMA);
 
         /* Abort the USART DMA Rx stream */
         if (hswpmi->hdmarx != NULL)
         {
           /* Set the SWPMI Rx DMA Abort callback :
              will lead to call HAL_SWPMI_ErrorCallback() at end of DMA abort procedure */
           hswpmi->hdmarx->XferAbortCallback = SWPMI_DMAAbortOnError;
           /* Abort DMA RX */
           if (HAL_DMA_Abort_IT(hswpmi->hdmarx) != HAL_OK)
           {
             /* Call Directly hswpmi->hdmarx->XferAbortCallback function in case of error */
             hswpmi->hdmarx->XferAbortCallback(hswpmi->hdmarx);
           }
         }
         else
         {
           /* Set the SWPMI state ready to be able to start again the process */
           hswpmi->State = HAL_SWPMI_STATE_READY;
 
 #if (USE_HAL_SWPMI_REGISTER_CALLBACKS == 1)
           hswpmi->ErrorCallback(hswpmi);
 #else
           HAL_SWPMI_ErrorCallback(hswpmi);
 #endif
         }
       }
       else
       {
         /* Set the SWPMI state ready to be able to start again the process */
         hswpmi->State = HAL_SWPMI_STATE_READY;
 
 #if (USE_HAL_SWPMI_REGISTER_CALLBACKS == 1)
         hswpmi->ErrorCallback(hswpmi);
 #else
         HAL_SWPMI_ErrorCallback(hswpmi);
 #endif
       }
     }
   }
 
   /* SWPMI in mode Receiver ---------------------------------------------------*/
   if (((regisr & SWPMI_FLAG_RXNE) != 0U) && ((regier & SWPMI_IT_RIE)  != 0U))
   {
     SWPMI_Receive_IT(hswpmi);
   }
 
   /* SWPMI in mode Transmitter ------------------------------------------------*/
   if (((regisr & SWPMI_FLAG_TXE) != 0U) && ((regier & SWPMI_IT_TIE) != 0U))
   {
     SWPMI_Transmit_IT(hswpmi);
   }
 
   /* SWPMI in mode Transmitter (Transmit buffer empty) ------------------------*/
   if (((regisr & SWPMI_FLAG_TXBEF) != 0U) && ((regier & SWPMI_IT_TXBEIE) != 0U))
   {
     SWPMI_EndTransmit_IT(hswpmi);
   }
 
   /* SWPMI in mode Receiver (Receive buffer full) -----------------------------*/
   if (((regisr & SWPMI_FLAG_RXBFF) != 0U) && ((regier & SWPMI_IT_RXBFIE) != 0U))
   {
     SWPMI_EndReceive_IT(hswpmi);
   }
 
   /* Both Transmission and reception complete ---------------------------------*/
   if (((regisr & SWPMI_FLAG_TCF) != 0U) && ((regier & SWPMI_IT_TCIE) != 0U))
   {
     SWPMI_EndTransmitReceive_IT(hswpmi);
   }
 }
 
 /**
   * @brief Tx Transfer completed callback.
   * @param hswpmi SWPMI handle
   * @retval None
   */
 __weak void HAL_SWPMI_TxCpltCallback(SWPMI_HandleTypeDef *hswpmi)
 {
   /* Prevent unused argument(s) compilation warning */
   UNUSED(hswpmi);
 
   /* NOTE : This function should not be modified, when the callback is needed,
             the HAL_SWPMI_TxCpltCallback is to be implemented in the user file
    */
 }
 
 /**
   * @brief  Tx Half Transfer completed callback.
   * @param  hswpmi SWPMI handle
   * @retval None
   */
 __weak void HAL_SWPMI_TxHalfCpltCallback(SWPMI_HandleTypeDef *hswpmi)
 {
   /* Prevent unused argument(s) compilation warning */
   UNUSED(hswpmi);
 
   /* NOTE: This function should not be modified, when the callback is needed,
            the HAL_SWPMI_TxHalfCpltCallback is to be implemented in the user file
    */
 }
 
 /**
   * @brief Rx Transfer completed callback.
   * @param hswpmi SWPMI handle
   * @retval None
   */
 __weak void HAL_SWPMI_RxCpltCallback(SWPMI_HandleTypeDef *hswpmi)
 {
   /* Prevent unused argument(s) compilation warning */
   UNUSED(hswpmi);
 
   /* NOTE : This function should not be modified, when the callback is needed,
             the HAL_SWPMI_RxCpltCallback is to be implemented in the user file
    */
 }
 
 /**
   * @brief  Rx Half Transfer completed callback.
   * @param  hswpmi SWPMI handle
   * @retval None
   */
 __weak void HAL_SWPMI_RxHalfCpltCallback(SWPMI_HandleTypeDef *hswpmi)
 {
   /* Prevent unused argument(s) compilation warning */
   UNUSED(hswpmi);
 
   /* NOTE: This function should not be modified, when the callback is needed,
            the HAL_SWPMI_RxHalfCpltCallback is to be implemented in the user file
    */
 }
 
 /**
   * @brief SWPMI error callback.
   * @param hswpmi SWPMI handle
   * @retval None
   */
 __weak void HAL_SWPMI_ErrorCallback(SWPMI_HandleTypeDef *hswpmi)
 {
   /* Prevent unused argument(s) compilation warning */
   UNUSED(hswpmi);
 
   /* NOTE : This function should not be modified, when the callback is needed,
             the HAL_SWPMI_ErrorCallback is to be implemented in the user file
    */
 }
 
 /**
   * @}
   */
 
 /** @defgroup SWPMI_Exported_Group4 Peripheral Control methods
   * @ingroup RTEMSBSPsARMSTM32H7
   *  @brief   SWPMI control functions
   *
 @verbatim
  ===============================================================================
                       ##### Peripheral Control methods #####
  ===============================================================================
     [..]
     This subsection provides a set of functions allowing to control the SWPMI.
      (+) HAL_SWPMI_GetState() API is helpful to check in run-time the state of the SWPMI peripheral
      (+) HAL_SWPMI_GetError() API is helpful to check in run-time the error state of the SWPMI peripheral
 @endverbatim
   * @{
   */
 
 /**
   * @brief Return the SWPMI handle state.
   * @param hswpmi SWPMI handle
   * @retval HAL state
   */
 HAL_SWPMI_StateTypeDef HAL_SWPMI_GetState(SWPMI_HandleTypeDef *hswpmi)
 {
   /* Return SWPMI handle state */
   return hswpmi->State;
 }
 
 /**
 * @brief  Return the SWPMI error code.
 * @param  hswpmi : pointer to a SWPMI_HandleTypeDef structure that contains
   *              the configuration information for the specified SWPMI.
 * @retval SWPMI Error Code
 */
 uint32_t HAL_SWPMI_GetError(SWPMI_HandleTypeDef *hswpmi)
 {
   return hswpmi->ErrorCode;
 }
 
 /**
   * @}
   */
 
 /**
   * @}
   */
 
 /* Private functions ---------------------------------------------------------*/
 
 /** @defgroup SWPMI_Private_Functions SWPMI Private Functions
   * @ingroup RTEMSBSPsARMSTM32H7
   * @{
   */
 
 /**
   * @brief Transmit an amount of data in interrupt mode.
   * @note  Function called under interruption only, once interruptions have been enabled by HAL_SWPMI_Transmit_IT()
   * @param  hswpmi SWPMI handle
   * @retval None
   */
 static void SWPMI_Transmit_IT(SWPMI_HandleTypeDef *hswpmi)
 {
   HAL_SWPMI_StateTypeDef tmp_state = hswpmi->State;
 
   if ((tmp_state == HAL_SWPMI_STATE_BUSY_TX) || (tmp_state == HAL_SWPMI_STATE_BUSY_TX_RX))
   {
     if (hswpmi->TxXferCount == 0U)
     {
       /* Disable the SWPMI TXE and Underrun Interrupts */
       CLEAR_BIT(hswpmi->Instance->IER, (SWPMI_IT_TIE | SWPMI_IT_TXUNRIE));
     }
     else
     {
       hswpmi->Instance->TDR = (uint32_t) * hswpmi->pTxBuffPtr;
       hswpmi->pTxBuffPtr++;
       hswpmi->TxXferCount--;
     }
   }
   else
   {
     /* nothing to do */
   }
 }
 
 /**
   * @brief  Wraps up transmission in non-blocking mode.
   * @param  hswpmi SWPMI handle
   * @retval None
   */
 static void SWPMI_EndTransmit_IT(SWPMI_HandleTypeDef *hswpmi)
 {
   /* Clear the SWPMI Transmit buffer empty Flag */
   WRITE_REG(hswpmi->Instance->ICR, SWPMI_FLAG_TXBEF);
   /* Disable the all SWPMI Transmit Interrupts  */
   CLEAR_BIT(hswpmi->Instance->IER, SWPMI_IT_TIE | SWPMI_IT_TXUNRIE | SWPMI_IT_TXBEIE);
 
   /* Check if a receive Process is ongoing or not */
   if (hswpmi->State == HAL_SWPMI_STATE_BUSY_TX_RX)
   {
     hswpmi->State = HAL_SWPMI_STATE_BUSY_RX;
   }
   else
   {
     hswpmi->State = HAL_SWPMI_STATE_READY;
   }
 
 #if (USE_HAL_SWPMI_REGISTER_CALLBACKS == 1)
   hswpmi->TxCpltCallback(hswpmi);
 #else
   HAL_SWPMI_TxCpltCallback(hswpmi);
 #endif
 }
 
 /**
   * @brief Receive an amount of data in interrupt mode.
   * @note  Function called under interruption only, once interruptions have been enabled by HAL_SWPMI_Receive_IT()
   * @param  hswpmi SWPMI handle
   * @retval None
   */
 static void SWPMI_Receive_IT(SWPMI_HandleTypeDef *hswpmi)
 {
   HAL_SWPMI_StateTypeDef tmp_state = hswpmi->State;
 
   if ((tmp_state == HAL_SWPMI_STATE_BUSY_RX) || (tmp_state == HAL_SWPMI_STATE_BUSY_TX_RX))
   {
     *hswpmi->pRxBuffPtr = (uint32_t)(hswpmi->Instance->RDR);
     hswpmi->pRxBuffPtr++;
 
     --hswpmi->RxXferCount;
     if (hswpmi->RxXferCount == 0U)
     {
       /* Wait for RXBFF flag to update state */
 #if (USE_HAL_SWPMI_REGISTER_CALLBACKS == 1)
       hswpmi->RxCpltCallback(hswpmi);
 #else
       HAL_SWPMI_RxCpltCallback(hswpmi);
 #endif
     }
   }
   else
   {
     /* nothing to do */
   }
 }
 
 /**
   * @brief  Wraps up reception in non-blocking mode.
   * @param  hswpmi SWPMI handle
   * @retval None
   */
 static void SWPMI_EndReceive_IT(SWPMI_HandleTypeDef *hswpmi)
 {
   /* Clear the SWPMI Receive buffer full Flag */
   WRITE_REG(hswpmi->Instance->ICR, SWPMI_FLAG_RXBFF);
   /* Disable the all SWPMI Receive Interrupts  */
   CLEAR_BIT(hswpmi->Instance->IER, SWPMI_IT_RIE | SWPMI_IT_RXBERIE | SWPMI_IT_RXOVRIE | SWPMI_IT_RXBFIE);
 
   /* Check if a transmit Process is ongoing or not */
   if (hswpmi->State == HAL_SWPMI_STATE_BUSY_TX_RX)
   {
     hswpmi->State = HAL_SWPMI_STATE_BUSY_TX;
   }
   else
   {
     hswpmi->State = HAL_SWPMI_STATE_READY;
   }
 }
 
 /**
   * @brief  Wraps up transmission and reception in non-blocking mode.
   * @param  hswpmi SWPMI handle
   * @retval None
   */
 static void SWPMI_EndTransmitReceive_IT(SWPMI_HandleTypeDef *hswpmi)
 {
   /* Clear the SWPMI Transmission Complete Flag */
   WRITE_REG(hswpmi->Instance->ICR, SWPMI_FLAG_TCF);
   /* Disable the SWPMI Transmission  Complete Interrupt */
   CLEAR_BIT(hswpmi->Instance->IER, SWPMI_IT_TCIE);
 
   /* Check if a receive Process is ongoing or not */
   if (hswpmi->State == HAL_SWPMI_STATE_BUSY_TX_RX)
   {
     hswpmi->State = HAL_SWPMI_STATE_BUSY_RX;
   }
   else if (hswpmi->State == HAL_SWPMI_STATE_BUSY_TX)
   {
     hswpmi->State = HAL_SWPMI_STATE_READY;
   }
   else
   {
     /* nothing to do */
   }
 }
 
 /**
   * @brief DMA SWPMI transmit process complete callback.
   * @param hdma DMA handle
   * @retval None
   */
 static void SWPMI_DMATransmitCplt(DMA_HandleTypeDef *hdma)
 {
   SWPMI_HandleTypeDef *hswpmi = (SWPMI_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
   uint32_t tickstart;
 
   /* DMA Normal mode*/
   if (((((DMA_Stream_TypeDef *)hdma->Instance)->CR) & DMA_SxCR_CIRC) == 0U)
   {
     hswpmi->TxXferCount = 0U;
 
     /* Disable the DMA transfer for transmit request by setting the TXDMA bit
     in the SWPMI CR register */
     CLEAR_BIT(hswpmi->Instance->CR, SWPMI_CR_TXDMA);
 
     /* Init tickstart for timeout management*/
     tickstart = HAL_GetTick();
 
     /* Wait the TXBEF */
     if (SWPMI_WaitOnFlagSetUntilTimeout(hswpmi, SWPMI_FLAG_TXBEF, tickstart, SWPMI_TIMEOUT_VALUE) != HAL_OK)
     {
       /* Timeout occurred */
       hswpmi->ErrorCode |= HAL_SWPMI_ERROR_TXBEF_TIMEOUT;
 
 #if (USE_HAL_SWPMI_REGISTER_CALLBACKS == 1)
       hswpmi->ErrorCallback(hswpmi);
 #else
       HAL_SWPMI_ErrorCallback(hswpmi);
 #endif
     }
     else
     {
       /* No Timeout */
       /* Check if a receive process is ongoing or not */
       if (hswpmi->State == HAL_SWPMI_STATE_BUSY_TX_RX)
       {
         hswpmi->State = HAL_SWPMI_STATE_BUSY_RX;
       }
       else
       {
         hswpmi->State = HAL_SWPMI_STATE_READY;
       }
 
 #if (USE_HAL_SWPMI_REGISTER_CALLBACKS == 1)
       hswpmi->TxCpltCallback(hswpmi);
 #else
       HAL_SWPMI_TxCpltCallback(hswpmi);
 #endif
     }
   }
   /* DMA Circular mode */
   else
   {
 #if (USE_HAL_SWPMI_REGISTER_CALLBACKS == 1)
     hswpmi->TxCpltCallback(hswpmi);
 #else
     HAL_SWPMI_TxCpltCallback(hswpmi);
 #endif
   }
 }
 
 /**
   * @brief DMA SWPMI transmit process half complete callback.
   * @param hdma DMA handle
   * @retval None
   */
 static void SWPMI_DMATxHalfCplt(DMA_HandleTypeDef *hdma)
 {
   SWPMI_HandleTypeDef *hswpmi = (SWPMI_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
 
 #if (USE_HAL_SWPMI_REGISTER_CALLBACKS == 1)
   hswpmi->TxHalfCpltCallback(hswpmi);
 #else
   HAL_SWPMI_TxHalfCpltCallback(hswpmi);
 #endif
 }
 
 
 /**
   * @brief DMA SWPMI receive process complete callback.
   * @param hdma DMA handle
   * @retval None
   */
 static void SWPMI_DMAReceiveCplt(DMA_HandleTypeDef *hdma)
 {
   SWPMI_HandleTypeDef *hswpmi = (SWPMI_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
 
   /* DMA Normal mode*/
   if (((((DMA_Stream_TypeDef *)hdma->Instance)->CR) & DMA_SxCR_CIRC) == 0U)
   {
     hswpmi->RxXferCount = 0U;
 
     /* Disable the DMA transfer for the receiver request by setting the RXDMA bit
     in the SWPMI CR register */
     CLEAR_BIT(hswpmi->Instance->CR, SWPMI_CR_RXDMA);
 
     /* Check if a transmit Process is ongoing or not */
     if (hswpmi->State == HAL_SWPMI_STATE_BUSY_TX_RX)
     {
       hswpmi->State = HAL_SWPMI_STATE_BUSY_TX;
     }
     else
     {
       hswpmi->State = HAL_SWPMI_STATE_READY;
     }
   }
 #if (USE_HAL_SWPMI_REGISTER_CALLBACKS == 1)
   hswpmi->RxCpltCallback(hswpmi);
 #else
   HAL_SWPMI_RxCpltCallback(hswpmi);
 #endif
 }
 
 /**
   * @brief DMA SWPMI receive process half complete callback.
   * @param hdma DMA handle
   * @retval None
   */
 static void SWPMI_DMARxHalfCplt(DMA_HandleTypeDef *hdma)
 {
   SWPMI_HandleTypeDef *hswpmi = (SWPMI_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
 
 #if (USE_HAL_SWPMI_REGISTER_CALLBACKS == 1)
   hswpmi->RxHalfCpltCallback(hswpmi);
 #else
   HAL_SWPMI_RxHalfCpltCallback(hswpmi);
 #endif
 }
 
 /**
   * @brief DMA SWPMI communication error callback.
   * @param hdma DMA handle
   * @retval None
   */
 static void SWPMI_DMAError(DMA_HandleTypeDef *hdma)
 {
   SWPMI_HandleTypeDef *hswpmi = (SWPMI_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
 
   /* Update handle */
   hswpmi->RxXferCount = 0U;
   hswpmi->TxXferCount = 0U;
   hswpmi->State = HAL_SWPMI_STATE_READY;
   hswpmi->ErrorCode |= HAL_SWPMI_ERROR_DMA;
 
 #if (USE_HAL_SWPMI_REGISTER_CALLBACKS == 1)
   hswpmi->ErrorCallback(hswpmi);
 #else
   HAL_SWPMI_ErrorCallback(hswpmi);
 #endif
 }
 
 /**
   * @brief DMA SWPMI communication abort callback.
   * @param hdma DMA handle
   * @retval None
   */
 static void SWPMI_DMAAbortOnError(DMA_HandleTypeDef *hdma)
 {
   SWPMI_HandleTypeDef *hswpmi = (SWPMI_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
 
   /* Update handle */
   hswpmi->RxXferCount = 0U;
   hswpmi->TxXferCount = 0U;
   hswpmi->State = HAL_SWPMI_STATE_READY;
 
 #if (USE_HAL_SWPMI_REGISTER_CALLBACKS == 1)
   hswpmi->ErrorCallback(hswpmi);
 #else
   HAL_SWPMI_ErrorCallback(hswpmi);
 #endif
 }
 
 /**
   * @brief  Handle SWPMI Communication Timeout.
   * @param  hswpmi SWPMI handle
   * @param  Flag specifies the SWPMI flag to check.
   * @param  Tickstart Tick start value
   * @param  Timeout timeout duration.
   * @retval HAL status
   */
 static HAL_StatusTypeDef SWPMI_WaitOnFlagSetUntilTimeout(SWPMI_HandleTypeDef *hswpmi, uint32_t Flag, uint32_t Tickstart, uint32_t Timeout)
 {
   HAL_StatusTypeDef status = HAL_OK;
 
   /* Wait until flag is set */
   while (!(HAL_IS_BIT_SET(hswpmi->Instance->ISR, Flag)))
   {
     /* Check for the Timeout */
     if ((((HAL_GetTick() - Tickstart) >  Timeout) && (Timeout != HAL_MAX_DELAY)) || (Timeout == 0U))
     {
       /* Set the SWPMI state ready to be able to start again the process */
       hswpmi->State = HAL_SWPMI_STATE_READY;
 
       status = HAL_TIMEOUT;
       break;
     }
   }
 
   return status;
 }
 
 /**
   * @}
   */
 
 #endif /* HAL_SWPMI_MODULE_ENABLED */
 
 /**
   * @}
   */
 
 
 /**
   * @}
   */

This page was automatically generated by the 2.3.7 LXR engine. The LXR team