--- /dev/null
+/**\r
+ ******************************************************************************\r
+ * @file stm32f7xx_hal_irda.c\r
+ * @author MCD Application Team\r
+ * @version V1.0.0RC1\r
+ * @date 24-March-2015\r
+ * @brief IRDA HAL module driver.\r
+ * This file provides firmware functions to manage the following \r
+ * functionalities of the IrDA SIR ENDEC block (IrDA):\r
+ * + Initialization and de-initialization methods\r
+ * + IO operation methods\r
+ * + Peripheral Control methods\r
+ *\r
+ @verbatim\r
+ ==============================================================================\r
+ ##### How to use this driver #####\r
+ ==============================================================================\r
+ [..]\r
+ The IRDA HAL driver can be used as follows:\r
+ \r
+ (#) Declare a IRDA_HandleTypeDef handle structure.\r
+ (#) Initialize the IRDA low level resources by implementing the HAL_IRDA_MspInit() API:\r
+ (##) Enable the USARTx interface clock.\r
+ (##) IRDA pins configuration:\r
+ (+++) Enable the clock for the IRDA GPIOs.\r
+ (+++) Configure these IRDA pins as alternate function pull-up.\r
+ (##) NVIC configuration if you need to use interrupt process (HAL_IRDA_Transmit_IT()\r
+ and HAL_IRDA_Receive_IT() APIs):\r
+ (+++) Configure the USARTx interrupt priority.\r
+ (+++) Enable the NVIC USART IRQ handle.\r
+ (##) DMA Configuration if you need to use DMA process (HAL_IRDA_Transmit_DMA()\r
+ and HAL_IRDA_Receive_DMA() APIs):\r
+ (+++) Declare a DMA handle structure for the Tx/Rx stream.\r
+ (+++) Enable the DMAx interface clock.\r
+ (+++) Configure the declared DMA handle structure with the required Tx/Rx parameters. \r
+ (+++) Configure the DMA Tx/Rx Stream.\r
+ (+++) Associate the initialized DMA handle to the IRDA DMA Tx/Rx handle.\r
+ (+++) Configure the priority and enable the NVIC for the transfer complete interrupt on the DMA Tx/Rx Stream.\r
+\r
+ (#) Program the Baud Rate, Word Length, Parity, IrDA Mode, Prescaler \r
+ and Mode(Receiver/Transmitter) in the hirda Init structure.\r
+\r
+ (#) Initialize the IRDA registers by calling the HAL_IRDA_Init() API:\r
+ (++) This API configures also the low level Hardware GPIO, CLOCK, CORTEX...etc)\r
+ by calling the customized HAL_IRDA_MspInit() API.\r
+ -@@- The specific IRDA interrupts (Transmission complete interrupt, \r
+ RXNE interrupt and Error Interrupts) will be managed using the macros\r
+ __HAL_IRDA_ENABLE_IT() and __HAL_IRDA_DISABLE_IT() inside the transmit and receive process.\r
+ \r
+ (#) Three operation modes are available within this driver :\r
+ \r
+ *** Polling mode IO operation ***\r
+ =================================\r
+ [..] \r
+ (+) Send an amount of data in blocking mode using HAL_IRDA_Transmit() \r
+ (+) Receive an amount of data in blocking mode using HAL_IRDA_Receive()\r
+ \r
+ *** Interrupt mode IO operation *** \r
+ ===================================\r
+ [..] \r
+ (+) Send an amount of data in non blocking mode using HAL_IRDA_Transmit_IT() \r
+ (+) At transmission end of transfer HAL_IRDA_TxCpltCallback is executed and user can \r
+ add his own code by customization of function pointer HAL_IRDA_TxCpltCallback\r
+ (+) Receive an amount of data in non blocking mode using HAL_IRDA_Receive_IT() \r
+ (+) At reception end of transfer HAL_IRDA_RxCpltCallback is executed and user can \r
+ add his own code by customization of function pointer HAL_IRDA_RxCpltCallback \r
+ (+) In case of transfer Error, HAL_IRDA_ErrorCallback() function is executed and user can \r
+ add his own code by customization of function pointer HAL_IRDA_ErrorCallback\r
+\r
+ *** DMA mode IO operation *** \r
+ =============================\r
+ [..]\r
+ (+) Send an amount of data in non blocking mode (DMA) using HAL_IRDA_Transmit_DMA() \r
+ (+) At transmission end of transfer HAL_IRDA_TxCpltCallback is executed and user can \r
+ add his own code by customization of function pointer HAL_IRDA_TxCpltCallback\r
+ (+) Receive an amount of data in non blocking mode (DMA) using HAL_IRDA_Receive_DMA() \r
+ (+) At reception end of transfer HAL_IRDA_RxCpltCallback is executed and user can \r
+ add his own code by customization of function pointer HAL_IRDA_RxCpltCallback \r
+ (+) In case of transfer Error, HAL_IRDA_ErrorCallback() function is executed and user can \r
+ add his own code by customization of function pointer HAL_IRDA_ErrorCallback \r
+\r
+ *** IRDA HAL driver macros list ***\r
+ ===================================\r
+ [..]\r
+ Below the list of most used macros in IRDA HAL driver.\r
+ \r
+ (+) __HAL_IRDA_ENABLE: Enable the IRDA peripheral \r
+ (+) __HAL_IRDA_DISABLE: Disable the IRDA peripheral \r
+ (+) __HAL_IRDA_GET_FLAG : Checks whether the specified IRDA flag is set or not\r
+ (+) __HAL_IRDA_CLEAR_FLAG : Clears the specified IRDA pending flag\r
+ (+) __HAL_IRDA_ENABLE_IT: Enables the specified IRDA interrupt\r
+ (+) __HAL_IRDA_DISABLE_IT: Disables the specified IRDA interrupt\r
+ \r
+ (@) You can refer to the IRDA HAL driver header file for more useful macros\r
+\r
+ @endverbatim\r
+ ******************************************************************************\r
+ * @attention\r
+ *\r
+ * <h2><center>© COPYRIGHT(c) 2015 STMicroelectronics</center></h2>\r
+ *\r
+ * Redistribution and use in source and binary forms, with or without modification,\r
+ * are permitted provided that the following conditions are met:\r
+ * 1. Redistributions of source code must retain the above copyright notice,\r
+ * this list of conditions and the following disclaimer.\r
+ * 2. Redistributions in binary form must reproduce the above copyright notice,\r
+ * this list of conditions and the following disclaimer in the documentation\r
+ * and/or other materials provided with the distribution.\r
+ * 3. Neither the name of STMicroelectronics nor the names of its contributors\r
+ * may be used to endorse or promote products derived from this software\r
+ * without specific prior written permission.\r
+ *\r
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"\r
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\r
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\r
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\r
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\r
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\r
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\r
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\r
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
+ *\r
+ ******************************************************************************\r
+ */ \r
+\r
+/* Includes ------------------------------------------------------------------*/\r
+#include "stm32f7xx_hal.h"\r
+\r
+/** @addtogroup STM32F7xx_HAL_Driver\r
+ * @{\r
+ */\r
+\r
+/** @defgroup IRDA IRDA\r
+ * @brief HAL IRDA module driver\r
+ * @{\r
+ */\r
+#ifdef HAL_IRDA_MODULE_ENABLED\r
+ \r
+/* Private typedef -----------------------------------------------------------*/\r
+/* Private define ------------------------------------------------------------*/\r
+/** @addtogroup IRDA_Private_Constants\r
+ * @{\r
+ */\r
+#define TEACK_REACK_TIMEOUT 1000\r
+#define HAL_IRDA_TXDMA_TIMEOUTVALUE 22000\r
+#define IRDA_CR1_FIELDS ((uint32_t)(USART_CR1_M | USART_CR1_PCE \\r
+ | USART_CR1_PS | USART_CR1_TE | USART_CR1_RE))\r
+/**\r
+ * @}\r
+ */\r
+/* Private macro -------------------------------------------------------------*/\r
+/* Private variables ---------------------------------------------------------*/\r
+/* Private function prototypes -----------------------------------------------*/\r
+/** @addtogroup IRDA_Private_Functions\r
+ * @{\r
+ */\r
+static void IRDA_DMATransmitCplt(DMA_HandleTypeDef *hdma);\r
+static void IRDA_DMATransmitHalfCplt(DMA_HandleTypeDef *hdma);\r
+static void IRDA_DMAReceiveCplt(DMA_HandleTypeDef *hdma);\r
+static void IRDA_DMAReceiveHalfCplt(DMA_HandleTypeDef *hdma);\r
+static void IRDA_DMAError(DMA_HandleTypeDef *hdma); \r
+static void IRDA_SetConfig (IRDA_HandleTypeDef *hirda);\r
+static HAL_StatusTypeDef IRDA_CheckIdleState(IRDA_HandleTypeDef *hirda);\r
+static HAL_StatusTypeDef IRDA_WaitOnFlagUntilTimeout(IRDA_HandleTypeDef *hirda, uint32_t Flag, FlagStatus Status, uint32_t Timeout);\r
+static HAL_StatusTypeDef IRDA_Transmit_IT(IRDA_HandleTypeDef *hirda);\r
+static HAL_StatusTypeDef IRDA_Receive_IT(IRDA_HandleTypeDef *hirda);\r
+/**\r
+ * @}\r
+ */\r
+/* Exported functions --------------------------------------------------------*/\r
+/** @defgroup IRDA_Exported_Functions IrDA Exported Functions\r
+ * @{\r
+ */\r
+\r
+/** @defgroup IRDA_Exported_Functions_Group1 IrDA Initialization and de-initialization functions \r
+ * @brief Initialization and Configuration functions \r
+ *\r
+@verbatim \r
+\r
+===============================================================================\r
+ ##### Initialization and Configuration functions #####\r
+ =============================================================================== \r
+ [..]\r
+ This subsection provides a set of functions allowing to initialize the USARTx or the UARTy \r
+ in IrDA mode.\r
+ (+) For the asynchronous mode only these parameters can be configured: \r
+ (++) BaudRate\r
+ (++) WordLength \r
+ (++) Parity: If the parity is enabled, then the MSB bit of the data written\r
+ in the data register is transmitted but is changed by the parity bit.\r
+ Depending on the frame length defined by the M bit (8-bits or 9-bits),\r
+ please refer to Reference manual for possible IRDA frame formats.\r
+ (++) Prescaler: A pulse of width less than two and greater than one PSC period(s) may or may\r
+ not be rejected. The receiver set up time should be managed by software. The IrDA physical layer\r
+ specification specifies a minimum of 10 ms delay between transmission and \r
+ reception (IrDA is a half duplex protocol).\r
+ (++) Mode: Receiver/transmitter modes\r
+ (++) IrDAMode: the IrDA can operate in the Normal mode or in the Low power mode.\r
+ [..]\r
+ The HAL_IRDA_Init() API follows IRDA configuration procedures (details for the procedures\r
+ are available in reference manual).\r
+\r
+@endverbatim\r
+ * @{\r
+ */\r
+\r
+/**\r
+ * @brief Initializes the IRDA mode according to the specified\r
+ * parameters in the IRDA_InitTypeDef and create the associated handle.\r
+ * @param hirda: pointer to a IRDA_HandleTypeDef structure that contains\r
+ * the configuration information for the specified IRDA module.\r
+ * @retval HAL status\r
+ */\r
+HAL_StatusTypeDef HAL_IRDA_Init(IRDA_HandleTypeDef *hirda)\r
+{\r
+ /* Check the IRDA handle allocation */\r
+ if(hirda == NULL)\r
+ {\r
+ return HAL_ERROR;\r
+ }\r
+\r
+ /* Check the USART/UART associated to the IRDA handle */\r
+ assert_param(IS_IRDA_INSTANCE(hirda->Instance));\r
+\r
+ if(hirda->State == HAL_IRDA_STATE_RESET)\r
+ {\r
+ /* Init the low level hardware : GPIO, CLOCK, CORTEX */\r
+ HAL_IRDA_MspInit(hirda);\r
+ }\r
+\r
+ hirda->State = HAL_IRDA_STATE_BUSY;\r
+\r
+ /* Disable the Peripheral to update the configuration registers */\r
+ __HAL_IRDA_DISABLE(hirda);\r
+\r
+ /* Set the IRDA Communication parameters */\r
+ IRDA_SetConfig(hirda);\r
+\r
+ /* In IRDA mode, the following bits must be kept cleared: \r
+ - LINEN, STOP and CLKEN bits in the USART_CR2 register,\r
+ - SCEN and HDSEL bits in the USART_CR3 register.*/\r
+ hirda->Instance->CR2 &= ~(USART_CR2_LINEN | USART_CR2_CLKEN | USART_CR2_STOP); \r
+ hirda->Instance->CR3 &= ~(USART_CR3_SCEN | USART_CR3_HDSEL); \r
+\r
+ /* set the UART/USART in IRDA mode */\r
+ hirda->Instance->CR3 |= USART_CR3_IREN; \r
+\r
+ /* Enable the Peripheral */\r
+ __HAL_IRDA_ENABLE(hirda);\r
+\r
+ /* TEACK and/or REACK to check before moving hirda->State to Ready */\r
+ return (IRDA_CheckIdleState(hirda));\r
+}\r
+\r
+/**\r
+ * @brief DeInitializes the IRDA peripheral \r
+ * @param hirda: pointer to a IRDA_HandleTypeDef structure that contains\r
+ * the configuration information for the specified IRDA module.\r
+ * @retval HAL status\r
+ */\r
+HAL_StatusTypeDef HAL_IRDA_DeInit(IRDA_HandleTypeDef *hirda)\r
+{\r
+ /* Check the IRDA handle allocation */\r
+ if(hirda == NULL)\r
+ {\r
+ return HAL_ERROR;\r
+ }\r
+ \r
+ /* Check the parameters */\r
+ assert_param(IS_IRDA_INSTANCE(hirda->Instance)); \r
+ \r
+ hirda->State = HAL_IRDA_STATE_BUSY;\r
+\r
+ /* DeInit the low level hardware */\r
+ HAL_IRDA_MspDeInit(hirda);\r
+ /* Disable the Peripheral */\r
+ __HAL_IRDA_DISABLE(hirda);\r
+\r
+ hirda->ErrorCode = HAL_IRDA_ERROR_NONE;\r
+ hirda->State = HAL_IRDA_STATE_RESET;\r
+\r
+ /* Release Lock */\r
+ __HAL_UNLOCK(hirda);\r
+\r
+ return HAL_OK;\r
+}\r
+\r
+/**\r
+ * @brief IRDA MSP Init.\r
+ * @param hirda: pointer to a IRDA_HandleTypeDef structure that contains\r
+ * the configuration information for the specified IRDA module.\r
+ * @retval None\r
+ */\r
+ __weak void HAL_IRDA_MspInit(IRDA_HandleTypeDef *hirda)\r
+{\r
+ /* NOTE : This function Should not be modified, when the callback is needed,\r
+ the HAL_IRDA_MspInit could be implemented in the user file\r
+ */ \r
+}\r
+\r
+/**\r
+ * @brief IRDA MSP DeInit.\r
+ * @param hirda: pointer to a IRDA_HandleTypeDef structure that contains\r
+ * the configuration information for the specified IRDA module.\r
+ * @retval None\r
+ */\r
+ __weak void HAL_IRDA_MspDeInit(IRDA_HandleTypeDef *hirda)\r
+{\r
+ /* NOTE : This function Should not be modified, when the callback is needed,\r
+ the HAL_IRDA_MspDeInit could be implemented in the user file\r
+ */ \r
+}\r
+\r
+/**\r
+ * @}\r
+ */\r
+\r
+/** @defgroup IRDA_Exported_Functions_Group2 IO operation functions \r
+ * @brief IRDA Transmit/Receive functions \r
+ *\r
+@verbatim \r
+ ===============================================================================\r
+ ##### IO operation functions #####\r
+ =============================================================================== \r
+ This subsection provides a set of functions allowing to manage the IRDA data transfers.\r
+ [..]\r
+ IrDA is a half duplex communication protocol. If the Transmitter is busy, any data\r
+ on the IrDA receive line will be ignored by the IrDA decoder and if the Receiver \r
+ is busy, data on the TX from the USART to IrDA will not be encoded by IrDA.\r
+ While receiving data, transmission should be avoided as the data to be transmitted\r
+ could be corrupted.\r
+\r
+ (#) There are two modes of transfer:\r
+ (++) Blocking mode: the communication is performed in polling mode. \r
+ The HAL status of all data processing is returned by the same function \r
+ after finishing transfer. \r
+ (++) No-Blocking mode: the communication is performed using Interrupts \r
+ or DMA, these API's return the HAL status.\r
+ The end of the data processing will be indicated through the \r
+ dedicated IRDA IRQ when using Interrupt mode or the DMA IRQ when \r
+ using DMA mode.\r
+ The HAL_IRDA_TxCpltCallback(), HAL_IRDA_RxCpltCallback() user callbacks \r
+ will be executed respectively at the end of the Transmit or Receive process\r
+ The HAL_IRDA_ErrorCallback() user callback will be executed when a communication error is detected\r
+\r
+ (#) Blocking mode API's are :\r
+ (++) HAL_IRDA_Transmit()\r
+ (++) HAL_IRDA_Receive() \r
+ \r
+ (#) Non-Blocking mode API's with Interrupt are :\r
+ (++) HAL_IRDA_Transmit_IT()\r
+ (++) HAL_IRDA_Receive_IT()\r
+ (++) HAL_IRDA_IRQHandler()\r
+ (++) IRDA_Transmit_IT()\r
+ (++) IRDA_Receive_IT()\r
+\r
+ (#) Non-Blocking mode functions with DMA are :\r
+ (++) HAL_IRDA_Transmit_DMA()\r
+ (++) HAL_IRDA_Receive_DMA()\r
+\r
+ (#) A set of Transfer Complete Callbacks are provided in No_Blocking mode:\r
+ (++) HAL_IRDA_TxCpltCallback()\r
+ (++) HAL_IRDA_RxCpltCallback()\r
+ (++) HAL_IRDA_ErrorCallback()\r
+ \r
+@endverbatim\r
+ * @{\r
+ */\r
+\r
+/**\r
+ * @brief Sends an amount of data in blocking mode.\r
+ * @param hirda: pointer to a IRDA_HandleTypeDef structure that contains\r
+ * the configuration information for the specified IRDA module.\r
+ * @param pData: Pointer to data buffer\r
+ * @param Size: Amount of data to be sent\r
+ * @param Timeout: Specify timeout value \r
+ * @retval HAL status\r
+ */\r
+HAL_StatusTypeDef HAL_IRDA_Transmit(IRDA_HandleTypeDef *hirda, uint8_t *pData, uint16_t Size, uint32_t Timeout)\r
+{\r
+ uint16_t* tmp;\r
+ \r
+ if ((hirda->State == HAL_IRDA_STATE_READY) || (hirda->State == HAL_IRDA_STATE_BUSY_RX)) \r
+ {\r
+ if((pData == NULL) || (Size == 0)) \r
+ {\r
+ return HAL_ERROR; \r
+ }\r
+ \r
+ /* Process Locked */\r
+ __HAL_LOCK(hirda);\r
+ hirda->ErrorCode = HAL_IRDA_ERROR_NONE;\r
+\r
+ if(hirda->State == HAL_IRDA_STATE_BUSY_RX) \r
+ {\r
+ hirda->State = HAL_IRDA_STATE_BUSY_TX_RX;\r
+ }\r
+ else\r
+ {\r
+ hirda->State = HAL_IRDA_STATE_BUSY_TX;\r
+ } \r
+ \r
+ hirda->TxXferSize = Size;\r
+ hirda->TxXferCount = Size;\r
+ while(hirda->TxXferCount > 0)\r
+ {\r
+ hirda->TxXferCount--;\r
+\r
+ if(IRDA_WaitOnFlagUntilTimeout(hirda, IRDA_FLAG_TXE, RESET, Timeout) != HAL_OK)\r
+ { \r
+ return HAL_TIMEOUT;\r
+ }\r
+ if ((hirda->Init.WordLength == IRDA_WORDLENGTH_9B) && (hirda->Init.Parity == IRDA_PARITY_NONE))\r
+ {\r
+ tmp = (uint16_t*) pData;\r
+ hirda->Instance->TDR = (*tmp & (uint16_t)0x01FF); \r
+ pData +=2;\r
+ }\r
+ else\r
+ { \r
+ hirda->Instance->TDR = (*pData++ & (uint8_t)0xFF); \r
+ }\r
+ } \r
+\r
+ if(IRDA_WaitOnFlagUntilTimeout(hirda, IRDA_FLAG_TC, RESET, Timeout) != HAL_OK)\r
+ { \r
+ return HAL_TIMEOUT;\r
+ } \r
+\r
+ if(hirda->State == HAL_IRDA_STATE_BUSY_TX_RX) \r
+ {\r
+ hirda->State = HAL_IRDA_STATE_BUSY_RX;\r
+ }\r
+ else\r
+ {\r
+ hirda->State = HAL_IRDA_STATE_READY;\r
+ } \r
+ \r
+ /* Process Unlocked */\r
+ __HAL_UNLOCK(hirda);\r
+ \r
+ return HAL_OK;\r
+ }\r
+ else\r
+ {\r
+ return HAL_BUSY; \r
+ }\r
+}\r
+\r
+/**\r
+ * @brief Receive an amount of data in blocking mode. \r
+ * @param hirda: pointer to a IRDA_HandleTypeDef structure that contains\r
+ * the configuration information for the specified IRDA module.\r
+ * @param pData: Pointer to data buffer\r
+ * @param Size: Amount of data to be received\r
+ * @param Timeout: Specify timeout value \r
+ * @retval HAL status\r
+ */\r
+HAL_StatusTypeDef HAL_IRDA_Receive(IRDA_HandleTypeDef *hirda, uint8_t *pData, uint16_t Size, uint32_t Timeout)\r
+{ \r
+ uint16_t* tmp;\r
+ uint16_t uhMask;\r
+ \r
+ if ((hirda->State == HAL_IRDA_STATE_READY) || (hirda->State == HAL_IRDA_STATE_BUSY_TX))\r
+ { \r
+ if((pData == NULL) || (Size == 0)) \r
+ {\r
+ return HAL_ERROR; \r
+ }\r
+ \r
+ /* Process Locked */\r
+ __HAL_LOCK(hirda);\r
+ hirda->ErrorCode = HAL_IRDA_ERROR_NONE;\r
+\r
+ if(hirda->State == HAL_IRDA_STATE_BUSY_TX) \r
+ {\r
+ hirda->State = HAL_IRDA_STATE_BUSY_TX_RX;\r
+ }\r
+ else\r
+ {\r
+ hirda->State = HAL_IRDA_STATE_BUSY_RX;\r
+ } \r
+ \r
+ hirda->RxXferSize = Size; \r
+ hirda->RxXferCount = Size;\r
+\r
+ /* Computation of the mask to apply to the RDR register \r
+ of the UART associated to the IRDA */\r
+ IRDA_MASK_COMPUTATION(hirda);\r
+ uhMask = hirda->Mask;\r
+\r
+ /* Check data remaining to be received */\r
+ while(hirda->RxXferCount > 0)\r
+ {\r
+ hirda->RxXferCount--;\r
+\r
+ if(IRDA_WaitOnFlagUntilTimeout(hirda, IRDA_FLAG_RXNE, RESET, Timeout) != HAL_OK)\r
+ { \r
+ return HAL_TIMEOUT;\r
+ } \r
+ if ((hirda->Init.WordLength == IRDA_WORDLENGTH_9B) && (hirda->Init.Parity == IRDA_PARITY_NONE))\r
+ {\r
+ tmp = (uint16_t*) pData ;\r
+ *tmp = (uint16_t)(hirda->Instance->RDR & uhMask);\r
+ pData +=2;\r
+ }\r
+ else\r
+ {\r
+ *pData++ = (uint8_t)(hirda->Instance->RDR & (uint8_t)uhMask); \r
+ } \r
+ } \r
+\r
+ if(hirda->State == HAL_IRDA_STATE_BUSY_TX_RX) \r
+ {\r
+ hirda->State = HAL_IRDA_STATE_BUSY_TX;\r
+ }\r
+ else\r
+ {\r
+ hirda->State = HAL_IRDA_STATE_READY;\r
+ }\r
+ \r
+ /* Process Unlocked */\r
+ __HAL_UNLOCK(hirda);\r
+ \r
+ return HAL_OK;\r
+ }\r
+ else\r
+ {\r
+ return HAL_BUSY; \r
+ }\r
+}\r
+\r
+/**\r
+ * @brief Send an amount of data in non blocking mode. \r
+ * @param hirda: pointer to a IRDA_HandleTypeDef structure that contains\r
+ * the configuration information for the specified IRDA module.\r
+ * @param pData: Pointer to data buffer\r
+ * @param Size: Amount of data to be sent\r
+ * @retval HAL status\r
+ */\r
+HAL_StatusTypeDef HAL_IRDA_Transmit_IT(IRDA_HandleTypeDef *hirda, uint8_t *pData, uint16_t Size)\r
+{\r
+ if ((hirda->State == HAL_IRDA_STATE_READY) || (hirda->State == HAL_IRDA_STATE_BUSY_RX))\r
+ {\r
+ if((pData == NULL) || (Size == 0)) \r
+ {\r
+ return HAL_ERROR;\r
+ }\r
+ \r
+ /* Process Locked */\r
+ __HAL_LOCK(hirda);\r
+ \r
+ hirda->pTxBuffPtr = pData;\r
+ hirda->TxXferSize = Size;\r
+ hirda->TxXferCount = Size;\r
+\r
+ hirda->ErrorCode = HAL_IRDA_ERROR_NONE;\r
+ if(hirda->State == HAL_IRDA_STATE_BUSY_RX) \r
+ {\r
+ hirda->State = HAL_IRDA_STATE_BUSY_TX_RX;\r
+ }\r
+ else\r
+ {\r
+ hirda->State = HAL_IRDA_STATE_BUSY_TX;\r
+ }\r
+ \r
+ /* Enable the IRDA Error Interrupt: (Frame error, noise error, overrun error) */\r
+ __HAL_IRDA_ENABLE_IT(hirda, IRDA_IT_ERR);\r
+ \r
+ /* Process Unlocked */\r
+ __HAL_UNLOCK(hirda); \r
+ \r
+ /* Enable the IRDA Transmit Complete Interrupt */\r
+ __HAL_IRDA_ENABLE_IT(hirda, IRDA_IT_TC);\r
+ \r
+ return HAL_OK;\r
+ }\r
+ else\r
+ {\r
+ return HAL_BUSY; \r
+ }\r
+}\r
+\r
+/**\r
+ * @brief Receives an amount of data in non blocking mode. \r
+ * @param hirda: pointer to a IRDA_HandleTypeDef structure that contains\r
+ * the configuration information for the specified IRDA module.\r
+ * @param pData: Pointer to data buffer\r
+ * @param Size: Amount of data to be received\r
+ * @retval HAL status\r
+ */\r
+HAL_StatusTypeDef HAL_IRDA_Receive_IT(IRDA_HandleTypeDef *hirda, uint8_t *pData, uint16_t Size)\r
+{ \r
+ if ((hirda->State == HAL_IRDA_STATE_READY) || (hirda->State == HAL_IRDA_STATE_BUSY_TX))\r
+ {\r
+ if((pData == NULL) || (Size == 0)) \r
+ {\r
+ return HAL_ERROR;\r
+ }\r
+ \r
+ /* Process Locked */\r
+ __HAL_LOCK(hirda);\r
+ \r
+ hirda->pRxBuffPtr = pData;\r
+ hirda->RxXferSize = Size;\r
+ hirda->RxXferCount = Size;\r
+ \r
+ /* Computation of the mask to apply to the RDR register \r
+ of the UART associated to the IRDA */\r
+ IRDA_MASK_COMPUTATION(hirda); \r
+ \r
+ hirda->ErrorCode = HAL_IRDA_ERROR_NONE; \r
+ if(hirda->State == HAL_IRDA_STATE_BUSY_TX) \r
+ {\r
+ hirda->State = HAL_IRDA_STATE_BUSY_TX_RX;\r
+ }\r
+ else\r
+ {\r
+ hirda->State = HAL_IRDA_STATE_BUSY_RX;\r
+ }\r
+ \r
+ /* Enable the IRDA Parity Error Interrupt */\r
+ __HAL_IRDA_ENABLE_IT(hirda, IRDA_IT_PE);\r
+ \r
+ /* Enable the IRDA Error Interrupt: (Frame error, noise error, overrun error) */\r
+ __HAL_IRDA_ENABLE_IT(hirda, IRDA_IT_ERR);\r
+ \r
+ /* Process Unlocked */\r
+ __HAL_UNLOCK(hirda);\r
+ \r
+ /* Enable the IRDA Data Register not empty Interrupt */\r
+ __HAL_IRDA_ENABLE_IT(hirda, IRDA_IT_RXNE);\r
+ \r
+ return HAL_OK;\r
+ }\r
+ else\r
+ {\r
+ return HAL_BUSY; \r
+ }\r
+}\r
+\r
+/**\r
+ * @brief Sends an amount of data in non blocking mode. \r
+ * @param hirda: pointer to a IRDA_HandleTypeDef structure that contains\r
+ * the configuration information for the specified IRDA module.\r
+ * @param pData: Pointer to data buffer\r
+ * @param Size: Amount of data to be sent\r
+ * @retval HAL status\r
+ */\r
+HAL_StatusTypeDef HAL_IRDA_Transmit_DMA(IRDA_HandleTypeDef *hirda, uint8_t *pData, uint16_t Size)\r
+{\r
+ uint32_t *tmp;\r
+ \r
+ if ((hirda->State == HAL_IRDA_STATE_READY) || (hirda->State == HAL_IRDA_STATE_BUSY_RX))\r
+ {\r
+ if((pData == NULL) || (Size == 0)) \r
+ {\r
+ return HAL_ERROR;\r
+ }\r
+ \r
+ /* Process Locked */\r
+ __HAL_LOCK(hirda);\r
+ \r
+ hirda->pTxBuffPtr = pData;\r
+ hirda->TxXferSize = Size;\r
+ hirda->TxXferCount = Size; \r
+ \r
+ hirda->ErrorCode = HAL_IRDA_ERROR_NONE;\r
+ \r
+ if(hirda->State == HAL_IRDA_STATE_BUSY_RX) \r
+ {\r
+ hirda->State = HAL_IRDA_STATE_BUSY_TX_RX;\r
+ }\r
+ else\r
+ {\r
+ hirda->State = HAL_IRDA_STATE_BUSY_TX;\r
+ }\r
+ \r
+ /* Set the IRDA DMA transfer complete callback */\r
+ hirda->hdmatx->XferCpltCallback = IRDA_DMATransmitCplt;\r
+ \r
+ /* Set the IRDA DMA half transfer complete callback */\r
+ hirda->hdmatx->XferHalfCpltCallback = IRDA_DMATransmitHalfCplt;\r
+\r
+ /* Set the DMA error callback */\r
+ hirda->hdmatx->XferErrorCallback = IRDA_DMAError;\r
+\r
+ /* Enable the IRDA transmit DMA channel */\r
+ tmp = (uint32_t*)&pData;\r
+ HAL_DMA_Start_IT(hirda->hdmatx, *(uint32_t*)tmp, (uint32_t)&hirda->Instance->TDR, Size);\r
+ \r
+ /* Clear the TC flag in the SR register by writing 0 to it */\r
+ __HAL_IRDA_CLEAR_IT(hirda, IRDA_FLAG_TC);\r
+ \r
+ /* Enable the DMA transfer for transmit request by setting the DMAT bit\r
+ in the IRDA CR3 register */\r
+ hirda->Instance->CR3 |= USART_CR3_DMAT;\r
+ \r
+ /* Process Unlocked */\r
+ __HAL_UNLOCK(hirda);\r
+ \r
+ return HAL_OK;\r
+ }\r
+ else\r
+ {\r
+ return HAL_BUSY; \r
+ }\r
+}\r
+\r
+/**\r
+ * @brief Receives an amount of data in non blocking mode. \r
+ * @param hirda: pointer to a IRDA_HandleTypeDef structure that contains\r
+ * the configuration information for the specified IRDA module.\r
+ * @param pData: Pointer to data buffer\r
+ * @param Size: Amount of data to be received\r
+ * @note When the IRDA parity is enabled (PCE = 1) the data received contain the parity bit.\r
+ * @retval HAL status\r
+ */\r
+HAL_StatusTypeDef HAL_IRDA_Receive_DMA(IRDA_HandleTypeDef *hirda, uint8_t *pData, uint16_t Size)\r
+{\r
+ uint32_t *tmp;\r
+ \r
+ if ((hirda->State == HAL_IRDA_STATE_READY) || (hirda->State == HAL_IRDA_STATE_BUSY_TX))\r
+ {\r
+ if((pData == NULL) || (Size == 0)) \r
+ {\r
+ return HAL_ERROR;\r
+ }\r
+ \r
+ /* Process Locked */\r
+ __HAL_LOCK(hirda);\r
+ \r
+ hirda->pRxBuffPtr = pData;\r
+ hirda->RxXferSize = Size;\r
+\r
+ hirda->ErrorCode = HAL_IRDA_ERROR_NONE;\r
+ if(hirda->State == HAL_IRDA_STATE_BUSY_TX) \r
+ {\r
+ hirda->State = HAL_IRDA_STATE_BUSY_TX_RX;\r
+ }\r
+ else\r
+ {\r
+ hirda->State = HAL_IRDA_STATE_BUSY_RX;\r
+ }\r
+ \r
+ /* Set the IRDA DMA transfer complete callback */\r
+ hirda->hdmarx->XferCpltCallback = IRDA_DMAReceiveCplt;\r
+ \r
+ /* Set the IRDA DMA half transfer complete callback */\r
+ hirda->hdmarx->XferHalfCpltCallback = IRDA_DMAReceiveHalfCplt;\r
+ \r
+ /* Set the DMA error callback */\r
+ hirda->hdmarx->XferErrorCallback = IRDA_DMAError;\r
+\r
+ /* Enable the DMA channel */\r
+ tmp = (uint32_t*)&pData;\r
+ HAL_DMA_Start_IT(hirda->hdmarx, (uint32_t)&hirda->Instance->RDR, *(uint32_t*)tmp, Size);\r
+\r
+ /* Enable the DMA transfer for the receiver request by setting the DMAR bit \r
+ in the IRDA CR3 register */\r
+ hirda->Instance->CR3 |= USART_CR3_DMAR;\r
+ \r
+ /* Process Unlocked */\r
+ __HAL_UNLOCK(hirda);\r
+ \r
+ return HAL_OK;\r
+ }\r
+ else\r
+ {\r
+ return HAL_BUSY; \r
+ }\r
+}\r
+\r
+/**\r
+ * @brief Pauses the DMA Transfer.\r
+ * @param hirda: pointer to a IRDA_HandleTypeDef structure that contains\r
+ * the configuration information for the specified IRDA module.\r
+ * @retval HAL status\r
+ */\r
+HAL_StatusTypeDef HAL_IRDA_DMAPause(IRDA_HandleTypeDef *hirda)\r
+{\r
+ /* Process Locked */\r
+ __HAL_LOCK(hirda);\r
+ \r
+ if(hirda->State == HAL_IRDA_STATE_BUSY_TX)\r
+ {\r
+ /* Disable the UART DMA Tx request */\r
+ hirda->Instance->CR3 &= (uint32_t)(~USART_CR3_DMAT);\r
+ }\r
+ else if(hirda->State == HAL_IRDA_STATE_BUSY_RX)\r
+ {\r
+ /* Disable the UART DMA Rx request */\r
+ hirda->Instance->CR3 &= (uint32_t)(~USART_CR3_DMAR);\r
+ }\r
+ else if (hirda->State == HAL_IRDA_STATE_BUSY_TX_RX)\r
+ {\r
+ /* Disable the UART DMA Tx & Rx requests */\r
+ hirda->Instance->CR3 &= (uint32_t)(~USART_CR3_DMAT);\r
+ hirda->Instance->CR3 &= (uint32_t)(~USART_CR3_DMAR);\r
+ }\r
+ \r
+ /* Process Unlocked */\r
+ __HAL_UNLOCK(hirda);\r
+ \r
+ return HAL_OK; \r
+}\r
+\r
+/**\r
+ * @brief Resumes the DMA Transfer.\r
+ * @param hirda: pointer to a IRDA_HandleTypeDef structure that contains\r
+ * the configuration information for the specified UART module.\r
+ * @retval HAL status\r
+ */\r
+HAL_StatusTypeDef HAL_IRDA_DMAResume(IRDA_HandleTypeDef *hirda)\r
+{\r
+ /* Process Locked */\r
+ __HAL_LOCK(hirda);\r
+ \r
+ if(hirda->State == HAL_IRDA_STATE_BUSY_TX)\r
+ {\r
+ /* Enable the UART DMA Tx request */\r
+ hirda->Instance->CR3 |= USART_CR3_DMAT;\r
+ }\r
+ else if(hirda->State == HAL_IRDA_STATE_BUSY_RX)\r
+ {\r
+ /* Clear the Overrun flag before resuming the Rx transfer*/\r
+ __HAL_IRDA_CLEAR_IT(hirda, IRDA_CLEAR_OREF);\r
+\r
+ /* Enable the UART DMA Rx request */\r
+ hirda->Instance->CR3 |= USART_CR3_DMAR;\r
+ }\r
+ else if(hirda->State == HAL_IRDA_STATE_BUSY_TX_RX)\r
+ {\r
+ /* Clear the Overrun flag before resuming the Rx transfer*/\r
+ __HAL_IRDA_CLEAR_IT(hirda, IRDA_CLEAR_OREF);\r
+ \r
+ /* Enable the UART DMA Tx & Rx request */\r
+ hirda->Instance->CR3 |= USART_CR3_DMAT;\r
+ hirda->Instance->CR3 |= USART_CR3_DMAR;\r
+ }\r
+ \r
+ /* Process Unlocked */\r
+ __HAL_UNLOCK(hirda);\r
+ \r
+ return HAL_OK;\r
+}\r
+\r
+/**\r
+ * @brief Stops the DMA Transfer.\r
+ * @param hirda: pointer to a IRDA_HandleTypeDef structure that contains\r
+ * the configuration information for the specified UART module.\r
+ * @retval HAL status\r
+ */\r
+HAL_StatusTypeDef HAL_IRDA_DMAStop(IRDA_HandleTypeDef *hirda)\r
+{\r
+ /* The Lock is not implemented on this API to allow the user application\r
+ to call the HAL UART API under callbacks HAL_UART_TxCpltCallback() / HAL_UART_RxCpltCallback():\r
+ when calling HAL_DMA_Abort() API the DMA TX/RX Transfer complete interrupt is generated\r
+ and the correspond call back is executed HAL_UART_TxCpltCallback() / HAL_UART_RxCpltCallback()\r
+ */\r
+\r
+ /* Disable the UART Tx/Rx DMA requests */\r
+ hirda->Instance->CR3 &= ~USART_CR3_DMAT;\r
+ hirda->Instance->CR3 &= ~USART_CR3_DMAR;\r
+ \r
+ /* Abort the UART DMA tx channel */\r
+ if(hirda->hdmatx != NULL)\r
+ {\r
+ HAL_DMA_Abort(hirda->hdmatx);\r
+ }\r
+ /* Abort the UART DMA rx channel */\r
+ if(hirda->hdmarx != NULL)\r
+ {\r
+ HAL_DMA_Abort(hirda->hdmarx);\r
+ }\r
+ \r
+ hirda->State = HAL_IRDA_STATE_READY;\r
+\r
+ return HAL_OK;\r
+}\r
+\r
+/**\r
+ * @brief This function handles IRDA interrupt request.\r
+ * @param hirda: pointer to a IRDA_HandleTypeDef structure that contains\r
+ * the configuration information for the specified IRDA module.\r
+ * @retval None\r
+ */\r
+void HAL_IRDA_IRQHandler(IRDA_HandleTypeDef *hirda)\r
+{\r
+ /* IRDA parity error interrupt occurred -------------------------------------*/\r
+ if((__HAL_IRDA_GET_IT(hirda, IRDA_IT_PE) != RESET) && (__HAL_IRDA_GET_IT_SOURCE(hirda, IRDA_IT_PE) != RESET))\r
+ { \r
+ __HAL_IRDA_CLEAR_IT(hirda, IRDA_CLEAR_PEF);\r
+\r
+ hirda->ErrorCode |= HAL_IRDA_ERROR_PE;\r
+ /* Set the IRDA state ready to be able to start again the process */\r
+ hirda->State = HAL_IRDA_STATE_READY;\r
+ }\r
+ \r
+ /* IRDA frame error interrupt occurred --------------------------------------*/\r
+ if((__HAL_IRDA_GET_IT(hirda, IRDA_IT_FE) != RESET) && (__HAL_IRDA_GET_IT_SOURCE(hirda, IRDA_IT_ERR) != RESET))\r
+ { \r
+ __HAL_IRDA_CLEAR_IT(hirda, IRDA_CLEAR_FEF);\r
+\r
+ hirda->ErrorCode |= HAL_IRDA_ERROR_FE;\r
+ /* Set the IRDA state ready to be able to start again the process */\r
+ hirda->State = HAL_IRDA_STATE_READY;\r
+ }\r
+ \r
+ /* IRDA noise error interrupt occurred --------------------------------------*/\r
+ if((__HAL_IRDA_GET_IT(hirda, IRDA_IT_NE) != RESET) && (__HAL_IRDA_GET_IT_SOURCE(hirda, IRDA_IT_ERR) != RESET))\r
+ { \r
+ __HAL_IRDA_CLEAR_IT(hirda, IRDA_CLEAR_NEF);\r
+\r
+ hirda->ErrorCode |= HAL_IRDA_ERROR_NE; \r
+ /* Set the IRDA state ready to be able to start again the process */\r
+ hirda->State = HAL_IRDA_STATE_READY;\r
+ }\r
+ \r
+ /* IRDA Over-Run interrupt occurred -----------------------------------------*/\r
+ if((__HAL_IRDA_GET_IT(hirda, IRDA_IT_ORE) != RESET) && (__HAL_IRDA_GET_IT_SOURCE(hirda, IRDA_IT_ERR) != RESET))\r
+ { \r
+ __HAL_IRDA_CLEAR_IT(hirda, IRDA_CLEAR_OREF);\r
+\r
+ hirda->ErrorCode |= HAL_IRDA_ERROR_ORE; \r
+ /* Set the IRDA state ready to be able to start again the process */\r
+ hirda->State = HAL_IRDA_STATE_READY;\r
+ }\r
+ \r
+ /* Call IRDA Error Call back function if need be --------------------------*/\r
+ if(hirda->ErrorCode != HAL_IRDA_ERROR_NONE)\r
+ {\r
+ HAL_IRDA_ErrorCallback(hirda);\r
+ } \r
+\r
+ /* IRDA in mode Receiver ---------------------------------------------------*/\r
+ if((__HAL_IRDA_GET_IT(hirda, IRDA_IT_RXNE) != RESET) && (__HAL_IRDA_GET_IT_SOURCE(hirda, IRDA_IT_RXNE) != RESET))\r
+ { \r
+ IRDA_Receive_IT(hirda);\r
+ /* Clear RXNE interrupt flag */\r
+ __HAL_IRDA_SEND_REQ(hirda, IRDA_RXDATA_FLUSH_REQUEST);\r
+ }\r
+ \r
+ /* IRDA in mode Transmitter ------------------------------------------------*/\r
+ if((__HAL_IRDA_GET_IT(hirda, IRDA_IT_TXE) != RESET) &&(__HAL_IRDA_GET_IT_SOURCE(hirda, IRDA_IT_TXE) != RESET))\r
+ {\r
+ IRDA_Transmit_IT(hirda);\r
+ } \r
+ \r
+}\r
+\r
+/**\r
+ * @brief Tx Transfer complete callbacks.\r
+ * @param hirda: pointer to a IRDA_HandleTypeDef structure that contains\r
+ * the configuration information for the specified IRDA module.\r
+ * @retval None\r
+ */\r
+ __weak void HAL_IRDA_TxHalfCpltCallback(IRDA_HandleTypeDef *hirda)\r
+{\r
+ /* NOTE : This function should not be modified, when the callback is needed,\r
+ the HAL_IRDA_TxHalfCpltCallback can be implemented in the user file\r
+ */ \r
+}\r
+\r
+/**\r
+ * @brief Tx Half Transfer completed callbacks.\r
+ * @param hirda: pointer to a IRDA_HandleTypeDef structure that contains\r
+ * the configuration information for the specified USART module.\r
+ * @retval None\r
+ */\r
+ __weak void HAL_IRDA_TxCpltCallback(IRDA_HandleTypeDef *hirda)\r
+{\r
+ /* NOTE : This function should not be modified, when the callback is needed,\r
+ the HAL_IRDA_TxCpltCallback can be implemented in the user file\r
+ */ \r
+}\r
+\r
+/**\r
+ * @brief Rx Transfer complete callbacks.\r
+ * @param hirda: pointer to a IRDA_HandleTypeDef structure that contains\r
+ * the configuration information for the specified IRDA module.\r
+ * @retval None\r
+ */\r
+__weak void HAL_IRDA_RxHalfCpltCallback(IRDA_HandleTypeDef *hirda)\r
+{\r
+ /* NOTE : This function should not be modified, when the callback is needed,\r
+ the HAL_IRDA_RxHalfCpltCallback can be implemented in the user file\r
+ */\r
+}\r
+\r
+/**\r
+ * @brief Rx Half Transfer complete callbacks.\r
+ * @param hirda: pointer to a IRDA_HandleTypeDef structure that contains\r
+ * the configuration information for the specified IRDA module.\r
+ * @retval None\r
+ */\r
+__weak void HAL_IRDA_RxCpltCallback(IRDA_HandleTypeDef *hirda)\r
+{\r
+ /* NOTE : This function should not be modified, when the callback is needed,\r
+ the HAL_IRDA_RxCpltCallback can be implemented in the user file\r
+ */\r
+}\r
+\r
+/**\r
+ * @brief IRDA error callbacks.\r
+ * @param hirda: pointer to a IRDA_HandleTypeDef structure that contains\r
+ * the configuration information for the specified IRDA module.\r
+ * @retval None\r
+ */\r
+ __weak void HAL_IRDA_ErrorCallback(IRDA_HandleTypeDef *hirda)\r
+{\r
+ /* NOTE : This function should not be modified, when the callback is needed,\r
+ the HAL_IRDA_ErrorCallback can be implemented in the user file\r
+ */ \r
+}\r
+\r
+/**\r
+ * @}\r
+ */\r
+\r
+/** @defgroup IRDA_Exported_Functions_Group3 Peripheral Control functions \r
+ * @brief IRDA control functions \r
+ *\r
+@verbatim \r
+ ===============================================================================\r
+ ##### Peripheral Control functions #####\r
+ =============================================================================== \r
+ [..]\r
+ This subsection provides a set of functions allowing to control the IRDA.\r
+ (+) HAL_IRDA_GetState() API can be helpful to check in run-time the state of the IRDA peripheral. \r
+ (+) IRDA_SetConfig() API is used to configure the IRDA communications parameters.\r
+@endverbatim\r
+ * @{\r
+ */\r
+\r
+/**\r
+ * @brief Returns the IRDA state.\r
+ * @param hirda: pointer to a IRDA_HandleTypeDef structure that contains\r
+ * the configuration information for the specified IRDA module.\r
+ * @retval HAL state\r
+ */\r
+HAL_IRDA_StateTypeDef HAL_IRDA_GetState(IRDA_HandleTypeDef *hirda)\r
+{\r
+ return hirda->State;\r
+}\r
+\r
+/**\r
+ * @brief Return the IRDA error code\r
+ * @param hirda : pointer to a IRDA_HandleTypeDef structure that contains\r
+ * the configuration information for the specified IRDA.\r
+* @retval IRDA Error Code\r
+*/\r
+uint32_t HAL_IRDA_GetError(IRDA_HandleTypeDef *hirda)\r
+{\r
+ return hirda->ErrorCode;\r
+}\r
+\r
+/**\r
+ * @}\r
+ */\r
+\r
+/**\r
+ * @brief Configure the IRDA peripheral \r
+ * @param hirda: irda handle\r
+ * @retval None\r
+ */\r
+static void IRDA_SetConfig(IRDA_HandleTypeDef *hirda)\r
+{\r
+ uint32_t tmpreg = 0x00000000;\r
+ uint32_t clocksource = 0x00000000;\r
+ \r
+ /* Check the communication parameters */ \r
+ assert_param(IS_IRDA_BAUDRATE(hirda->Init.BaudRate)); \r
+ assert_param(IS_IRDA_WORD_LENGTH(hirda->Init.WordLength));\r
+ assert_param(IS_IRDA_PARITY(hirda->Init.Parity));\r
+ assert_param(IS_IRDA_TX_RX_MODE(hirda->Init.Mode));\r
+ assert_param(IS_IRDA_PRESCALER(hirda->Init.Prescaler)); \r
+ assert_param(IS_IRDA_POWERMODE(hirda->Init.PowerMode)); \r
+ /*-------------------------- USART CR1 Configuration -----------------------*/ \r
+ /* Configure the IRDA Word Length, Parity and transfer Mode: \r
+ Set the M bits according to hirda->Init.WordLength value \r
+ Set PCE and PS bits according to hirda->Init.Parity value\r
+ Set TE and RE bits according to hirda->Init.Mode value */\r
+ tmpreg = (uint32_t)hirda->Init.WordLength | hirda->Init.Parity | hirda->Init.Mode ;\r
+ \r
+ MODIFY_REG(hirda->Instance->CR1, IRDA_CR1_FIELDS, tmpreg);\r
+ \r
+ /*-------------------------- USART CR3 Configuration -----------------------*/\r
+ MODIFY_REG(hirda->Instance->CR3, USART_CR3_IRLP, hirda->Init.PowerMode);\r
+ \r
+ /*-------------------------- USART GTPR Configuration ----------------------*/ \r
+ MODIFY_REG(hirda->Instance->GTPR, (uint32_t)USART_GTPR_PSC, hirda->Init.Prescaler);\r
+ \r
+ /*-------------------------- USART BRR Configuration -----------------------*/ \r
+ IRDA_GETCLOCKSOURCE(hirda, clocksource);\r
+ switch (clocksource)\r
+ {\r
+ case IRDA_CLOCKSOURCE_PCLK1: \r
+ hirda->Instance->BRR = (uint16_t)(HAL_RCC_GetPCLK1Freq() / hirda->Init.BaudRate);\r
+ break;\r
+ case IRDA_CLOCKSOURCE_PCLK2: \r
+ hirda->Instance->BRR = (uint16_t)(HAL_RCC_GetPCLK2Freq() / hirda->Init.BaudRate);\r
+ break;\r
+ case IRDA_CLOCKSOURCE_HSI: \r
+ hirda->Instance->BRR = (uint16_t)(HSI_VALUE / hirda->Init.BaudRate); \r
+ break; \r
+ case IRDA_CLOCKSOURCE_SYSCLK: \r
+ hirda->Instance->BRR = (uint16_t)(HAL_RCC_GetSysClockFreq() / hirda->Init.BaudRate);\r
+ break; \r
+ case IRDA_CLOCKSOURCE_LSE: \r
+ hirda->Instance->BRR = (uint16_t)(LSE_VALUE / hirda->Init.BaudRate); \r
+ break;\r
+ default:\r
+ break;\r
+ } \r
+}\r
+\r
+/**\r
+ * @brief Check the IRDA Idle State\r
+ * @param hirda: pointer to a IRDA_HandleTypeDef structure that contains\r
+ * the configuration information for the specified IRDA module.\r
+ * @retval HAL status\r
+ */\r
+static HAL_StatusTypeDef IRDA_CheckIdleState(IRDA_HandleTypeDef *hirda)\r
+{\r
+ /* Initialize the IRDA ErrorCode */\r
+ hirda->ErrorCode = HAL_IRDA_ERROR_NONE;\r
+ \r
+ /* Check if the Transmitter is enabled */\r
+ if((hirda->Instance->CR1 & USART_CR1_TE) == USART_CR1_TE)\r
+ {\r
+ /* Wait until TEACK flag is set */\r
+ if(IRDA_WaitOnFlagUntilTimeout(hirda, USART_ISR_TEACK, RESET, TEACK_REACK_TIMEOUT) != HAL_OK)\r
+ { \r
+ hirda->State= HAL_IRDA_STATE_TIMEOUT;\r
+ return HAL_TIMEOUT;\r
+ } \r
+ }\r
+ /* Check if the Receiver is enabled */\r
+ if((hirda->Instance->CR1 & USART_CR1_RE) == USART_CR1_RE)\r
+ {\r
+ if(IRDA_WaitOnFlagUntilTimeout(hirda, USART_ISR_REACK, RESET, TEACK_REACK_TIMEOUT) != HAL_OK)\r
+ { \r
+ hirda->State= HAL_IRDA_STATE_TIMEOUT;\r
+ return HAL_TIMEOUT;\r
+ } \r
+ }\r
+ /* Process Unlocked */\r
+ __HAL_UNLOCK(hirda);\r
+ \r
+ /* Initialize the IRDA state*/\r
+ hirda->State= HAL_IRDA_STATE_READY;\r
+ \r
+ return HAL_OK;\r
+}\r
+\r
+/**\r
+ * @brief This function handles IRDA Communication Timeout.\r
+ * @param hirda: pointer to a IRDA_HandleTypeDef structure that contains\r
+ * the configuration information for the specified IRDA module.\r
+ * @param Flag: specifies the IRDA flag to check.\r
+ * @param Status: The new Flag status (SET or RESET).\r
+ * @param Timeout: Timeout duration\r
+ * @retval HAL status\r
+ */\r
+static HAL_StatusTypeDef IRDA_WaitOnFlagUntilTimeout(IRDA_HandleTypeDef *hirda, uint32_t Flag, FlagStatus Status, uint32_t Timeout) \r
+{\r
+ uint32_t tickstart = 0x00;\r
+ tickstart = HAL_GetTick();\r
+ \r
+ /* Wait until flag is set */\r
+ if(Status == RESET)\r
+ {\r
+ while(__HAL_IRDA_GET_FLAG(hirda, Flag) == RESET)\r
+ {\r
+ /* Check for the Timeout */\r
+ if(Timeout != HAL_MAX_DELAY)\r
+ {\r
+ if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))\r
+ {\r
+ /* Disable TXE, RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts for the interrupt process */\r
+ __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_TXE);\r
+ __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_RXNE);\r
+ __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_PE);\r
+ __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_ERR);\r
+\r
+ hirda->State= HAL_IRDA_STATE_TIMEOUT;\r
+\r
+ /* Process Unlocked */\r
+ __HAL_UNLOCK(hirda);\r
+\r
+ return HAL_TIMEOUT;\r
+ }\r
+ }\r
+ }\r
+ }\r
+ else\r
+ {\r
+ while(__HAL_IRDA_GET_FLAG(hirda, Flag) != RESET)\r
+ {\r
+ /* Check for the Timeout */\r
+ if(Timeout != HAL_MAX_DELAY)\r
+ {\r
+ if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))\r
+ {\r
+ /* Disable TXE, RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts for the interrupt process */\r
+ __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_TXE);\r
+ __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_RXNE);\r
+ __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_PE);\r
+ __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_ERR);\r
+\r
+ hirda->State= HAL_IRDA_STATE_TIMEOUT;\r
+\r
+ /* Process Unlocked */\r
+ __HAL_UNLOCK(hirda);\r
+\r
+ return HAL_TIMEOUT;\r
+ }\r
+ }\r
+ }\r
+ }\r
+ return HAL_OK; \r
+}\r
+\r
+/**\r
+ * @brief Send an amount of data in non blocking mode. \r
+ * @param hirda: pointer to a IRDA_HandleTypeDef structure that contains\r
+ * the configuration information for the specified IRDA module.\r
+ * @retval HAL status\r
+ */\r
+static HAL_StatusTypeDef IRDA_Transmit_IT(IRDA_HandleTypeDef *hirda)\r
+{\r
+ uint16_t* tmp;\r
+ \r
+ if((hirda->State == HAL_IRDA_STATE_BUSY_TX) || (hirda->State == HAL_IRDA_STATE_BUSY_TX_RX))\r
+ {\r
+ if(hirda->TxXferCount == 0)\r
+ {\r
+ /* Disable the IRDA Transmit Complete Interrupt */\r
+ __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_TXE);\r
+ \r
+ if(hirda->State == HAL_IRDA_STATE_BUSY_TX_RX) \r
+ {\r
+ hirda->State = HAL_IRDA_STATE_BUSY_RX;\r
+ }\r
+ else\r
+ {\r
+ /* Disable the IRDA Error Interrupt: (Frame error, noise error, overrun error) */\r
+ __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_ERR);\r
+ \r
+ hirda->State = HAL_IRDA_STATE_READY;\r
+ }\r
+\r
+ HAL_IRDA_TxCpltCallback(hirda);\r
+ \r
+ return HAL_OK;\r
+ }\r
+ else\r
+ {\r
+ if ((hirda->Init.WordLength == IRDA_WORDLENGTH_9B) && (hirda->Init.Parity == IRDA_PARITY_NONE))\r
+ {\r
+ tmp = (uint16_t*) hirda->pTxBuffPtr;\r
+ hirda->Instance->TDR = (*tmp & (uint16_t)0x01FF);\r
+ hirda->pTxBuffPtr += 2;\r
+ }\r
+ else\r
+ {\r
+ hirda->Instance->TDR = (uint8_t)(*hirda->pTxBuffPtr++ & (uint8_t)0xFF); \r
+ }\r
+ hirda->TxXferCount--;\r
+ return HAL_OK;\r
+ }\r
+ }\r
+ else\r
+ {\r
+ return HAL_BUSY;\r
+ }\r
+}\r
+\r
+/**\r
+ * @brief Receive an amount of data in non blocking mode. \r
+ * Function called under interruption only, once\r
+ * interruptions have been enabled by HAL_IRDA_Receive_IT()\r
+ * @param hirda: pointer to a IRDA_HandleTypeDef structure that contains\r
+ * the configuration information for the specified IRDA module.\r
+ * @retval HAL status\r
+ */\r
+static HAL_StatusTypeDef IRDA_Receive_IT(IRDA_HandleTypeDef *hirda)\r
+{\r
+ uint16_t* tmp;\r
+ uint16_t uhMask = hirda->Mask;\r
+ \r
+ if ((hirda->State == HAL_IRDA_STATE_BUSY_RX) || (hirda->State == HAL_IRDA_STATE_BUSY_TX_RX))\r
+ {\r
+ if ((hirda->Init.WordLength == IRDA_WORDLENGTH_9B) && (hirda->Init.Parity == IRDA_PARITY_NONE))\r
+ {\r
+ tmp = (uint16_t*) hirda->pRxBuffPtr ;\r
+ *tmp = (uint16_t)(hirda->Instance->RDR & uhMask);\r
+ hirda->pRxBuffPtr +=2;\r
+ }\r
+ else\r
+ {\r
+ *hirda->pRxBuffPtr++ = (uint8_t)(hirda->Instance->RDR & (uint8_t)uhMask); \r
+ }\r
+ \r
+ if(--hirda->RxXferCount == 0)\r
+ {\r
+ while(HAL_IS_BIT_SET(hirda->Instance->ISR, IRDA_FLAG_RXNE))\r
+ {\r
+ }\r
+ __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_RXNE);\r
+ \r
+ if(hirda->State == HAL_IRDA_STATE_BUSY_TX_RX) \r
+ {\r
+ hirda->State = HAL_IRDA_STATE_BUSY_TX;\r
+ }\r
+ else\r
+ { \r
+ /* Disable the IRDA Parity Error Interrupt */\r
+ __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_PE);\r
+ \r
+ /* Disable the IRDA Error Interrupt: (Frame error, noise error, overrun error) */\r
+ __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_ERR);\r
+ \r
+ hirda->State = HAL_IRDA_STATE_READY;\r
+ }\r
+ \r
+ HAL_IRDA_RxCpltCallback(hirda);\r
+ \r
+ return HAL_OK;\r
+ }\r
+ \r
+ return HAL_OK;\r
+ }\r
+ else\r
+ {\r
+ return HAL_BUSY; \r
+ }\r
+}\r
+ \r
+/**\r
+ * @brief DMA IRDA Tx transfer completed callback \r
+ * @param hirda: pointer to a IRDA_HandleTypeDef structure that contains\r
+ * the configuration information for the specified IRDA module.\r
+ * @retval None\r
+ */\r
+static void IRDA_DMATransmitCplt(DMA_HandleTypeDef *hdma) \r
+{\r
+ IRDA_HandleTypeDef* hirda = ( IRDA_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;\r
+ \r
+ /* DMA Normal mode */\r
+ if((hdma->Instance->CR & DMA_SxCR_CIRC) == 0)\r
+ {\r
+ hirda->TxXferCount = 0;\r
+ \r
+ /* Disable the DMA transfer for transmit request by setting the DMAT bit\r
+ in the IRDA CR3 register */\r
+ hirda->Instance->CR3 &= (uint16_t)~((uint16_t)USART_CR3_DMAT);\r
+ \r
+ /* Wait for IRDA TC Flag */\r
+ if(IRDA_WaitOnFlagUntilTimeout(hirda, IRDA_FLAG_TC, RESET, HAL_IRDA_TXDMA_TIMEOUTVALUE) != HAL_OK)\r
+ {\r
+ /* Timeout Occured */ \r
+ hirda->State = HAL_IRDA_STATE_TIMEOUT;\r
+ HAL_IRDA_ErrorCallback(hirda);\r
+ }\r
+ else\r
+ {\r
+ /* No Timeout */\r
+ \r
+ if(hirda->State == HAL_IRDA_STATE_BUSY_TX_RX)\r
+ {\r
+ hirda->State = HAL_IRDA_STATE_BUSY_RX;\r
+ }\r
+ else\r
+ {\r
+ hirda->State = HAL_IRDA_STATE_READY;\r
+ }\r
+ HAL_IRDA_TxCpltCallback(hirda);\r
+ }\r
+ }\r
+ /* DMA Circular mode */\r
+ else\r
+ {\r
+ HAL_IRDA_TxCpltCallback(hirda);\r
+ }\r
+}\r
+\r
+/**\r
+ * @brief DMA IRDA receive process half complete callback \r
+ * @param hdma: pointer to a DMA_HandleTypeDef structure that contains\r
+ * the configuration information for the specified DMA module.\r
+ * @retval None\r
+ */\r
+static void IRDA_DMATransmitHalfCplt(DMA_HandleTypeDef *hdma)\r
+{\r
+ IRDA_HandleTypeDef* hirda = ( IRDA_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;\r
+\r
+ HAL_IRDA_TxHalfCpltCallback(hirda); \r
+}\r
+\r
+/**\r
+ * @brief DMA IRDA Rx Transfer completed callback \r
+ * @param hdma: DMA handle\r
+ * @retval None\r
+ */\r
+static void IRDA_DMAReceiveCplt(DMA_HandleTypeDef *hdma) \r
+{\r
+ IRDA_HandleTypeDef* hirda = ( IRDA_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;\r
+ /* DMA Normal mode */\r
+ if((hdma->Instance->CR & DMA_SxCR_CIRC) == 0)\r
+ {\r
+ hirda->RxXferCount = 0;\r
+ \r
+ /* Disable the DMA transfer for the receiver request by setting the DMAR bit \r
+ in the IRDA CR3 register */\r
+ hirda->Instance->CR3 &= (uint16_t)~((uint16_t)USART_CR3_DMAR);\r
+ \r
+ if(hirda->State == HAL_IRDA_STATE_BUSY_TX_RX) \r
+ {\r
+ hirda->State = HAL_IRDA_STATE_BUSY_TX;\r
+ }\r
+ else\r
+ {\r
+ hirda->State = HAL_IRDA_STATE_READY;\r
+ }\r
+ }\r
+ \r
+ HAL_IRDA_RxCpltCallback(hirda);\r
+}\r
+\r
+/**\r
+ * @brief DMA IRDA receive process half complete callback \r
+ * @param hdma: pointer to a DMA_HandleTypeDef structure that contains\r
+ * the configuration information for the specified DMA module.\r
+ * @retval None\r
+ */\r
+static void IRDA_DMAReceiveHalfCplt(DMA_HandleTypeDef *hdma)\r
+{\r
+ IRDA_HandleTypeDef* hirda = ( IRDA_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;\r
+\r
+ HAL_IRDA_RxHalfCpltCallback(hirda); \r
+}\r
+\r
+/**\r
+ * @brief DMA IRDA communication error callback \r
+ * @param hdma: DMA handle\r
+ * @retval None\r
+ */\r
+static void IRDA_DMAError(DMA_HandleTypeDef *hdma) \r
+{\r
+ IRDA_HandleTypeDef* hirda = ( IRDA_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;\r
+ hirda->RxXferCount = 0;\r
+ hirda->TxXferCount = 0;\r
+ hirda->State= HAL_IRDA_STATE_READY;\r
+ hirda->ErrorCode |= HAL_IRDA_ERROR_DMA;\r
+ HAL_IRDA_ErrorCallback(hirda);\r
+}\r
+\r
+/**\r
+ * @}\r
+ */\r
+\r
+/**\r
+ * @}\r
+ */\r
+\r
+#endif /* HAL_IRDA_MODULE_ENABLED */\r
+\r
+/**\r
+ * @}\r
+ */\r
+\r
+/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/\r
+\r
projects / freertos / blobdiff