lib/main/STM32F1/Drivers/STM32F1xx_HAL_Driver/Src/stm32f1xx_hal_irda.c

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