WebSVN – canSerial – Diff – /trunk/Drivers/STM32F1xx_HAL_Driver/Src/stm32f1xx_hal_irda.c

 /**
   ******************************************************************************
   * @file    stm32f1xx_hal_irda.c
   * @author  MCD Application Team
   * @brief   IRDA HAL module driver.
   *          This file provides firmware functions to manage the following
   *          functionalities of the IrDA SIR ENDEC block (IrDA):
   *           + Initialization and de-initialization functions
   *           + IO operation functions
   *           + Peripheral Control functions
   *           + Peripheral State and Errors functions
-  @verbatim
+  *
-  ==============================================================================
+  ******************************************************************************
-                        ##### How to use this driver #####
+  * @attention
-  ==============================================================================
+  *
-  [..]
+  * Copyright (c) 2016 STMicroelectronics.
-    The IRDA HAL driver can be used as follows:
+  * All rights reserved.
+  *
-    (#) Declare a IRDA_HandleTypeDef handle structure (eg. IRDA_HandleTypeDef hirda).
+  * This software is licensed under terms that can be found in the LICENSE file
-    (#) Initialize the IRDA low level resources by implementing the HAL_IRDA_MspInit() API:
+  * in the root directory of this software component.
-        (##) Enable the USARTx interface clock.
+  * If no LICENSE file comes with this software, it is provided AS-IS.
-        (##) IRDA pins configuration:
+  *
-            (+++) Enable the clock for the IRDA GPIOs.
+  ******************************************************************************
-            (+++) Configure IRDA pins as alternate function pull-up.
+  @verbatim
-        (##) NVIC configuration if you need to use interrupt process (HAL_IRDA_Transmit_IT()
+  ==============================================================================
-             and HAL_IRDA_Receive_IT() APIs):
+                        ##### How to use this driver #####
-            (+++) Configure the USARTx interrupt priority.
+  ==============================================================================
-            (+++) Enable the NVIC USART IRQ handle.
+  [..]
-        (##) DMA Configuration if you need to use DMA process (HAL_IRDA_Transmit_DMA()
+    The IRDA HAL driver can be used as follows:
-             and HAL_IRDA_Receive_DMA() APIs):
-            (+++) Declare a DMA handle structure for the Tx/Rx channel.
+    (#) Declare a IRDA_HandleTypeDef handle structure (eg. IRDA_HandleTypeDef hirda).
-            (+++) Enable the DMAx interface clock.
+    (#) Initialize the IRDA low level resources by implementing the HAL_IRDA_MspInit() API:
-            (+++) Configure the declared DMA handle structure with the required Tx/Rx parameters.
+        (##) Enable the USARTx interface clock.
-            (+++) Configure the DMA Tx/Rx channel.
+        (##) IRDA pins configuration:
-            (+++) Associate the initialized DMA handle to the IRDA DMA Tx/Rx handle.
+            (+++) Enable the clock for the IRDA GPIOs.
-            (+++) Configure the priority and enable the NVIC for the transfer complete interrupt on the DMA Tx/Rx channel.
+            (+++) Configure IRDA pins as alternate function pull-up.
-            (+++) Configure the IRDAx interrupt priority and enable the NVIC USART IRQ handle
+        (##) NVIC configuration if you need to use interrupt process (HAL_IRDA_Transmit_IT()
-                  (used for last byte sending completion detection in DMA non circular mode)
+             and HAL_IRDA_Receive_IT() APIs):
+            (+++) Configure the USARTx interrupt priority.
-    (#) Program the Baud Rate, Word Length, Parity, IrDA Mode, Prescaler
+            (+++) Enable the NVIC USART IRQ handle.
-        and Mode(Receiver/Transmitter) in the hirda Init structure.
+        (##) DMA Configuration if you need to use DMA process (HAL_IRDA_Transmit_DMA()
+             and HAL_IRDA_Receive_DMA() APIs):
-    (#) Initialize the IRDA registers by calling the HAL_IRDA_Init() API:
+            (+++) Declare a DMA handle structure for the Tx/Rx channel.
-        (++) This API configures also the low level Hardware GPIO, CLOCK, CORTEX...etc)
+            (+++) Enable the DMAx interface clock.
-             by calling the customized HAL_IRDA_MspInit() API.
+            (+++) Configure the declared DMA handle structure with the required Tx/Rx parameters.
+            (+++) Configure the DMA Tx/Rx channel.
-         -@@- The specific IRDA interrupts (Transmission complete interrupt,
+            (+++) Associate the initialized DMA handle to the IRDA DMA Tx/Rx handle.
-             RXNE interrupt and Error Interrupts) will be managed using the macros
+            (+++) Configure the priority and enable the NVIC for the transfer complete interrupt on the DMA Tx/Rx channel.
-             __HAL_IRDA_ENABLE_IT() and __HAL_IRDA_DISABLE_IT() inside the transmit and receive process.
+            (+++) Configure the IRDAx interrupt priority and enable the NVIC USART IRQ handle
+                  (used for last byte sending completion detection in DMA non circular mode)
-    (#) Three operation modes are available within this driver :
+    (#) Program the Baud Rate, Word Length, Parity, IrDA Mode, Prescaler
-    *** Polling mode IO operation ***
+        and Mode(Receiver/Transmitter) in the hirda Init structure.
-    =================================
-    [..]
+    (#) Initialize the IRDA registers by calling the HAL_IRDA_Init() API:
-      (+) Send an amount of data in blocking mode using HAL_IRDA_Transmit()
+        (++) This API configures also the low level Hardware GPIO, CLOCK, CORTEX...etc)
-      (+) Receive an amount of data in blocking mode using HAL_IRDA_Receive()
+             by calling the customized HAL_IRDA_MspInit() API.
-    *** Interrupt mode IO operation ***
+         -@@- The specific IRDA interrupts (Transmission complete interrupt,
-    ===================================
+             RXNE interrupt and Error Interrupts) will be managed using the macros
-    [..]
+             __HAL_IRDA_ENABLE_IT() and __HAL_IRDA_DISABLE_IT() inside the transmit and receive process.
-      (+) Send an amount of data in non blocking mode using HAL_IRDA_Transmit_IT()
-      (+) At transmission end of transfer HAL_IRDA_TxCpltCallback is executed and user can
+    (#) Three operation modes are available within this driver :
-           add his own code by customization of function pointer HAL_IRDA_TxCpltCallback
-      (+) Receive an amount of data in non blocking mode using HAL_IRDA_Receive_IT()
+    *** Polling mode IO operation ***
-      (+) At reception end of transfer HAL_IRDA_RxCpltCallback is executed and user can
+    =================================
-           add his own code by customization of function pointer HAL_IRDA_RxCpltCallback
+    [..]
-      (+) In case of transfer Error, HAL_IRDA_ErrorCallback() function is executed and user can
+      (+) Send an amount of data in blocking mode using HAL_IRDA_Transmit()
-           add his own code by customization of function pointer HAL_IRDA_ErrorCallback
+      (+) Receive an amount of data in blocking mode using HAL_IRDA_Receive()
-    *** DMA mode IO operation ***
+    *** Interrupt mode IO operation ***
-    =============================
+    ===================================
     [..]
-      (+) Send an amount of data in non blocking mode (DMA) using HAL_IRDA_Transmit_DMA()
+      (+) Send an amount of data in non blocking mode using HAL_IRDA_Transmit_IT()
-      (+) At transmission end of half transfer HAL_IRDA_TxHalfCpltCallback is executed and user can
+      (+) At transmission end of transfer HAL_IRDA_TxCpltCallback is executed and user can
-            add his own code by customization of function pointer HAL_IRDA_TxHalfCpltCallback
+           add his own code by customization of function pointer HAL_IRDA_TxCpltCallback
-      (+) At transmission end of transfer HAL_IRDA_TxCpltCallback is executed and user can
+      (+) Receive an amount of data in non blocking mode using HAL_IRDA_Receive_IT()
-           add his own code by customization of function pointer HAL_IRDA_TxCpltCallback
+      (+) At reception end of transfer HAL_IRDA_RxCpltCallback is executed and user can
-      (+) Receive an amount of data in non blocking mode (DMA) using HAL_IRDA_Receive_DMA()
+           add his own code by customization of function pointer HAL_IRDA_RxCpltCallback
-      (+) At reception end of half transfer HAL_IRDA_RxHalfCpltCallback is executed and user can
+      (+) In case of transfer Error, HAL_IRDA_ErrorCallback() function is executed and user can
-            add his own code by customization of function pointer HAL_IRDA_RxHalfCpltCallback
+           add his own code by customization of function pointer HAL_IRDA_ErrorCallback
-      (+) At reception end of transfer HAL_IRDA_RxCpltCallback is executed and user can
-           add his own code by customization of function pointer HAL_IRDA_RxCpltCallback
+    *** DMA mode IO operation ***
-      (+) In case of transfer Error, HAL_IRDA_ErrorCallback() function is executed and user can
+    =============================
-           add his own code by customization of function pointer HAL_IRDA_ErrorCallback
+    [..]
-      (+) Pause the DMA Transfer using HAL_IRDA_DMAPause()
+      (+) Send an amount of data in non blocking mode (DMA) using HAL_IRDA_Transmit_DMA()
-      (+) Resume the DMA Transfer using HAL_IRDA_DMAResume()
+      (+) At transmission end of half transfer HAL_IRDA_TxHalfCpltCallback is executed and user can
-      (+) Stop the DMA Transfer using HAL_IRDA_DMAStop()
+            add his own code by customization of function pointer HAL_IRDA_TxHalfCpltCallback
+      (+) At transmission end of transfer HAL_IRDA_TxCpltCallback is executed and user can
-    *** IRDA HAL driver macros list ***
+           add his own code by customization of function pointer HAL_IRDA_TxCpltCallback
-    ===================================
+      (+) Receive an amount of data in non blocking mode (DMA) using HAL_IRDA_Receive_DMA()
-    [..]
+      (+) At reception end of half transfer HAL_IRDA_RxHalfCpltCallback is executed and user can
-      Below the list of most used macros in IRDA HAL driver.
+            add his own code by customization of function pointer HAL_IRDA_RxHalfCpltCallback
+      (+) At reception end of transfer HAL_IRDA_RxCpltCallback is executed and user can
-       (+) __HAL_IRDA_ENABLE: Enable the IRDA peripheral
+           add his own code by customization of function pointer HAL_IRDA_RxCpltCallback
-       (+) __HAL_IRDA_DISABLE: Disable the IRDA peripheral
+      (+) In case of transfer Error, HAL_IRDA_ErrorCallback() function is executed and user can
-       (+) __HAL_IRDA_GET_FLAG : Check whether the specified IRDA flag is set or not
+           add his own code by customization of function pointer HAL_IRDA_ErrorCallback
-       (+) __HAL_IRDA_CLEAR_FLAG : Clear the specified IRDA pending flag
+      (+) Pause the DMA Transfer using HAL_IRDA_DMAPause()
-       (+) __HAL_IRDA_ENABLE_IT: Enable the specified IRDA interrupt
+      (+) Resume the DMA Transfer using HAL_IRDA_DMAResume()
-       (+) __HAL_IRDA_DISABLE_IT: Disable the specified IRDA interrupt
+      (+) Stop the DMA Transfer using HAL_IRDA_DMAStop()
-       (+) __HAL_IRDA_GET_IT_SOURCE: Check whether the specified IRDA interrupt has occurred or not
+    *** IRDA HAL driver macros list ***
-    [..]
+    ===================================
-     (@) You can refer to the IRDA HAL driver header file for more useful macros
+    [..]
+      Below the list of most used macros in IRDA HAL driver.
-    ##### Callback registration #####
-    ==================================
+       (+) __HAL_IRDA_ENABLE: Enable the IRDA peripheral
+       (+) __HAL_IRDA_DISABLE: Disable the IRDA peripheral
-    [..]
+       (+) __HAL_IRDA_GET_FLAG : Check whether the specified IRDA flag is set or not
-      The compilation define USE_HAL_IRDA_REGISTER_CALLBACKS when set to 1
+       (+) __HAL_IRDA_CLEAR_FLAG : Clear the specified IRDA pending flag
-      allows the user to configure dynamically the driver callbacks.
+       (+) __HAL_IRDA_ENABLE_IT: Enable the specified IRDA interrupt
+       (+) __HAL_IRDA_DISABLE_IT: Disable the specified IRDA interrupt
-    [..]
+       (+) __HAL_IRDA_GET_IT_SOURCE: Check whether the specified IRDA interrupt has occurred or not
-      Use Function @ref HAL_IRDA_RegisterCallback() to register a user callback.
-      Function @ref HAL_IRDA_RegisterCallback() allows to register following callbacks:
+    [..]
-       (+) TxHalfCpltCallback        : Tx Half Complete Callback.
+     (@) You can refer to the IRDA HAL driver header file for more useful macros
-       (+) TxCpltCallback            : Tx Complete Callback.
-       (+) RxHalfCpltCallback        : Rx Half Complete Callback.
+    ##### Callback registration #####
-       (+) RxCpltCallback            : Rx Complete Callback.
+    ==================================
-       (+) ErrorCallback             : Error Callback.
-       (+) AbortCpltCallback         : Abort Complete Callback.
+    [..]
-       (+) AbortTransmitCpltCallback : Abort Transmit Complete Callback.
+      The compilation define USE_HAL_IRDA_REGISTER_CALLBACKS when set to 1
-       (+) AbortReceiveCpltCallback  : Abort Receive Complete Callback.
+      allows the user to configure dynamically the driver callbacks.
-       (+) MspInitCallback           : IRDA MspInit.
-       (+) MspDeInitCallback         : IRDA MspDeInit.
+    [..]
-      This function takes as parameters the HAL peripheral handle, the Callback ID
+      Use Function HAL_IRDA_RegisterCallback() to register a user callback.
-      and a pointer to the user callback function.
+      Function HAL_IRDA_RegisterCallback() allows to register following callbacks:
+       (+) TxHalfCpltCallback        : Tx Half Complete Callback.
-    [..]
+       (+) TxCpltCallback            : Tx Complete Callback.
-      Use function @ref HAL_IRDA_UnRegisterCallback() to reset a callback to the default
+       (+) RxHalfCpltCallback        : Rx Half Complete Callback.
-      weak (surcharged) function.
+       (+) RxCpltCallback            : Rx Complete Callback.
-      @ref HAL_IRDA_UnRegisterCallback() takes as parameters the HAL peripheral handle,
+       (+) ErrorCallback             : Error Callback.
-      and the Callback ID.
+       (+) AbortCpltCallback         : Abort Complete Callback.
-      This function allows to reset following callbacks:
+       (+) AbortTransmitCpltCallback : Abort Transmit Complete Callback.
-       (+) TxHalfCpltCallback        : Tx Half Complete Callback.
+       (+) AbortReceiveCpltCallback  : Abort Receive Complete Callback.
-       (+) TxCpltCallback            : Tx Complete Callback.
+       (+) MspInitCallback           : IRDA MspInit.
-       (+) RxHalfCpltCallback        : Rx Half Complete Callback.
+       (+) MspDeInitCallback         : IRDA MspDeInit.
-       (+) RxCpltCallback            : Rx Complete Callback.
+      This function takes as parameters the HAL peripheral handle, the Callback ID
-       (+) ErrorCallback             : Error Callback.
+      and a pointer to the user callback function.
-       (+) AbortCpltCallback         : Abort Complete Callback.
-       (+) AbortTransmitCpltCallback : Abort Transmit Complete Callback.
+    [..]
-       (+) AbortReceiveCpltCallback  : Abort Receive Complete Callback.
+      Use function HAL_IRDA_UnRegisterCallback() to reset a callback to the default
-       (+) MspInitCallback           : IRDA MspInit.
+      weak (surcharged) function.
-       (+) MspDeInitCallback         : IRDA MspDeInit.
+      HAL_IRDA_UnRegisterCallback() takes as parameters the HAL peripheral handle,
+      and the Callback ID.
-    [..]
+      This function allows to reset following callbacks:
-      By default, after the @ref HAL_IRDA_Init() and when the state is HAL_IRDA_STATE_RESET
+       (+) TxHalfCpltCallback        : Tx Half Complete Callback.
-      all callbacks are set to the corresponding weak (surcharged) functions:
+       (+) TxCpltCallback            : Tx Complete Callback.
-      examples @ref HAL_IRDA_TxCpltCallback(), @ref HAL_IRDA_RxHalfCpltCallback().
+       (+) RxHalfCpltCallback        : Rx Half Complete Callback.
-      Exception done for MspInit and MspDeInit functions that are respectively
+       (+) RxCpltCallback            : Rx Complete Callback.
-      reset to the legacy weak (surcharged) functions in the @ref HAL_IRDA_Init()
+       (+) ErrorCallback             : Error Callback.
-      and @ref HAL_IRDA_DeInit() only when these callbacks are null (not registered beforehand).
+       (+) AbortCpltCallback         : Abort Complete Callback.
-      If not, MspInit or MspDeInit are not null, the @ref HAL_IRDA_Init() and @ref HAL_IRDA_DeInit()
+       (+) AbortTransmitCpltCallback : Abort Transmit Complete Callback.
-      keep and use the user MspInit/MspDeInit callbacks (registered beforehand).
+       (+) AbortReceiveCpltCallback  : Abort Receive Complete Callback.
+       (+) MspInitCallback           : IRDA MspInit.
-    [..]
+       (+) MspDeInitCallback         : IRDA MspDeInit.
-      Callbacks can be registered/unregistered in HAL_IRDA_STATE_READY state only.
-      Exception done MspInit/MspDeInit that can be registered/unregistered
+    [..]
-      in HAL_IRDA_STATE_READY or HAL_IRDA_STATE_RESET state, thus registered (user)
+      By default, after the HAL_IRDA_Init() and when the state is HAL_IRDA_STATE_RESET
-      MspInit/DeInit callbacks can be used during the Init/DeInit.
+      all callbacks are set to the corresponding weak (surcharged) functions:
-      In that case first register the MspInit/MspDeInit user callbacks
+      examples HAL_IRDA_TxCpltCallback(), HAL_IRDA_RxHalfCpltCallback().
-      using @ref HAL_IRDA_RegisterCallback() before calling @ref HAL_IRDA_DeInit()
+      Exception done for MspInit and MspDeInit functions that are respectively
-      or @ref HAL_IRDA_Init() function.
+      reset to the legacy weak (surcharged) functions in the HAL_IRDA_Init()
+      and HAL_IRDA_DeInit() only when these callbacks are null (not registered beforehand).
-    [..]
+      If not, MspInit or MspDeInit are not null, the HAL_IRDA_Init() and HAL_IRDA_DeInit()
-      When The compilation define USE_HAL_IRDA_REGISTER_CALLBACKS is set to 0 or
+      keep and use the user MspInit/MspDeInit callbacks (registered beforehand).
-      not defined, the callback registration feature is not available
-      and weak (surcharged) callbacks are used.
+    [..]
+      Callbacks can be registered/unregistered in HAL_IRDA_STATE_READY state only.
-  @endverbatim
+      Exception done MspInit/MspDeInit that can be registered/unregistered
-     [..]
+      in HAL_IRDA_STATE_READY or HAL_IRDA_STATE_RESET state, thus registered (user)
-       (@) Additional remark: If the parity is enabled, then the MSB bit of the data written
+      MspInit/DeInit callbacks can be used during the Init/DeInit.
-           in the data register is transmitted but is changed by the parity bit.
+      In that case first register the MspInit/MspDeInit user callbacks
-           Depending on the frame length defined by the M bit (8-bits or 9-bits),
+      using HAL_IRDA_RegisterCallback() before calling HAL_IRDA_DeInit()
-           the possible IRDA frame formats are as listed in the following table:
+      or HAL_IRDA_Init() function.
-    +-------------------------------------------------------------+
-    |   M bit |  PCE bit  |            IRDA frame                 |
+    [..]
-    |---------------------|---------------------------------------|
+      When The compilation define USE_HAL_IRDA_REGISTER_CALLBACKS is set to 0 or
-    |    0    |    0      |    | SB | 8 bit data | 1 STB |        |
+      not defined, the callback registration feature is not available
-    |---------|-----------|---------------------------------------|
+      and weak (surcharged) callbacks are used.
-    |    0    |    1      |    | SB | 7 bit data | PB | 1 STB |   |
-    |---------|-----------|---------------------------------------|
+  @endverbatim
-    |    1    |    0      |    | SB | 9 bit data | 1 STB |        |
+     [..]
-    |---------|-----------|---------------------------------------|
+       (@) Additional remark: If the parity is enabled, then the MSB bit of the data written
-    |    1    |    1      |    | SB | 8 bit data | PB | 1 STB |   |
+           in the data register is transmitted but is changed by the parity bit.
-    +-------------------------------------------------------------+
+           Depending on the frame length defined by the M bit (8-bits or 9-bits),
-  ******************************************************************************
+           the possible IRDA frame formats are as listed in the following table:
-  * @attention
+    +-------------------------------------------------------------+
-  *
+    |   M bit |  PCE bit  |            IRDA frame                 |
-  * <h2><center>&copy; Copyright (c) 2016 STMicroelectronics.
+    |---------------------|---------------------------------------|
-  * All rights reserved.</center></h2>
+    |    0    |    0      |    | SB | 8 bit data | 1 STB |        |
-  *
+    |---------|-----------|---------------------------------------|
-  * This software component is licensed by ST under BSD 3-Clause license,
+    |    0    |    1      |    | SB | 7 bit data | PB | 1 STB |   |
-  * the "License"; You may not use this file except in compliance with the
+    |---------|-----------|---------------------------------------|
-  * License. You may obtain a copy of the License at:
+    |    1    |    0      |    | SB | 9 bit data | 1 STB |        |
-  *                        opensource.org/licenses/BSD-3-Clause
+    |---------|-----------|---------------------------------------|
-  *
+    |    1    |    1      |    | SB | 8 bit data | PB | 1 STB |   |
-  ******************************************************************************
+    +-------------------------------------------------------------+
-  */
+  ******************************************************************************
+  */
-/* Includes ------------------------------------------------------------------*/
-#include "stm32f1xx_hal.h"
+/* Includes ------------------------------------------------------------------*/
+#include "stm32f1xx_hal.h"
-/** @addtogroup STM32F1xx_HAL_Driver
-  * @{
+/** @addtogroup STM32F1xx_HAL_Driver
-  */
+  * @{
+  */
-/** @defgroup IRDA IRDA
-  * @brief HAL IRDA module driver
+/** @defgroup IRDA IRDA
-  * @{
+  * @brief HAL IRDA module driver
-  */
+  * @{
+  */
-#ifdef HAL_IRDA_MODULE_ENABLED
+#ifdef HAL_IRDA_MODULE_ENABLED
-/* Private typedef -----------------------------------------------------------*/
-/* Private define ------------------------------------------------------------*/
+/* Private typedef -----------------------------------------------------------*/
-/* Private constants ---------------------------------------------------------*/
+/* Private define ------------------------------------------------------------*/
-/* Private macro -------------------------------------------------------------*/
+/* Private constants ---------------------------------------------------------*/
-/* Private variables ---------------------------------------------------------*/
+/* Private macro -------------------------------------------------------------*/
-/* Private function prototypes -----------------------------------------------*/
+/* Private variables ---------------------------------------------------------*/
-/** @addtogroup IRDA_Private_Functions
+/* Private function prototypes -----------------------------------------------*/
-  * @{
+/** @addtogroup IRDA_Private_Functions
-  */
+  * @{
-#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
+  */
-void IRDA_InitCallbacksToDefault(IRDA_HandleTypeDef *hirda);
+#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
-#endif /* USE_HAL_IRDA_REGISTER_CALLBACKS */
+void IRDA_InitCallbacksToDefault(IRDA_HandleTypeDef *hirda);
-static void IRDA_SetConfig(IRDA_HandleTypeDef *hirda);
+#endif /* USE_HAL_IRDA_REGISTER_CALLBACKS */
-static HAL_StatusTypeDef IRDA_Transmit_IT(IRDA_HandleTypeDef *hirda);
+static void IRDA_SetConfig(IRDA_HandleTypeDef *hirda);
-static HAL_StatusTypeDef IRDA_EndTransmit_IT(IRDA_HandleTypeDef *hirda);
+static HAL_StatusTypeDef IRDA_Transmit_IT(IRDA_HandleTypeDef *hirda);
-static HAL_StatusTypeDef IRDA_Receive_IT(IRDA_HandleTypeDef *hirda);
+static HAL_StatusTypeDef IRDA_EndTransmit_IT(IRDA_HandleTypeDef *hirda);
-static void IRDA_DMATransmitCplt(DMA_HandleTypeDef *hdma);
+static HAL_StatusTypeDef IRDA_Receive_IT(IRDA_HandleTypeDef *hirda);
-static void IRDA_DMATransmitHalfCplt(DMA_HandleTypeDef *hdma);
+static void IRDA_DMATransmitCplt(DMA_HandleTypeDef *hdma);
-static void IRDA_DMAReceiveCplt(DMA_HandleTypeDef *hdma);
+static void IRDA_DMATransmitHalfCplt(DMA_HandleTypeDef *hdma);
-static void IRDA_DMAReceiveHalfCplt(DMA_HandleTypeDef *hdma);
+static void IRDA_DMAReceiveCplt(DMA_HandleTypeDef *hdma);
-static void IRDA_DMAError(DMA_HandleTypeDef *hdma);
+static void IRDA_DMAReceiveHalfCplt(DMA_HandleTypeDef *hdma);
-static void IRDA_DMAAbortOnError(DMA_HandleTypeDef *hdma);
+static void IRDA_DMAError(DMA_HandleTypeDef *hdma);
-static void IRDA_DMATxAbortCallback(DMA_HandleTypeDef *hdma);
+static void IRDA_DMAAbortOnError(DMA_HandleTypeDef *hdma);
-static void IRDA_DMARxAbortCallback(DMA_HandleTypeDef *hdma);
+static void IRDA_DMATxAbortCallback(DMA_HandleTypeDef *hdma);
-static void IRDA_DMATxOnlyAbortCallback(DMA_HandleTypeDef *hdma);
+static void IRDA_DMARxAbortCallback(DMA_HandleTypeDef *hdma);
-static void IRDA_DMARxOnlyAbortCallback(DMA_HandleTypeDef *hdma);
+static void IRDA_DMATxOnlyAbortCallback(DMA_HandleTypeDef *hdma);
-static HAL_StatusTypeDef IRDA_WaitOnFlagUntilTimeout(IRDA_HandleTypeDef *hirda, uint32_t Flag, FlagStatus Status, uint32_t Tickstart, uint32_t Timeout);
+static void IRDA_DMARxOnlyAbortCallback(DMA_HandleTypeDef *hdma);
-static void IRDA_EndTxTransfer(IRDA_HandleTypeDef *hirda);
+static HAL_StatusTypeDef IRDA_WaitOnFlagUntilTimeout(IRDA_HandleTypeDef *hirda, uint32_t Flag, FlagStatus Status, uint32_t Tickstart, uint32_t Timeout);
-static void IRDA_EndRxTransfer(IRDA_HandleTypeDef *hirda);
+static void IRDA_EndTxTransfer(IRDA_HandleTypeDef *hirda);
-/**
+static void IRDA_EndRxTransfer(IRDA_HandleTypeDef *hirda);
-  * @}
+/**
-  */
+  * @}
+  */
-/* Exported functions --------------------------------------------------------*/
-/** @defgroup IRDA_Exported_Functions IrDA Exported Functions
+/* Exported functions --------------------------------------------------------*/
-  * @{
+/** @defgroup IRDA_Exported_Functions IrDA Exported Functions
-  */
+  * @{
+  */
-/** @defgroup IRDA_Exported_Functions_Group1 IrDA Initialization and de-initialization functions
-  *  @brief    Initialization and Configuration functions
+/** @defgroup IRDA_Exported_Functions_Group1 IrDA Initialization and de-initialization functions
-  *
+  *  @brief    Initialization and Configuration functions
-@verbatim
+  *
+@verbatim
-  ==============================================================================
-            ##### Initialization and Configuration functions #####
+  ==============================================================================
-  ==============================================================================
+            ##### Initialization and Configuration functions #####
-    [..]
+  ==============================================================================
-    This subsection provides a set of functions allowing to initialize the USARTx or the UARTy
+    [..]
-    in asynchronous IrDA mode.
+    This subsection provides a set of functions allowing to initialize the USARTx or the UARTy
-      (+) For the asynchronous mode only these parameters can be configured:
+    in asynchronous IrDA mode.
-        (++) BaudRate
+      (+) For the asynchronous mode only these parameters can be configured:
-        (++) WordLength
+        (++) BaudRate
-        (++) Parity: If the parity is enabled, then the MSB bit of the data written
+        (++) WordLength
-             in the data register is transmitted but is changed by the parity bit.
+        (++) Parity: If the parity is enabled, then the MSB bit of the data written
-             Depending on the frame length defined by the M bit (8-bits or 9-bits),
+             in the data register is transmitted but is changed by the parity bit.
-             please refer to Reference manual for possible IRDA frame formats.
+             Depending on the frame length defined by the M bit (8-bits or 9-bits),
-        (++) Prescaler: A pulse of width less than two and greater than one PSC period(s) may or may
+             please refer to Reference manual for possible IRDA frame formats.
-             not be rejected. The receiver set up time should be managed by software. The IrDA physical layer
+        (++) Prescaler: A pulse of width less than two and greater than one PSC period(s) may or may
-             specification specifies a minimum of 10 ms delay between transmission and
+             not be rejected. The receiver set up time should be managed by software. The IrDA physical layer
-             reception (IrDA is a half duplex protocol).
+             specification specifies a minimum of 10 ms delay between transmission and
-        (++) Mode: Receiver/transmitter modes
+             reception (IrDA is a half duplex protocol).
-        (++) IrDAMode: the IrDA can operate in the Normal mode or in the Low power mode.
+        (++) Mode: Receiver/transmitter modes
-    [..]
+        (++) IrDAMode: the IrDA can operate in the Normal mode or in the Low power mode.
-    The HAL_IRDA_Init() API follows IRDA configuration procedures (details for the procedures
+    [..]
-    are available in reference manual).
+    The HAL_IRDA_Init() API follows IRDA configuration procedures (details for the procedures
+    are available in reference manual).
-@endverbatim
-  * @{
+@endverbatim
-  */
+  * @{
+  */
-/**
-  * @brief  Initializes the IRDA mode according to the specified
+/**
-  *         parameters in the IRDA_InitTypeDef and create the associated handle.
+  * @brief  Initializes the IRDA mode according to the specified
-  * @param  hirda  Pointer to a IRDA_HandleTypeDef structure that contains
+  *         parameters in the IRDA_InitTypeDef and create the associated handle.
-  *                the configuration information for the specified IRDA module.
+  * @param  hirda  Pointer to a IRDA_HandleTypeDef structure that contains
-  * @retval HAL status
+  *                the configuration information for the specified IRDA module.
-  */
+  * @retval HAL status
-HAL_StatusTypeDef HAL_IRDA_Init(IRDA_HandleTypeDef *hirda)
+  */
-{
+HAL_StatusTypeDef HAL_IRDA_Init(IRDA_HandleTypeDef *hirda)
-  /* Check the IRDA handle allocation */
+{
-  if (hirda == NULL)
+  /* Check the IRDA handle allocation */
-  {
+  if (hirda == NULL)
-    return HAL_ERROR;
+  {
-  }
+    return HAL_ERROR;
+  }
-  /* Check the IRDA instance parameters */
-  assert_param(IS_IRDA_INSTANCE(hirda->Instance));
+  /* Check the IRDA instance parameters */
-  /* Check the IRDA mode parameter in the IRDA handle */
+  assert_param(IS_IRDA_INSTANCE(hirda->Instance));
-  assert_param(IS_IRDA_POWERMODE(hirda->Init.IrDAMode));
+  /* Check the IRDA mode parameter in the IRDA handle */
+  assert_param(IS_IRDA_POWERMODE(hirda->Init.IrDAMode));
-  if (hirda->gState == HAL_IRDA_STATE_RESET)
-  {
+  if (hirda->gState == HAL_IRDA_STATE_RESET)
-    /* Allocate lock resource and initialize it */
+  {
-    hirda->Lock = HAL_UNLOCKED;
+    /* Allocate lock resource and initialize it */
+    hirda->Lock = HAL_UNLOCKED;
-#if USE_HAL_IRDA_REGISTER_CALLBACKS == 1
-    IRDA_InitCallbacksToDefault(hirda);
+#if USE_HAL_IRDA_REGISTER_CALLBACKS == 1
+    IRDA_InitCallbacksToDefault(hirda);
-    if (hirda->MspInitCallback == NULL)
-    {
+    if (hirda->MspInitCallback == NULL)
-      hirda->MspInitCallback = HAL_IRDA_MspInit;
+    {
-    }
+      hirda->MspInitCallback = HAL_IRDA_MspInit;
+    }
-    /* Init the low level hardware */
-    hirda->MspInitCallback(hirda);
+    /* Init the low level hardware */
-#else
+    hirda->MspInitCallback(hirda);
-    /* Init the low level hardware : GPIO, CLOCK */
+#else
-    HAL_IRDA_MspInit(hirda);
+    /* Init the low level hardware : GPIO, CLOCK */
-#endif /* USE_HAL_IRDA_REGISTER_CALLBACKS */
+    HAL_IRDA_MspInit(hirda);
-  }
+#endif /* USE_HAL_IRDA_REGISTER_CALLBACKS */
+  }
-  hirda->gState = HAL_IRDA_STATE_BUSY;
+  hirda->gState = HAL_IRDA_STATE_BUSY;
-  /* Disable the IRDA peripheral */
-  __HAL_IRDA_DISABLE(hirda);
+  /* Disable the IRDA peripheral */
+  __HAL_IRDA_DISABLE(hirda);
-  /* Set the IRDA communication parameters */
-  IRDA_SetConfig(hirda);
+  /* Set the IRDA communication parameters */
+  IRDA_SetConfig(hirda);
-  /* In IrDA mode, the following bits must be kept cleared:
-  - LINEN, STOP and CLKEN bits in the USART_CR2 register,
+  /* In IrDA mode, the following bits must be kept cleared:
-  - SCEN and HDSEL bits in the USART_CR3 register.*/
+  - LINEN, STOP and CLKEN bits in the USART_CR2 register,
-  CLEAR_BIT(hirda->Instance->CR2, (USART_CR2_LINEN | USART_CR2_STOP | USART_CR2_CLKEN));
+  - SCEN and HDSEL bits in the USART_CR3 register.*/
-  CLEAR_BIT(hirda->Instance->CR3, (USART_CR3_SCEN | USART_CR3_HDSEL));
+  CLEAR_BIT(hirda->Instance->CR2, (USART_CR2_LINEN | USART_CR2_STOP | USART_CR2_CLKEN));
+  CLEAR_BIT(hirda->Instance->CR3, (USART_CR3_SCEN | USART_CR3_HDSEL));
-  /* Enable the IRDA peripheral */
-  __HAL_IRDA_ENABLE(hirda);
+  /* Enable the IRDA peripheral */
+  __HAL_IRDA_ENABLE(hirda);
-  /* Set the prescaler */
-  MODIFY_REG(hirda->Instance->GTPR, USART_GTPR_PSC, hirda->Init.Prescaler);
+  /* Set the prescaler */
+  MODIFY_REG(hirda->Instance->GTPR, USART_GTPR_PSC, hirda->Init.Prescaler);
-  /* Configure the IrDA mode */
-  MODIFY_REG(hirda->Instance->CR3, USART_CR3_IRLP, hirda->Init.IrDAMode);
+  /* Configure the IrDA mode */
+  MODIFY_REG(hirda->Instance->CR3, USART_CR3_IRLP, hirda->Init.IrDAMode);
-  /* Enable the IrDA mode by setting the IREN bit in the CR3 register */
-  SET_BIT(hirda->Instance->CR3, USART_CR3_IREN);
+  /* Enable the IrDA mode by setting the IREN bit in the CR3 register */
+  SET_BIT(hirda->Instance->CR3, USART_CR3_IREN);
-  /* Initialize the IRDA state*/
-  hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
+  /* Initialize the IRDA state*/
-  hirda->gState = HAL_IRDA_STATE_READY;
+  hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
-  hirda->RxState = HAL_IRDA_STATE_READY;
+  hirda->gState = HAL_IRDA_STATE_READY;
+  hirda->RxState = HAL_IRDA_STATE_READY;
-  return HAL_OK;
-}
+  return HAL_OK;
+}
-/**
-  * @brief  DeInitializes the IRDA peripheral
+/**
-  * @param  hirda  Pointer to a IRDA_HandleTypeDef structure that contains
+  * @brief  DeInitializes the IRDA peripheral
-  *                the configuration information for the specified IRDA module.
+  * @param  hirda  Pointer to a IRDA_HandleTypeDef structure that contains
-  * @retval HAL status
+  *                the configuration information for the specified IRDA module.
-  */
+  * @retval HAL status
-HAL_StatusTypeDef HAL_IRDA_DeInit(IRDA_HandleTypeDef *hirda)
+  */
-{
+HAL_StatusTypeDef HAL_IRDA_DeInit(IRDA_HandleTypeDef *hirda)
-  /* Check the IRDA handle allocation */
+{
-  if (hirda == NULL)
+  /* Check the IRDA handle allocation */
-  {
+  if (hirda == NULL)
-    return HAL_ERROR;
+  {
-  }
+    return HAL_ERROR;
+  }
-  /* Check the parameters */
-  assert_param(IS_IRDA_INSTANCE(hirda->Instance));
+  /* Check the parameters */
+  assert_param(IS_IRDA_INSTANCE(hirda->Instance));
-  hirda->gState = HAL_IRDA_STATE_BUSY;
+  hirda->gState = HAL_IRDA_STATE_BUSY;
-  /* Disable the Peripheral */
-  __HAL_IRDA_DISABLE(hirda);
+  /* Disable the Peripheral */
+  __HAL_IRDA_DISABLE(hirda);
-  /* DeInit the low level hardware */
-#if USE_HAL_IRDA_REGISTER_CALLBACKS == 1
+  /* DeInit the low level hardware */
-  if (hirda->MspDeInitCallback == NULL)
+#if USE_HAL_IRDA_REGISTER_CALLBACKS == 1
-  {
+  if (hirda->MspDeInitCallback == NULL)
-    hirda->MspDeInitCallback = HAL_IRDA_MspDeInit;
+  {
-  }
+    hirda->MspDeInitCallback = HAL_IRDA_MspDeInit;
-  /* DeInit the low level hardware */
+  }
-  hirda->MspDeInitCallback(hirda);
+  /* DeInit the low level hardware */
-#else
+  hirda->MspDeInitCallback(hirda);
-  HAL_IRDA_MspDeInit(hirda);
+#else
-#endif /* USE_HAL_IRDA_REGISTER_CALLBACKS */
+  HAL_IRDA_MspDeInit(hirda);
+#endif /* USE_HAL_IRDA_REGISTER_CALLBACKS */
-  hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
+  hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
-  hirda->gState = HAL_IRDA_STATE_RESET;
-  hirda->RxState = HAL_IRDA_STATE_RESET;
+  hirda->gState = HAL_IRDA_STATE_RESET;
+  hirda->RxState = HAL_IRDA_STATE_RESET;
-  /* Release Lock */
-  __HAL_UNLOCK(hirda);
+  /* Release Lock */
+  __HAL_UNLOCK(hirda);
-  return HAL_OK;
-}
+  return HAL_OK;
+}
-/**
-  * @brief  IRDA MSP Init.
+/**
-  * @param  hirda  Pointer to a IRDA_HandleTypeDef structure that contains
+  * @brief  IRDA MSP Init.
-  *                the configuration information for the specified IRDA module.
+  * @param  hirda  Pointer to a IRDA_HandleTypeDef structure that contains
-  * @retval None
+  *                the configuration information for the specified IRDA module.
-  */
+  * @retval None
-__weak void HAL_IRDA_MspInit(IRDA_HandleTypeDef *hirda)
+  */
-{
+__weak void HAL_IRDA_MspInit(IRDA_HandleTypeDef *hirda)
-  /* Prevent unused argument(s) compilation warning */
+{
-  UNUSED(hirda);
+  /* Prevent unused argument(s) compilation warning */
+  UNUSED(hirda);
-  /* NOTE: This function should not be modified, when the callback is needed,
-           the HAL_IRDA_MspInit can be implemented in the user file
+  /* NOTE: This function should not be modified, when the callback is needed,
-   */
+           the HAL_IRDA_MspInit can be implemented in the user file
-}
+   */
+}
-/**
-  * @brief  IRDA MSP DeInit.
+/**
-  * @param  hirda  Pointer to a IRDA_HandleTypeDef structure that contains
+  * @brief  IRDA MSP DeInit.
-  *                the configuration information for the specified IRDA module.
+  * @param  hirda  Pointer to a IRDA_HandleTypeDef structure that contains
-  * @retval None
+  *                the configuration information for the specified IRDA module.
-  */
+  * @retval None
-__weak void HAL_IRDA_MspDeInit(IRDA_HandleTypeDef *hirda)
+  */
-{
+__weak void HAL_IRDA_MspDeInit(IRDA_HandleTypeDef *hirda)
-  /* Prevent unused argument(s) compilation warning */
+{
-  UNUSED(hirda);
+  /* Prevent unused argument(s) compilation warning */
+  UNUSED(hirda);
-  /* NOTE: This function should not be modified, when the callback is needed,
-           the HAL_IRDA_MspDeInit can be implemented in the user file
+  /* NOTE: This function should not be modified, when the callback is needed,
-   */
+           the HAL_IRDA_MspDeInit can be implemented in the user file
-}
+   */
+}
-#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
-/**
+#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
-  * @brief  Register a User IRDA Callback
+/**
-  *         To be used instead of the weak predefined callback
+  * @brief  Register a User IRDA Callback
-  * @param  hirda irda handle
+  *         To be used instead of the weak predefined callback
-  * @param  CallbackID ID of the callback to be registered
+  * @note   The HAL_IRDA_RegisterCallback() may be called before HAL_IRDA_Init() in HAL_IRDA_STATE_RESET
-  *         This parameter can be one of the following values:
+  *         to register callbacks for HAL_IRDA_MSPINIT_CB_ID and HAL_IRDA_MSPDEINIT_CB_ID
-  *           @arg @ref HAL_IRDA_TX_HALFCOMPLETE_CB_ID Tx Half Complete Callback ID
+  * @param  hirda irda handle
-  *           @arg @ref HAL_IRDA_TX_COMPLETE_CB_ID Tx Complete Callback ID
+  * @param  CallbackID ID of the callback to be registered
-  *           @arg @ref HAL_IRDA_RX_HALFCOMPLETE_CB_ID Rx Half Complete Callback ID
+  *         This parameter can be one of the following values:
-  *           @arg @ref HAL_IRDA_RX_COMPLETE_CB_ID Rx Complete Callback ID
+  *           @arg @ref HAL_IRDA_TX_HALFCOMPLETE_CB_ID Tx Half Complete Callback ID
-  *           @arg @ref HAL_IRDA_ERROR_CB_ID Error Callback ID
+  *           @arg @ref HAL_IRDA_TX_COMPLETE_CB_ID Tx Complete Callback ID
-  *           @arg @ref HAL_IRDA_ABORT_COMPLETE_CB_ID Abort Complete Callback ID
+  *           @arg @ref HAL_IRDA_RX_HALFCOMPLETE_CB_ID Rx Half Complete Callback ID
-  *           @arg @ref HAL_IRDA_ABORT_TRANSMIT_COMPLETE_CB_ID Abort Transmit Complete Callback ID
+  *           @arg @ref HAL_IRDA_RX_COMPLETE_CB_ID Rx Complete Callback ID
-  *           @arg @ref HAL_IRDA_ABORT_RECEIVE_COMPLETE_CB_ID Abort Receive Complete Callback ID
+  *           @arg @ref HAL_IRDA_ERROR_CB_ID Error Callback ID
-  *           @arg @ref HAL_IRDA_MSPINIT_CB_ID MspInit Callback ID
+  *           @arg @ref HAL_IRDA_ABORT_COMPLETE_CB_ID Abort Complete Callback ID
-  *           @arg @ref HAL_IRDA_MSPDEINIT_CB_ID MspDeInit Callback ID
+  *           @arg @ref HAL_IRDA_ABORT_TRANSMIT_COMPLETE_CB_ID Abort Transmit Complete Callback ID
-  * @param  pCallback pointer to the Callback function
+  *           @arg @ref HAL_IRDA_ABORT_RECEIVE_COMPLETE_CB_ID Abort Receive Complete Callback ID
-  * @retval HAL status
+  *           @arg @ref HAL_IRDA_MSPINIT_CB_ID MspInit Callback ID
-  */
+  *           @arg @ref HAL_IRDA_MSPDEINIT_CB_ID MspDeInit Callback ID
-HAL_StatusTypeDef HAL_IRDA_RegisterCallback(IRDA_HandleTypeDef *hirda, HAL_IRDA_CallbackIDTypeDef CallbackID, pIRDA_CallbackTypeDef pCallback)
+  * @param  pCallback pointer to the Callback function
-{
+  * @retval HAL status
-  HAL_StatusTypeDef status = HAL_OK;
+  */
+HAL_StatusTypeDef HAL_IRDA_RegisterCallback(IRDA_HandleTypeDef *hirda, HAL_IRDA_CallbackIDTypeDef CallbackID, pIRDA_CallbackTypeDef pCallback)
-  if (pCallback == NULL)
+{
-  {
+  HAL_StatusTypeDef status = HAL_OK;
-    /* Update the error code */
-    hirda->ErrorCode |= HAL_IRDA_ERROR_INVALID_CALLBACK;
+  if (pCallback == NULL)
+  {
-    return HAL_ERROR;
+    /* Update the error code */
-  }
+    hirda->ErrorCode |= HAL_IRDA_ERROR_INVALID_CALLBACK;
-  /* Process locked */
-  __HAL_LOCK(hirda);
+    return HAL_ERROR;
+  }
-  if (hirda->gState == HAL_IRDA_STATE_READY)
-  {
+  if (hirda->gState == HAL_IRDA_STATE_READY)
-    switch (CallbackID)
+  {
-    {
+    switch (CallbackID)
-      case HAL_IRDA_TX_HALFCOMPLETE_CB_ID :
+    {
-        hirda->TxHalfCpltCallback = pCallback;
+      case HAL_IRDA_TX_HALFCOMPLETE_CB_ID :
-        break;
+        hirda->TxHalfCpltCallback = pCallback;
+        break;
-      case HAL_IRDA_TX_COMPLETE_CB_ID :
-        hirda->TxCpltCallback = pCallback;
+      case HAL_IRDA_TX_COMPLETE_CB_ID :
-        break;
+        hirda->TxCpltCallback = pCallback;
+        break;
-      case HAL_IRDA_RX_HALFCOMPLETE_CB_ID :
-        hirda->RxHalfCpltCallback = pCallback;
+      case HAL_IRDA_RX_HALFCOMPLETE_CB_ID :
-        break;
+        hirda->RxHalfCpltCallback = pCallback;
+        break;
-      case HAL_IRDA_RX_COMPLETE_CB_ID :
-        hirda->RxCpltCallback = pCallback;
+      case HAL_IRDA_RX_COMPLETE_CB_ID :
-        break;
+        hirda->RxCpltCallback = pCallback;
+        break;
-      case HAL_IRDA_ERROR_CB_ID :
-        hirda->ErrorCallback = pCallback;
+      case HAL_IRDA_ERROR_CB_ID :
-        break;
+        hirda->ErrorCallback = pCallback;
+        break;
-      case HAL_IRDA_ABORT_COMPLETE_CB_ID :
-        hirda->AbortCpltCallback = pCallback;
+      case HAL_IRDA_ABORT_COMPLETE_CB_ID :
-        break;
+        hirda->AbortCpltCallback = pCallback;
+        break;
-      case HAL_IRDA_ABORT_TRANSMIT_COMPLETE_CB_ID :
-        hirda->AbortTransmitCpltCallback = pCallback;
+      case HAL_IRDA_ABORT_TRANSMIT_COMPLETE_CB_ID :
-        break;
+        hirda->AbortTransmitCpltCallback = pCallback;
+        break;
-      case HAL_IRDA_ABORT_RECEIVE_COMPLETE_CB_ID :
-        hirda->AbortReceiveCpltCallback = pCallback;
+      case HAL_IRDA_ABORT_RECEIVE_COMPLETE_CB_ID :
-        break;
+        hirda->AbortReceiveCpltCallback = pCallback;
+        break;
-      case HAL_IRDA_MSPINIT_CB_ID :
-        hirda->MspInitCallback = pCallback;
+      case HAL_IRDA_MSPINIT_CB_ID :
-        break;
+        hirda->MspInitCallback = pCallback;
+        break;
-      case HAL_IRDA_MSPDEINIT_CB_ID :
-        hirda->MspDeInitCallback = pCallback;
+      case HAL_IRDA_MSPDEINIT_CB_ID :
-        break;
+        hirda->MspDeInitCallback = pCallback;
+        break;
-      default :
-        /* Update the error code */
+      default :
-        hirda->ErrorCode |= HAL_IRDA_ERROR_INVALID_CALLBACK;
+        /* Update the error code */
+        hirda->ErrorCode |= HAL_IRDA_ERROR_INVALID_CALLBACK;
-        /* Return error status */
-        status =  HAL_ERROR;
+        /* Return error status */
-        break;
+        status =  HAL_ERROR;
-    }
+        break;
-  }
+    }
-  else if (hirda->gState == HAL_IRDA_STATE_RESET)
+  }
-  {
+  else if (hirda->gState == HAL_IRDA_STATE_RESET)
-    switch (CallbackID)
+  {
-    {
+    switch (CallbackID)
-      case HAL_IRDA_MSPINIT_CB_ID :
+    {
-        hirda->MspInitCallback = pCallback;
+      case HAL_IRDA_MSPINIT_CB_ID :
-        break;
+        hirda->MspInitCallback = pCallback;
+        break;
-      case HAL_IRDA_MSPDEINIT_CB_ID :
-        hirda->MspDeInitCallback = pCallback;
+      case HAL_IRDA_MSPDEINIT_CB_ID :
-        break;
+        hirda->MspDeInitCallback = pCallback;
+        break;
-      default :
-        /* Update the error code */
+      default :
-        hirda->ErrorCode |= HAL_IRDA_ERROR_INVALID_CALLBACK;
+        /* Update the error code */
+        hirda->ErrorCode |= HAL_IRDA_ERROR_INVALID_CALLBACK;
-        /* Return error status */
-        status =  HAL_ERROR;
+        /* Return error status */
-        break;
+        status =  HAL_ERROR;
-    }
+        break;
-  }
+    }
-  else
+  }
-  {
+  else
-    /* Update the error code */
+  {
-    hirda->ErrorCode |= HAL_IRDA_ERROR_INVALID_CALLBACK;
+    /* Update the error code */
+    hirda->ErrorCode |= HAL_IRDA_ERROR_INVALID_CALLBACK;
-    /* Return error status */
-    status =  HAL_ERROR;
+    /* Return error status */
-  }
+    status =  HAL_ERROR;
+  }
-  /* Release Lock */
-  __HAL_UNLOCK(hirda);
+  return status;
+}
-  return status;
-}
+/**
+  * @brief  Unregister an IRDA callback
-/**
+  *         IRDA callback is redirected to the weak predefined callback
-  * @brief  Unregister an IRDA callback
+  * @note   The HAL_IRDA_UnRegisterCallback() may be called before HAL_IRDA_Init() in HAL_IRDA_STATE_RESET
-  *         IRDA callback is redirected to the weak predefined callback
+  *         to un-register callbacks for HAL_IRDA_MSPINIT_CB_ID and HAL_IRDA_MSPDEINIT_CB_ID
   * @param  hirda irda handle
   * @param  CallbackID ID of the callback to be unregistered
   *         This parameter can be one of the following values:
   *           @arg @ref HAL_IRDA_TX_HALFCOMPLETE_CB_ID Tx Half Complete Callback ID
   *           @arg @ref HAL_IRDA_TX_COMPLETE_CB_ID Tx Complete Callback ID
   *           @arg @ref HAL_IRDA_RX_HALFCOMPLETE_CB_ID Rx Half Complete Callback ID
   *           @arg @ref HAL_IRDA_RX_COMPLETE_CB_ID Rx Complete Callback ID
   *           @arg @ref HAL_IRDA_ERROR_CB_ID Error Callback ID
   *           @arg @ref HAL_IRDA_ABORT_COMPLETE_CB_ID Abort Complete Callback ID
   *           @arg @ref HAL_IRDA_ABORT_TRANSMIT_COMPLETE_CB_ID Abort Transmit Complete Callback ID
   *           @arg @ref HAL_IRDA_ABORT_RECEIVE_COMPLETE_CB_ID Abort Receive Complete Callback ID
   *           @arg @ref HAL_IRDA_MSPINIT_CB_ID MspInit Callback ID
   *           @arg @ref HAL_IRDA_MSPDEINIT_CB_ID MspDeInit Callback ID
   * @retval HAL status
   */
 HAL_StatusTypeDef HAL_IRDA_UnRegisterCallback(IRDA_HandleTypeDef *hirda, HAL_IRDA_CallbackIDTypeDef CallbackID)
 {
   HAL_StatusTypeDef status = HAL_OK;
-  /* Process locked */
+  if (HAL_IRDA_STATE_READY == hirda->gState)
-  __HAL_LOCK(hirda);
+  {
+    switch (CallbackID)
-  if (HAL_IRDA_STATE_READY == hirda->gState)
+    {
-  {
+      case HAL_IRDA_TX_HALFCOMPLETE_CB_ID :
-    switch (CallbackID)
+        hirda->TxHalfCpltCallback = HAL_IRDA_TxHalfCpltCallback;               /* Legacy weak  TxHalfCpltCallback       */
-    {
+        break;
-      case HAL_IRDA_TX_HALFCOMPLETE_CB_ID :
-        hirda->TxHalfCpltCallback = HAL_IRDA_TxHalfCpltCallback;               /* Legacy weak  TxHalfCpltCallback       */
+      case HAL_IRDA_TX_COMPLETE_CB_ID :
-        break;
+        hirda->TxCpltCallback = HAL_IRDA_TxCpltCallback;                       /* Legacy weak TxCpltCallback            */
+        break;
-      case HAL_IRDA_TX_COMPLETE_CB_ID :
-        hirda->TxCpltCallback = HAL_IRDA_TxCpltCallback;                       /* Legacy weak TxCpltCallback            */
+      case HAL_IRDA_RX_HALFCOMPLETE_CB_ID :
-        break;
+        hirda->RxHalfCpltCallback = HAL_IRDA_RxHalfCpltCallback;               /* Legacy weak RxHalfCpltCallback        */
+        break;
-      case HAL_IRDA_RX_HALFCOMPLETE_CB_ID :
-        hirda->RxHalfCpltCallback = HAL_IRDA_RxHalfCpltCallback;               /* Legacy weak RxHalfCpltCallback        */
+      case HAL_IRDA_RX_COMPLETE_CB_ID :
-        break;
+        hirda->RxCpltCallback = HAL_IRDA_RxCpltCallback;                       /* Legacy weak RxCpltCallback            */
+        break;
-      case HAL_IRDA_RX_COMPLETE_CB_ID :
-        hirda->RxCpltCallback = HAL_IRDA_RxCpltCallback;                       /* Legacy weak RxCpltCallback            */
+      case HAL_IRDA_ERROR_CB_ID :
-        break;
+        hirda->ErrorCallback = HAL_IRDA_ErrorCallback;                         /* Legacy weak ErrorCallback             */
+        break;
-      case HAL_IRDA_ERROR_CB_ID :
-        hirda->ErrorCallback = HAL_IRDA_ErrorCallback;                         /* Legacy weak ErrorCallback             */
+      case HAL_IRDA_ABORT_COMPLETE_CB_ID :
-        break;
+        hirda->AbortCpltCallback = HAL_IRDA_AbortCpltCallback;                 /* Legacy weak AbortCpltCallback         */
+        break;
-      case HAL_IRDA_ABORT_COMPLETE_CB_ID :
-        hirda->AbortCpltCallback = HAL_IRDA_AbortCpltCallback;                 /* Legacy weak AbortCpltCallback         */
+      case HAL_IRDA_ABORT_TRANSMIT_COMPLETE_CB_ID :
-        break;
+        hirda->AbortTransmitCpltCallback = HAL_IRDA_AbortTransmitCpltCallback; /* Legacy weak AbortTransmitCpltCallback */
+        break;
-      case HAL_IRDA_ABORT_TRANSMIT_COMPLETE_CB_ID :
-        hirda->AbortTransmitCpltCallback = HAL_IRDA_AbortTransmitCpltCallback; /* Legacy weak AbortTransmitCpltCallback */
+      case HAL_IRDA_ABORT_RECEIVE_COMPLETE_CB_ID :
-        break;
+        hirda->AbortReceiveCpltCallback = HAL_IRDA_AbortReceiveCpltCallback;   /* Legacy weak AbortReceiveCpltCallback  */
+        break;
-      case HAL_IRDA_ABORT_RECEIVE_COMPLETE_CB_ID :
-        hirda->AbortReceiveCpltCallback = HAL_IRDA_AbortReceiveCpltCallback;   /* Legacy weak AbortReceiveCpltCallback  */
+      case HAL_IRDA_MSPINIT_CB_ID :
-        break;
+        hirda->MspInitCallback = HAL_IRDA_MspInit;                             /* Legacy weak MspInitCallback           */
+        break;
-      case HAL_IRDA_MSPINIT_CB_ID :
-        hirda->MspInitCallback = HAL_IRDA_MspInit;                             /* Legacy weak MspInitCallback           */
+      case HAL_IRDA_MSPDEINIT_CB_ID :
-        break;
+        hirda->MspDeInitCallback = HAL_IRDA_MspDeInit;                         /* Legacy weak MspDeInitCallback         */
+        break;
-      case HAL_IRDA_MSPDEINIT_CB_ID :
-        hirda->MspDeInitCallback = HAL_IRDA_MspDeInit;                         /* Legacy weak MspDeInitCallback         */
+      default :
-        break;
+        /* Update the error code */
+        hirda->ErrorCode |= HAL_IRDA_ERROR_INVALID_CALLBACK;
-      default :
-        /* Update the error code */
+        /* Return error status */
-        hirda->ErrorCode |= HAL_IRDA_ERROR_INVALID_CALLBACK;
+        status =  HAL_ERROR;
+        break;
-        /* Return error status */
+    }
-        status =  HAL_ERROR;
+  }
-        break;
+  else if (HAL_IRDA_STATE_RESET == hirda->gState)
-    }
+  {
-  }
+    switch (CallbackID)
-  else if (HAL_IRDA_STATE_RESET == hirda->gState)
+    {
-  {
+      case HAL_IRDA_MSPINIT_CB_ID :
-    switch (CallbackID)
+        hirda->MspInitCallback = HAL_IRDA_MspInit;
-    {
+        break;
-      case HAL_IRDA_MSPINIT_CB_ID :
-        hirda->MspInitCallback = HAL_IRDA_MspInit;
+      case HAL_IRDA_MSPDEINIT_CB_ID :
-        break;
+        hirda->MspDeInitCallback = HAL_IRDA_MspDeInit;
+        break;
-      case HAL_IRDA_MSPDEINIT_CB_ID :
-        hirda->MspDeInitCallback = HAL_IRDA_MspDeInit;
+      default :
-        break;
+        /* Update the error code */
+        hirda->ErrorCode |= HAL_IRDA_ERROR_INVALID_CALLBACK;
-      default :
-        /* Update the error code */
+        /* Return error status */
-        hirda->ErrorCode |= HAL_IRDA_ERROR_INVALID_CALLBACK;
+        status =  HAL_ERROR;
+        break;
-        /* Return error status */
+    }
-        status =  HAL_ERROR;
+  }
-        break;
+  else
-    }
+  {
-  }
+    /* Update the error code */
-  else
+    hirda->ErrorCode |= HAL_IRDA_ERROR_INVALID_CALLBACK;
-  {
-    /* Update the error code */
+    /* Return error status */
-    hirda->ErrorCode |= HAL_IRDA_ERROR_INVALID_CALLBACK;
+    status =  HAL_ERROR;
+  }
-    /* Return error status */
-    status =  HAL_ERROR;
+  return status;
-  }
+}
+#endif /* USE_HAL_IRDA_REGISTER_CALLBACKS */
-  /* Release Lock */
-  __HAL_UNLOCK(hirda);
+/**
+  * @}
-  return status;
+  */
-}
-#endif /* USE_HAL_IRDA_REGISTER_CALLBACKS */
+/** @defgroup IRDA_Exported_Functions_Group2 IO operation functions
+  *  @brief   IRDA Transmit and Receive functions
-/**
+  *
-  * @}
+@verbatim
-  */
+  ==============================================================================
+                      ##### IO operation functions #####
-/** @defgroup IRDA_Exported_Functions_Group2 IO operation functions
+  ==============================================================================
-  *  @brief   IRDA Transmit and Receive functions
+    [..]
-  *
+    This subsection provides a set of functions allowing to manage the IRDA data transfers.
-@verbatim
+    IrDA is a half duplex communication protocol. If the Transmitter is busy, any data
-  ==============================================================================
+    on the IrDA receive line will be ignored by the IrDA decoder and if the Receiver
-                      ##### IO operation functions #####
+    is busy, data on the TX from the USART to IrDA will not be encoded by IrDA.
-  ==============================================================================
+    While receiving data, transmission should be avoided as the data to be transmitted
-    [..]
+    could be corrupted.
-    This subsection provides a set of functions allowing to manage the IRDA data transfers.
-    IrDA is a half duplex communication protocol. If the Transmitter is busy, any data
+    (#) There are two modes of transfer:
-    on the IrDA receive line will be ignored by the IrDA decoder and if the Receiver
+       (++) Blocking mode: The communication is performed in polling mode.
-    is busy, data on the TX from the USART to IrDA will not be encoded by IrDA.
+            The HAL status of all data processing is returned by the same function
-    While receiving data, transmission should be avoided as the data to be transmitted
+            after finishing transfer.
-    could be corrupted.
+       (++) Non-Blocking mode: The communication is performed using Interrupts
+           or DMA, these API's return the HAL status.
-    (#) There are two modes of transfer:
+           The end of the data processing will be indicated through the
-       (++) Blocking mode: The communication is performed in polling mode.
+           dedicated IRDA IRQ when using Interrupt mode or the DMA IRQ when
-            The HAL status of all data processing is returned by the same function
+           using DMA mode.
-            after finishing transfer.
+           The HAL_IRDA_TxCpltCallback(), HAL_IRDA_RxCpltCallback() user callbacks
-       (++) Non-Blocking mode: The communication is performed using Interrupts
+           will be executed respectively at the end of the Transmit or Receive process
-           or DMA, these API's return the HAL status.
+           The HAL_IRDA_ErrorCallback() user callback will be executed when a communication error is detected
-           The end of the data processing will be indicated through the
-           dedicated IRDA IRQ when using Interrupt mode or the DMA IRQ when
+    (#) Blocking mode APIs are :
-           using DMA mode.
+        (++) HAL_IRDA_Transmit()
-           The HAL_IRDA_TxCpltCallback(), HAL_IRDA_RxCpltCallback() user callbacks
+        (++) HAL_IRDA_Receive()
-           will be executed respectively at the end of the Transmit or Receive process
-           The HAL_IRDA_ErrorCallback() user callback will be executed when a communication error is detected
+    (#) Non Blocking mode APIs with Interrupt are :
+        (++) HAL_IRDA_Transmit_IT()
-    (#) Blocking mode APIs are :
+        (++) HAL_IRDA_Receive_IT()
-        (++) HAL_IRDA_Transmit()
+        (++) HAL_IRDA_IRQHandler()
-        (++) HAL_IRDA_Receive()
+    (#) Non Blocking mode functions with DMA are :
-    (#) Non Blocking mode APIs with Interrupt are :
+        (++) HAL_IRDA_Transmit_DMA()
-        (++) HAL_IRDA_Transmit_IT()
+        (++) HAL_IRDA_Receive_DMA()
-        (++) HAL_IRDA_Receive_IT()
+        (++) HAL_IRDA_DMAPause()
-        (++) HAL_IRDA_IRQHandler()
+        (++) HAL_IRDA_DMAResume()
+        (++) HAL_IRDA_DMAStop()
-    (#) Non Blocking mode functions with DMA are :
-        (++) HAL_IRDA_Transmit_DMA()
+    (#) A set of Transfer Complete Callbacks are provided in Non Blocking mode:
-        (++) HAL_IRDA_Receive_DMA()
+        (++) HAL_IRDA_TxHalfCpltCallback()
-        (++) HAL_IRDA_DMAPause()
+        (++) HAL_IRDA_TxCpltCallback()
-        (++) HAL_IRDA_DMAResume()
+        (++) HAL_IRDA_RxHalfCpltCallback()
-        (++) HAL_IRDA_DMAStop()
+        (++) HAL_IRDA_RxCpltCallback()
+        (++) HAL_IRDA_ErrorCallback()
-    (#) A set of Transfer Complete Callbacks are provided in Non Blocking mode:
-        (++) HAL_IRDA_TxHalfCpltCallback()
+    (#) Non-Blocking mode transfers could be aborted using Abort API's :
-        (++) HAL_IRDA_TxCpltCallback()
+        (+) HAL_IRDA_Abort()
-        (++) HAL_IRDA_RxHalfCpltCallback()
+        (+) HAL_IRDA_AbortTransmit()
-        (++) HAL_IRDA_RxCpltCallback()
+        (+) HAL_IRDA_AbortReceive()
-        (++) HAL_IRDA_ErrorCallback()
+        (+) HAL_IRDA_Abort_IT()
+        (+) HAL_IRDA_AbortTransmit_IT()
-    (#) Non-Blocking mode transfers could be aborted using Abort API's :
+        (+) HAL_IRDA_AbortReceive_IT()
-        (+) HAL_IRDA_Abort()
-        (+) HAL_IRDA_AbortTransmit()
+    (#) For Abort services based on interrupts (HAL_IRDA_Abortxxx_IT), a set of Abort Complete Callbacks are provided:
-        (+) HAL_IRDA_AbortReceive()
+        (+) HAL_IRDA_AbortCpltCallback()
-        (+) HAL_IRDA_Abort_IT()
+        (+) HAL_IRDA_AbortTransmitCpltCallback()
-        (+) HAL_IRDA_AbortTransmit_IT()
+        (+) HAL_IRDA_AbortReceiveCpltCallback()
-        (+) HAL_IRDA_AbortReceive_IT()
+    (#) In Non-Blocking mode transfers, possible errors are split into 2 categories.
-    (#) For Abort services based on interrupts (HAL_IRDA_Abortxxx_IT), a set of Abort Complete Callbacks are provided:
+        Errors are handled as follows :
-        (+) HAL_IRDA_AbortCpltCallback()
+        (+) Error is considered as Recoverable and non blocking : Transfer could go till end, but error severity is
-        (+) HAL_IRDA_AbortTransmitCpltCallback()
+            to be evaluated by user : this concerns Frame Error, Parity Error or Noise Error in Interrupt mode reception .
-        (+) HAL_IRDA_AbortReceiveCpltCallback()
+            Received character is then retrieved and stored in Rx buffer, Error code is set to allow user to identify error type,
+            and HAL_IRDA_ErrorCallback() user callback is executed. Transfer is kept ongoing on IRDA side.
-    (#) In Non-Blocking mode transfers, possible errors are split into 2 categories.
+            If user wants to abort it, Abort services should be called by user.
-        Errors are handled as follows :
+        (+) Error is considered as Blocking : Transfer could not be completed properly and is aborted.
-        (+) Error is considered as Recoverable and non blocking : Transfer could go till end, but error severity is
+            This concerns Overrun Error In Interrupt mode reception and all errors in DMA mode.
-            to be evaluated by user : this concerns Frame Error, Parity Error or Noise Error in Interrupt mode reception .
+            Error code is set to allow user to identify error type, and HAL_IRDA_ErrorCallback() user callback is executed.
-            Received character is then retrieved and stored in Rx buffer, Error code is set to allow user to identify error type,
-            and HAL_IRDA_ErrorCallback() user callback is executed. Transfer is kept ongoing on IRDA side.
+@endverbatim
-            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 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_IRDA_ErrorCallback() user callback is executed.
+/**
+  * @brief Sends an amount of data in blocking mode.
-@endverbatim
+  * @note  When UART parity is not enabled (PCE = 0), and Word Length is configured to 9 bits (M1-M0 = 01),
-  * @{
+  *        the sent data is handled as a set of u16. In this case, Size must reflect the number
-  */
+  *        of u16 available through pData.
+  * @param hirda Pointer to a IRDA_HandleTypeDef structure that contains
-/**
+  *              the configuration information for the specified IRDA module.
-  * @brief Sends an amount of data in blocking mode.
+  * @param pData Pointer to data buffer (u8 or u16 data elements).
-  * @note  When UART parity is not enabled (PCE = 0), and Word Length is configured to 9 bits (M1-M0 = 01),
+  * @param Size  Amount of data elements (u8 or u16) to be sent.
-  *        the sent data is handled as a set of u16. In this case, Size must reflect the number
+  * @param Timeout Specify timeout value.
-  *        of u16 available through pData.
+  * @retval HAL status
-  * @param hirda Pointer to a IRDA_HandleTypeDef structure that contains
+  */
-  *              the configuration information for the specified IRDA module.
+HAL_StatusTypeDef HAL_IRDA_Transmit(IRDA_HandleTypeDef *hirda, const uint8_t *pData, uint16_t Size, uint32_t Timeout)
-  * @param pData Pointer to data buffer (u8 or u16 data elements).
+{
-  * @param Size  Amount of data elements (u8 or u16) to be sent.
+  const uint16_t *tmp;
-  * @param Timeout Specify timeout value.
+  uint32_t tickstart = 0U;
-  * @retval HAL status
-  */
+  /* Check that a Tx process is not already ongoing */
-HAL_StatusTypeDef HAL_IRDA_Transmit(IRDA_HandleTypeDef *hirda, uint8_t *pData, uint16_t Size, uint32_t Timeout)
+  if (hirda->gState == HAL_IRDA_STATE_READY)
-{
+  {
-  uint16_t *tmp;
+    if ((pData == NULL) || (Size == 0U))
-  uint32_t tickstart = 0U;
+    {
+      return  HAL_ERROR;
-  /* Check that a Tx process is not already ongoing */
+    }
-  if (hirda->gState == HAL_IRDA_STATE_READY)
-  {
+    /* Process Locked */
-    if ((pData == NULL) || (Size == 0U))
+    __HAL_LOCK(hirda);
-    {
-      return  HAL_ERROR;
+    hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
-    }
+    hirda->gState = HAL_IRDA_STATE_BUSY_TX;
-    /* Process Locked */
+    /* Init tickstart for timeout management*/
-    __HAL_LOCK(hirda);
+    tickstart = HAL_GetTick();
-    hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
+    hirda->TxXferSize = Size;
-    hirda->gState = HAL_IRDA_STATE_BUSY_TX;
+    hirda->TxXferCount = Size;
+    while (hirda->TxXferCount > 0U)
-    /* Init tickstart for timeout management*/
+    {
-    tickstart = HAL_GetTick();
+      hirda->TxXferCount--;
+      if (hirda->Init.WordLength == IRDA_WORDLENGTH_9B)
-    hirda->TxXferSize = Size;
+      {
-    hirda->TxXferCount = Size;
+        if (IRDA_WaitOnFlagUntilTimeout(hirda, IRDA_FLAG_TXE, RESET, tickstart, Timeout) != HAL_OK)
-    while (hirda->TxXferCount > 0U)
+        {
-    {
+          return HAL_TIMEOUT;
-      hirda->TxXferCount--;
+        }
-      if (hirda->Init.WordLength == IRDA_WORDLENGTH_9B)
+        tmp = (const uint16_t *) pData;
-      {
+        hirda->Instance->DR = (*tmp & (uint16_t)0x01FF);
-        if (IRDA_WaitOnFlagUntilTimeout(hirda, IRDA_FLAG_TXE, RESET, tickstart, Timeout) != HAL_OK)
+        if (hirda->Init.Parity == IRDA_PARITY_NONE)
         {
-          return HAL_TIMEOUT;
+          pData += 2U;
         }
-        tmp = (uint16_t *) pData;
+        else
-        hirda->Instance->DR = (*tmp & (uint16_t)0x01FF);
+        {
-        if (hirda->Init.Parity == IRDA_PARITY_NONE)
+          pData += 1U;
-        {
+        }
-          pData += 2U;
+      }
-        }
+      else
-        else
+      {
-        {
+        if (IRDA_WaitOnFlagUntilTimeout(hirda, IRDA_FLAG_TXE, RESET, tickstart, Timeout) != HAL_OK)
-          pData += 1U;
+        {
-        }
+          return HAL_TIMEOUT;
-      }
+        }
-      else
+        hirda->Instance->DR = (*pData++ & (uint8_t)0xFF);
-      {
+      }
-        if (IRDA_WaitOnFlagUntilTimeout(hirda, IRDA_FLAG_TXE, RESET, tickstart, Timeout) != HAL_OK)
+    }
-        {
-          return HAL_TIMEOUT;
+    if (IRDA_WaitOnFlagUntilTimeout(hirda, IRDA_FLAG_TC, RESET, tickstart, Timeout) != HAL_OK)
-        }
+    {
-        hirda->Instance->DR = (*pData++ & (uint8_t)0xFF);
+      return HAL_TIMEOUT;
-      }
+    }
-    }
+    /* At end of Tx process, restore hirda->gState to Ready */
-    if (IRDA_WaitOnFlagUntilTimeout(hirda, IRDA_FLAG_TC, RESET, tickstart, Timeout) != HAL_OK)
+    hirda->gState = HAL_IRDA_STATE_READY;
-    {
-      return HAL_TIMEOUT;
+    /* Process Unlocked */
-    }
+    __HAL_UNLOCK(hirda);
-    /* At end of Tx process, restore hirda->gState to Ready */
+    return HAL_OK;
-    hirda->gState = HAL_IRDA_STATE_READY;
+  }
+  else
-    /* Process Unlocked */
+  {
-    __HAL_UNLOCK(hirda);
+    return HAL_BUSY;
+  }
-    return HAL_OK;
+}
-  }
-  else
+/**
-  {
+  * @brief Receive an amount of data in blocking mode.
-    return HAL_BUSY;
+  * @note  When UART parity is not enabled (PCE = 0), and Word Length is configured to 9 bits (M1-M0 = 01),
-  }
+  *        the received data is handled as a set of u16. In this case, Size must reflect the number
-}
+  *        of u16 available through pData.
+  * @param hirda Pointer to a IRDA_HandleTypeDef structure that contains
-/**
+  *              the configuration information for the specified IRDA module.
-  * @brief Receive an amount of data in blocking mode.
+  * @param pData Pointer to data buffer (u8 or u16 data elements).
-  * @note  When UART parity is not enabled (PCE = 0), and Word Length is configured to 9 bits (M1-M0 = 01),
+  * @param Size  Amount of data elements (u8 or u16) to be received.
-  *        the received data is handled as a set of u16. In this case, Size must reflect the number
+  * @param Timeout Specify timeout value
-  *        of u16 available through pData.
+  * @retval HAL status
-  * @param hirda Pointer to a IRDA_HandleTypeDef structure that contains
+  */
-  *              the configuration information for the specified IRDA module.
+HAL_StatusTypeDef HAL_IRDA_Receive(IRDA_HandleTypeDef *hirda, uint8_t *pData, uint16_t Size, uint32_t Timeout)
-  * @param pData Pointer to data buffer (u8 or u16 data elements).
+{
-  * @param Size  Amount of data elements (u8 or u16) to be received.
+  uint16_t *tmp;
-  * @param Timeout Specify timeout value
+  uint32_t tickstart = 0U;
-  * @retval HAL status
-  */
+  /* Check that a Rx process is not already ongoing */
-HAL_StatusTypeDef HAL_IRDA_Receive(IRDA_HandleTypeDef *hirda, uint8_t *pData, uint16_t Size, uint32_t Timeout)
+  if (hirda->RxState == HAL_IRDA_STATE_READY)
-{
+  {
-  uint16_t *tmp;
+    if ((pData == NULL) || (Size == 0U))
-  uint32_t tickstart = 0U;
+    {
+      return  HAL_ERROR;
-  /* Check that a Rx process is not already ongoing */
+    }
-  if (hirda->RxState == HAL_IRDA_STATE_READY)
-  {
+    /* Process Locked */
-    if ((pData == NULL) || (Size == 0U))
+    __HAL_LOCK(hirda);
-    {
-      return  HAL_ERROR;
+    hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
-    }
+    hirda->RxState = HAL_IRDA_STATE_BUSY_RX;
-    /* Process Locked */
+    /* Init tickstart for timeout management*/
-    __HAL_LOCK(hirda);
+    tickstart = HAL_GetTick();
-    hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
+    hirda->RxXferSize = Size;
-    hirda->RxState = HAL_IRDA_STATE_BUSY_RX;
+    hirda->RxXferCount = Size;
-    /* Init tickstart for timeout management*/
+    /* Check the remain data to be received */
-    tickstart = HAL_GetTick();
+    while (hirda->RxXferCount > 0U)
+    {
-    hirda->RxXferSize = Size;
+      hirda->RxXferCount--;
-    hirda->RxXferCount = Size;
+      if (hirda->Init.WordLength == IRDA_WORDLENGTH_9B)
-    /* Check the remain data to be received */
+      {
-    while (hirda->RxXferCount > 0U)
+        if (IRDA_WaitOnFlagUntilTimeout(hirda, IRDA_FLAG_RXNE, RESET, tickstart, Timeout) != HAL_OK)
-    {
+        {
-      hirda->RxXferCount--;
+          return HAL_TIMEOUT;
+        }
-      if (hirda->Init.WordLength == IRDA_WORDLENGTH_9B)
+        tmp = (uint16_t *) pData ;
-      {
+        if (hirda->Init.Parity == IRDA_PARITY_NONE)
-        if (IRDA_WaitOnFlagUntilTimeout(hirda, IRDA_FLAG_RXNE, RESET, tickstart, Timeout) != HAL_OK)
+        {
-        {
+          *tmp = (uint16_t)(hirda->Instance->DR & (uint16_t)0x01FF);
-          return HAL_TIMEOUT;
+          pData += 2U;
         }
-        tmp = (uint16_t *) pData ;
+        else
-        if (hirda->Init.Parity == IRDA_PARITY_NONE)
+        {
-        {
+          *tmp = (uint16_t)(hirda->Instance->DR & (uint16_t)0x00FF);
-          *tmp = (uint16_t)(hirda->Instance->DR & (uint16_t)0x01FF);
+          pData += 1U;
-          pData += 2U;
+        }
-        }
+      }
-        else
+      else
-        {
+      {
-          *tmp = (uint16_t)(hirda->Instance->DR & (uint16_t)0x00FF);
+        if (IRDA_WaitOnFlagUntilTimeout(hirda, IRDA_FLAG_RXNE, RESET, tickstart, Timeout) != HAL_OK)
-          pData += 1U;
+        {
-        }
+          return HAL_TIMEOUT;
-      }
+        }
-      else
+        if (hirda->Init.Parity == IRDA_PARITY_NONE)
-      {
+        {
-        if (IRDA_WaitOnFlagUntilTimeout(hirda, IRDA_FLAG_RXNE, RESET, tickstart, Timeout) != HAL_OK)
+          *pData++ = (uint8_t)(hirda->Instance->DR & (uint8_t)0x00FF);
-        {
+        }
-          return HAL_TIMEOUT;
+        else
-        }
+        {
-        if (hirda->Init.Parity == IRDA_PARITY_NONE)
+          *pData++ = (uint8_t)(hirda->Instance->DR & (uint8_t)0x007F);
-        {
+        }
-          *pData++ = (uint8_t)(hirda->Instance->DR & (uint8_t)0x00FF);
+      }
-        }
+    }
-        else
-        {
+    /* At end of Rx process, restore hirda->RxState to Ready */
-          *pData++ = (uint8_t)(hirda->Instance->DR & (uint8_t)0x007F);
+    hirda->RxState = HAL_IRDA_STATE_READY;
-        }
-      }
+    /* Process Unlocked */
-    }
+    __HAL_UNLOCK(hirda);
-    /* At end of Rx process, restore hirda->RxState to Ready */
+    return HAL_OK;
-    hirda->RxState = HAL_IRDA_STATE_READY;
+  }
+  else
-    /* Process Unlocked */
+  {
-    __HAL_UNLOCK(hirda);
+    return HAL_BUSY;
+  }
-    return HAL_OK;
+}
-  }
-  else
+/**
-  {
+  * @brief Send an amount of data in non blocking mode.
-    return HAL_BUSY;
+  * @note  When UART parity is not enabled (PCE = 0), and Word Length is configured to 9 bits (M1-M0 = 01),
-  }
+  *        the sent data is handled as a set of u16. In this case, Size must reflect the number
-}
+  *        of u16 available through pData.
+  * @param hirda Pointer to a IRDA_HandleTypeDef structure that contains
-/**
+  *              the configuration information for the specified IRDA module.
-  * @brief Send an amount of data in non blocking mode.
+  * @param pData Pointer to data buffer (u8 or u16 data elements).
-  * @note  When UART parity is not enabled (PCE = 0), and Word Length is configured to 9 bits (M1-M0 = 01),
+  * @param Size  Amount of data elements (u8 or u16) to be sent.
-  *        the sent data is handled as a set of u16. In this case, Size must reflect the number
+  * @retval HAL status
-  *        of u16 available through pData.
+  */
-  * @param hirda Pointer to a IRDA_HandleTypeDef structure that contains
+HAL_StatusTypeDef HAL_IRDA_Transmit_IT(IRDA_HandleTypeDef *hirda, const uint8_t *pData, uint16_t Size)
-  *              the configuration information for the specified IRDA module.
+{
-  * @param pData Pointer to data buffer (u8 or u16 data elements).
+  /* Check that a Tx process is not already ongoing */
-  * @param Size  Amount of data elements (u8 or u16) to be sent.
+  if (hirda->gState == HAL_IRDA_STATE_READY)
-  * @retval HAL status
+  {
-  */
+    if ((pData == NULL) || (Size == 0U))
-HAL_StatusTypeDef HAL_IRDA_Transmit_IT(IRDA_HandleTypeDef *hirda, uint8_t *pData, uint16_t Size)
+    {
-{
+      return HAL_ERROR;
-  /* Check that a Tx process is not already ongoing */
+    }
-  if (hirda->gState == HAL_IRDA_STATE_READY)
-  {
+    /* Process Locked */
-    if ((pData == NULL) || (Size == 0U))
+    __HAL_LOCK(hirda);
-    {
-      return HAL_ERROR;
+    hirda->pTxBuffPtr = pData;
-    }
+    hirda->TxXferSize = Size;
+    hirda->TxXferCount = Size;
-    /* Process Locked */
-    __HAL_LOCK(hirda);
+    hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
+    hirda->gState = HAL_IRDA_STATE_BUSY_TX;
-    hirda->pTxBuffPtr = pData;
-    hirda->TxXferSize = Size;
+    /* Process Unlocked */
-    hirda->TxXferCount = Size;
+    __HAL_UNLOCK(hirda);
-    hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
+    /* Enable the IRDA Transmit Data Register Empty Interrupt */
-    hirda->gState = HAL_IRDA_STATE_BUSY_TX;
+    SET_BIT(hirda->Instance->CR1, USART_CR1_TXEIE);
-    /* Process Unlocked */
+    return HAL_OK;
-    __HAL_UNLOCK(hirda);
+  }
+  else
-    /* Enable the IRDA Transmit Data Register Empty Interrupt */
+  {
-    SET_BIT(hirda->Instance->CR1, USART_CR1_TXEIE);
+    return HAL_BUSY;
+  }
-    return HAL_OK;
+}
-  }
-  else
+/**
-  {
+  * @brief Receive an amount of data in non blocking mode.
-    return HAL_BUSY;
+  * @note  When UART parity is not enabled (PCE = 0), and Word Length is configured to 9 bits (M1-M0 = 01),
-  }
+  *        the received data is handled as a set of u16. In this case, Size must reflect the number
-}
+  *        of u16 available through pData.
+  * @param hirda Pointer to a IRDA_HandleTypeDef structure that contains
-/**
+  *              the configuration information for the specified IRDA module.
-  * @brief Receive an amount of data in non blocking mode.
+  * @param pData Pointer to data buffer (u8 or u16 data elements).
-  * @note  When UART parity is not enabled (PCE = 0), and Word Length is configured to 9 bits (M1-M0 = 01),
+  * @param Size  Amount of data elements (u8 or u16) to be received.
-  *        the received data is handled as a set of u16. In this case, Size must reflect the number
+  * @retval HAL status
-  *        of u16 available through pData.
+  */
-  * @param hirda Pointer to a IRDA_HandleTypeDef structure that contains
+HAL_StatusTypeDef HAL_IRDA_Receive_IT(IRDA_HandleTypeDef *hirda, uint8_t *pData, uint16_t Size)
-  *              the configuration information for the specified IRDA module.
+{
-  * @param pData Pointer to data buffer (u8 or u16 data elements).
+  /* Check that a Rx process is not already ongoing */
-  * @param Size  Amount of data elements (u8 or u16) to be received.
+  if (hirda->RxState == HAL_IRDA_STATE_READY)
-  * @retval HAL status
+  {
-  */
+    if ((pData == NULL) || (Size == 0U))
-HAL_StatusTypeDef HAL_IRDA_Receive_IT(IRDA_HandleTypeDef *hirda, uint8_t *pData, uint16_t Size)
+    {
-{
+      return HAL_ERROR;
-  /* Check that a Rx process is not already ongoing */
+    }
-  if (hirda->RxState == HAL_IRDA_STATE_READY)
-  {
+    /* Process Locked */
-    if ((pData == NULL) || (Size == 0U))
+    __HAL_LOCK(hirda);
-    {
-      return HAL_ERROR;
+    hirda->pRxBuffPtr = pData;
-    }
+    hirda->RxXferSize = Size;
+    hirda->RxXferCount = Size;
-    /* Process Locked */
-    __HAL_LOCK(hirda);
+    hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
+    hirda->RxState = HAL_IRDA_STATE_BUSY_RX;
-    hirda->pRxBuffPtr = pData;
-    hirda->RxXferSize = Size;
+    /* Process Unlocked */
-    hirda->RxXferCount = Size;
+    __HAL_UNLOCK(hirda);
-    hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
+    if (hirda->Init.Parity != IRDA_PARITY_NONE)
-    hirda->RxState = HAL_IRDA_STATE_BUSY_RX;
+    {
+      /* Enable the IRDA Parity Error and Data Register Not Empty Interrupts */
-    /* Process Unlocked */
+      SET_BIT(hirda->Instance->CR1, USART_CR1_PEIE | USART_CR1_RXNEIE);
-    __HAL_UNLOCK(hirda);
+    }
+    else
-    /* Enable the IRDA Parity Error and Data Register Not Empty Interrupts */
+    {
-    SET_BIT(hirda->Instance->CR1, USART_CR1_PEIE | USART_CR1_RXNEIE);
+      /* Enable the IRDA Data Register Not Empty Interrupts */
+       SET_BIT(hirda->Instance->CR1, USART_CR1_RXNEIE);
-    /* Enable the IRDA Error Interrupt: (Frame error, Noise error, Overrun error) */
+    }
-    SET_BIT(hirda->Instance->CR3, USART_CR3_EIE);
+    /* Enable the IRDA Error Interrupt: (Frame error, Noise error, Overrun error) */
-    return HAL_OK;
+    SET_BIT(hirda->Instance->CR3, USART_CR3_EIE);
-  }
-  else
+    return HAL_OK;
-  {
+  }
-    return HAL_BUSY;
+  else
-  }
+  {
-}
+    return HAL_BUSY;
+  }
-/**
+}
-  * @brief Send an amount of data in DMA mode.
-  * @note  When UART parity is not enabled (PCE = 0), and Word Length is configured to 9 bits (M1-M0 = 01),
+/**
-  *        the sent data is handled as a set of u16. In this case, Size must reflect the number
+  * @brief Send an amount of data in DMA mode.
-  *        of u16 available through pData.
+  * @note  When UART parity is not enabled (PCE = 0), and Word Length is configured to 9 bits (M1-M0 = 01),
-  * @param hirda Pointer to a IRDA_HandleTypeDef structure that contains
+  *        the sent data is handled as a set of u16. In this case, Size must reflect the number
-  *              the configuration information for the specified IRDA module.
+  *        of u16 available through pData.
-  * @param pData Pointer to data buffer (u8 or u16 data elements).
+  * @param hirda Pointer to a IRDA_HandleTypeDef structure that contains
-  * @param Size  Amount of data elements (u8 or u16) to be sent.
+  *              the configuration information for the specified IRDA module.
-  * @retval HAL status
+  * @param pData Pointer to data buffer (u8 or u16 data elements).
-  */
+  * @param Size  Amount of data elements (u8 or u16) to be sent.
-HAL_StatusTypeDef HAL_IRDA_Transmit_DMA(IRDA_HandleTypeDef *hirda, uint8_t *pData, uint16_t Size)
+  * @retval HAL status
-{
+  */
-  uint32_t *tmp;
+HAL_StatusTypeDef HAL_IRDA_Transmit_DMA(IRDA_HandleTypeDef *hirda, const uint8_t *pData, uint16_t Size)
+{
-  /* Check that a Tx process is not already ongoing */
+  const uint32_t *tmp;
-  if (hirda->gState == HAL_IRDA_STATE_READY)
-  {
+  /* Check that a Tx process is not already ongoing */
-    if ((pData == NULL) || (Size == 0U))
+  if (hirda->gState == HAL_IRDA_STATE_READY)
-    {
+  {
-      return HAL_ERROR;
+    if ((pData == NULL) || (Size == 0U))
-    }
+    {
+      return HAL_ERROR;
-    /* Process Locked */
+    }
-    __HAL_LOCK(hirda);
+    /* Process Locked */
-    hirda->pTxBuffPtr = pData;
+    __HAL_LOCK(hirda);
-    hirda->TxXferSize = Size;
-    hirda->TxXferCount = Size;
+    hirda->pTxBuffPtr = pData;
+    hirda->TxXferSize = Size;
-    hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
+    hirda->TxXferCount = Size;
-    hirda->gState = HAL_IRDA_STATE_BUSY_TX;
+    hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
-    /* Set the IRDA DMA transfer complete callback */
+    hirda->gState = HAL_IRDA_STATE_BUSY_TX;
-    hirda->hdmatx->XferCpltCallback = IRDA_DMATransmitCplt;
+    /* Set the IRDA DMA transfer complete callback */
-    /* Set the IRDA DMA half transfer complete callback */
+    hirda->hdmatx->XferCpltCallback = IRDA_DMATransmitCplt;
-    hirda->hdmatx->XferHalfCpltCallback = IRDA_DMATransmitHalfCplt;
+    /* Set the IRDA DMA half transfer complete callback */
-    /* Set the DMA error callback */
+    hirda->hdmatx->XferHalfCpltCallback = IRDA_DMATransmitHalfCplt;
-    hirda->hdmatx->XferErrorCallback = IRDA_DMAError;
+    /* Set the DMA error callback */
-    /* Set the DMA abort callback */
+    hirda->hdmatx->XferErrorCallback = IRDA_DMAError;
-    hirda->hdmatx->XferAbortCallback = NULL;
+    /* Set the DMA abort callback */
-    /* Enable the IRDA transmit DMA channel */
+    hirda->hdmatx->XferAbortCallback = NULL;
-    tmp = (uint32_t *)&pData;
-    HAL_DMA_Start_IT(hirda->hdmatx, *(uint32_t *)tmp, (uint32_t)&hirda->Instance->DR, Size);
+    /* Enable the IRDA transmit DMA channel */
+    tmp = (const uint32_t *)&pData;
-    /* Clear the TC flag in the SR register by writing 0 to it */
+    HAL_DMA_Start_IT(hirda->hdmatx, *(const uint32_t *)tmp, (uint32_t)&hirda->Instance->DR, Size);
-    __HAL_IRDA_CLEAR_FLAG(hirda, IRDA_FLAG_TC);
+    /* Clear the TC flag in the SR register by writing 0 to it */
-    /* Process Unlocked */
+    __HAL_IRDA_CLEAR_FLAG(hirda, IRDA_FLAG_TC);
-    __HAL_UNLOCK(hirda);
+    /* Process Unlocked */
-    /* Enable the DMA transfer for transmit request by setting the DMAT bit
+    __HAL_UNLOCK(hirda);
-    in the USART CR3 register */
-    SET_BIT(hirda->Instance->CR3, USART_CR3_DMAT);
+    /* Enable the DMA transfer for transmit request by setting the DMAT bit
+    in the USART CR3 register */
-    return HAL_OK;
+    SET_BIT(hirda->Instance->CR3, USART_CR3_DMAT);
-  }
-  else
+    return HAL_OK;
-  {
+  }
-    return HAL_BUSY;
+  else
-  }
+  {
-}
+    return HAL_BUSY;
+  }
-/**
+}
-  * @brief Receives an amount of data in DMA mode.
-  * @note  When UART parity is not enabled (PCE = 0), and Word Length is configured to 9 bits (M1-M0 = 01),
+/**
-  *        the received data is handled as a set of u16. In this case, Size must reflect the number
+  * @brief Receives an amount of data in DMA mode.
-  *        of u16 available through pData.
+  * @note  When UART parity is not enabled (PCE = 0), and Word Length is configured to 9 bits (M1-M0 = 01),
-  * @param hirda Pointer to a IRDA_HandleTypeDef structure that contains
+  *        the received data is handled as a set of u16. In this case, Size must reflect the number
-  *              the configuration information for the specified IRDA module.
+  *        of u16 available through pData.
-  * @param pData Pointer to data buffer (u8 or u16 data elements).
+  * @param hirda Pointer to a IRDA_HandleTypeDef structure that contains
-  * @param Size  Amount of data elements (u8 or u16) to be received.
+  *              the configuration information for the specified IRDA module.
-  * @note   When the IRDA parity is enabled (PCE = 1) the data received contain the parity bit.
+  * @param pData Pointer to data buffer (u8 or u16 data elements).
-  * @retval HAL status
+  * @param Size  Amount of data elements (u8 or u16) to be received.
-  */
+  * @note   When the IRDA parity is enabled (PCE = 1) the data received contain the parity bit.
-HAL_StatusTypeDef HAL_IRDA_Receive_DMA(IRDA_HandleTypeDef *hirda, uint8_t *pData, uint16_t Size)
+  * @retval HAL status
-{
+  */
-  uint32_t *tmp;
+HAL_StatusTypeDef HAL_IRDA_Receive_DMA(IRDA_HandleTypeDef *hirda, uint8_t *pData, uint16_t Size)
+{
-  /* Check that a Rx process is not already ongoing */
+  uint32_t *tmp;
-  if (hirda->RxState == HAL_IRDA_STATE_READY)
-  {
+  /* Check that a Rx process is not already ongoing */
-    if ((pData == NULL) || (Size == 0U))
+  if (hirda->RxState == HAL_IRDA_STATE_READY)
-    {
+  {
-      return HAL_ERROR;
+    if ((pData == NULL) || (Size == 0U))
-    }
+    {
+      return HAL_ERROR;
-    /* Process Locked */
+    }
-    __HAL_LOCK(hirda);
+    /* Process Locked */
-    hirda->pRxBuffPtr = pData;
+    __HAL_LOCK(hirda);
-    hirda->RxXferSize = Size;
+    hirda->pRxBuffPtr = pData;
-    hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
+    hirda->RxXferSize = Size;
-    hirda->RxState = HAL_IRDA_STATE_BUSY_RX;
+    hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
-    /* Set the IRDA DMA transfer complete callback */
+    hirda->RxState = HAL_IRDA_STATE_BUSY_RX;
-    hirda->hdmarx->XferCpltCallback = IRDA_DMAReceiveCplt;
+    /* Set the IRDA DMA transfer complete callback */
-    /* Set the IRDA DMA half transfer complete callback */
+    hirda->hdmarx->XferCpltCallback = IRDA_DMAReceiveCplt;
-    hirda->hdmarx->XferHalfCpltCallback = IRDA_DMAReceiveHalfCplt;
+    /* Set the IRDA DMA half transfer complete callback */
-    /* Set the DMA error callback */
+    hirda->hdmarx->XferHalfCpltCallback = IRDA_DMAReceiveHalfCplt;
-    hirda->hdmarx->XferErrorCallback = IRDA_DMAError;
+    /* Set the DMA error callback */
-    /* Set the DMA abort callback */
+    hirda->hdmarx->XferErrorCallback = IRDA_DMAError;
-    hirda->hdmarx->XferAbortCallback = NULL;
+    /* Set the DMA abort callback */
-    /* Enable the DMA channel */
+    hirda->hdmarx->XferAbortCallback = NULL;
-    tmp = (uint32_t *)&pData;
-    HAL_DMA_Start_IT(hirda->hdmarx, (uint32_t)&hirda->Instance->DR, *(uint32_t *)tmp, Size);
+    /* Enable the DMA channel */
+    tmp = (uint32_t *)&pData;
-    /* Clear the Overrun flag just before enabling the DMA Rx request: can be mandatory for the second transfer */
+    HAL_DMA_Start_IT(hirda->hdmarx, (uint32_t)&hirda->Instance->DR, *(uint32_t *)tmp, Size);
-    __HAL_IRDA_CLEAR_OREFLAG(hirda);
+    /* Clear the Overrun flag just before enabling the DMA Rx request: can be mandatory for the second transfer */
-    /* Process Unlocked */
+    __HAL_IRDA_CLEAR_OREFLAG(hirda);
-    __HAL_UNLOCK(hirda);
+    /* Process Unlocked */
-    /* Enable the IRDA Parity Error Interrupt */
+    __HAL_UNLOCK(hirda);
-    SET_BIT(hirda->Instance->CR1, USART_CR1_PEIE);
+    if (hirda->Init.Parity != IRDA_PARITY_NONE)
-    /* Enable the IRDA Error Interrupt: (Frame error, Noise error, Overrun error) */
+    {
-    SET_BIT(hirda->Instance->CR3, USART_CR3_EIE);
+      /* Enable the IRDA Parity Error Interrupt */
+      SET_BIT(hirda->Instance->CR1, USART_CR1_PEIE);
-    /* Enable the DMA transfer for the receiver request by setting the DMAR bit
+    }
-    in the USART CR3 register */
-    SET_BIT(hirda->Instance->CR3, USART_CR3_DMAR);
+    /* Enable the IRDA Error Interrupt: (Frame error, Noise error, Overrun error) */
+    SET_BIT(hirda->Instance->CR3, USART_CR3_EIE);
-    return HAL_OK;
-  }
+    /* Enable the DMA transfer for the receiver request by setting the DMAR bit
-  else
+    in the USART CR3 register */
-  {
+    SET_BIT(hirda->Instance->CR3, USART_CR3_DMAR);
-    return HAL_BUSY;
-  }
+    return HAL_OK;
-}
+  }
+  else
-/**
+  {
-  * @brief Pauses the DMA Transfer.
+    return HAL_BUSY;
-  * @param  hirda  Pointer to a IRDA_HandleTypeDef structure that contains
+  }
-  *                the configuration information for the specified IRDA module.
+}
-  * @retval HAL status
-  */
+/**
-HAL_StatusTypeDef HAL_IRDA_DMAPause(IRDA_HandleTypeDef *hirda)
+  * @brief Pauses the DMA Transfer.
-{
+  * @param  hirda  Pointer to a IRDA_HandleTypeDef structure that contains
-  uint32_t dmarequest = 0x00U;
+  *                the configuration information for the specified IRDA module.
+  * @retval HAL status
-  /* Process Locked */
+  */
-  __HAL_LOCK(hirda);
+HAL_StatusTypeDef HAL_IRDA_DMAPause(IRDA_HandleTypeDef *hirda)
+{
-  dmarequest = HAL_IS_BIT_SET(hirda->Instance->CR3, USART_CR3_DMAT);
+  uint32_t dmarequest = 0x00U;
-  if ((hirda->gState == HAL_IRDA_STATE_BUSY_TX) && dmarequest)
-  {
+  /* Process Locked */
-    /* Disable the IRDA DMA Tx request */
+  __HAL_LOCK(hirda);
-    CLEAR_BIT(hirda->Instance->CR3, USART_CR3_DMAT);
-  }
+  dmarequest = HAL_IS_BIT_SET(hirda->Instance->CR3, USART_CR3_DMAT);
+  if ((hirda->gState == HAL_IRDA_STATE_BUSY_TX) && dmarequest)
-  dmarequest = HAL_IS_BIT_SET(hirda->Instance->CR3, USART_CR3_DMAR);
+  {
-  if ((hirda->RxState == HAL_IRDA_STATE_BUSY_RX) && dmarequest)
+    /* Disable the IRDA DMA Tx request */
-  {
+    CLEAR_BIT(hirda->Instance->CR3, USART_CR3_DMAT);
-    /* Disable PE and ERR (Frame error, noise error, overrun error) interrupts */
+  }
-    CLEAR_BIT(hirda->Instance->CR1, USART_CR1_PEIE);
-    CLEAR_BIT(hirda->Instance->CR3, USART_CR3_EIE);
+  dmarequest = HAL_IS_BIT_SET(hirda->Instance->CR3, USART_CR3_DMAR);
+  if ((hirda->RxState == HAL_IRDA_STATE_BUSY_RX) && dmarequest)
-    /* Disable the IRDA DMA Rx request */
+  {
-    CLEAR_BIT(hirda->Instance->CR3, USART_CR3_DMAR);
+    /* Disable PE and ERR (Frame error, noise error, overrun error) interrupts */
-  }
+    CLEAR_BIT(hirda->Instance->CR1, USART_CR1_PEIE);
+    CLEAR_BIT(hirda->Instance->CR3, USART_CR3_EIE);
-  /* Process Unlocked */
-  __HAL_UNLOCK(hirda);
+    /* Disable the IRDA DMA Rx request */
+    CLEAR_BIT(hirda->Instance->CR3, USART_CR3_DMAR);
-  return HAL_OK;
+  }
-}
+  /* Process Unlocked */
-/**
+  __HAL_UNLOCK(hirda);
-  * @brief Resumes the DMA Transfer.
-  * @param  hirda  Pointer to a IRDA_HandleTypeDef structure that contains
+  return HAL_OK;
-  *                the configuration information for the specified IRDA module.
+}
-  * @retval HAL status
-  */
+/**
-HAL_StatusTypeDef HAL_IRDA_DMAResume(IRDA_HandleTypeDef *hirda)
+  * @brief Resumes the DMA Transfer.
-{
+  * @param  hirda  Pointer to a IRDA_HandleTypeDef structure that contains
-  /* Process Locked */
+  *                the configuration information for the specified IRDA module.
-  __HAL_LOCK(hirda);
+  * @retval HAL status
+  */
-  if (hirda->gState == HAL_IRDA_STATE_BUSY_TX)
+HAL_StatusTypeDef HAL_IRDA_DMAResume(IRDA_HandleTypeDef *hirda)
-  {
+{
-    /* Enable the IRDA DMA Tx request */
+  /* Process Locked */
-    SET_BIT(hirda->Instance->CR3, USART_CR3_DMAT);
+  __HAL_LOCK(hirda);
-  }
+  if (hirda->gState == HAL_IRDA_STATE_BUSY_TX)
-  if (hirda->RxState == HAL_IRDA_STATE_BUSY_RX)
+  {
-  {
+    /* Enable the IRDA DMA Tx request */
-    /* Clear the Overrun flag before resuming the Rx transfer */
+    SET_BIT(hirda->Instance->CR3, USART_CR3_DMAT);
-    __HAL_IRDA_CLEAR_OREFLAG(hirda);
+  }
-    /* Re-enable PE and ERR (Frame error, noise error, overrun error) interrupts */
+  if (hirda->RxState == HAL_IRDA_STATE_BUSY_RX)
-    SET_BIT(hirda->Instance->CR1, USART_CR1_PEIE);
+  {
-    SET_BIT(hirda->Instance->CR3, USART_CR3_EIE);
+    /* Clear the Overrun flag before resuming the Rx transfer */
+    __HAL_IRDA_CLEAR_OREFLAG(hirda);
-    /* Enable the IRDA DMA Rx request */
-    SET_BIT(hirda->Instance->CR3, USART_CR3_DMAR);
+    /* Re-enable PE and ERR (Frame error, noise error, overrun error) interrupts */
-  }
+    if (hirda->Init.Parity != IRDA_PARITY_NONE)
+    {
-  /* Process Unlocked */
+      SET_BIT(hirda->Instance->CR1, USART_CR1_PEIE);
-  __HAL_UNLOCK(hirda);
+    }
+    SET_BIT(hirda->Instance->CR3, USART_CR3_EIE);
-  return HAL_OK;
-}
+    /* Enable the IRDA DMA Rx request */
+    SET_BIT(hirda->Instance->CR3, USART_CR3_DMAR);
-/**
+  }
-  * @brief Stops the DMA Transfer.
-  * @param  hirda  Pointer to a IRDA_HandleTypeDef structure that contains
+  /* Process Unlocked */
-  *                the configuration information for the specified IRDA module.
+  __HAL_UNLOCK(hirda);
-  * @retval HAL status
-  */
+  return HAL_OK;
-HAL_StatusTypeDef HAL_IRDA_DMAStop(IRDA_HandleTypeDef *hirda)
+}
-{
-  uint32_t dmarequest = 0x00U;
+/**
-  /* The Lock is not implemented on this API to allow the user application
+  * @brief Stops the DMA Transfer.
-     to call the HAL IRDA API under callbacks HAL_IRDA_TxCpltCallback() / HAL_IRDA_RxCpltCallback():
+  * @param  hirda  Pointer to a IRDA_HandleTypeDef structure that contains
-     when calling HAL_DMA_Abort() API the DMA TX/RX Transfer complete interrupt is generated
+  *                the configuration information for the specified IRDA module.
-     and the correspond call back is executed HAL_IRDA_TxCpltCallback() / HAL_IRDA_RxCpltCallback()
+  * @retval HAL status
   */
+HAL_StatusTypeDef HAL_IRDA_DMAStop(IRDA_HandleTypeDef *hirda)
-  /* Stop IRDA DMA Tx request if ongoing */
+{
-  dmarequest = HAL_IS_BIT_SET(hirda->Instance->CR3, USART_CR3_DMAT);
+  uint32_t dmarequest = 0x00U;
-  if ((hirda->gState == HAL_IRDA_STATE_BUSY_TX) && dmarequest)
+  /* The Lock is not implemented on this API to allow the user application
-  {
+     to call the HAL IRDA API under callbacks HAL_IRDA_TxCpltCallback() / HAL_IRDA_RxCpltCallback():
-    CLEAR_BIT(hirda->Instance->CR3, USART_CR3_DMAT);
+     when calling HAL_DMA_Abort() API the DMA TX/RX Transfer complete interrupt is generated
+     and the correspond call back is executed HAL_IRDA_TxCpltCallback() / HAL_IRDA_RxCpltCallback()
-    /* Abort the IRDA DMA Tx channel */
+  */
-    if (hirda->hdmatx != NULL)
-    {
+  /* Stop IRDA DMA Tx request if ongoing */
-      HAL_DMA_Abort(hirda->hdmatx);
+  dmarequest = HAL_IS_BIT_SET(hirda->Instance->CR3, USART_CR3_DMAT);
-    }
+  if ((hirda->gState == HAL_IRDA_STATE_BUSY_TX) && dmarequest)
-    IRDA_EndTxTransfer(hirda);
+  {
-  }
+    CLEAR_BIT(hirda->Instance->CR3, USART_CR3_DMAT);
-  /* Stop IRDA DMA Rx request if ongoing */
+    /* Abort the IRDA DMA Tx channel */
-  dmarequest = HAL_IS_BIT_SET(hirda->Instance->CR3, USART_CR3_DMAR);
+    if (hirda->hdmatx != NULL)
-  if ((hirda->RxState == HAL_IRDA_STATE_BUSY_RX) && dmarequest)
+    {
-  {
+      HAL_DMA_Abort(hirda->hdmatx);
-    CLEAR_BIT(hirda->Instance->CR3, USART_CR3_DMAR);
+    }
+    IRDA_EndTxTransfer(hirda);
-    /* Abort the IRDA DMA Rx channel */
+  }
-    if (hirda->hdmarx != NULL)
-    {
+  /* Stop IRDA DMA Rx request if ongoing */
-      HAL_DMA_Abort(hirda->hdmarx);
+  dmarequest = HAL_IS_BIT_SET(hirda->Instance->CR3, USART_CR3_DMAR);
-    }
+  if ((hirda->RxState == HAL_IRDA_STATE_BUSY_RX) && dmarequest)
-    IRDA_EndRxTransfer(hirda);
+  {
-  }
+    CLEAR_BIT(hirda->Instance->CR3, USART_CR3_DMAR);
-  return HAL_OK;
+    /* Abort the IRDA DMA Rx channel */
-}
+    if (hirda->hdmarx != NULL)
+    {
-/**
+      HAL_DMA_Abort(hirda->hdmarx);
-  * @brief  Abort ongoing transfers (blocking mode).
+    }
-  * @param  hirda IRDA handle.
+    IRDA_EndRxTransfer(hirda);
-  * @note   This procedure could be used for aborting any ongoing transfer started in Interrupt or DMA mode.
+  }
-  *         This procedure performs following operations :
-  *           - Disable PPP Interrupts
+  return HAL_OK;
-  *           - Disable the DMA transfer in the peripheral register (if enabled)
+}
-  *           - Abort DMA transfer by calling HAL_DMA_Abort (in case of transfer in DMA mode)
-  *           - Set handle State to READY
+/**
-  * @note   This procedure is executed in blocking mode : when exiting function, Abort is considered as completed.
+  * @brief  Abort ongoing transfers (blocking mode).
-  * @retval HAL status
+  * @param  hirda IRDA handle.
-*/
+  * @note   This procedure could be used for aborting any ongoing transfer started in Interrupt or DMA mode.
-HAL_StatusTypeDef HAL_IRDA_Abort(IRDA_HandleTypeDef *hirda)
+  *         This procedure performs following operations :
-{
+  *           - Disable PPP Interrupts
-  /* Disable TXEIE, TCIE, RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts */
+  *           - Disable the DMA transfer in the peripheral register (if enabled)
-  CLEAR_BIT(hirda->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE | USART_CR1_TXEIE | USART_CR1_TCIE));
+  *           - Abort DMA transfer by calling HAL_DMA_Abort (in case of transfer in DMA mode)
-  CLEAR_BIT(hirda->Instance->CR3, USART_CR3_EIE);
+  *           - Set handle State to READY
+  * @note   This procedure is executed in blocking mode : when exiting function, Abort is considered as completed.
-  /* Disable the IRDA DMA Tx request if enabled */
+  * @retval HAL status
-  if (HAL_IS_BIT_SET(hirda->Instance->CR3, USART_CR3_DMAT))
+*/
-  {
+HAL_StatusTypeDef HAL_IRDA_Abort(IRDA_HandleTypeDef *hirda)
-    CLEAR_BIT(hirda->Instance->CR3, USART_CR3_DMAT);
+{
+  /* Disable TXEIE, TCIE, RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts */
-    /* Abort the IRDA DMA Tx channel : use blocking DMA Abort API (no callback) */
+  CLEAR_BIT(hirda->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE | USART_CR1_TXEIE | USART_CR1_TCIE));
-    if (hirda->hdmatx != NULL)
+  CLEAR_BIT(hirda->Instance->CR3, USART_CR3_EIE);
-    {
-      /* Set the IRDA DMA Abort callback to Null.
+  /* Disable the IRDA DMA Tx request if enabled */
-         No call back execution at end of DMA abort procedure */
+  if (HAL_IS_BIT_SET(hirda->Instance->CR3, USART_CR3_DMAT))
-      hirda->hdmatx->XferAbortCallback = NULL;
+  {
+    CLEAR_BIT(hirda->Instance->CR3, USART_CR3_DMAT);
-      HAL_DMA_Abort(hirda->hdmatx);
-    }
+    /* Abort the IRDA DMA Tx channel : use blocking DMA Abort API (no callback) */
-  }
+    if (hirda->hdmatx != NULL)
+    {
-  /* Disable the IRDA DMA Rx request if enabled */
+      /* Set the IRDA DMA Abort callback to Null.
-  if (HAL_IS_BIT_SET(hirda->Instance->CR3, USART_CR3_DMAR))
+         No call back execution at end of DMA abort procedure */
-  {
+      hirda->hdmatx->XferAbortCallback = NULL;
-    CLEAR_BIT(hirda->Instance->CR3, USART_CR3_DMAR);
+      HAL_DMA_Abort(hirda->hdmatx);
-    /* Abort the IRDA DMA Rx channel : use blocking DMA Abort API (no callback) */
+    }
-    if (hirda->hdmarx != NULL)
+  }
-    {
-      /* Set the IRDA DMA Abort callback to Null.
+  /* Disable the IRDA DMA Rx request if enabled */
-         No call back execution at end of DMA abort procedure */
+  if (HAL_IS_BIT_SET(hirda->Instance->CR3, USART_CR3_DMAR))
-      hirda->hdmarx->XferAbortCallback = NULL;
+  {
+    CLEAR_BIT(hirda->Instance->CR3, USART_CR3_DMAR);
-      HAL_DMA_Abort(hirda->hdmarx);
-    }
+    /* Abort the IRDA DMA Rx channel : use blocking DMA Abort API (no callback) */
-  }
+    if (hirda->hdmarx != NULL)
+    {
-  /* Reset Tx and Rx transfer counters */
+      /* Set the IRDA DMA Abort callback to Null.
-  hirda->TxXferCount = 0x00U;
+         No call back execution at end of DMA abort procedure */
-  hirda->RxXferCount = 0x00U;
+      hirda->hdmarx->XferAbortCallback = NULL;
-  /* Reset ErrorCode */
+      HAL_DMA_Abort(hirda->hdmarx);
-  hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
+    }
+  }
-  /* Restore hirda->RxState and hirda->gState to Ready */
-  hirda->RxState = HAL_IRDA_STATE_READY;
+  /* Reset Tx and Rx transfer counters */
-  hirda->gState = HAL_IRDA_STATE_READY;
+  hirda->TxXferCount = 0x00U;
+  hirda->RxXferCount = 0x00U;
-  return HAL_OK;
-}
+  /* Reset ErrorCode */
+  hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
-/**
-  * @brief  Abort ongoing Transmit transfer (blocking mode).
+  /* Restore hirda->RxState and hirda->gState to Ready */
-  * @param  hirda IRDA handle.
+  hirda->RxState = HAL_IRDA_STATE_READY;
-  * @note   This procedure could be used for aborting any ongoing transfer started in Interrupt or DMA mode.
+  hirda->gState = HAL_IRDA_STATE_READY;
-  *         This procedure performs following operations :
-  *           - Disable PPP Interrupts
+  return HAL_OK;
-  *           - Disable the DMA transfer in the peripheral register (if enabled)
+}
-  *           - Abort DMA transfer by calling HAL_DMA_Abort (in case of transfer in DMA mode)
-  *           - Set handle State to READY
+/**
-  * @note   This procedure is executed in blocking mode : when exiting function, Abort is considered as completed.
+  * @brief  Abort ongoing Transmit transfer (blocking mode).
-  * @retval HAL status
+  * @param  hirda IRDA handle.
-*/
+  * @note   This procedure could be used for aborting any ongoing transfer started in Interrupt or DMA mode.
-HAL_StatusTypeDef HAL_IRDA_AbortTransmit(IRDA_HandleTypeDef *hirda)
+  *         This procedure performs following operations :
-{
+  *           - Disable PPP Interrupts
-  /* Disable TXEIE and TCIE interrupts */
+  *           - Disable the DMA transfer in the peripheral register (if enabled)
-  CLEAR_BIT(hirda->Instance->CR1, (USART_CR1_TXEIE | USART_CR1_TCIE));
+  *           - Abort DMA transfer by calling HAL_DMA_Abort (in case of transfer in DMA mode)
+  *           - Set handle State to READY
-  /* Disable the IRDA DMA Tx request if enabled */
+  * @note   This procedure is executed in blocking mode : when exiting function, Abort is considered as completed.
-  if (HAL_IS_BIT_SET(hirda->Instance->CR3, USART_CR3_DMAT))
+  * @retval HAL status
-  {
+*/
-    CLEAR_BIT(hirda->Instance->CR3, USART_CR3_DMAT);
+HAL_StatusTypeDef HAL_IRDA_AbortTransmit(IRDA_HandleTypeDef *hirda)
+{
-    /* Abort the IRDA DMA Tx channel : use blocking DMA Abort API (no callback) */
+  /* Disable TXEIE and TCIE interrupts */
-    if (hirda->hdmatx != NULL)
+  CLEAR_BIT(hirda->Instance->CR1, (USART_CR1_TXEIE | USART_CR1_TCIE));
-    {
-      /* Set the IRDA DMA Abort callback to Null.
+  /* Disable the IRDA DMA Tx request if enabled */
-         No call back execution at end of DMA abort procedure */
+  if (HAL_IS_BIT_SET(hirda->Instance->CR3, USART_CR3_DMAT))
-      hirda->hdmatx->XferAbortCallback = NULL;
+  {
+    CLEAR_BIT(hirda->Instance->CR3, USART_CR3_DMAT);
-      HAL_DMA_Abort(hirda->hdmatx);
-    }
+    /* Abort the IRDA DMA Tx channel : use blocking DMA Abort API (no callback) */
-  }
+    if (hirda->hdmatx != NULL)
+    {
-  /* Reset Tx transfer counter */
+      /* Set the IRDA DMA Abort callback to Null.
-  hirda->TxXferCount = 0x00U;
+         No call back execution at end of DMA abort procedure */
+      hirda->hdmatx->XferAbortCallback = NULL;
-  /* Restore hirda->gState to Ready */
-  hirda->gState = HAL_IRDA_STATE_READY;
+      HAL_DMA_Abort(hirda->hdmatx);
+    }
-  return HAL_OK;
+  }
-}
+  /* Reset Tx transfer counter */
-/**
+  hirda->TxXferCount = 0x00U;
-  * @brief  Abort ongoing Receive transfer (blocking mode).
-  * @param  hirda IRDA handle.
+  /* Restore hirda->gState to Ready */
-  * @note   This procedure could be used for aborting any ongoing transfer started in Interrupt or DMA mode.
+  hirda->gState = HAL_IRDA_STATE_READY;
-  *         This procedure performs following operations :
-  *           - Disable PPP Interrupts
+  return HAL_OK;
-  *           - Disable the DMA transfer in the peripheral register (if enabled)
+}
-  *           - Abort DMA transfer by calling HAL_DMA_Abort (in case of transfer in DMA mode)
-  *           - Set handle State to READY
+/**
-  * @note   This procedure is executed in blocking mode : when exiting function, Abort is considered as completed.
+  * @brief  Abort ongoing Receive transfer (blocking mode).
-  * @retval HAL status
+  * @param  hirda IRDA handle.
-*/
+  * @note   This procedure could be used for aborting any ongoing transfer started in Interrupt or DMA mode.
-HAL_StatusTypeDef HAL_IRDA_AbortReceive(IRDA_HandleTypeDef *hirda)
+  *         This procedure performs following operations :
-{
+  *           - Disable PPP Interrupts
-  /* Disable RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts */
+  *           - Disable the DMA transfer in the peripheral register (if enabled)
-  CLEAR_BIT(hirda->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE));
+  *           - Abort DMA transfer by calling HAL_DMA_Abort (in case of transfer in DMA mode)
-  CLEAR_BIT(hirda->Instance->CR3, USART_CR3_EIE);
+  *           - Set handle State to READY
+  * @note   This procedure is executed in blocking mode : when exiting function, Abort is considered as completed.
-  /* Disable the IRDA DMA Rx request if enabled */
+  * @retval HAL status
-  if (HAL_IS_BIT_SET(hirda->Instance->CR3, USART_CR3_DMAR))
+*/
-  {
+HAL_StatusTypeDef HAL_IRDA_AbortReceive(IRDA_HandleTypeDef *hirda)
-    CLEAR_BIT(hirda->Instance->CR3, USART_CR3_DMAR);
+{
+  /* Disable RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts */
-    /* Abort the IRDA DMA Rx channel : use blocking DMA Abort API (no callback) */
+  CLEAR_BIT(hirda->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE));
-    if (hirda->hdmarx != NULL)
+  CLEAR_BIT(hirda->Instance->CR3, USART_CR3_EIE);
-    {
-      /* Set the IRDA DMA Abort callback to Null.
+  /* Disable the IRDA DMA Rx request if enabled */
-         No call back execution at end of DMA abort procedure */
+  if (HAL_IS_BIT_SET(hirda->Instance->CR3, USART_CR3_DMAR))
-      hirda->hdmarx->XferAbortCallback = NULL;
+  {
+    CLEAR_BIT(hirda->Instance->CR3, USART_CR3_DMAR);
-      HAL_DMA_Abort(hirda->hdmarx);
-    }
+    /* Abort the IRDA DMA Rx channel : use blocking DMA Abort API (no callback) */
-  }
+    if (hirda->hdmarx != NULL)
+    {
-  /* Reset Rx transfer counter */
+      /* Set the IRDA DMA Abort callback to Null.
-  hirda->RxXferCount = 0x00U;
+         No call back execution at end of DMA abort procedure */
+      hirda->hdmarx->XferAbortCallback = NULL;
-  /* Restore hirda->RxState to Ready */
-  hirda->RxState = HAL_IRDA_STATE_READY;
+      HAL_DMA_Abort(hirda->hdmarx);
+    }
-  return HAL_OK;
+  }
-}
+  /* Reset Rx transfer counter */
-/**
+  hirda->RxXferCount = 0x00U;
-  * @brief  Abort ongoing transfers (Interrupt mode).
-  * @param  hirda IRDA handle.
+  /* Restore hirda->RxState to Ready */
-  * @note   This procedure could be used for aborting any ongoing transfer started in Interrupt or DMA mode.
+  hirda->RxState = HAL_IRDA_STATE_READY;
-  *         This procedure performs following operations :
-  *           - Disable PPP Interrupts
+  return HAL_OK;
-  *           - Disable the DMA transfer in the peripheral register (if enabled)
+}
-  *           - Abort DMA transfer by calling HAL_DMA_Abort_IT (in case of transfer in DMA mode)
-  *           - Set handle State to READY
+/**
-  *           - At abort completion, call user abort complete callback
+  * @brief  Abort ongoing transfers (Interrupt mode).
-  * @note   This procedure is executed in Interrupt mode, meaning that abort procedure could be
+  * @param  hirda IRDA handle.
-  *         considered as completed only when user abort complete callback is executed (not when exiting function).
+  * @note   This procedure could be used for aborting any ongoing transfer started in Interrupt or DMA mode.
-  * @retval HAL status
+  *         This procedure performs following operations :
-*/
+  *           - Disable PPP Interrupts
-HAL_StatusTypeDef HAL_IRDA_Abort_IT(IRDA_HandleTypeDef *hirda)
+  *           - Disable the DMA transfer in the peripheral register (if enabled)
-{
+  *           - Abort DMA transfer by calling HAL_DMA_Abort_IT (in case of transfer in DMA mode)
-  uint32_t AbortCplt = 0x01U;
+  *           - Set handle State to READY
+  *           - At abort completion, call user abort complete callback
-  /* Disable TXEIE, TCIE, RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts */
+  * @note   This procedure is executed in Interrupt mode, meaning that abort procedure could be
-  CLEAR_BIT(hirda->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE | USART_CR1_TXEIE | USART_CR1_TCIE));
+  *         considered as completed only when user abort complete callback is executed (not when exiting function).
-  CLEAR_BIT(hirda->Instance->CR3, USART_CR3_EIE);
+  * @retval HAL status
+*/
-  /* If DMA Tx and/or DMA Rx Handles are associated to IRDA Handle, DMA Abort complete callbacks should be initialised
+HAL_StatusTypeDef HAL_IRDA_Abort_IT(IRDA_HandleTypeDef *hirda)
-     before any call to DMA Abort functions */
+{
-  /* DMA Tx Handle is valid */
+  uint32_t AbortCplt = 0x01U;
-  if (hirda->hdmatx != NULL)
-  {
+  /* Disable TXEIE, TCIE, RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts */
-    /* Set DMA Abort Complete callback if IRDA DMA Tx request if enabled.
+  CLEAR_BIT(hirda->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE | USART_CR1_TXEIE | USART_CR1_TCIE));
-       Otherwise, set it to NULL */
+  CLEAR_BIT(hirda->Instance->CR3, USART_CR3_EIE);
-    if (HAL_IS_BIT_SET(hirda->Instance->CR3, USART_CR3_DMAT))
-    {
+  /* If DMA Tx and/or DMA Rx Handles are associated to IRDA Handle, DMA Abort complete callbacks should be initialised
-      hirda->hdmatx->XferAbortCallback = IRDA_DMATxAbortCallback;
+     before any call to DMA Abort functions */
-    }
+  /* DMA Tx Handle is valid */
-    else
+  if (hirda->hdmatx != NULL)
-    {
+  {
-      hirda->hdmatx->XferAbortCallback = NULL;
+    /* Set DMA Abort Complete callback if IRDA DMA Tx request if enabled.
-    }
+       Otherwise, set it to NULL */
-  }
+    if (HAL_IS_BIT_SET(hirda->Instance->CR3, USART_CR3_DMAT))
-  /* DMA Rx Handle is valid */
+    {
-  if (hirda->hdmarx != NULL)
+      hirda->hdmatx->XferAbortCallback = IRDA_DMATxAbortCallback;
-  {
+    }
-    /* Set DMA Abort Complete callback if IRDA DMA Rx request if enabled.
+    else
-       Otherwise, set it to NULL */
+    {
-    if (HAL_IS_BIT_SET(hirda->Instance->CR3, USART_CR3_DMAR))
+      hirda->hdmatx->XferAbortCallback = NULL;
-    {
+    }
-      hirda->hdmarx->XferAbortCallback = IRDA_DMARxAbortCallback;
+  }
-    }
+  /* DMA Rx Handle is valid */
-    else
+  if (hirda->hdmarx != NULL)
-    {
+  {
-      hirda->hdmarx->XferAbortCallback = NULL;
+    /* Set DMA Abort Complete callback if IRDA DMA Rx request if enabled.
-    }
+       Otherwise, set it to NULL */
-  }
+    if (HAL_IS_BIT_SET(hirda->Instance->CR3, USART_CR3_DMAR))
+    {
-  /* Disable the IRDA DMA Tx request if enabled */
+      hirda->hdmarx->XferAbortCallback = IRDA_DMARxAbortCallback;
-  if (HAL_IS_BIT_SET(hirda->Instance->CR3, USART_CR3_DMAT))
+    }
-  {
+    else
-    /* Disable DMA Tx at IRDA level */
+    {
-    CLEAR_BIT(hirda->Instance->CR3, USART_CR3_DMAT);
+      hirda->hdmarx->XferAbortCallback = NULL;
+    }
-    /* Abort the IRDA DMA Tx channel : use non blocking DMA Abort API (callback) */
+  }
-    if (hirda->hdmatx != NULL)
-    {
+  /* Disable the IRDA DMA Tx request if enabled */
-      /* IRDA Tx DMA Abort callback has already been initialised :
+  if (HAL_IS_BIT_SET(hirda->Instance->CR3, USART_CR3_DMAT))
-         will lead to call HAL_IRDA_AbortCpltCallback() at end of DMA abort procedure */
+  {
+    /* Disable DMA Tx at IRDA level */
-      /* Abort DMA TX */
+    CLEAR_BIT(hirda->Instance->CR3, USART_CR3_DMAT);
-      if (HAL_DMA_Abort_IT(hirda->hdmatx) != HAL_OK)
-      {
+    /* Abort the IRDA DMA Tx channel : use non blocking DMA Abort API (callback) */
-        hirda->hdmatx->XferAbortCallback = NULL;
+    if (hirda->hdmatx != NULL)
-      }
+    {
-      else
+      /* IRDA Tx DMA Abort callback has already been initialised :
-      {
+         will lead to call HAL_IRDA_AbortCpltCallback() at end of DMA abort procedure */
-        AbortCplt = 0x00U;
-      }
+      /* Abort DMA TX */
-    }
+      if (HAL_DMA_Abort_IT(hirda->hdmatx) != HAL_OK)
-  }
+      {
+        hirda->hdmatx->XferAbortCallback = NULL;
-  /* Disable the IRDA DMA Rx request if enabled */
+      }
-  if (HAL_IS_BIT_SET(hirda->Instance->CR3, USART_CR3_DMAR))
+      else
-  {
+      {
-    CLEAR_BIT(hirda->Instance->CR3, USART_CR3_DMAR);
+        AbortCplt = 0x00U;
+      }
-    /* Abort the IRDA DMA Rx channel : use non blocking DMA Abort API (callback) */
+    }
-    if (hirda->hdmarx != NULL)
+  }
-    {
-      /* IRDA Rx DMA Abort callback has already been initialised :
+  /* Disable the IRDA DMA Rx request if enabled */
-         will lead to call HAL_IRDA_AbortCpltCallback() at end of DMA abort procedure */
+  if (HAL_IS_BIT_SET(hirda->Instance->CR3, USART_CR3_DMAR))
+  {
-      /* Abort DMA RX */
+    CLEAR_BIT(hirda->Instance->CR3, USART_CR3_DMAR);
-      if (HAL_DMA_Abort_IT(hirda->hdmarx) != HAL_OK)
-      {
+    /* Abort the IRDA DMA Rx channel : use non blocking DMA Abort API (callback) */
-        hirda->hdmarx->XferAbortCallback = NULL;
+    if (hirda->hdmarx != NULL)
-        AbortCplt = 0x01U;
+    {
-      }
+      /* IRDA Rx DMA Abort callback has already been initialised :
-      else
+         will lead to call HAL_IRDA_AbortCpltCallback() at end of DMA abort procedure */
-      {
-        AbortCplt = 0x00U;
+      /* Abort DMA RX */
-      }
+      if (HAL_DMA_Abort_IT(hirda->hdmarx) != HAL_OK)
-    }
+      {
-  }
+        hirda->hdmarx->XferAbortCallback = NULL;
+        AbortCplt = 0x01U;
-  /* if no DMA abort complete callback execution is required => call user Abort Complete callback */
+      }
-  if (AbortCplt == 0x01U)
+      else
-  {
+      {
-    /* Reset Tx and Rx transfer counters */
+        AbortCplt = 0x00U;
-    hirda->TxXferCount = 0x00U;
+      }
-    hirda->RxXferCount = 0x00U;
+    }
+  }
-    /* Reset ErrorCode */
-    hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
+  /* if no DMA abort complete callback execution is required => call user Abort Complete callback */
+  if (AbortCplt == 0x01U)
-    /* Restore hirda->gState and hirda->RxState to Ready */
+  {
-    hirda->gState  = HAL_IRDA_STATE_READY;
+    /* Reset Tx and Rx transfer counters */
-    hirda->RxState = HAL_IRDA_STATE_READY;
+    hirda->TxXferCount = 0x00U;
+    hirda->RxXferCount = 0x00U;
-    /* As no DMA to be aborted, call directly user Abort complete callback */
-#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
+    /* Reset ErrorCode */
-    /* Call registered Abort complete callback */
+    hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
-    hirda->AbortCpltCallback(hirda);
-#else
+    /* Restore hirda->gState and hirda->RxState to Ready */
-    /* Call legacy weak Abort complete callback */
+    hirda->gState  = HAL_IRDA_STATE_READY;
-    HAL_IRDA_AbortCpltCallback(hirda);
+    hirda->RxState = HAL_IRDA_STATE_READY;
-#endif /* USE_HAL_IRDA_REGISTER_CALLBACK */
-  }
+    /* As no DMA to be aborted, call directly user Abort complete callback */
+#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
-  return HAL_OK;
+    /* Call registered Abort complete callback */
-}
+    hirda->AbortCpltCallback(hirda);
+#else
-/**
+    /* Call legacy weak Abort complete callback */
-  * @brief  Abort ongoing Transmit transfer (Interrupt mode).
+    HAL_IRDA_AbortCpltCallback(hirda);
-  * @param  hirda IRDA handle.
+#endif /* USE_HAL_IRDA_REGISTER_CALLBACK */
-  * @note   This procedure could be used for aborting any ongoing transfer started in Interrupt or DMA mode.
+  }
-  *         This procedure performs following operations :
-  *           - Disable IRDA Interrupts (Tx)
+  return HAL_OK;
-  *           - Disable the DMA transfer in the peripheral register (if enabled)
+}
-  *           - Abort DMA transfer by calling HAL_DMA_Abort_IT (in case of transfer in DMA mode)
-  *           - Set handle State to READY
+/**
-  *           - At abort completion, call user abort complete callback
+  * @brief  Abort ongoing Transmit transfer (Interrupt mode).
-  * @note   This procedure is executed in Interrupt mode, meaning that abort procedure could be
+  * @param  hirda IRDA handle.
-  *         considered as completed only when user abort complete callback is executed (not when exiting function).
+  * @note   This procedure could be used for aborting any ongoing transfer started in Interrupt or DMA mode.
-  * @retval HAL status
+  *         This procedure performs following operations :
-*/
+  *           - Disable IRDA Interrupts (Tx)
-HAL_StatusTypeDef HAL_IRDA_AbortTransmit_IT(IRDA_HandleTypeDef *hirda)
+  *           - Disable the DMA transfer in the peripheral register (if enabled)
-{
+  *           - Abort DMA transfer by calling HAL_DMA_Abort_IT (in case of transfer in DMA mode)
-  /* Disable TXEIE and TCIE interrupts */
+  *           - Set handle State to READY
-  CLEAR_BIT(hirda->Instance->CR1, (USART_CR1_TXEIE | USART_CR1_TCIE));
+  *           - At abort completion, call user abort complete callback
+  * @note   This procedure is executed in Interrupt mode, meaning that abort procedure could be
-  /* Disable the IRDA DMA Tx request if enabled */
+  *         considered as completed only when user abort complete callback is executed (not when exiting function).
-  if (HAL_IS_BIT_SET(hirda->Instance->CR3, USART_CR3_DMAT))
+  * @retval HAL status
-  {
+*/
-    CLEAR_BIT(hirda->Instance->CR3, USART_CR3_DMAT);
+HAL_StatusTypeDef HAL_IRDA_AbortTransmit_IT(IRDA_HandleTypeDef *hirda)
+{
-    /* Abort the IRDA DMA Tx channel : use non blocking DMA Abort API (callback) */
+  /* Disable TXEIE and TCIE interrupts */
-    if (hirda->hdmatx != NULL)
+  CLEAR_BIT(hirda->Instance->CR1, (USART_CR1_TXEIE | USART_CR1_TCIE));
-    {
-      /* Set the IRDA DMA Abort callback :
+  /* Disable the IRDA DMA Tx request if enabled */
-         will lead to call HAL_IRDA_AbortCpltCallback() at end of DMA abort procedure */
+  if (HAL_IS_BIT_SET(hirda->Instance->CR3, USART_CR3_DMAT))
-      hirda->hdmatx->XferAbortCallback = IRDA_DMATxOnlyAbortCallback;
+  {
+    CLEAR_BIT(hirda->Instance->CR3, USART_CR3_DMAT);
-      /* Abort DMA TX */
-      if (HAL_DMA_Abort_IT(hirda->hdmatx) != HAL_OK)
+    /* Abort the IRDA DMA Tx channel : use non blocking DMA Abort API (callback) */
-      {
+    if (hirda->hdmatx != NULL)
-        /* Call Directly hirda->hdmatx->XferAbortCallback function in case of error */
+    {
-        hirda->hdmatx->XferAbortCallback(hirda->hdmatx);
+      /* Set the IRDA DMA Abort callback :
-      }
+         will lead to call HAL_IRDA_AbortCpltCallback() at end of DMA abort procedure */
-    }
+      hirda->hdmatx->XferAbortCallback = IRDA_DMATxOnlyAbortCallback;
-    else
-    {
+      /* Abort DMA TX */
-      /* Reset Tx transfer counter */
+      if (HAL_DMA_Abort_IT(hirda->hdmatx) != HAL_OK)
-      hirda->TxXferCount = 0x00U;
+      {
+        /* Call Directly hirda->hdmatx->XferAbortCallback function in case of error */
-      /* Restore hirda->gState to Ready */
+        hirda->hdmatx->XferAbortCallback(hirda->hdmatx);
-      hirda->gState = HAL_IRDA_STATE_READY;
+      }
+    }
-      /* As no DMA to be aborted, call directly user Abort complete callback */
+    else
-#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
+    {
-      /* Call registered Abort Transmit Complete Callback */
+      /* Reset Tx transfer counter */
-      hirda->AbortTransmitCpltCallback(hirda);
+      hirda->TxXferCount = 0x00U;
-#else
-      /* Call legacy weak Abort Transmit Complete Callback */
+      /* Restore hirda->gState to Ready */
-      HAL_IRDA_AbortTransmitCpltCallback(hirda);
+      hirda->gState = HAL_IRDA_STATE_READY;
-#endif /* USE_HAL_IRDA_REGISTER_CALLBACK */
-    }
+      /* As no DMA to be aborted, call directly user Abort complete callback */
-  }
+#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
-  else
+      /* Call registered Abort Transmit Complete Callback */
-  {
+      hirda->AbortTransmitCpltCallback(hirda);
-    /* Reset Tx transfer counter */
+#else
-    hirda->TxXferCount = 0x00U;
+      /* Call legacy weak Abort Transmit Complete Callback */
+      HAL_IRDA_AbortTransmitCpltCallback(hirda);
-    /* Restore hirda->gState to Ready */
+#endif /* USE_HAL_IRDA_REGISTER_CALLBACK */
-    hirda->gState = HAL_IRDA_STATE_READY;
+    }
+  }
-    /* As no DMA to be aborted, call directly user Abort complete callback */
+  else
-#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
+  {
-    /* Call registered Abort Transmit Complete Callback */
+    /* Reset Tx transfer counter */
-    hirda->AbortTransmitCpltCallback(hirda);
+    hirda->TxXferCount = 0x00U;
-#else
-    /* Call legacy weak Abort Transmit Complete Callback */
+    /* Restore hirda->gState to Ready */
-    HAL_IRDA_AbortTransmitCpltCallback(hirda);
+    hirda->gState = HAL_IRDA_STATE_READY;
-#endif /* USE_HAL_IRDA_REGISTER_CALLBACK */
-  }
+    /* As no DMA to be aborted, call directly user Abort complete callback */
+#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
-  return HAL_OK;
+    /* Call registered Abort Transmit Complete Callback */
-}
+    hirda->AbortTransmitCpltCallback(hirda);
+#else
-/**
+    /* Call legacy weak Abort Transmit Complete Callback */
-  * @brief  Abort ongoing Receive transfer (Interrupt mode).
+    HAL_IRDA_AbortTransmitCpltCallback(hirda);
-  * @param  hirda IRDA handle.
+#endif /* USE_HAL_IRDA_REGISTER_CALLBACK */
-  * @note   This procedure could be used for aborting any ongoing transfer started in Interrupt or DMA mode.
+  }
-  *         This procedure performs following operations :
-  *           - Disable PPP Interrupts
+  return HAL_OK;
-  *           - Disable the DMA transfer in the peripheral register (if enabled)
+}
-  *           - Abort DMA transfer by calling HAL_DMA_Abort_IT (in case of transfer in DMA mode)
-  *           - Set handle State to READY
+/**
-  *           - At abort completion, call user abort complete callback
+  * @brief  Abort ongoing Receive transfer (Interrupt mode).
-  * @note   This procedure is executed in Interrupt mode, meaning that abort procedure could be
+  * @param  hirda IRDA handle.
-  *         considered as completed only when user abort complete callback is executed (not when exiting function).
+  * @note   This procedure could be used for aborting any ongoing transfer started in Interrupt or DMA mode.
-  * @retval HAL status
+  *         This procedure performs following operations :
-*/
+  *           - Disable PPP Interrupts
-HAL_StatusTypeDef HAL_IRDA_AbortReceive_IT(IRDA_HandleTypeDef *hirda)
+  *           - Disable the DMA transfer in the peripheral register (if enabled)
-{
+  *           - Abort DMA transfer by calling HAL_DMA_Abort_IT (in case of transfer in DMA mode)
-  /* Disable RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts */
+  *           - Set handle State to READY
-  CLEAR_BIT(hirda->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE));
+  *           - At abort completion, call user abort complete callback
-  CLEAR_BIT(hirda->Instance->CR3, USART_CR3_EIE);
+  * @note   This procedure is executed in Interrupt mode, meaning that abort procedure could be
+  *         considered as completed only when user abort complete callback is executed (not when exiting function).
-  /* Disable the IRDA DMA Rx request if enabled */
+  * @retval HAL status
-  if (HAL_IS_BIT_SET(hirda->Instance->CR3, USART_CR3_DMAR))
+*/
-  {
+HAL_StatusTypeDef HAL_IRDA_AbortReceive_IT(IRDA_HandleTypeDef *hirda)
-    CLEAR_BIT(hirda->Instance->CR3, USART_CR3_DMAR);
+{
+  /* Disable RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts */
-    /* Abort the IRDA DMA Rx channel : use non blocking DMA Abort API (callback) */
+  CLEAR_BIT(hirda->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE));
-    if (hirda->hdmarx != NULL)
+  CLEAR_BIT(hirda->Instance->CR3, USART_CR3_EIE);
-    {
-      /* Set the IRDA DMA Abort callback :
+  /* Disable the IRDA DMA Rx request if enabled */
-         will lead to call HAL_IRDA_AbortCpltCallback() at end of DMA abort procedure */
+  if (HAL_IS_BIT_SET(hirda->Instance->CR3, USART_CR3_DMAR))
-      hirda->hdmarx->XferAbortCallback = IRDA_DMARxOnlyAbortCallback;
+  {
+    CLEAR_BIT(hirda->Instance->CR3, USART_CR3_DMAR);
-      /* Abort DMA RX */
-      if (HAL_DMA_Abort_IT(hirda->hdmarx) != HAL_OK)
+    /* Abort the IRDA DMA Rx channel : use non blocking DMA Abort API (callback) */
-      {
+    if (hirda->hdmarx != NULL)
-        /* Call Directly hirda->hdmarx->XferAbortCallback function in case of error */
+    {
-        hirda->hdmarx->XferAbortCallback(hirda->hdmarx);
+      /* Set the IRDA DMA Abort callback :
-      }
+         will lead to call HAL_IRDA_AbortCpltCallback() at end of DMA abort procedure */
-    }
+      hirda->hdmarx->XferAbortCallback = IRDA_DMARxOnlyAbortCallback;
-    else
-    {
+      /* Abort DMA RX */
-      /* Reset Rx transfer counter */
+      if (HAL_DMA_Abort_IT(hirda->hdmarx) != HAL_OK)
-      hirda->RxXferCount = 0x00U;
+      {
+        /* Call Directly hirda->hdmarx->XferAbortCallback function in case of error */
-      /* Restore hirda->RxState to Ready */
+        hirda->hdmarx->XferAbortCallback(hirda->hdmarx);
-      hirda->RxState = HAL_IRDA_STATE_READY;
+      }
+    }
-      /* As no DMA to be aborted, call directly user Abort complete callback */
+    else
-#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
+    {
-      /* Call registered Abort Receive Complete Callback */
+      /* Reset Rx transfer counter */
-      hirda->AbortReceiveCpltCallback(hirda);
+      hirda->RxXferCount = 0x00U;
-#else
-      /* Call legacy weak Abort Receive Complete Callback */
+      /* Restore hirda->RxState to Ready */
-      HAL_IRDA_AbortReceiveCpltCallback(hirda);
+      hirda->RxState = HAL_IRDA_STATE_READY;
-#endif /* USE_HAL_IRDA_REGISTER_CALLBACK */
-    }
+      /* As no DMA to be aborted, call directly user Abort complete callback */
-  }
+#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
-  else
+      /* Call registered Abort Receive Complete Callback */
-  {
+      hirda->AbortReceiveCpltCallback(hirda);
-    /* Reset Rx transfer counter */
+#else
-    hirda->RxXferCount = 0x00U;
+      /* Call legacy weak Abort Receive Complete Callback */
+      HAL_IRDA_AbortReceiveCpltCallback(hirda);
-    /* Restore hirda->RxState to Ready */
+#endif /* USE_HAL_IRDA_REGISTER_CALLBACK */
-    hirda->RxState = HAL_IRDA_STATE_READY;
+    }
+  }
-    /* As no DMA to be aborted, call directly user Abort complete callback */
+  else
-#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
+  {
-    /* Call registered Abort Receive Complete Callback */
+    /* Reset Rx transfer counter */
-    hirda->AbortReceiveCpltCallback(hirda);
+    hirda->RxXferCount = 0x00U;
-#else
-    /* Call legacy weak Abort Receive Complete Callback */
+    /* Restore hirda->RxState to Ready */
-    HAL_IRDA_AbortReceiveCpltCallback(hirda);
+    hirda->RxState = HAL_IRDA_STATE_READY;
-#endif /* USE_HAL_IRDA_REGISTER_CALLBACK */
-  }
+    /* As no DMA to be aborted, call directly user Abort complete callback */
+#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
-  return HAL_OK;
+    /* Call registered Abort Receive Complete Callback */
-}
+    hirda->AbortReceiveCpltCallback(hirda);
+#else
-/**
+    /* Call legacy weak Abort Receive Complete Callback */
-  * @brief  This function handles IRDA interrupt request.
+    HAL_IRDA_AbortReceiveCpltCallback(hirda);
-  * @param  hirda  Pointer to a IRDA_HandleTypeDef structure that contains
+#endif /* USE_HAL_IRDA_REGISTER_CALLBACK */
-  *                the configuration information for the specified IRDA module.
+  }
-  * @retval None
-  */
+  return HAL_OK;
-void HAL_IRDA_IRQHandler(IRDA_HandleTypeDef *hirda)
+}
-{
-  uint32_t isrflags   = READ_REG(hirda->Instance->SR);
+/**
-  uint32_t cr1its     = READ_REG(hirda->Instance->CR1);
+  * @brief  This function handles IRDA interrupt request.
-  uint32_t cr3its     = READ_REG(hirda->Instance->CR3);
+  * @param  hirda  Pointer to a IRDA_HandleTypeDef structure that contains
-  uint32_t errorflags = 0x00U;
+  *                the configuration information for the specified IRDA module.
-  uint32_t dmarequest = 0x00U;
+  * @retval None
+  */
-  /* If no error occurs */
+void HAL_IRDA_IRQHandler(IRDA_HandleTypeDef *hirda)
-  errorflags = (isrflags & (uint32_t)(USART_SR_PE | USART_SR_FE | USART_SR_ORE | USART_SR_NE));
+{
-  if (errorflags == RESET)
+  uint32_t isrflags   = READ_REG(hirda->Instance->SR);
-  {
+  uint32_t cr1its     = READ_REG(hirda->Instance->CR1);
-    /* IRDA in mode Receiver -----------------------------------------------*/
+  uint32_t cr3its     = READ_REG(hirda->Instance->CR3);
-    if (((isrflags & USART_SR_RXNE) != RESET) && ((cr1its & USART_CR1_RXNEIE) != RESET))
+  uint32_t errorflags = 0x00U;
-    {
+  uint32_t dmarequest = 0x00U;
-      IRDA_Receive_IT(hirda);
-      return;
+  /* If no error occurs */
-    }
+  errorflags = (isrflags & (uint32_t)(USART_SR_PE | USART_SR_FE | USART_SR_ORE | USART_SR_NE));
-  }
+  if (errorflags == RESET)
+  {
-  /* If some errors occur */
+    /* IRDA in mode Receiver -----------------------------------------------*/
-  if ((errorflags != RESET) && (((cr3its & USART_CR3_EIE) != RESET) || ((cr1its & (USART_CR1_RXNEIE | USART_CR1_PEIE)) != RESET)))
+    if (((isrflags & USART_SR_RXNE) != RESET) && ((cr1its & USART_CR1_RXNEIE) != RESET))
-  {
+    {
-    /* IRDA parity error interrupt occurred -------------------------------*/
+      IRDA_Receive_IT(hirda);
-    if (((isrflags & USART_SR_PE) != RESET) && ((cr1its & USART_CR1_PEIE) != RESET))
+      return;
-    {
+    }
-      hirda->ErrorCode |= HAL_IRDA_ERROR_PE;
+  }
-    }
+  /* If some errors occur */
-    /* IRDA noise error interrupt occurred --------------------------------*/
+  if ((errorflags != RESET) && (((cr3its & USART_CR3_EIE) != RESET) || ((cr1its & (USART_CR1_RXNEIE | USART_CR1_PEIE)) != RESET)))
-    if (((isrflags & USART_SR_NE) != RESET) && ((cr3its & USART_CR3_EIE) != RESET))
+  {
-    {
+    /* IRDA parity error interrupt occurred -------------------------------*/
-      hirda->ErrorCode |= HAL_IRDA_ERROR_NE;
+    if (((isrflags & USART_SR_PE) != RESET) && ((cr1its & USART_CR1_PEIE) != RESET))
-    }
+    {
+      hirda->ErrorCode |= HAL_IRDA_ERROR_PE;
-    /* IRDA frame error interrupt occurred --------------------------------*/
+    }
-    if (((isrflags & USART_SR_FE) != RESET) && ((cr3its & USART_CR3_EIE) != RESET))
-    {
+    /* IRDA noise error interrupt occurred --------------------------------*/
-      hirda->ErrorCode |= HAL_IRDA_ERROR_FE;
+    if (((isrflags & USART_SR_NE) != RESET) && ((cr3its & USART_CR3_EIE) != RESET))
-    }
+    {
+      hirda->ErrorCode |= HAL_IRDA_ERROR_NE;
-    /* IRDA Over-Run interrupt occurred -----------------------------------*/
+    }
-    if (((isrflags & USART_SR_ORE) != RESET) && (((cr1its & USART_CR1_RXNEIE) != RESET) || ((cr3its & USART_CR3_EIE) != RESET)))
-    {
+    /* IRDA frame error interrupt occurred --------------------------------*/
-      hirda->ErrorCode |= HAL_IRDA_ERROR_ORE;
+    if (((isrflags & USART_SR_FE) != RESET) && ((cr3its & USART_CR3_EIE) != RESET))
-    }
+    {
-    /* Call IRDA Error Call back function if need be -----------------------*/
+      hirda->ErrorCode |= HAL_IRDA_ERROR_FE;
-    if (hirda->ErrorCode != HAL_IRDA_ERROR_NONE)
+    }
-    {
-      /* IRDA in mode Receiver ---------------------------------------------*/
+    /* IRDA Over-Run interrupt occurred -----------------------------------*/
-      if (((isrflags & USART_SR_RXNE) != RESET) && ((cr1its & USART_CR1_RXNEIE) != RESET))
+    if (((isrflags & USART_SR_ORE) != RESET) && (((cr1its & USART_CR1_RXNEIE) != RESET) || ((cr3its & USART_CR3_EIE) != RESET)))
-      {
+    {
-        IRDA_Receive_IT(hirda);
+      hirda->ErrorCode |= HAL_IRDA_ERROR_ORE;
-      }
+    }
+    /* Call IRDA Error Call back function if need be -----------------------*/
-      /* If Overrun error occurs, or if any error occurs in DMA mode reception,
+    if (hirda->ErrorCode != HAL_IRDA_ERROR_NONE)
-         consider error as blocking */
+    {
-      dmarequest = HAL_IS_BIT_SET(hirda->Instance->CR3, USART_CR3_DMAR);
+      /* IRDA in mode Receiver ---------------------------------------------*/
-      if (((hirda->ErrorCode & HAL_IRDA_ERROR_ORE) != RESET) || dmarequest)
+      if (((isrflags & USART_SR_RXNE) != RESET) && ((cr1its & USART_CR1_RXNEIE) != RESET))
       {
-        /* Blocking error : transfer is aborted
+        IRDA_Receive_IT(hirda);
-           Set the IRDA state ready to be able to start again the process,
+      }
-           Disable Rx Interrupts, and disable Rx DMA request, if ongoing */
-        IRDA_EndRxTransfer(hirda);
+      /* If Overrun error occurs, or if any error occurs in DMA mode reception,
+         consider error as blocking */
-        /* Disable the IRDA DMA Rx request if enabled */
+      dmarequest = HAL_IS_BIT_SET(hirda->Instance->CR3, USART_CR3_DMAR);
-        if (HAL_IS_BIT_SET(hirda->Instance->CR3, USART_CR3_DMAR))
+      if (((hirda->ErrorCode & HAL_IRDA_ERROR_ORE) != RESET) || dmarequest)
-        {
+      {
-          CLEAR_BIT(hirda->Instance->CR3, USART_CR3_DMAR);
+        /* Blocking error : transfer is aborted
+           Set the IRDA state ready to be able to start again the process,
-          /* Abort the IRDA DMA Rx channel */
+           Disable Rx Interrupts, and disable Rx DMA request, if ongoing */
-          if (hirda->hdmarx != NULL)
+        IRDA_EndRxTransfer(hirda);
-          {
-            /* Set the IRDA DMA Abort callback :
+        /* Disable the IRDA DMA Rx request if enabled */
-            will lead to call HAL_IRDA_ErrorCallback() at end of DMA abort procedure */
+        if (HAL_IS_BIT_SET(hirda->Instance->CR3, USART_CR3_DMAR))
-            hirda->hdmarx->XferAbortCallback = IRDA_DMAAbortOnError;
+        {
+          CLEAR_BIT(hirda->Instance->CR3, USART_CR3_DMAR);
-            /* Abort DMA RX */
-            if (HAL_DMA_Abort_IT(hirda->hdmarx) != HAL_OK)
+          /* Abort the IRDA DMA Rx channel */
-            {
+          if (hirda->hdmarx != NULL)
-              /* Call Directly XferAbortCallback function in case of error */
+          {
-              hirda->hdmarx->XferAbortCallback(hirda->hdmarx);
+            /* Set the IRDA DMA Abort callback :
-            }
+            will lead to call HAL_IRDA_ErrorCallback() at end of DMA abort procedure */
-          }
+            hirda->hdmarx->XferAbortCallback = IRDA_DMAAbortOnError;
-          else
-          {
+            /* Abort DMA RX */
-#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
+            if (HAL_DMA_Abort_IT(hirda->hdmarx) != HAL_OK)
-            /* Call registered user error callback */
+            {
-            hirda->ErrorCallback(hirda);
+              /* Call Directly XferAbortCallback function in case of error */
-#else
+              hirda->hdmarx->XferAbortCallback(hirda->hdmarx);
-            /* Call legacy weak user error callback */
+            }
-            HAL_IRDA_ErrorCallback(hirda);
+          }
-#endif /* USE_HAL_IRDA_REGISTER_CALLBACK */
+          else
-          }
+          {
-        }
+#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
-        else
+            /* Call registered user error callback */
-        {
+            hirda->ErrorCallback(hirda);
-#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
+#else
-          /* Call registered user error callback */
+            /* Call legacy weak user error callback */
-          hirda->ErrorCallback(hirda);
+            HAL_IRDA_ErrorCallback(hirda);
-#else
+#endif /* USE_HAL_IRDA_REGISTER_CALLBACK */
-          /* Call legacy weak user error callback */
+          }
-          HAL_IRDA_ErrorCallback(hirda);
+        }
-#endif /* USE_HAL_IRDA_REGISTER_CALLBACK */
+        else
-        }
+        {
-      }
+#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
-      else
+          /* Call registered user error callback */
-      {
+          hirda->ErrorCallback(hirda);
-        /* Non Blocking error : transfer could go on.
+#else
-           Error is notified to user through user error callback */
+          /* Call legacy weak user error callback */
-#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
+          HAL_IRDA_ErrorCallback(hirda);
-        /* Call registered user error callback */
+#endif /* USE_HAL_IRDA_REGISTER_CALLBACK */
-        hirda->ErrorCallback(hirda);
+        }
-#else
+      }
-        /* Call legacy weak user error callback */
+      else
-        HAL_IRDA_ErrorCallback(hirda);
+      {
-#endif /* USE_HAL_IRDA_REGISTER_CALLBACK */
+        /* Non Blocking error : transfer could go on.
+           Error is notified to user through user error callback */
-        hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
+#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
-      }
+        /* Call registered user error callback */
-    }
+        hirda->ErrorCallback(hirda);
-    return;
+#else
-  } /* End if some error occurs */
+        /* Call legacy weak user error callback */
+        HAL_IRDA_ErrorCallback(hirda);
-  /* IRDA in mode Transmitter ------------------------------------------------*/
+#endif /* USE_HAL_IRDA_REGISTER_CALLBACK */
-  if (((isrflags & USART_SR_TXE) != RESET) && ((cr1its & USART_CR1_TXEIE) != RESET))
-  {
+        hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
-    IRDA_Transmit_IT(hirda);
+      }
-    return;
+    }
-  }
+    return;
+  } /* End if some error occurs */
-  /* IRDA in mode Transmitter end --------------------------------------------*/
-  if (((isrflags & USART_SR_TC) != RESET) && ((cr1its & USART_CR1_TCIE) != RESET))
+  /* IRDA in mode Transmitter ------------------------------------------------*/
-  {
+  if (((isrflags & USART_SR_TXE) != RESET) && ((cr1its & USART_CR1_TXEIE) != RESET))
-    IRDA_EndTransmit_IT(hirda);
+  {
-    return;
+    IRDA_Transmit_IT(hirda);
-  }
+    return;
-}
+  }
-/**
+  /* IRDA in mode Transmitter end --------------------------------------------*/
-  * @brief  Tx Transfer complete callback.
+  if (((isrflags & USART_SR_TC) != RESET) && ((cr1its & USART_CR1_TCIE) != RESET))
-  * @param  hirda  Pointer to a IRDA_HandleTypeDef structure that contains
+  {
-  *                the configuration information for the specified IRDA module.
+    IRDA_EndTransmit_IT(hirda);
-  * @retval None
+    return;
-  */
+  }
-__weak void HAL_IRDA_TxCpltCallback(IRDA_HandleTypeDef *hirda)
+}
-{
-  /* Prevent unused argument(s) compilation warning */
+/**
-  UNUSED(hirda);
+  * @brief  Tx Transfer complete callback.
+  * @param  hirda  Pointer to a IRDA_HandleTypeDef structure that contains
-  /* NOTE : This function should not be modified, when the callback is needed,
+  *                the configuration information for the specified IRDA module.
-            the HAL_IRDA_TxCpltCallback can be implemented in the user file.
+  * @retval None
-   */
+  */
-}
+__weak void HAL_IRDA_TxCpltCallback(IRDA_HandleTypeDef *hirda)
+{
-/**
+  /* Prevent unused argument(s) compilation warning */
-  * @brief  Tx Half Transfer completed callback.
+  UNUSED(hirda);
-  * @param  hirda  Pointer to a IRDA_HandleTypeDef structure that contains
-  *                the configuration information for the specified USART module.
+  /* NOTE : This function should not be modified, when the callback is needed,
-  * @retval None
+            the HAL_IRDA_TxCpltCallback can be implemented in the user file.
-  */
+   */
-__weak void HAL_IRDA_TxHalfCpltCallback(IRDA_HandleTypeDef *hirda)
+}
-{
-  /* Prevent unused argument(s) compilation warning */
+/**
-  UNUSED(hirda);
+  * @brief  Tx Half Transfer completed callback.
+  * @param  hirda  Pointer to a IRDA_HandleTypeDef structure that contains
-  /* NOTE : This function should not be modified, when the callback is needed,
+  *                the configuration information for the specified USART module.
-            the HAL_IRDA_TxHalfCpltCallback can be implemented in the user file.
+  * @retval None
-   */
+  */
-}
+__weak void HAL_IRDA_TxHalfCpltCallback(IRDA_HandleTypeDef *hirda)
+{
-/**
+  /* Prevent unused argument(s) compilation warning */
-  * @brief  Rx Transfer complete callback.
+  UNUSED(hirda);
-  * @param  hirda  Pointer to a IRDA_HandleTypeDef structure that contains
-  *                the configuration information for the specified IRDA module.
+  /* NOTE : This function should not be modified, when the callback is needed,
-  * @retval None
+            the HAL_IRDA_TxHalfCpltCallback can be implemented in the user file.
-  */
+   */
-__weak void HAL_IRDA_RxCpltCallback(IRDA_HandleTypeDef *hirda)
+}
-{
-  /* Prevent unused argument(s) compilation warning */
+/**
-  UNUSED(hirda);
+  * @brief  Rx Transfer complete callback.
+  * @param  hirda  Pointer to a IRDA_HandleTypeDef structure that contains
-  /* NOTE : This function should not be modified, when the callback is needed,
+  *                the configuration information for the specified IRDA module.
-            the HAL_IRDA_RxCpltCallback can be implemented in the user file.
+  * @retval None
-   */
+  */
-}
+__weak void HAL_IRDA_RxCpltCallback(IRDA_HandleTypeDef *hirda)
+{
-/**
+  /* Prevent unused argument(s) compilation warning */
-  * @brief  Rx Half Transfer complete callback.
+  UNUSED(hirda);
-  * @param  hirda  Pointer to a IRDA_HandleTypeDef structure that contains
-  *                the configuration information for the specified IRDA module.
+  /* NOTE : This function should not be modified, when the callback is needed,
-  * @retval None
+            the HAL_IRDA_RxCpltCallback can be implemented in the user file.
-  */
+   */
-__weak void HAL_IRDA_RxHalfCpltCallback(IRDA_HandleTypeDef *hirda)
+}
-{
-  /* Prevent unused argument(s) compilation warning */
+/**
-  UNUSED(hirda);
+  * @brief  Rx Half Transfer complete callback.
+  * @param  hirda  Pointer to a IRDA_HandleTypeDef structure that contains
-  /* NOTE : This function should not be modified, when the callback is needed,
+  *                the configuration information for the specified IRDA module.
-            the HAL_IRDA_RxHalfCpltCallback can be implemented in the user file.
+  * @retval None
-   */
+  */
-}
+__weak void HAL_IRDA_RxHalfCpltCallback(IRDA_HandleTypeDef *hirda)
+{
-/**
+  /* Prevent unused argument(s) compilation warning */
-  * @brief  IRDA error callback.
+  UNUSED(hirda);
-  * @param  hirda  Pointer to a IRDA_HandleTypeDef structure that contains
-  *                the configuration information for the specified IRDA module.
+  /* NOTE : This function should not be modified, when the callback is needed,
-  * @retval None
+            the HAL_IRDA_RxHalfCpltCallback can be implemented in the user file.
-  */
+   */
-__weak void HAL_IRDA_ErrorCallback(IRDA_HandleTypeDef *hirda)
+}
-{
-  /* Prevent unused argument(s) compilation warning */
+/**
-  UNUSED(hirda);
+  * @brief  IRDA error callback.
+  * @param  hirda  Pointer to a IRDA_HandleTypeDef structure that contains
-  /* NOTE : This function should not be modified, when the callback is needed,
+  *                the configuration information for the specified IRDA module.
-            the HAL_IRDA_ErrorCallback can be implemented in the user file.
+  * @retval None
-   */
+  */
-}
+__weak void HAL_IRDA_ErrorCallback(IRDA_HandleTypeDef *hirda)
+{
-/**
+  /* Prevent unused argument(s) compilation warning */
-  * @brief  IRDA Abort Complete callback.
+  UNUSED(hirda);
-  * @param  hirda Pointer to a IRDA_HandleTypeDef structure that contains
-  *                the configuration information for the specified IRDA module.
+  /* NOTE : This function should not be modified, when the callback is needed,
-  * @retval None
+            the HAL_IRDA_ErrorCallback can be implemented in the user file.
-  */
+   */
-__weak void HAL_IRDA_AbortCpltCallback(IRDA_HandleTypeDef *hirda)
+}
-{
-  /* Prevent unused argument(s) compilation warning */
+/**
-  UNUSED(hirda);
+  * @brief  IRDA Abort Complete callback.
+  * @param  hirda Pointer to a IRDA_HandleTypeDef structure that contains
-  /* NOTE : This function should not be modified, when the callback is needed,
+  *                the configuration information for the specified IRDA module.
-            the HAL_IRDA_AbortCpltCallback can be implemented in the user file.
+  * @retval None
-   */
+  */
-}
+__weak void HAL_IRDA_AbortCpltCallback(IRDA_HandleTypeDef *hirda)
+{
-/**
+  /* Prevent unused argument(s) compilation warning */
-  * @brief  IRDA Abort Transmit Complete callback.
+  UNUSED(hirda);
-  * @param  hirda Pointer to a IRDA_HandleTypeDef structure that contains
-  *                the configuration information for the specified IRDA module.
+  /* NOTE : This function should not be modified, when the callback is needed,
-  * @retval None
+            the HAL_IRDA_AbortCpltCallback can be implemented in the user file.
-  */
+   */
-__weak void HAL_IRDA_AbortTransmitCpltCallback(IRDA_HandleTypeDef *hirda)
+}
-{
-  /* Prevent unused argument(s) compilation warning */
+/**
-  UNUSED(hirda);
+  * @brief  IRDA Abort Transmit Complete callback.
+  * @param  hirda Pointer to a IRDA_HandleTypeDef structure that contains
-  /* NOTE : This function should not be modified, when the callback is needed,
+  *                the configuration information for the specified IRDA module.
-            the HAL_IRDA_AbortTransmitCpltCallback can be implemented in the user file.
+  * @retval None
-   */
+  */
-}
+__weak void HAL_IRDA_AbortTransmitCpltCallback(IRDA_HandleTypeDef *hirda)
+{
-/**
+  /* Prevent unused argument(s) compilation warning */
-  * @brief  IRDA Abort Receive Complete callback.
+  UNUSED(hirda);
-  * @param  hirda Pointer to a IRDA_HandleTypeDef structure that contains
-  *                the configuration information for the specified IRDA module.
+  /* NOTE : This function should not be modified, when the callback is needed,
-  * @retval None
+            the HAL_IRDA_AbortTransmitCpltCallback can be implemented in the user file.
-  */
+   */
-__weak void HAL_IRDA_AbortReceiveCpltCallback(IRDA_HandleTypeDef *hirda)
+}
-{
-  /* Prevent unused argument(s) compilation warning */
+/**
-  UNUSED(hirda);
+  * @brief  IRDA Abort Receive Complete callback.
+  * @param  hirda Pointer to a IRDA_HandleTypeDef structure that contains
-  /* NOTE : This function should not be modified, when the callback is needed,
+  *                the configuration information for the specified IRDA module.
-            the HAL_IRDA_AbortReceiveCpltCallback can be implemented in the user file.
+  * @retval None
-   */
+  */
-}
+__weak void HAL_IRDA_AbortReceiveCpltCallback(IRDA_HandleTypeDef *hirda)
+{
-/**
+  /* Prevent unused argument(s) compilation warning */
-  * @}
+  UNUSED(hirda);
-  */
+  /* NOTE : This function should not be modified, when the callback is needed,
-/** @defgroup IRDA_Exported_Functions_Group3 Peripheral State and Errors functions
+            the HAL_IRDA_AbortReceiveCpltCallback can be implemented in the user file.
-  *  @brief   IRDA State and Errors functions
+   */
-  *
+}
-@verbatim
-  ==============================================================================
+/**
-                  ##### Peripheral State and Errors functions #####
+  * @}
-  ==============================================================================
+  */
-  [..]
-    This subsection provides a set of functions allowing to return the State of IrDA
+/** @defgroup IRDA_Exported_Functions_Group3 Peripheral State and Errors functions
-    communication process and also return Peripheral Errors occurred during communication process
+  *  @brief   IRDA State and Errors functions
-     (+) HAL_IRDA_GetState() API can be helpful to check in run-time the state of the IrDA peripheral.
+  *
-     (+) HAL_IRDA_GetError() check in run-time errors that could be occurred during communication.
+@verbatim
+  ==============================================================================
-@endverbatim
+                  ##### Peripheral State and Errors functions #####
-  * @{
+  ==============================================================================
-  */
+  [..]
+    This subsection provides a set of functions allowing to return the State of IrDA
-/**
+    communication process and also return Peripheral Errors occurred during communication process
-  * @brief  Return the IRDA state.
+     (+) HAL_IRDA_GetState() API can be helpful to check in run-time the state of the IrDA peripheral.
-  * @param  hirda  Pointer to a IRDA_HandleTypeDef structure that contains
+     (+) HAL_IRDA_GetError() check in run-time errors that could be occurred during communication.
-  *                the configuration information for the specified IRDA.
-  * @retval HAL state
+@endverbatim
-  */
+  * @{
-HAL_IRDA_StateTypeDef HAL_IRDA_GetState(IRDA_HandleTypeDef *hirda)
+  */
-{
-  uint32_t temp1 = 0x00U, temp2 = 0x00U;
+/**
-  temp1 = hirda->gState;
+  * @brief  Return the IRDA state.
-  temp2 = hirda->RxState;
+  * @param  hirda  Pointer to a IRDA_HandleTypeDef structure that contains
+  *                the configuration information for the specified IRDA.
-  return (HAL_IRDA_StateTypeDef)(temp1 | temp2);
+  * @retval HAL state
-}
+  */
+HAL_IRDA_StateTypeDef HAL_IRDA_GetState(const IRDA_HandleTypeDef *hirda)
-/**
+{
-  * @brief  Return the IRDA error code
+  uint32_t temp1 = 0x00U, temp2 = 0x00U;
-  * @param  hirda  Pointer to a IRDA_HandleTypeDef structure that contains
+  temp1 = hirda->gState;
-  *              the configuration information for the specified IRDA.
+  temp2 = hirda->RxState;
-  * @retval IRDA Error Code
-  */
+  return (HAL_IRDA_StateTypeDef)(temp1 | temp2);
-uint32_t HAL_IRDA_GetError(IRDA_HandleTypeDef *hirda)
+}
-{
-  return hirda->ErrorCode;
+/**
-}
+  * @brief  Return the IRDA error code
+  * @param  hirda  Pointer to a IRDA_HandleTypeDef structure that contains
-/**
+  *              the configuration information for the specified IRDA.
-  * @}
+  * @retval IRDA Error Code
   */
+uint32_t HAL_IRDA_GetError(const IRDA_HandleTypeDef *hirda)
-/**
+{
-  * @}
+  return hirda->ErrorCode;
-  */
+}
-/** @defgroup IRDA_Private_Functions IRDA Private Functions
+/**
-  * @{
+  * @}
   */
-#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
+/**
-/**
+  * @}
-  * @brief  Initialize the callbacks to their default values.
+  */
-  * @param  hirda IRDA handle.
-  * @retval none
+/** @defgroup IRDA_Private_Functions IRDA Private Functions
-  */
+  * @{
-void IRDA_InitCallbacksToDefault(IRDA_HandleTypeDef *hirda)
+  */
-{
-  /* Init the IRDA Callback settings */
+#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
-  hirda->TxHalfCpltCallback        = HAL_IRDA_TxHalfCpltCallback;        /* Legacy weak TxHalfCpltCallback        */
+/**
-  hirda->TxCpltCallback            = HAL_IRDA_TxCpltCallback;            /* Legacy weak TxCpltCallback            */
+  * @brief  Initialize the callbacks to their default values.
-  hirda->RxHalfCpltCallback        = HAL_IRDA_RxHalfCpltCallback;        /* Legacy weak RxHalfCpltCallback        */
+  * @param  hirda IRDA handle.
-  hirda->RxCpltCallback            = HAL_IRDA_RxCpltCallback;            /* Legacy weak RxCpltCallback            */
+  * @retval none
-  hirda->ErrorCallback             = HAL_IRDA_ErrorCallback;             /* Legacy weak ErrorCallback             */
+  */
-  hirda->AbortCpltCallback         = HAL_IRDA_AbortCpltCallback;         /* Legacy weak AbortCpltCallback         */
+void IRDA_InitCallbacksToDefault(IRDA_HandleTypeDef *hirda)
-  hirda->AbortTransmitCpltCallback = HAL_IRDA_AbortTransmitCpltCallback; /* Legacy weak AbortTransmitCpltCallback */
+{
-  hirda->AbortReceiveCpltCallback  = HAL_IRDA_AbortReceiveCpltCallback;  /* Legacy weak AbortReceiveCpltCallback  */
+  /* Init the IRDA Callback settings */
+  hirda->TxHalfCpltCallback        = HAL_IRDA_TxHalfCpltCallback;        /* Legacy weak TxHalfCpltCallback        */
-}
+  hirda->TxCpltCallback            = HAL_IRDA_TxCpltCallback;            /* Legacy weak TxCpltCallback            */
-#endif /* USE_HAL_IRDA_REGISTER_CALLBACKS */
+  hirda->RxHalfCpltCallback        = HAL_IRDA_RxHalfCpltCallback;        /* Legacy weak RxHalfCpltCallback        */
+  hirda->RxCpltCallback            = HAL_IRDA_RxCpltCallback;            /* Legacy weak RxCpltCallback            */
-/**
+  hirda->ErrorCallback             = HAL_IRDA_ErrorCallback;             /* Legacy weak ErrorCallback             */
-  * @brief  DMA IRDA transmit process complete callback.
+  hirda->AbortCpltCallback         = HAL_IRDA_AbortCpltCallback;         /* Legacy weak AbortCpltCallback         */
-  * @param  hdma  Pointer to a DMA_HandleTypeDef structure that contains
+  hirda->AbortTransmitCpltCallback = HAL_IRDA_AbortTransmitCpltCallback; /* Legacy weak AbortTransmitCpltCallback */
-  *               the configuration information for the specified DMA.
+  hirda->AbortReceiveCpltCallback  = HAL_IRDA_AbortReceiveCpltCallback;  /* Legacy weak AbortReceiveCpltCallback  */
-  * @retval None
-  */
+}
-static void IRDA_DMATransmitCplt(DMA_HandleTypeDef *hdma)
+#endif /* USE_HAL_IRDA_REGISTER_CALLBACKS */
-{
-  IRDA_HandleTypeDef *hirda = (IRDA_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
+/**
-  /* DMA Normal mode */
+  * @brief  DMA IRDA transmit process complete callback.
-  if ((hdma->Instance->CCR & DMA_CCR_CIRC) == 0U)
+  * @param  hdma  Pointer to a DMA_HandleTypeDef structure that contains
-  {
+  *               the configuration information for the specified DMA.
-    hirda->TxXferCount = 0U;
+  * @retval None
+  */
-    /* Disable the DMA transfer for transmit request by resetting the DMAT bit
+static void IRDA_DMATransmitCplt(DMA_HandleTypeDef *hdma)
-       in the IRDA CR3 register */
+{
-    CLEAR_BIT(hirda->Instance->CR3, USART_CR3_DMAT);
+  IRDA_HandleTypeDef *hirda = (IRDA_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
+  /* DMA Normal mode */
-    /* Enable the IRDA Transmit Complete Interrupt */
+  if ((hdma->Instance->CCR & DMA_CCR_CIRC) == 0U)
-    SET_BIT(hirda->Instance->CR1, USART_CR1_TCIE);
+  {
-  }
+    hirda->TxXferCount = 0U;
-  /* DMA Circular mode */
-  else
+    /* Disable the DMA transfer for transmit request by resetting the DMAT bit
-  {
+       in the IRDA CR3 register */
-#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
+    CLEAR_BIT(hirda->Instance->CR3, USART_CR3_DMAT);
-    /* Call registered Tx complete callback */
-    hirda->TxCpltCallback(hirda);
+    /* Enable the IRDA Transmit Complete Interrupt */
-#else
+    SET_BIT(hirda->Instance->CR1, USART_CR1_TCIE);
-    /* Call legacy weak Tx complete callback */
+  }
-    HAL_IRDA_TxCpltCallback(hirda);
+  /* DMA Circular mode */
-#endif /* USE_HAL_IRDA_REGISTER_CALLBACK */
+  else
-  }
+  {
-}
+#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
+    /* Call registered Tx complete callback */
-/**
+    hirda->TxCpltCallback(hirda);
-  * @brief DMA IRDA receive process half complete callback
+#else
-  * @param  hdma  Pointer to a DMA_HandleTypeDef structure that contains
+    /* Call legacy weak Tx complete callback */
-  *               the configuration information for the specified DMA.
+    HAL_IRDA_TxCpltCallback(hirda);
-  * @retval None
+#endif /* USE_HAL_IRDA_REGISTER_CALLBACK */
-  */
+  }
-static void IRDA_DMATransmitHalfCplt(DMA_HandleTypeDef *hdma)
+}
-{
-  IRDA_HandleTypeDef *hirda = (IRDA_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
+/**
+  * @brief DMA IRDA receive process half complete callback
-#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
+  * @param  hdma  Pointer to a DMA_HandleTypeDef structure that contains
-  /* Call registered Tx Half complete callback */
+  *               the configuration information for the specified DMA.
-  hirda->TxHalfCpltCallback(hirda);
+  * @retval None
-#else
+  */
-  /* Call legacy weak Tx complete callback */
+static void IRDA_DMATransmitHalfCplt(DMA_HandleTypeDef *hdma)
-  HAL_IRDA_TxHalfCpltCallback(hirda);
+{
-#endif /* USE_HAL_IRDA_REGISTER_CALLBACK */
+  IRDA_HandleTypeDef *hirda = (IRDA_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
-}
+#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
-/**
+  /* Call registered Tx Half complete callback */
-  * @brief  DMA IRDA receive process complete callback.
+  hirda->TxHalfCpltCallback(hirda);
-  * @param  hdma  Pointer to a DMA_HandleTypeDef structure that contains
+#else
-  *               the configuration information for the specified DMA.
+  /* Call legacy weak Tx complete callback */
-  * @retval None
+  HAL_IRDA_TxHalfCpltCallback(hirda);
-  */
+#endif /* USE_HAL_IRDA_REGISTER_CALLBACK */
-static void IRDA_DMAReceiveCplt(DMA_HandleTypeDef *hdma)
+}
-{
-  IRDA_HandleTypeDef *hirda = (IRDA_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
+/**
+  * @brief  DMA IRDA receive process complete callback.
-  /* DMA Normal mode */
+  * @param  hdma  Pointer to a DMA_HandleTypeDef structure that contains
-  if ((hdma->Instance->CCR & DMA_CCR_CIRC) == 0U)
+  *               the configuration information for the specified DMA.
-  {
+  * @retval None
-    hirda->RxXferCount = 0U;
+  */
+static void IRDA_DMAReceiveCplt(DMA_HandleTypeDef *hdma)
-    /* Disable PE and ERR (Frame error, noise error, overrun error) interrupts */
+{
-    CLEAR_BIT(hirda->Instance->CR1, USART_CR1_PEIE);
+  IRDA_HandleTypeDef *hirda = (IRDA_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
-    CLEAR_BIT(hirda->Instance->CR3, USART_CR3_EIE);
+  /* DMA Normal mode */
-    /* Disable the DMA transfer for the receiver request by resetting the DMAR bit
+  if ((hdma->Instance->CCR & DMA_CCR_CIRC) == 0U)
-       in the IRDA CR3 register */
+  {
-    CLEAR_BIT(hirda->Instance->CR3, USART_CR3_DMAR);
+    hirda->RxXferCount = 0U;
-    /* At end of Rx process, restore hirda->RxState to Ready */
+    /* Disable PE and ERR (Frame error, noise error, overrun error) interrupts */
-    hirda->RxState = HAL_IRDA_STATE_READY;
+    CLEAR_BIT(hirda->Instance->CR1, USART_CR1_PEIE);
-  }
+    CLEAR_BIT(hirda->Instance->CR3, USART_CR3_EIE);
-#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
+    /* Disable the DMA transfer for the receiver request by resetting the DMAR bit
-  /* Call registered Rx complete callback */
+       in the IRDA CR3 register */
-  hirda->RxCpltCallback(hirda);
+    CLEAR_BIT(hirda->Instance->CR3, USART_CR3_DMAR);
-#else
-  /* Call legacy weak Rx complete callback */
+    /* At end of Rx process, restore hirda->RxState to Ready */
-  HAL_IRDA_RxCpltCallback(hirda);
+    hirda->RxState = HAL_IRDA_STATE_READY;
-#endif /* USE_HAL_IRDA_REGISTER_CALLBACKS */
+  }
-}
+#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
-/**
+  /* Call registered Rx complete callback */
-  * @brief DMA IRDA receive process half complete callback.
+  hirda->RxCpltCallback(hirda);
-  * @param  hdma  Pointer to a DMA_HandleTypeDef structure that contains
+#else
-  *               the configuration information for the specified DMA.
+  /* Call legacy weak Rx complete callback */
-  * @retval None
+  HAL_IRDA_RxCpltCallback(hirda);
-  */
+#endif /* USE_HAL_IRDA_REGISTER_CALLBACKS */
-static void IRDA_DMAReceiveHalfCplt(DMA_HandleTypeDef *hdma)
+}
-{
-  IRDA_HandleTypeDef *hirda = (IRDA_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
+/**
+  * @brief DMA IRDA receive process half complete callback.
-#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
+  * @param  hdma  Pointer to a DMA_HandleTypeDef structure that contains
-  /*Call registered Rx Half complete callback*/
+  *               the configuration information for the specified DMA.
-  hirda->RxHalfCpltCallback(hirda);
+  * @retval None
-#else
+  */
-  /* Call legacy weak Rx Half complete callback */
+static void IRDA_DMAReceiveHalfCplt(DMA_HandleTypeDef *hdma)
-  HAL_IRDA_RxHalfCpltCallback(hirda);
+{
-#endif /* USE_HAL_IRDA_REGISTER_CALLBACK */
+  IRDA_HandleTypeDef *hirda = (IRDA_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
-}
+#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
-/**
+  /*Call registered Rx Half complete callback*/
-  * @brief  DMA IRDA communication error callback.
+  hirda->RxHalfCpltCallback(hirda);
-  * @param  hdma  Pointer to a DMA_HandleTypeDef structure that contains
+#else
-  *               the configuration information for the specified DMA.
+  /* Call legacy weak Rx Half complete callback */
-  * @retval None
+  HAL_IRDA_RxHalfCpltCallback(hirda);
-  */
+#endif /* USE_HAL_IRDA_REGISTER_CALLBACK */
-static void IRDA_DMAError(DMA_HandleTypeDef *hdma)
+}
-{
-  uint32_t dmarequest = 0x00U;
+/**
-  IRDA_HandleTypeDef *hirda = (IRDA_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
+  * @brief  DMA IRDA communication error callback.
+  * @param  hdma  Pointer to a DMA_HandleTypeDef structure that contains
-  /* Stop IRDA DMA Tx request if ongoing */
+  *               the configuration information for the specified DMA.
-  dmarequest = HAL_IS_BIT_SET(hirda->Instance->CR3, USART_CR3_DMAT);
+  * @retval None
-  if ((hirda->gState == HAL_IRDA_STATE_BUSY_TX) && dmarequest)
+  */
-  {
+static void IRDA_DMAError(DMA_HandleTypeDef *hdma)
-    hirda->TxXferCount = 0U;
+{
-    IRDA_EndTxTransfer(hirda);
+  uint32_t dmarequest = 0x00U;
-  }
+  IRDA_HandleTypeDef *hirda = (IRDA_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
-  /* Stop IRDA DMA Rx request if ongoing */
+  /* Stop IRDA DMA Tx request if ongoing */
-  dmarequest = HAL_IS_BIT_SET(hirda->Instance->CR3, USART_CR3_DMAR);
+  dmarequest = HAL_IS_BIT_SET(hirda->Instance->CR3, USART_CR3_DMAT);
-  if ((hirda->RxState == HAL_IRDA_STATE_BUSY_RX) && dmarequest)
+  if ((hirda->gState == HAL_IRDA_STATE_BUSY_TX) && dmarequest)
   {
-    hirda->RxXferCount = 0U;
+    hirda->TxXferCount = 0U;
-    IRDA_EndRxTransfer(hirda);
+    IRDA_EndTxTransfer(hirda);
   }
-  hirda->ErrorCode |= HAL_IRDA_ERROR_DMA;
+  /* Stop IRDA DMA Rx request if ongoing */
+  dmarequest = HAL_IS_BIT_SET(hirda->Instance->CR3, USART_CR3_DMAR);
-#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
+  if ((hirda->RxState == HAL_IRDA_STATE_BUSY_RX) && dmarequest)
-  /* Call registered user error callback */
+  {
-  hirda->ErrorCallback(hirda);
+    hirda->RxXferCount = 0U;
-#else
+    IRDA_EndRxTransfer(hirda);
-  /* Call legacy weak user error callback */
+  }
-  HAL_IRDA_ErrorCallback(hirda);
-#endif /* USE_HAL_IRDA_REGISTER_CALLBACK */
+  hirda->ErrorCode |= HAL_IRDA_ERROR_DMA;
-}
+#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
-/**
+  /* Call registered user error callback */
-  * @brief  This function handles IRDA Communication Timeout.
+  hirda->ErrorCallback(hirda);
-  * @param  hirda  Pointer to a IRDA_HandleTypeDef structure that contains
+#else
-  *                the configuration information for the specified IRDA.
+  /* Call legacy weak user error callback */
-  * @param  Flag specifies the IRDA flag to check.
+  HAL_IRDA_ErrorCallback(hirda);
-  * @param  Status The new Flag status (SET or RESET).
+#endif /* USE_HAL_IRDA_REGISTER_CALLBACK */
-  * @param  Tickstart Tick start value
+}
-  * @param  Timeout Timeout duration
-  * @retval HAL status
+/**
-  */
+  * @brief  This function handles IRDA Communication Timeout. It waits
-static HAL_StatusTypeDef IRDA_WaitOnFlagUntilTimeout(IRDA_HandleTypeDef *hirda, uint32_t Flag, FlagStatus Status, uint32_t Tickstart, uint32_t Timeout)
+  *         until a flag is no longer in the specified status.
-{
+  * @param  hirda  Pointer to a IRDA_HandleTypeDef structure that contains
-  /* Wait until flag is set */
+  *                the configuration information for the specified IRDA.
-  while ((__HAL_IRDA_GET_FLAG(hirda, Flag) ? SET : RESET) == Status)
+  * @param  Flag specifies the IRDA flag to check.
-  {
+  * @param  Status The actual Flag status (SET or RESET).
-    /* Check for the Timeout */
+  * @param  Tickstart Tick start value
-    if (Timeout != HAL_MAX_DELAY)
+  * @param  Timeout Timeout duration
-    {
+  * @retval HAL status
-      if ((Timeout == 0U) || ((HAL_GetTick() - Tickstart) > Timeout))
+  */
-      {
+static HAL_StatusTypeDef IRDA_WaitOnFlagUntilTimeout(IRDA_HandleTypeDef *hirda, uint32_t Flag, FlagStatus Status, uint32_t Tickstart, uint32_t Timeout)
-        /* Disable TXE, RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts for the interrupt process */
+{
-        CLEAR_BIT(hirda->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE | USART_CR1_TXEIE));
+  /* Wait until flag is set */
-        CLEAR_BIT(hirda->Instance->CR3, USART_CR3_EIE);
+  while ((__HAL_IRDA_GET_FLAG(hirda, Flag) ? SET : RESET) == Status)
+  {
-        hirda->gState  = HAL_IRDA_STATE_READY;
+    /* Check for the Timeout */
-        hirda->RxState = HAL_IRDA_STATE_READY;
+    if (Timeout != HAL_MAX_DELAY)
+    {
-        /* Process Unlocked */
+      if ((Timeout == 0U) || ((HAL_GetTick() - Tickstart) > Timeout))
-        __HAL_UNLOCK(hirda);
+      {
+        /* Disable TXE, RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts for the interrupt process */
-        return HAL_TIMEOUT;
+        CLEAR_BIT(hirda->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE | USART_CR1_TXEIE));
-      }
+        CLEAR_BIT(hirda->Instance->CR3, USART_CR3_EIE);
-    }
-  }
+        hirda->gState  = HAL_IRDA_STATE_READY;
-  return HAL_OK;
+        hirda->RxState = HAL_IRDA_STATE_READY;
-}
+        /* Process Unlocked */
-/**
+        __HAL_UNLOCK(hirda);
-  * @brief  End ongoing Tx transfer on IRDA peripheral (following error detection or Transmit completion).
-  * @param  hirda IRDA handle.
+        return HAL_TIMEOUT;
-  * @retval None
+      }
-  */
+    }
-static void IRDA_EndTxTransfer(IRDA_HandleTypeDef *hirda)
+  }
-{
+  return HAL_OK;
-  /* Disable TXEIE and TCIE interrupts */
+}
-  CLEAR_BIT(hirda->Instance->CR1, (USART_CR1_TXEIE | USART_CR1_TCIE));
+/**
-  /* At end of Tx process, restore hirda->gState to Ready */
+  * @brief  End ongoing Tx transfer on IRDA peripheral (following error detection or Transmit completion).
-  hirda->gState = HAL_IRDA_STATE_READY;
+  * @param  hirda IRDA handle.
-}
+  * @retval None
+  */
-/**
+static void IRDA_EndTxTransfer(IRDA_HandleTypeDef *hirda)
-  * @brief  End ongoing Rx transfer on IRDA peripheral (following error detection or Reception completion).
+{
-  * @param  hirda IRDA handle.
+  /* Disable TXEIE and TCIE interrupts */
-  * @retval None
+  CLEAR_BIT(hirda->Instance->CR1, (USART_CR1_TXEIE | USART_CR1_TCIE));
-  */
-static void IRDA_EndRxTransfer(IRDA_HandleTypeDef *hirda)
+  /* At end of Tx process, restore hirda->gState to Ready */
-{
+  hirda->gState = HAL_IRDA_STATE_READY;
-  /* Disable RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts */
+}
-  CLEAR_BIT(hirda->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE));
-  CLEAR_BIT(hirda->Instance->CR3, USART_CR3_EIE);
+/**
+  * @brief  End ongoing Rx transfer on IRDA peripheral (following error detection or Reception completion).
-  /* At end of Rx process, restore hirda->RxState to Ready */
+  * @param  hirda IRDA handle.
-  hirda->RxState = HAL_IRDA_STATE_READY;
+  * @retval None
-}
+  */
+static void IRDA_EndRxTransfer(IRDA_HandleTypeDef *hirda)
-/**
+{
-  * @brief  DMA IRDA communication abort callback, when initiated by HAL services on Error
+  /* Disable RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts */
-  *         (To be called at end of DMA Abort procedure following error occurrence).
+  CLEAR_BIT(hirda->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE));
-  * @param  hdma DMA handle.
+  CLEAR_BIT(hirda->Instance->CR3, USART_CR3_EIE);
-  * @retval None
-  */
+  /* At end of Rx process, restore hirda->RxState to Ready */
-static void IRDA_DMAAbortOnError(DMA_HandleTypeDef *hdma)
+  hirda->RxState = HAL_IRDA_STATE_READY;
-{
+}
-  IRDA_HandleTypeDef *hirda = (IRDA_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
-  hirda->RxXferCount = 0x00U;
+/**
-  hirda->TxXferCount = 0x00U;
+  * @brief  DMA IRDA communication abort callback, when initiated by HAL services on Error
+  *         (To be called at end of DMA Abort procedure following error occurrence).
-#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
+  * @param  hdma DMA handle.
-  /* Call registered user error callback */
+  * @retval None
-  hirda->ErrorCallback(hirda);
+  */
-#else
+static void IRDA_DMAAbortOnError(DMA_HandleTypeDef *hdma)
-  /* Call legacy weak user error callback */
+{
-  HAL_IRDA_ErrorCallback(hirda);
+  IRDA_HandleTypeDef *hirda = (IRDA_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
-#endif /* USE_HAL_IRDA_REGISTER_CALLBACK */
+  hirda->RxXferCount = 0x00U;
-}
+  hirda->TxXferCount = 0x00U;
-/**
+#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
-  * @brief  DMA IRDA Tx communication abort callback, when initiated by user
+  /* Call registered user error callback */
-  *         (To be called at end of DMA Tx Abort procedure following user abort request).
+  hirda->ErrorCallback(hirda);
-  * @note   When this callback is executed, User Abort complete call back is called only if no
+#else
-  *         Abort still ongoing for Rx DMA Handle.
+  /* Call legacy weak user error callback */
-  * @param  hdma DMA handle.
+  HAL_IRDA_ErrorCallback(hirda);
-  * @retval None
+#endif /* USE_HAL_IRDA_REGISTER_CALLBACK */
-  */
+}
-static void IRDA_DMATxAbortCallback(DMA_HandleTypeDef *hdma)
-{
+/**
-  IRDA_HandleTypeDef *hirda = (IRDA_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
+  * @brief  DMA IRDA Tx communication abort callback, when initiated by user
+  *         (To be called at end of DMA Tx Abort procedure following user abort request).
-  hirda->hdmatx->XferAbortCallback = NULL;
+  * @note   When this callback is executed, User Abort complete call back is called only if no
+  *         Abort still ongoing for Rx DMA Handle.
-  /* Check if an Abort process is still ongoing */
+  * @param  hdma DMA handle.
-  if (hirda->hdmarx != NULL)
+  * @retval None
-  {
+  */
-    if (hirda->hdmarx->XferAbortCallback != NULL)
+static void IRDA_DMATxAbortCallback(DMA_HandleTypeDef *hdma)
-    {
+{
-      return;
+  IRDA_HandleTypeDef *hirda = (IRDA_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
-    }
-  }
+  hirda->hdmatx->XferAbortCallback = NULL;
-  /* No Abort process still ongoing : All DMA channels are aborted, call user Abort Complete callback */
+  /* Check if an Abort process is still ongoing */
-  hirda->TxXferCount = 0x00U;
+  if (hirda->hdmarx != NULL)
-  hirda->RxXferCount = 0x00U;
+  {
+    if (hirda->hdmarx->XferAbortCallback != NULL)
-  /* Reset ErrorCode */
+    {
-  hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
+      return;
+    }
-  /* Restore hirda->gState and hirda->RxState to Ready */
+  }
-  hirda->gState  = HAL_IRDA_STATE_READY;
-  hirda->RxState = HAL_IRDA_STATE_READY;
+  /* No Abort process still ongoing : All DMA channels are aborted, call user Abort Complete callback */
+  hirda->TxXferCount = 0x00U;
-  /* Call user Abort complete callback */
+  hirda->RxXferCount = 0x00U;
-#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
-  /* Call registered Abort complete callback */
+  /* Reset ErrorCode */
-  hirda->AbortCpltCallback(hirda);
+  hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
-#else
-  /* Call legacy weak Abort complete callback */
+  /* Restore hirda->gState and hirda->RxState to Ready */
-  HAL_IRDA_AbortCpltCallback(hirda);
+  hirda->gState  = HAL_IRDA_STATE_READY;
-#endif /* USE_HAL_IRDA_REGISTER_CALLBACK */
+  hirda->RxState = HAL_IRDA_STATE_READY;
-}
+  /* Call user Abort complete callback */
-/**
+#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
-  * @brief  DMA IRDA Rx communication abort callback, when initiated by user
+  /* Call registered Abort complete callback */
-  *         (To be called at end of DMA Rx Abort procedure following user abort request).
+  hirda->AbortCpltCallback(hirda);
-  * @note   When this callback is executed, User Abort complete call back is called only if no
+#else
-  *         Abort still ongoing for Tx DMA Handle.
+  /* Call legacy weak Abort complete callback */
-  * @param  hdma DMA handle.
+  HAL_IRDA_AbortCpltCallback(hirda);
-  * @retval None
+#endif /* USE_HAL_IRDA_REGISTER_CALLBACK */
-  */
+}
-static void IRDA_DMARxAbortCallback(DMA_HandleTypeDef *hdma)
-{
+/**
-  IRDA_HandleTypeDef *hirda = (IRDA_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
+  * @brief  DMA IRDA Rx communication abort callback, when initiated by user
+  *         (To be called at end of DMA Rx Abort procedure following user abort request).
-  hirda->hdmarx->XferAbortCallback = NULL;
+  * @note   When this callback is executed, User Abort complete call back is called only if no
+  *         Abort still ongoing for Tx DMA Handle.
-  /* Check if an Abort process is still ongoing */
+  * @param  hdma DMA handle.
-  if (hirda->hdmatx != NULL)
+  * @retval None
-  {
+  */
-    if (hirda->hdmatx->XferAbortCallback != NULL)
+static void IRDA_DMARxAbortCallback(DMA_HandleTypeDef *hdma)
-    {
+{
-      return;
+  IRDA_HandleTypeDef *hirda = (IRDA_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
-    }
-  }
+  hirda->hdmarx->XferAbortCallback = NULL;
-  /* No Abort process still ongoing : All DMA channels are aborted, call user Abort Complete callback */
+  /* Check if an Abort process is still ongoing */
-  hirda->TxXferCount = 0x00U;
+  if (hirda->hdmatx != NULL)
-  hirda->RxXferCount = 0x00U;
+  {
+    if (hirda->hdmatx->XferAbortCallback != NULL)
-  /* Reset ErrorCode */
+    {
-  hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
+      return;
+    }
-  /* Restore hirda->gState and hirda->RxState to Ready */
+  }
-  hirda->gState  = HAL_IRDA_STATE_READY;
-  hirda->RxState = HAL_IRDA_STATE_READY;
+  /* No Abort process still ongoing : All DMA channels are aborted, call user Abort Complete callback */
+  hirda->TxXferCount = 0x00U;
-  /* Call user Abort complete callback */
+  hirda->RxXferCount = 0x00U;
-#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
-  /* Call registered Abort complete callback */
+  /* Reset ErrorCode */
-  hirda->AbortCpltCallback(hirda);
+  hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
-#else
-  /* Call legacy weak Abort complete callback */
+  /* Restore hirda->gState and hirda->RxState to Ready */
-  HAL_IRDA_AbortCpltCallback(hirda);
+  hirda->gState  = HAL_IRDA_STATE_READY;
-#endif /* USE_HAL_IRDA_REGISTER_CALLBACK */
+  hirda->RxState = HAL_IRDA_STATE_READY;
-}
+  /* Call user Abort complete callback */
-/**
+#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
-  * @brief  DMA IRDA Tx communication abort callback, when initiated by user by a call to
+  /* Call registered Abort complete callback */
-  *         HAL_IRDA_AbortTransmit_IT API (Abort only Tx transfer)
+  hirda->AbortCpltCallback(hirda);
-  *         (This callback is executed at end of DMA Tx Abort procedure following user abort request,
+#else
-  *         and leads to user Tx Abort Complete callback execution).
+  /* Call legacy weak Abort complete callback */
-  * @param  hdma DMA handle.
+  HAL_IRDA_AbortCpltCallback(hirda);
-  * @retval None
+#endif /* USE_HAL_IRDA_REGISTER_CALLBACK */
-  */
+}
-static void IRDA_DMATxOnlyAbortCallback(DMA_HandleTypeDef *hdma)
-{
+/**
-  IRDA_HandleTypeDef *hirda = (IRDA_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
+  * @brief  DMA IRDA Tx communication abort callback, when initiated by user by a call to
+  *         HAL_IRDA_AbortTransmit_IT API (Abort only Tx transfer)
-  hirda->TxXferCount = 0x00U;
+  *         (This callback is executed at end of DMA Tx Abort procedure following user abort request,
+  *         and leads to user Tx Abort Complete callback execution).
-  /* Restore hirda->gState to Ready */
+  * @param  hdma DMA handle.
-  hirda->gState = HAL_IRDA_STATE_READY;
+  * @retval None
+  */
-  /* Call user Abort complete callback */
+static void IRDA_DMATxOnlyAbortCallback(DMA_HandleTypeDef *hdma)
-#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
+{
-  /* Call registered Abort Transmit Complete Callback */
+  IRDA_HandleTypeDef *hirda = (IRDA_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
-  hirda->AbortTransmitCpltCallback(hirda);
-#else
+  hirda->TxXferCount = 0x00U;
-  /* Call legacy weak Abort Transmit Complete Callback */
-  HAL_IRDA_AbortTransmitCpltCallback(hirda);
+  /* Restore hirda->gState to Ready */
-#endif /* USE_HAL_IRDA_REGISTER_CALLBACK */
+  hirda->gState = HAL_IRDA_STATE_READY;
-}
+  /* Call user Abort complete callback */
-/**
+#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
-  * @brief  DMA IRDA Rx communication abort callback, when initiated by user by a call to
+  /* Call registered Abort Transmit Complete Callback */
-  *         HAL_IRDA_AbortReceive_IT API (Abort only Rx transfer)
+  hirda->AbortTransmitCpltCallback(hirda);
-  *         (This callback is executed at end of DMA Rx Abort procedure following user abort request,
+#else
-  *         and leads to user Rx Abort Complete callback execution).
+  /* Call legacy weak Abort Transmit Complete Callback */
-  * @param  hdma DMA handle.
+  HAL_IRDA_AbortTransmitCpltCallback(hirda);
-  * @retval None
+#endif /* USE_HAL_IRDA_REGISTER_CALLBACK */
-  */
+}
-static void IRDA_DMARxOnlyAbortCallback(DMA_HandleTypeDef *hdma)
-{
+/**
-  IRDA_HandleTypeDef *hirda = (IRDA_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
+  * @brief  DMA IRDA Rx communication abort callback, when initiated by user by a call to
+  *         HAL_IRDA_AbortReceive_IT API (Abort only Rx transfer)
-  hirda->RxXferCount = 0x00U;
+  *         (This callback is executed at end of DMA Rx Abort procedure following user abort request,
+  *         and leads to user Rx Abort Complete callback execution).
-  /* Restore hirda->RxState to Ready */
+  * @param  hdma DMA handle.
-  hirda->RxState = HAL_IRDA_STATE_READY;
+  * @retval None
+  */
-  /* Call user Abort complete callback */
+static void IRDA_DMARxOnlyAbortCallback(DMA_HandleTypeDef *hdma)
-#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
+{
-  /* Call registered Abort Receive Complete Callback */
+  IRDA_HandleTypeDef *hirda = (IRDA_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
-  hirda->AbortReceiveCpltCallback(hirda);
-#else
+  hirda->RxXferCount = 0x00U;
-  /* Call legacy weak Abort Receive Complete Callback */
-  HAL_IRDA_AbortReceiveCpltCallback(hirda);
+  /* Restore hirda->RxState to Ready */
-#endif /* USE_HAL_IRDA_REGISTER_CALLBACK */
+  hirda->RxState = HAL_IRDA_STATE_READY;
-}
+  /* Call user Abort complete callback */
-/**
+#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
- * @brief  Send an amount of data in non blocking mode.
+  /* Call registered Abort Receive Complete Callback */
- * @param  hirda  Pointer to a IRDA_HandleTypeDef structure that contains
+  hirda->AbortReceiveCpltCallback(hirda);
- *                the configuration information for the specified IRDA module.
+#else
- * @retval HAL status
+  /* Call legacy weak Abort Receive Complete Callback */
- */
+  HAL_IRDA_AbortReceiveCpltCallback(hirda);
-static HAL_StatusTypeDef IRDA_Transmit_IT(IRDA_HandleTypeDef *hirda)
+#endif /* USE_HAL_IRDA_REGISTER_CALLBACK */
-{
+}
-  uint16_t *tmp;
+/**
-  /* Check that a Tx process is ongoing */
+ * @brief  Send an amount of data in non blocking mode.
-  if (hirda->gState == HAL_IRDA_STATE_BUSY_TX)
+ * @param  hirda  Pointer to a IRDA_HandleTypeDef structure that contains
-  {
+ *                the configuration information for the specified IRDA module.
-    if (hirda->Init.WordLength == IRDA_WORDLENGTH_9B)
+ * @retval HAL status
-    {
+ */
-      tmp = (uint16_t *) hirda->pTxBuffPtr;
+static HAL_StatusTypeDef IRDA_Transmit_IT(IRDA_HandleTypeDef *hirda)
-      hirda->Instance->DR = (uint16_t)(*tmp & (uint16_t)0x01FF);
+{
-      if (hirda->Init.Parity == IRDA_PARITY_NONE)
+  const uint16_t *tmp;
-      {
-        hirda->pTxBuffPtr += 2U;
+  /* Check that a Tx process is ongoing */
-      }
+  if (hirda->gState == HAL_IRDA_STATE_BUSY_TX)
-      else
+  {
-      {
+    if (hirda->Init.WordLength == IRDA_WORDLENGTH_9B)
-        hirda->pTxBuffPtr += 1U;
+    {
-      }
+      tmp = (const uint16_t *) hirda->pTxBuffPtr;
-    }
+      hirda->Instance->DR = (uint16_t)(*tmp & (uint16_t)0x01FF);
-    else
+      if (hirda->Init.Parity == IRDA_PARITY_NONE)
-    {
+      {
-      hirda->Instance->DR = (uint8_t)(*hirda->pTxBuffPtr++ & (uint8_t)0x00FF);
+        hirda->pTxBuffPtr += 2U;
-    }
+      }
+      else
-    if (--hirda->TxXferCount == 0U)
+      {
-    {
+        hirda->pTxBuffPtr += 1U;
-      /* Disable the IRDA Transmit Data Register Empty Interrupt */
+      }
-      CLEAR_BIT(hirda->Instance->CR1, USART_CR1_TXEIE);
+    }
+    else
-      /* Enable the IRDA Transmit Complete Interrupt */
+    {
-      SET_BIT(hirda->Instance->CR1, USART_CR1_TCIE);
+      hirda->Instance->DR = (uint8_t)(*hirda->pTxBuffPtr++ & (uint8_t)0x00FF);
     }
-    return HAL_OK;
+    if (--hirda->TxXferCount == 0U)
-  }
+    {
-  else
+      /* Disable the IRDA Transmit Data Register Empty Interrupt */
-  {
+      CLEAR_BIT(hirda->Instance->CR1, USART_CR1_TXEIE);
-    return HAL_BUSY;
-  }
+      /* Enable the IRDA Transmit Complete Interrupt */
-}
+      SET_BIT(hirda->Instance->CR1, USART_CR1_TCIE);
+    }
-/**
-  * @brief  Wraps up transmission in non blocking mode.
+    return HAL_OK;
-  * @param  hirda  Pointer to a IRDA_HandleTypeDef structure that contains
+  }
-  *                the configuration information for the specified IRDA module.
+  else
-  * @retval HAL status
+  {
-  */
+    return HAL_BUSY;
-static HAL_StatusTypeDef IRDA_EndTransmit_IT(IRDA_HandleTypeDef *hirda)
+  }
-{
+}
-  /* Disable the IRDA Transmit Complete Interrupt */
-  CLEAR_BIT(hirda->Instance->CR1, USART_CR1_TCIE);
+/**
+  * @brief  Wraps up transmission in non blocking mode.
-  /* Disable the IRDA Error Interrupt: (Frame error, noise error, overrun error) */
+  * @param  hirda  Pointer to a IRDA_HandleTypeDef structure that contains
-  CLEAR_BIT(hirda->Instance->CR3, USART_CR3_EIE);
+  *                the configuration information for the specified IRDA module.
+  * @retval HAL status
-  /* Tx process is ended, restore hirda->gState to Ready */
+  */
-  hirda->gState = HAL_IRDA_STATE_READY;
+static HAL_StatusTypeDef IRDA_EndTransmit_IT(IRDA_HandleTypeDef *hirda)
+{
-#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
+  /* Disable the IRDA Transmit Complete Interrupt */
-  /* Call registered Tx complete callback */
+  CLEAR_BIT(hirda->Instance->CR1, USART_CR1_TCIE);
-  hirda->TxCpltCallback(hirda);
-#else
+  /* Disable the IRDA Error Interrupt: (Frame error, noise error, overrun error) */
-  /* Call legacy weak Tx complete callback */
+  CLEAR_BIT(hirda->Instance->CR3, USART_CR3_EIE);
-  HAL_IRDA_TxCpltCallback(hirda);
-#endif /* USE_HAL_IRDA_REGISTER_CALLBACK */
+  /* Tx process is ended, restore hirda->gState to Ready */
+  hirda->gState = HAL_IRDA_STATE_READY;
-  return HAL_OK;
-}
+#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
+  /* Call registered Tx complete callback */
-/**
+  hirda->TxCpltCallback(hirda);
-  * @brief  Receives an amount of data in non blocking mode.
+#else
-  * @param  hirda  Pointer to a IRDA_HandleTypeDef structure that contains
+  /* Call legacy weak Tx complete callback */
-  *                the configuration information for the specified IRDA module.
+  HAL_IRDA_TxCpltCallback(hirda);
-  * @retval HAL status
+#endif /* USE_HAL_IRDA_REGISTER_CALLBACK */
-  */
-static HAL_StatusTypeDef IRDA_Receive_IT(IRDA_HandleTypeDef *hirda)
+  return HAL_OK;
-{
+}
-  uint16_t *tmp;
-  uint16_t  uhdata;
+/**
+  * @brief  Receives an amount of data in non blocking mode.
-  /* Check that a Rx process is ongoing */
+  * @param  hirda  Pointer to a IRDA_HandleTypeDef structure that contains
-  if (hirda->RxState == HAL_IRDA_STATE_BUSY_RX)
+  *                the configuration information for the specified IRDA module.
-  {
+  * @retval HAL status
-    uhdata = (uint16_t) READ_REG(hirda->Instance->DR);
+  */
-    if (hirda->Init.WordLength == IRDA_WORDLENGTH_9B)
+static HAL_StatusTypeDef IRDA_Receive_IT(IRDA_HandleTypeDef *hirda)
-    {
+{
-      tmp = (uint16_t *) hirda->pRxBuffPtr;
+  uint16_t *tmp;
-      if (hirda->Init.Parity == IRDA_PARITY_NONE)
+  uint16_t  uhdata;
-      {
-        *tmp = (uint16_t)(uhdata & (uint16_t)0x01FF);
+  /* Check that a Rx process is ongoing */
-        hirda->pRxBuffPtr += 2U;
+  if (hirda->RxState == HAL_IRDA_STATE_BUSY_RX)
-      }
+  {
-      else
+    uhdata = (uint16_t) READ_REG(hirda->Instance->DR);
-      {
+    if (hirda->Init.WordLength == IRDA_WORDLENGTH_9B)
-        *tmp = (uint16_t)(uhdata & (uint16_t)0x00FF);
+    {
-        hirda->pRxBuffPtr += 1U;
+      tmp = (uint16_t *) hirda->pRxBuffPtr;
-      }
+      if (hirda->Init.Parity == IRDA_PARITY_NONE)
-    }
+      {
-    else
+        *tmp = (uint16_t)(uhdata & (uint16_t)0x01FF);
-    {
+        hirda->pRxBuffPtr += 2U;
-      if (hirda->Init.Parity == IRDA_PARITY_NONE)
+      }
-      {
+      else
-        *hirda->pRxBuffPtr++ = (uint8_t)(uhdata & (uint8_t)0x00FF);
+      {
-      }
+        *tmp = (uint16_t)(uhdata & (uint16_t)0x00FF);
-      else
+        hirda->pRxBuffPtr += 1U;
-      {
+      }
-        *hirda->pRxBuffPtr++ = (uint8_t)(uhdata & (uint8_t)0x007F);
+    }
-      }
+    else
-    }
+    {
+      if (hirda->Init.Parity == IRDA_PARITY_NONE)
-    if (--hirda->RxXferCount == 0U)
+      {
-    {
+        *hirda->pRxBuffPtr++ = (uint8_t)(uhdata & (uint8_t)0x00FF);
-      /* Disable the IRDA Data Register not empty Interrupt */
+      }
-      CLEAR_BIT(hirda->Instance->CR1, USART_CR1_RXNEIE);
+      else
+      {
-      /* Disable the IRDA Parity Error Interrupt */
+        *hirda->pRxBuffPtr++ = (uint8_t)(uhdata & (uint8_t)0x007F);
-      CLEAR_BIT(hirda->Instance->CR1, USART_CR1_PEIE);
+      }
+    }
-      /* Disable the IRDA Error Interrupt: (Frame error, noise error, overrun error) */
-      CLEAR_BIT(hirda->Instance->CR3, USART_CR3_EIE);
+    if (--hirda->RxXferCount == 0U)
+    {
-      /* Rx process is completed, restore hirda->RxState to Ready */
+      /* Disable the IRDA Data Register not empty Interrupt */
-      hirda->RxState = HAL_IRDA_STATE_READY;
+      CLEAR_BIT(hirda->Instance->CR1, USART_CR1_RXNEIE);
-#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
+      /* Disable the IRDA Parity Error Interrupt */
-      /* Call registered Rx complete callback */
+      CLEAR_BIT(hirda->Instance->CR1, USART_CR1_PEIE);
-      hirda->RxCpltCallback(hirda);
-#else
+      /* Disable the IRDA Error Interrupt: (Frame error, noise error, overrun error) */
-      /* Call legacy weak Rx complete callback */
+      CLEAR_BIT(hirda->Instance->CR3, USART_CR3_EIE);
-      HAL_IRDA_RxCpltCallback(hirda);
-#endif /* USE_HAL_IRDA_REGISTER_CALLBACKS */
+      /* Rx process is completed, restore hirda->RxState to Ready */
+      hirda->RxState = HAL_IRDA_STATE_READY;
-      return HAL_OK;
-    }
+#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
-    return HAL_OK;
+      /* Call registered Rx complete callback */
-  }
+      hirda->RxCpltCallback(hirda);
-  else
+#else
-  {
+      /* Call legacy weak Rx complete callback */
-    return HAL_BUSY;
+      HAL_IRDA_RxCpltCallback(hirda);
-  }
+#endif /* USE_HAL_IRDA_REGISTER_CALLBACKS */
-}
+      return HAL_OK;
-/**
+    }
-  * @brief  Configures the IRDA peripheral.
+    return HAL_OK;
-  * @param  hirda  Pointer to a IRDA_HandleTypeDef structure that contains
+  }
-  *                the configuration information for the specified IRDA module.
+  else
-  * @retval None
+  {
-  */
+    return HAL_BUSY;
-static void IRDA_SetConfig(IRDA_HandleTypeDef *hirda)
+  }
-{
+}
-  uint32_t pclk;
+/**
-  /* Check the parameters */
+  * @brief  Configures the IRDA peripheral.
-  assert_param(IS_IRDA_INSTANCE(hirda->Instance));
+  * @param  hirda  Pointer to a IRDA_HandleTypeDef structure that contains
-  assert_param(IS_IRDA_BAUDRATE(hirda->Init.BaudRate));
+  *                the configuration information for the specified IRDA module.
-  assert_param(IS_IRDA_WORD_LENGTH(hirda->Init.WordLength));
+  * @retval None
-  assert_param(IS_IRDA_PARITY(hirda->Init.Parity));
+  */
-  assert_param(IS_IRDA_MODE(hirda->Init.Mode));
+static void IRDA_SetConfig(IRDA_HandleTypeDef *hirda)
-  assert_param(IS_IRDA_POWERMODE(hirda->Init.IrDAMode));
+{
+  uint32_t pclk;
-  /*-------------------------- USART CR2 Configuration ------------------------*/
-  /* Clear STOP[13:12] bits */
+  /* Check the parameters */
-  CLEAR_BIT(hirda->Instance->CR2, USART_CR2_STOP);
+  assert_param(IS_IRDA_INSTANCE(hirda->Instance));
+  assert_param(IS_IRDA_BAUDRATE(hirda->Init.BaudRate));
-  /*-------------------------- USART CR1 Configuration -----------------------*/
+  assert_param(IS_IRDA_WORD_LENGTH(hirda->Init.WordLength));
-  /* Clear M, PCE, PS, TE and RE bits */
+  assert_param(IS_IRDA_PARITY(hirda->Init.Parity));
-  CLEAR_BIT(hirda->Instance->CR1, (USART_CR1_M | USART_CR1_PCE | USART_CR1_PS | USART_CR1_TE | USART_CR1_RE));
+  assert_param(IS_IRDA_MODE(hirda->Init.Mode));
+  assert_param(IS_IRDA_POWERMODE(hirda->Init.IrDAMode));
-  /* Configure the USART Word Length, Parity and mode:
-     Set the M bits according to hirda->Init.WordLength value
+  /*-------------------------- USART CR2 Configuration ------------------------*/
-     Set PCE and PS bits according to hirda->Init.Parity value
+  /* Clear STOP[13:12] bits */
-     Set TE and RE bits according to hirda->Init.Mode value */
+  CLEAR_BIT(hirda->Instance->CR2, USART_CR2_STOP);
-  /* Write to USART CR1 */
-  SET_BIT(hirda->Instance->CR1, (hirda->Init.WordLength | hirda->Init.Parity | hirda->Init.Mode));
+  /*-------------------------- USART CR1 Configuration -----------------------*/
+  /* Clear M, PCE, PS, TE and RE bits */
-  /*-------------------------- USART CR3 Configuration -----------------------*/
+  CLEAR_BIT(hirda->Instance->CR1, (USART_CR1_M | USART_CR1_PCE | USART_CR1_PS | USART_CR1_TE | USART_CR1_RE));
-  /* Clear CTSE and RTSE bits */
-  CLEAR_BIT(hirda->Instance->CR3, (USART_CR3_RTSE | USART_CR3_CTSE));
+  /* Configure the USART Word Length, Parity and mode:
+     Set the M bits according to hirda->Init.WordLength value
-  /*-------------------------- USART BRR Configuration -----------------------*/
+     Set PCE and PS bits according to hirda->Init.Parity value
-  if(hirda->Instance == USART1)
+     Set TE and RE bits according to hirda->Init.Mode value */
-  {
+  /* Write to USART CR1 */
-    pclk = HAL_RCC_GetPCLK2Freq();
+  SET_BIT(hirda->Instance->CR1, (hirda->Init.WordLength | hirda->Init.Parity | hirda->Init.Mode));
-    SET_BIT(hirda->Instance->BRR, IRDA_BRR(pclk, hirda->Init.BaudRate));
-  }
+  /*-------------------------- USART CR3 Configuration -----------------------*/
-  else
+  /* Clear CTSE and RTSE bits */
-  {
+  CLEAR_BIT(hirda->Instance->CR3, (USART_CR3_RTSE | USART_CR3_CTSE));
-    pclk = HAL_RCC_GetPCLK1Freq();
-    SET_BIT(hirda->Instance->BRR, IRDA_BRR(pclk, hirda->Init.BaudRate));
+  /*-------------------------- USART BRR Configuration -----------------------*/
-  }
+  if(hirda->Instance == USART1)
-}
+  {
+    pclk = HAL_RCC_GetPCLK2Freq();
-/**
+    SET_BIT(hirda->Instance->BRR, IRDA_BRR(pclk, hirda->Init.BaudRate));
-  * @}
+  }
-  */
+  else
+  {
-#endif /* HAL_IRDA_MODULE_ENABLED */
+    pclk = HAL_RCC_GetPCLK1Freq();
-/**
+    SET_BIT(hirda->Instance->BRR, IRDA_BRR(pclk, hirda->Init.BaudRate));
-  * @}
+  }
-  */
+}
 /**
   * @}
   */
-/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
+#endif /* HAL_IRDA_MODULE_ENABLED */
+/**
+  * @}
+  */
+/**
+  * @}
+  */

Subversion Repositories canSerial

(root)/trunk/Drivers/STM32F1xx_HAL_Driver/Src/stm32f1xx_hal_irda.c – Rev 2 → 3