]> git.gir.st - tmk_keyboard.git/blob - tool/mbed/mbed-sdk/libraries/mbed/targets/cmsis/TARGET_STM/TARGET_STM32F1/stm32f1xx_hal_irda.c
git://git.gir.st / tmk_keyboard.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Squashed 'tmk_core/' changes from 7967731..b9e0ea0
[tmk_keyboard.git] / tool / mbed / mbed-sdk / libraries / mbed / targets / cmsis / TARGET_STM / TARGET_STM32F1 / stm32f1xx_hal_irda.c
1 /**
2 ******************************************************************************
3 * @file stm32f1xx_hal_irda.c
4 * @author MCD Application Team
5 * @version V1.0.0
6 * @date 15-December-2014
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 State and Errors functions
13 * + Peripheral Control functions
14 *
15 @verbatim
16 ==============================================================================
17 ##### How to use this driver #####
18 ==============================================================================
19 [..]
20 The IRDA HAL driver can be used as follows:
21
22 (#) Declare a IRDA_HandleTypeDef handle structure.
23 (#) Initialize the IRDA low level resources by implementing the HAL_IRDA_MspInit() API:
24 (##) Enable the USARTx interface clock.
25 (##) IRDA pins configuration:
26 (+++) Enable the clock for the IRDA GPIOs.
27 (+++) Configure the USART pins (TX as alternate function pull-up, RX as alternate function Input).
28 (##) NVIC configuration if you need to use interrupt process (HAL_IRDA_Transmit_IT()
29 and HAL_IRDA_Receive_IT() APIs):
30 (+++) Configure the USARTx interrupt priority.
31 (+++) Enable the NVIC USART IRQ handle.
32 (##) DMA Configuration if you need to use DMA process (HAL_IRDA_Transmit_DMA()
33 and HAL_IRDA_Receive_DMA() APIs):
34 (+++) Declare a DMA handle structure for the Tx/Rx channel.
35 (+++) Enable the DMAx interface clock.
36 (+++) Configure the declared DMA handle structure with the required Tx/Rx parameters.
37 (+++) Configure the DMA Tx/Rx channel.
38 (+++) Associate the initilalized DMA handle to the IRDA DMA Tx/Rx handle.
39 (+++) Configure the priority and enable the NVIC for the transfer complete interrupt on the DMA Tx/Rx channel.
40 (+++) Configure the USARTx interrupt priority and enable the NVIC USART IRQ handle
41 (used for last byte sending completion detection in DMA non circular mode)
42
43 (#) Program the Baud Rate, Word Length, Parity, IrDA Mode, Prescaler
44 and Mode(Receiver/Transmitter) in the hirda Init structure.
45
46 (#) Initialize the IRDA registers by calling the HAL_IRDA_Init() API:
47 (++) This API configures also the low level Hardware GPIO, CLOCK, CORTEX...etc)
48 by calling the customed HAL_IRDA_MspInit() API.
49
50 -@@- The specific IRDA interrupts (Transmission complete interrupt,
51 RXNE interrupt and Error Interrupts) will be managed using the macros
52 __HAL_IRDA_ENABLE_IT() and __HAL_IRDA_DISABLE_IT() inside the transmit and receive process.
53
54 (#) Three operation modes are available within this driver :
55
56 *** Polling mode IO operation ***
57 =================================
58 [..]
59 (+) Send an amount of data in blocking mode using HAL_IRDA_Transmit()
60 (+) Receive an amount of data in blocking mode using HAL_IRDA_Receive()
61
62 *** Interrupt mode IO operation ***
63 ===================================
64 [..]
65 (+) Send an amount of data in non blocking mode using HAL_IRDA_Transmit_IT()
66 (+) At transmission end of transfer HAL_IRDA_TxCpltCallback is executed and user can
67 add his own code by customization of function pointer HAL_IRDA_TxCpltCallback
68 (+) Receive an amount of data in non blocking mode using HAL_IRDA_Receive_IT()
69 (+) At reception end of transfer HAL_IRDA_RxCpltCallback is executed and user can
70 add his own code by customization of function pointer HAL_IRDA_RxCpltCallback
71 (+) In case of transfer Error, HAL_IRDA_ErrorCallback() function is executed and user can
72 add his own code by customization of function pointer HAL_IRDA_ErrorCallback
73
74 *** DMA mode IO operation ***
75 ==============================
76 [..]
77 (+) Send an amount of data in non blocking mode (DMA) using HAL_IRDA_Transmit_DMA()
78 (+) At transmission end of transfer HAL_IRDA_TxCpltCallback is executed and user can
79 add his own code by customization of function pointer HAL_IRDA_TxCpltCallback
80 (+) Receive an amount of data in non blocking mode (DMA) using HAL_IRDA_Receive_DMA()
81 (+) At reception end of transfer HAL_IRDA_RxCpltCallback is executed and user can
82 add his own code by customization of function pointer HAL_IRDA_RxCpltCallback
83 (+) In case of transfer Error, HAL_IRDA_ErrorCallback() function is executed and user can
84 add his own code by customization of function pointer HAL_IRDA_ErrorCallback
85
86 *** IRDA HAL driver macros list ***
87 ====================================
88 [..]
89 Below the list of most used macros in IRDA HAL driver.
90
91 (+) __HAL_IRDA_ENABLE: Enable the IRDA peripheral
92 (+) __HAL_IRDA_DISABLE: Disable the IRDA peripheral
93 (+) __HAL_IRDA_GET_FLAG : Check whether the specified IRDA flag is set or not
94 (+) __HAL_IRDA_CLEAR_FLAG : Clear the specified IRDA pending flag
95 (+) __HAL_IRDA_ENABLE_IT: Enable the specified IRDA interrupt
96 (+) __HAL_IRDA_DISABLE_IT: Disable the specified IRDA interrupt
97 (+) __HAL_IRDA_GET_IT_SOURCE: Check whether the specified IRDA interrupt has occurred or not
98
99 [..]
100 (@) You can refer to the IRDA HAL driver header file for more useful macros
101
102 @endverbatim
103 ******************************************************************************
104 * @attention
105 *
106 * <h2><center>&copy; COPYRIGHT(c) 2014 STMicroelectronics</center></h2>
107 *
108 * Redistribution and use in source and binary forms, with or without modification,
109 * are permitted provided that the following conditions are met:
110 * 1. Redistributions of source code must retain the above copyright notice,
111 * this list of conditions and the following disclaimer.
112 * 2. Redistributions in binary form must reproduce the above copyright notice,
113 * this list of conditions and the following disclaimer in the documentation
114 * and/or other materials provided with the distribution.
115 * 3. Neither the name of STMicroelectronics nor the names of its contributors
116 * may be used to endorse or promote products derived from this software
117 * without specific prior written permission.
118 *
119 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
120 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
121 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
122 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
123 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
124 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
125 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
126 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
127 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
128 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
129 *
130 ******************************************************************************
131 */
132
133 /* Includes ------------------------------------------------------------------*/
134 #include "stm32f1xx_hal.h"
135
136 /** @addtogroup STM32F1xx_HAL_Driver
137 * @{
138 */
139
140 /** @defgroup IRDA IRDA
141 * @brief HAL IRDA module driver
142 * @{
143 */
144
145 #ifdef HAL_IRDA_MODULE_ENABLED
146
147 /* Private typedef -----------------------------------------------------------*/
148 /* Private define ------------------------------------------------------------*/
149 /** @defgroup IRDA_Private_Constants IRDA Private Constants
150 * @{
151 */
152 #define IRDA_DR_MASK_U16_8DATABITS (uint16_t)0x00FF
153 #define IRDA_DR_MASK_U16_9DATABITS (uint16_t)0x01FF
154
155 #define IRDA_DR_MASK_U8_7DATABITS (uint8_t)0x7F
156 #define IRDA_DR_MASK_U8_8DATABITS (uint8_t)0xFF
157
158
159 /**
160 * @}
161 */
162
163 /* Private macros --------------------------------------------------------*/
164 /* Private variables ---------------------------------------------------------*/
165 /* Private function prototypes -----------------------------------------------*/
166 /** @addtogroup IRDA_Private_Functions IRDA Private Functions
167 * @{
168 */
169 static HAL_StatusTypeDef IRDA_Transmit_IT(IRDA_HandleTypeDef *hirda);
170 static HAL_StatusTypeDef IRDA_EndTransmit_IT(IRDA_HandleTypeDef *hirda);
171 static HAL_StatusTypeDef IRDA_Receive_IT(IRDA_HandleTypeDef *hirda);
172 static void IRDA_SetConfig (IRDA_HandleTypeDef *hirda);
173 static void IRDA_DMATransmitCplt(DMA_HandleTypeDef *hdma);
174 static void IRDA_DMATransmitHalfCplt(DMA_HandleTypeDef *hdma);
175 static void IRDA_DMAReceiveCplt(DMA_HandleTypeDef *hdma);
176 static void IRDA_DMAReceiveHalfCplt(DMA_HandleTypeDef *hdma);
177 static void IRDA_DMAError(DMA_HandleTypeDef *hdma);
178 static HAL_StatusTypeDef IRDA_WaitOnFlagUntilTimeout(IRDA_HandleTypeDef *hirda, uint32_t Flag, FlagStatus Status, uint32_t Timeout);
179 /**
180 * @}
181 */
182
183 /* Exported functions ---------------------------------------------------------*/
184
185 /** @defgroup IRDA_Exported_Functions IRDA Exported Functions
186 * @{
187 */
188
189 /** @defgroup IRDA_Exported_Functions_Group1 Initialization and de-initialization functions
190 * @brief Initialization and Configuration functions
191 *
192 @verbatim
193 ==============================================================================
194 ##### Initialization and Configuration functions #####
195 ==============================================================================
196 [..]
197 This subsection provides a set of functions allowing to initialize the USARTx or the UARTy
198 in IrDA mode.
199 (+) For the asynchronous mode only these parameters can be configured:
200 (++) Baud Rate
201 (++) Word Length
202 (++) Parity: If the parity is enabled, then the MSB bit of the data written
203 in the data register is transmitted but is changed by the parity bit.
204 Depending on the frame length defined by the M bit (8-bits or 9-bits),
205 the possible IRDA frame formats are as listed in the following table:
206 (+++) +-------------------------------------------------------------+
207 (+++) | M bit | PCE bit | IRDA frame |
208 (+++) |---------------------|---------------------------------------|
209 (+++) | 0 | 0 | | SB | 8 bit data | STB | |
210 (+++) |---------|-----------|---------------------------------------|
211 (+++) | 0 | 1 | | SB | 7 bit data | PB | STB | |
212 (+++) |---------|-----------|---------------------------------------|
213 (+++) | 1 | 0 | | SB | 9 bit data | STB | |
214 (+++) |---------|-----------|---------------------------------------|
215 (+++) | 1 | 1 | | SB | 8 bit data | PB | STB | |
216 (+++) +-------------------------------------------------------------+
217 (++) Prescaler: A pulse of width less than two and greater than one PSC period(s) may or may
218 not be rejected. The receiver set up time should be managed by software. The IrDA physical layer
219 specification specifies a minimum of 10 ms delay between transmission and
220 reception (IrDA is a half duplex protocol).
221 (++) Mode: Receiver/transmitter modes
222 (++) IrDAMode: the IrDA can operate in the Normal mode or in the Low power mode.
223
224 [..]
225 The HAL_IRDA_Init() function follows IRDA configuration procedures (details for the procedures
226 are available in reference manuals (RM0008 for STM32F10Xxx MCUs and RM0041 for STM32F100xx MCUs)).
227
228 @endverbatim
229 * @{
230 */
231
232 /**
233 * @brief Initializes the IRDA mode according to the specified
234 * parameters in the IRDA_InitTypeDef and create the associated handle.
235 * @param hirda: Pointer to a IRDA_HandleTypeDef structure that contains
236 * the configuration information for the specified IRDA module.
237 * @retval HAL status
238 */
239 HAL_StatusTypeDef HAL_IRDA_Init(IRDA_HandleTypeDef *hirda)
240 {
241 /* Check the IRDA handle allocation */
242 if(hirda == NULL)
243 {
244 return HAL_ERROR;
245 }
246
247 /* Check the IRDA instance parameters */
248 assert_param(IS_IRDA_INSTANCE(hirda->Instance));
249 /* Check the IRDA mode parameter in the IRDA handle */
250 assert_param(IS_IRDA_POWERMODE(hirda->Init.IrDAMode));
251
252 if(hirda->State == HAL_IRDA_STATE_RESET)
253 {
254 /* Allocate lock resource and initialize it */
255 hirda-> Lock = HAL_UNLOCKED;
256
257 /* Init the low level hardware */
258 HAL_IRDA_MspInit(hirda);
259 }
260
261 hirda->State = HAL_IRDA_STATE_BUSY;
262
263 /* Disable the IRDA peripheral */
264 __HAL_IRDA_DISABLE(hirda);
265
266 /* Set the IRDA communication parameters */
267 IRDA_SetConfig(hirda);
268
269 /* In IrDA mode, the following bits must be kept cleared:
270 - LINEN, STOP and CLKEN bits in the USART_CR2 register,
271 - SCEN and HDSEL bits in the USART_CR3 register.*/
272 CLEAR_BIT(hirda->Instance->CR2, (USART_CR2_LINEN | USART_CR2_STOP | USART_CR2_CLKEN));
273 CLEAR_BIT(hirda->Instance->CR3, (USART_CR3_SCEN | USART_CR3_HDSEL));
274
275 /* Enable the IRDA peripheral */
276 __HAL_IRDA_ENABLE(hirda);
277
278 /* Set the prescaler */
279 MODIFY_REG(hirda->Instance->GTPR, USART_GTPR_PSC, hirda->Init.Prescaler);
280
281 /* Configure the IrDA mode */
282 MODIFY_REG(hirda->Instance->CR3, USART_CR3_IRLP, hirda->Init.IrDAMode);
283
284 /* Enable the IrDA mode by setting the IREN bit in the CR3 register */
285 SET_BIT(hirda->Instance->CR3, USART_CR3_IREN);
286
287 /* Initialize the IRDA state*/
288 hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
289 hirda->State= HAL_IRDA_STATE_READY;
290
291 return HAL_OK;
292 }
293
294 /**
295 * @brief DeInitializes the IRDA peripheral
296 * @param hirda: Pointer to a IRDA_HandleTypeDef structure that contains
297 * the configuration information for the specified IRDA module.
298 * @retval HAL status
299 */
300 HAL_StatusTypeDef HAL_IRDA_DeInit(IRDA_HandleTypeDef *hirda)
301 {
302 /* Check the IRDA handle allocation */
303 if(hirda == NULL)
304 {
305 return HAL_ERROR;
306 }
307
308 /* Check the parameters */
309 assert_param(IS_IRDA_INSTANCE(hirda->Instance));
310
311 hirda->State = HAL_IRDA_STATE_BUSY;
312
313 /* Disable the Peripheral */
314 __HAL_IRDA_DISABLE(hirda);
315
316 /* DeInit the low level hardware */
317 HAL_IRDA_MspDeInit(hirda);
318
319 hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
320 hirda->State = HAL_IRDA_STATE_RESET;
321
322 /* Release Lock */
323 __HAL_UNLOCK(hirda);
324
325 return HAL_OK;
326 }
327
328 /**
329 * @brief IRDA MSP Init.
330 * @param hirda: Pointer to a IRDA_HandleTypeDef structure that contains
331 * the configuration information for the specified IRDA module.
332 * @retval None
333 */
334 __weak void HAL_IRDA_MspInit(IRDA_HandleTypeDef *hirda)
335 {
336 /* NOTE: This function should not be modified, when the callback is needed,
337 the HAL_IRDA_MspInit can be implemented in the user file
338 */
339 }
340
341 /**
342 * @brief IRDA MSP DeInit.
343 * @param hirda: Pointer to a IRDA_HandleTypeDef structure that contains
344 * the configuration information for the specified IRDA module.
345 * @retval None
346 */
347 __weak void HAL_IRDA_MspDeInit(IRDA_HandleTypeDef *hirda)
348 {
349 /* NOTE: This function should not be modified, when the callback is needed,
350 the HAL_IRDA_MspDeInit can be implemented in the user file
351 */
352 }
353
354 /**
355 * @}
356 */
357
358 /** @defgroup IRDA_Exported_Functions_Group2 IO operation functions
359 * @brief IRDA Transmit and Receive functions
360 *
361 @verbatim
362 ==============================================================================
363 ##### IO operation functions #####
364 ==============================================================================
365 [..]
366 This subsection provides a set of functions allowing to manage the IRDA data transfers.
367
368 [..]
369 IrDA is a half duplex communication protocol. If the Transmitter is busy, any data
370 on the IrDA receive line will be ignored by the IrDA decoder and if the Receiver
371 is busy, data on the TX from the USART to IrDA will not be encoded by IrDA.
372 While receiving data, transmission should be avoided as the data to be transmitted
373 could be corrupted.
374
375 (#) There are two modes of transfer:
376 (++) Blocking mode: The communication is performed in polling mode.
377 The HAL status of all data processing is returned by the same function
378 after finishing transfer.
379 (++) No-Blocking mode: The communication is performed using Interrupts
380 or DMA, These API's return the HAL status.
381 The end of the data processing will be indicated through the
382 dedicated IRDA IRQ when using Interrupt mode or the DMA IRQ when
383 using DMA mode.
384 The HAL_IRDA_TxCpltCallback(), HAL_IRDA_RxCpltCallback() user callbacks
385 will be executed respectively at the end of the transmit or Receive process
386 The HAL_IRDA_ErrorCallback() user callback will be executed when a communication
387 error is detected
388
389 (#) Blocking mode APIs are :
390 (++) HAL_IRDA_Transmit()
391 (++) HAL_IRDA_Receive()
392
393 (#) Non Blocking mode APIs with Interrupt are :
394 (++) HAL_IRDA_Transmit_IT()
395 (++) HAL_IRDA_Receive_IT()
396 (++) HAL_IRDA_IRQHandler()
397
398 (#) Non Blocking mode functions with DMA are :
399 (++) HAL_IRDA_Transmit_DMA()
400 (++) HAL_IRDA_Receive_DMA()
401 (++) HAL_IRDA_DMAPause()
402 (++) HAL_IRDA_DMAResume()
403 (++) HAL_IRDA_DMAStop()
404
405 (#) A set of Transfer Complete Callbacks are provided in non Blocking mode:
406 (++) HAL_IRDA_TxHalfCpltCallback()
407 (++) HAL_IRDA_TxCpltCallback()
408 (++) HAL_IRDA_RxHalfCpltCallback()
409 (++) HAL_IRDA_RxCpltCallback()
410 (++) HAL_IRDA_ErrorCallback()
411
412 @endverbatim
413 * @{
414 */
415
416 /**
417 * @brief Sends an amount of data in blocking mode.
418 * @param hirda: Pointer to a IRDA_HandleTypeDef structure that contains
419 * the configuration information for the specified IRDA module.
420 * @param pData: Pointer to data buffer
421 * @param Size: Amount of data to be sent
422 * @param Timeout: Specify timeout value
423 * @retval HAL status
424 */
425 HAL_StatusTypeDef HAL_IRDA_Transmit(IRDA_HandleTypeDef *hirda, uint8_t *pData, uint16_t Size, uint32_t Timeout)
426 {
427 uint16_t* tmp = 0;
428 uint32_t tmp_state = 0;
429
430 tmp_state = hirda->State;
431 if((tmp_state == HAL_IRDA_STATE_READY) || (tmp_state == HAL_IRDA_STATE_BUSY_RX))
432 {
433 if((pData == NULL) || (Size == 0))
434 {
435 return HAL_ERROR;
436 }
437
438 /* Process Locked */
439 __HAL_LOCK(hirda);
440
441 hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
442 if(hirda->State == HAL_IRDA_STATE_BUSY_RX)
443 {
444 hirda->State = HAL_IRDA_STATE_BUSY_TX_RX;
445 }
446 else
447 {
448 hirda->State = HAL_IRDA_STATE_BUSY_TX;
449 }
450
451 hirda->TxXferSize = Size;
452 hirda->TxXferCount = Size;
453 while(hirda->TxXferCount > 0)
454 {
455 if(hirda->Init.WordLength == IRDA_WORDLENGTH_9B)
456 {
457 if(IRDA_WaitOnFlagUntilTimeout(hirda, IRDA_FLAG_TXE, RESET, Timeout) != HAL_OK)
458 {
459 return HAL_TIMEOUT;
460 }
461 tmp = (uint16_t*) pData;
462 WRITE_REG(hirda->Instance->DR,(*tmp & IRDA_DR_MASK_U16_9DATABITS));
463 if(hirda->Init.Parity == IRDA_PARITY_NONE)
464 {
465 pData +=2;
466 }
467 else
468 {
469 pData +=1;
470 }
471 }
472 else
473 {
474 if(IRDA_WaitOnFlagUntilTimeout(hirda, IRDA_FLAG_TXE, RESET, Timeout) != HAL_OK)
475 {
476 return HAL_TIMEOUT;
477 }
478 WRITE_REG(hirda->Instance->DR, (*pData++ & IRDA_DR_MASK_U8_8DATABITS));
479 }
480 hirda->TxXferCount--;
481 }
482
483 if(IRDA_WaitOnFlagUntilTimeout(hirda, IRDA_FLAG_TC, RESET, Timeout) != HAL_OK)
484 {
485 return HAL_TIMEOUT;
486 }
487
488 if(hirda->State == HAL_IRDA_STATE_BUSY_TX_RX)
489 {
490 hirda->State = HAL_IRDA_STATE_BUSY_RX;
491 }
492 else
493 {
494 hirda->State = HAL_IRDA_STATE_READY;
495 }
496
497 /* Process Unlocked */
498 __HAL_UNLOCK(hirda);
499
500 return HAL_OK;
501 }
502 else
503 {
504 return HAL_BUSY;
505 }
506 }
507
508 /**
509 * @brief Receive an amount of data in blocking mode.
510 * @param hirda: Pointer to a IRDA_HandleTypeDef structure that contains
511 * the configuration information for the specified IRDA module.
512 * @param pData: Pointer to data buffer
513 * @param Size: Amount of data to be received
514 * @param Timeout: Specify timeout value
515 * @retval HAL status
516 */
517 HAL_StatusTypeDef HAL_IRDA_Receive(IRDA_HandleTypeDef *hirda, uint8_t *pData, uint16_t Size, uint32_t Timeout)
518 {
519 uint16_t* tmp = 0;
520 uint32_t tmp_state = 0;
521
522 tmp_state = hirda->State;
523 if((tmp_state == HAL_IRDA_STATE_READY) || (tmp_state == HAL_IRDA_STATE_BUSY_TX))
524 {
525 if((pData == NULL) || (Size == 0))
526 {
527 return HAL_ERROR;
528 }
529
530 /* Process Locked */
531 __HAL_LOCK(hirda);
532
533 hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
534 if(hirda->State == HAL_IRDA_STATE_BUSY_TX)
535 {
536 hirda->State = HAL_IRDA_STATE_BUSY_TX_RX;
537 }
538 else
539 {
540 hirda->State = HAL_IRDA_STATE_BUSY_RX;
541 }
542 hirda->RxXferSize = Size;
543 hirda->RxXferCount = Size;
544 /* Check the remain data to be received */
545 while(hirda->RxXferCount > 0)
546 {
547 if(hirda->Init.WordLength == IRDA_WORDLENGTH_9B)
548 {
549 if(IRDA_WaitOnFlagUntilTimeout(hirda, IRDA_FLAG_RXNE, RESET, Timeout) != HAL_OK)
550 {
551 return HAL_TIMEOUT;
552 }
553 tmp = (uint16_t*) pData ;
554 if(hirda->Init.Parity == IRDA_PARITY_NONE)
555 {
556 *tmp = (uint16_t)(hirda->Instance->DR & IRDA_DR_MASK_U16_9DATABITS);
557 pData +=2;
558 }
559 else
560 {
561 *tmp = (uint16_t)(hirda->Instance->DR & IRDA_DR_MASK_U16_8DATABITS);
562 pData +=1;
563 }
564 }
565 else
566 {
567 if(IRDA_WaitOnFlagUntilTimeout(hirda, IRDA_FLAG_RXNE, RESET, Timeout) != HAL_OK)
568 {
569 return HAL_TIMEOUT;
570 }
571 if(hirda->Init.Parity == IRDA_PARITY_NONE)
572 {
573 *pData++ = (uint8_t)(hirda->Instance->DR & IRDA_DR_MASK_U8_8DATABITS);
574 }
575 else
576 {
577 *pData++ = (uint8_t)(hirda->Instance->DR & IRDA_DR_MASK_U8_7DATABITS);
578 }
579 }
580 hirda->RxXferCount--;
581 }
582 if(hirda->State == HAL_IRDA_STATE_BUSY_TX_RX)
583 {
584 hirda->State = HAL_IRDA_STATE_BUSY_TX;
585 }
586 else
587 {
588 hirda->State = HAL_IRDA_STATE_READY;
589 }
590
591 /* Process Unlocked */
592 __HAL_UNLOCK(hirda);
593
594 return HAL_OK;
595 }
596 else
597 {
598 return HAL_BUSY;
599 }
600 }
601
602 /**
603 * @brief Sends an amount of data in non-blocking mode.
604 * @param hirda: Pointer to a IRDA_HandleTypeDef structure that contains
605 * the configuration information for the specified IRDA module.
606 * @param pData: Pointer to data buffer
607 * @param Size: Amount of data to be sent
608 * @retval HAL status
609 */
610 HAL_StatusTypeDef HAL_IRDA_Transmit_IT(IRDA_HandleTypeDef *hirda, uint8_t *pData, uint16_t Size)
611 {
612 uint32_t tmp_state = 0;
613
614 tmp_state = hirda->State;
615 if((tmp_state == HAL_IRDA_STATE_READY) || (tmp_state == HAL_IRDA_STATE_BUSY_RX))
616 {
617 if((pData == NULL) || (Size == 0))
618 {
619 return HAL_ERROR;
620 }
621 /* Process Locked */
622 __HAL_LOCK(hirda);
623
624 hirda->pTxBuffPtr = pData;
625 hirda->TxXferSize = Size;
626 hirda->TxXferCount = Size;
627
628 hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
629 if(hirda->State == HAL_IRDA_STATE_BUSY_RX)
630 {
631 hirda->State = HAL_IRDA_STATE_BUSY_TX_RX;
632 }
633 else
634 {
635 hirda->State = HAL_IRDA_STATE_BUSY_TX;
636 }
637
638 /* Process Unlocked */
639 __HAL_UNLOCK(hirda);
640
641 /* Enable the IRDA Error Interrupt: (Frame error, noise error, overrun error) */
642 __HAL_IRDA_ENABLE_IT(hirda, IRDA_IT_ERR);
643
644 /* Enable the IRDA Transmit Data Register Empty Interrupt */
645 __HAL_IRDA_ENABLE_IT(hirda, IRDA_IT_TXE);
646
647 return HAL_OK;
648 }
649 else
650 {
651 return HAL_BUSY;
652 }
653 }
654
655 /**
656 * @brief Receives an amount of data in non-blocking mode.
657 * @param hirda: Pointer to a IRDA_HandleTypeDef structure that contains
658 * the configuration information for the specified IRDA module.
659 * @param pData: Pointer to data buffer
660 * @param Size: Amount of data to be received
661 * @retval HAL status
662 */
663 HAL_StatusTypeDef HAL_IRDA_Receive_IT(IRDA_HandleTypeDef *hirda, uint8_t *pData, uint16_t Size)
664 {
665 uint32_t tmp_state = 0;
666
667 tmp_state = hirda->State;
668 if((tmp_state == HAL_IRDA_STATE_READY) || (tmp_state == HAL_IRDA_STATE_BUSY_TX))
669 {
670 if((pData == NULL) || (Size == 0))
671 {
672 return HAL_ERROR;
673 }
674
675 /* Process Locked */
676 __HAL_LOCK(hirda);
677
678 hirda->pRxBuffPtr = pData;
679 hirda->RxXferSize = Size;
680 hirda->RxXferCount = Size;
681
682 hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
683 if(hirda->State == HAL_IRDA_STATE_BUSY_TX)
684 {
685 hirda->State = HAL_IRDA_STATE_BUSY_TX_RX;
686 }
687 else
688 {
689 hirda->State = HAL_IRDA_STATE_BUSY_RX;
690 }
691
692 /* Process Unlocked */
693 __HAL_UNLOCK(hirda);
694
695 /* Enable the IRDA Data Register not empty Interrupt */
696 __HAL_IRDA_ENABLE_IT(hirda, IRDA_IT_RXNE);
697
698 /* Enable the IRDA Parity Error Interrupt */
699 __HAL_IRDA_ENABLE_IT(hirda, IRDA_IT_PE);
700
701 /* Enable the IRDA Error Interrupt: (Frame error, noise error, overrun error) */
702 __HAL_IRDA_ENABLE_IT(hirda, IRDA_IT_ERR);
703
704 return HAL_OK;
705 }
706 else
707 {
708 return HAL_BUSY;
709 }
710 }
711
712 /**
713 * @brief Sends an amount of data in non-blocking mode.
714 * @param hirda: Pointer to a IRDA_HandleTypeDef structure that contains
715 * the configuration information for the specified IRDA module.
716 * @param pData: Pointer to data buffer
717 * @param Size: Amount of data to be sent
718 * @retval HAL status
719 */
720 HAL_StatusTypeDef HAL_IRDA_Transmit_DMA(IRDA_HandleTypeDef *hirda, uint8_t *pData, uint16_t Size)
721 {
722 uint32_t *tmp = 0;
723 uint32_t tmp_state = 0;
724
725 tmp_state = hirda->State;
726 if((tmp_state == HAL_IRDA_STATE_READY) || (tmp_state == HAL_IRDA_STATE_BUSY_RX))
727 {
728 if((pData == NULL) || (Size == 0))
729 {
730 return HAL_ERROR;
731 }
732
733 /* Process Locked */
734 __HAL_LOCK(hirda);
735
736 hirda->pTxBuffPtr = pData;
737 hirda->TxXferSize = Size;
738 hirda->TxXferCount = Size;
739 hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
740
741 if(hirda->State == HAL_IRDA_STATE_BUSY_RX)
742 {
743 hirda->State = HAL_IRDA_STATE_BUSY_TX_RX;
744 }
745 else
746 {
747 hirda->State = HAL_IRDA_STATE_BUSY_TX;
748 }
749
750 /* Set the IRDA DMA transfer complete callback */
751 hirda->hdmatx->XferCpltCallback = IRDA_DMATransmitCplt;
752
753 /* Set the IRDA DMA half transfert complete callback */
754 hirda->hdmatx->XferHalfCpltCallback = IRDA_DMATransmitHalfCplt;
755
756 /* Set the DMA error callback */
757 hirda->hdmatx->XferErrorCallback = IRDA_DMAError;
758
759 /* Enable the IRDA transmit DMA channel */
760 tmp = (uint32_t*)&pData;
761 HAL_DMA_Start_IT(hirda->hdmatx, *(uint32_t*)tmp, (uint32_t)&hirda->Instance->DR, Size);
762
763 /* Clear the TC flag in the SR register by writing 0 to it */
764 __HAL_IRDA_CLEAR_FLAG(hirda, IRDA_FLAG_TC);
765
766 /* Enable the DMA transfer for transmit request by setting the DMAT bit
767 in the USART CR3 register */
768 SET_BIT(hirda->Instance->CR3, USART_CR3_DMAT);
769
770 /* Process Unlocked */
771 __HAL_UNLOCK(hirda);
772
773 return HAL_OK;
774 }
775 else
776 {
777 return HAL_BUSY;
778 }
779 }
780
781 /**
782 * @brief Receive an amount of data in non-blocking mode.
783 * @param hirda: Pointer to a IRDA_HandleTypeDef structure that contains
784 * the configuration information for the specified IRDA module.
785 * @param pData: Pointer to data buffer
786 * @param Size: Amount of data to be received
787 * @note When the IRDA parity is enabled (PCE = 1) the data received contain the parity bit.
788 * @retval HAL status
789 */
790 HAL_StatusTypeDef HAL_IRDA_Receive_DMA(IRDA_HandleTypeDef *hirda, uint8_t *pData, uint16_t Size)
791 {
792 uint32_t *tmp = 0;
793 uint32_t tmp_state = 0;
794
795 tmp_state = hirda->State;
796 if((tmp_state == HAL_IRDA_STATE_READY) || (tmp_state == HAL_IRDA_STATE_BUSY_TX))
797 {
798 if((pData == NULL) || (Size == 0))
799 {
800 return HAL_ERROR;
801 }
802
803 /* Process Locked */
804 __HAL_LOCK(hirda);
805
806 hirda->pRxBuffPtr = pData;
807 hirda->RxXferSize = Size;
808 hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
809 if(hirda->State == HAL_IRDA_STATE_BUSY_TX)
810 {
811 hirda->State = HAL_IRDA_STATE_BUSY_TX_RX;
812 }
813 else
814 {
815 hirda->State = HAL_IRDA_STATE_BUSY_RX;
816 }
817
818 /* Set the IRDA DMA transfer complete callback */
819 hirda->hdmarx->XferCpltCallback = IRDA_DMAReceiveCplt;
820
821 /* Set the IRDA DMA half transfert complete callback */
822 hirda->hdmarx->XferHalfCpltCallback = IRDA_DMAReceiveHalfCplt;
823
824 /* Set the DMA error callback */
825 hirda->hdmarx->XferErrorCallback = IRDA_DMAError;
826
827 /* Enable the DMA channel */
828 tmp = (uint32_t*)&pData;
829 HAL_DMA_Start_IT(hirda->hdmarx, (uint32_t)&hirda->Instance->DR, *(uint32_t*)tmp, Size);
830
831 /* Enable the DMA transfer for the receiver request by setting the DMAR bit
832 in the USART CR3 register */
833 SET_BIT(hirda->Instance->CR3, USART_CR3_DMAR);
834
835 /* Process Unlocked */
836 __HAL_UNLOCK(hirda);
837
838 return HAL_OK;
839 }
840 else
841 {
842 return HAL_BUSY;
843 }
844 }
845
846 /**
847 * @brief Pauses the DMA Transfer.
848 * @param hirda: Pointer to a IRDA_HandleTypeDef structure that contains
849 * the configuration information for the specified IRDA module.
850 * @retval HAL status
851 */
852 HAL_StatusTypeDef HAL_IRDA_DMAPause(IRDA_HandleTypeDef *hirda)
853 {
854 /* Process Locked */
855 __HAL_LOCK(hirda);
856
857 if(hirda->State == HAL_IRDA_STATE_BUSY_TX)
858 {
859 /* Disable the IRDA DMA Tx request */
860 CLEAR_BIT(hirda->Instance->CR3, USART_CR3_DMAT);
861 }
862 else if(hirda->State == HAL_IRDA_STATE_BUSY_RX)
863 {
864 /* Disable the IRDA DMA Rx request */
865 CLEAR_BIT(hirda->Instance->CR3, USART_CR3_DMAR);
866 }
867 else if (hirda->State == HAL_IRDA_STATE_BUSY_TX_RX)
868 {
869 /* Disable the IRDA DMA Tx & Rx requests */
870 CLEAR_BIT(hirda->Instance->CR3, (USART_CR3_DMAT | USART_CR3_DMAR));
871 }
872 else
873 {
874 /* Process Unlocked */
875 __HAL_UNLOCK(hirda);
876
877 return HAL_ERROR;
878 }
879
880 /* Process Unlocked */
881 __HAL_UNLOCK(hirda);
882
883 return HAL_OK;
884 }
885
886 /**
887 * @brief Resumes the DMA Transfer.
888 * @param hirda: Pointer to a IRDA_HandleTypeDef structure that contains
889 * the configuration information for the specified UART module.
890 * @retval HAL status
891 */
892 HAL_StatusTypeDef HAL_IRDA_DMAResume(IRDA_HandleTypeDef *hirda)
893 {
894 /* Process Locked */
895 __HAL_LOCK(hirda);
896
897 if(hirda->State == HAL_IRDA_STATE_BUSY_TX)
898 {
899 /* Enable the IRDA DMA Tx request */
900 SET_BIT(hirda->Instance->CR3, USART_CR3_DMAT);
901 }
902 else if(hirda->State == HAL_IRDA_STATE_BUSY_RX)
903 {
904 /* Clear the Overrun flag before resumming the Rx transfer*/
905 __HAL_IRDA_CLEAR_OREFLAG(hirda);
906 /* Enable the IRDA DMA Rx request */
907 SET_BIT(hirda->Instance->CR3, USART_CR3_DMAR);
908 }
909 else if(hirda->State == HAL_IRDA_STATE_BUSY_TX_RX)
910 {
911 /* Clear the Overrun flag before resumming the Rx transfer*/
912 __HAL_IRDA_CLEAR_OREFLAG(hirda);
913 /* Enable the IRDA DMA Tx & Rx request */
914 SET_BIT(hirda->Instance->CR3, (USART_CR3_DMAT | USART_CR3_DMAR));
915 }
916 else
917 {
918 /* Process Unlocked */
919 __HAL_UNLOCK(hirda);
920
921 return HAL_ERROR;
922 }
923
924 /* Process Unlocked */
925 __HAL_UNLOCK(hirda);
926
927 return HAL_OK;
928 }
929
930 /**
931 * @brief Stops the DMA Transfer.
932 * @param hirda: Pointer to a IRDA_HandleTypeDef structure that contains
933 * the configuration information for the specified UART module.
934 * @retval HAL status
935 */
936 HAL_StatusTypeDef HAL_IRDA_DMAStop(IRDA_HandleTypeDef *hirda)
937 {
938 /* The Lock is not implemented on this API to allow the user application
939 to call the HAL IRDA API under callbacks HAL_IRDA_TxCpltCallback() / HAL_IRDA_RxCpltCallback():
940 when calling HAL_DMA_Abort() API the DMA TX/RX Transfer complete interrupt is generated
941 and the correspond call back is executed HAL_IRDA_TxCpltCallback() / HAL_IRDA_RxCpltCallback()
942 */
943
944 /* Disable the IRDA Tx/Rx DMA requests */
945 CLEAR_BIT(hirda->Instance->CR3, USART_CR3_DMAT);
946 CLEAR_BIT(hirda->Instance->CR3, USART_CR3_DMAR);
947
948 /* Abort the IRDA DMA tx channel */
949 if(hirda->hdmatx != NULL)
950 {
951 HAL_DMA_Abort(hirda->hdmatx);
952 }
953 /* Abort the IRDA DMA rx channel */
954 if(hirda->hdmarx != NULL)
955 {
956 HAL_DMA_Abort(hirda->hdmarx);
957 }
958
959 hirda->State = HAL_IRDA_STATE_READY;
960
961 return HAL_OK;
962 }
963
964 /**
965 * @brief This function handles IRDA interrupt request.
966 * @param hirda: Pointer to a IRDA_HandleTypeDef structure that contains
967 * the configuration information for the specified IRDA module.
968 * @retval None
969 */
970 void HAL_IRDA_IRQHandler(IRDA_HandleTypeDef *hirda)
971 {
972 uint32_t tmp_flag = 0, tmp_it_source = 0;
973
974 tmp_flag = __HAL_IRDA_GET_FLAG(hirda, IRDA_FLAG_PE);
975 tmp_it_source = __HAL_IRDA_GET_IT_SOURCE(hirda, IRDA_IT_PE);
976 /* IRDA parity error interrupt occurred -----------------------------------*/
977 if((tmp_flag != RESET) && (tmp_it_source != RESET))
978 {
979 __HAL_IRDA_CLEAR_PEFLAG(hirda);
980 hirda->ErrorCode |= HAL_IRDA_ERROR_PE;
981 }
982
983 tmp_flag = __HAL_IRDA_GET_FLAG(hirda, IRDA_FLAG_FE);
984 tmp_it_source = __HAL_IRDA_GET_IT_SOURCE(hirda, IRDA_IT_ERR);
985 /* IRDA frame error interrupt occurred ------------------------------------*/
986 if((tmp_flag != RESET) && (tmp_it_source != RESET))
987 {
988 __HAL_IRDA_CLEAR_FEFLAG(hirda);
989 hirda->ErrorCode |= HAL_IRDA_ERROR_FE;
990 }
991
992 tmp_flag = __HAL_IRDA_GET_FLAG(hirda, IRDA_FLAG_NE);
993 /* IRDA noise error interrupt occurred ------------------------------------*/
994 if((tmp_flag != RESET) && (tmp_it_source != RESET))
995 {
996 __HAL_IRDA_CLEAR_NEFLAG(hirda);
997 hirda->ErrorCode |= HAL_IRDA_ERROR_NE;
998 }
999
1000 tmp_flag = __HAL_IRDA_GET_FLAG(hirda, IRDA_FLAG_ORE);
1001 /* IRDA Over-Run interrupt occurred ---------------------------------------*/
1002 if((tmp_flag != RESET) && (tmp_it_source != RESET))
1003 {
1004 __HAL_IRDA_CLEAR_OREFLAG(hirda);
1005 hirda->ErrorCode |= HAL_IRDA_ERROR_ORE;
1006 }
1007
1008 /* Call the Error call Back in case of Errors */
1009 if(hirda->ErrorCode != HAL_IRDA_ERROR_NONE)
1010 {
1011 /* Disable PE and ERR interrupt */
1012 __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_ERR);
1013 __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_PE);
1014 __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_TXE);
1015
1016 /* Set the IRDA state ready to be able to start again the process */
1017 hirda->State = HAL_IRDA_STATE_READY;
1018 HAL_IRDA_ErrorCallback(hirda);
1019 }
1020
1021 tmp_flag = __HAL_IRDA_GET_FLAG(hirda, IRDA_FLAG_RXNE);
1022 tmp_it_source = __HAL_IRDA_GET_IT_SOURCE(hirda, IRDA_IT_RXNE);
1023 /* IRDA in mode Receiver --------------------------------------------------*/
1024 if((tmp_flag != RESET) && (tmp_it_source != RESET))
1025 {
1026 IRDA_Receive_IT(hirda);
1027 }
1028
1029 tmp_flag = __HAL_IRDA_GET_FLAG(hirda, IRDA_FLAG_TXE);
1030 tmp_it_source = __HAL_IRDA_GET_IT_SOURCE(hirda, IRDA_IT_TXE);
1031 /* IRDA in mode Transmitter -----------------------------------------------*/
1032 if((tmp_flag != RESET) && (tmp_it_source != RESET))
1033 {
1034 IRDA_Transmit_IT(hirda);
1035 }
1036
1037 tmp_flag = __HAL_IRDA_GET_FLAG(hirda, IRDA_FLAG_TC);
1038 tmp_it_source = __HAL_IRDA_GET_IT_SOURCE(hirda, IRDA_IT_TC);
1039 /* IRDA in mode Transmitter (transmission end) -----------------------------*/
1040 if((tmp_flag != RESET) && (tmp_it_source != RESET))
1041 {
1042 IRDA_EndTransmit_IT(hirda);
1043 }
1044
1045 }
1046
1047 /**
1048 * @brief Tx Transfer completed callbacks.
1049 * @param hirda: Pointer to a IRDA_HandleTypeDef structure that contains
1050 * the configuration information for the specified IRDA module.
1051 * @retval None
1052 */
1053 __weak void HAL_IRDA_TxCpltCallback(IRDA_HandleTypeDef *hirda)
1054 {
1055 /* NOTE: This function should not be modified, when the callback is needed,
1056 the HAL_IRDA_TxCpltCallback can be implemented in the user file
1057 */
1058 }
1059
1060 /**
1061 * @brief Tx Half Transfer completed callbacks.
1062 * @param hirda: Pointer to a IRDA_HandleTypeDef structure that contains
1063 * the configuration information for the specified USART module.
1064 * @retval None
1065 */
1066 __weak void HAL_IRDA_TxHalfCpltCallback(IRDA_HandleTypeDef *hirda)
1067 {
1068 /* NOTE: This function should not be modified, when the callback is needed,
1069 the HAL_IRDA_TxHalfCpltCallback can be implemented in the user file
1070 */
1071 }
1072
1073 /**
1074 * @brief Rx Transfer completed callbacks.
1075 * @param hirda: Pointer to a IRDA_HandleTypeDef structure that contains
1076 * the configuration information for the specified IRDA module.
1077 * @retval None
1078 */
1079 __weak void HAL_IRDA_RxCpltCallback(IRDA_HandleTypeDef *hirda)
1080 {
1081 /* NOTE: This function should not be modified, when the callback is needed,
1082 the HAL_IRDA_RxCpltCallback can be implemented in the user file
1083 */
1084 }
1085
1086 /**
1087 * @brief Rx Half Transfer complete callbacks.
1088 * @param hirda: Pointer to a IRDA_HandleTypeDef structure that contains
1089 * the configuration information for the specified IRDA module.
1090 * @retval None
1091 */
1092 __weak void HAL_IRDA_RxHalfCpltCallback(IRDA_HandleTypeDef *hirda)
1093 {
1094 /* NOTE : This function should not be modified, when the callback is needed,
1095 the HAL_IRDA_RxHalfCpltCallback can be implemented in the user file
1096 */
1097 }
1098
1099 /**
1100 * @brief IRDA error callbacks.
1101 * @param hirda: Pointer to a IRDA_HandleTypeDef structure that contains
1102 * the configuration information for the specified IRDA module.
1103 * @retval None
1104 */
1105 __weak void HAL_IRDA_ErrorCallback(IRDA_HandleTypeDef *hirda)
1106 {
1107 /* NOTE: This function should not be modified, when the callback is needed,
1108 the HAL_IRDA_ErrorCallback can be implemented in the user file
1109 */
1110 }
1111
1112 /**
1113 * @}
1114 */
1115
1116 /** @defgroup IRDA_Exported_Functions_Group3 Peripheral State and Errors functions
1117 * @brief IRDA State and Errors functions
1118 *
1119 @verbatim
1120 ==============================================================================
1121 ##### Peripheral State and Errors functions #####
1122 ==============================================================================
1123 [..]
1124 This subsection provides a set of functions allowing to return the State of IrDA
1125 communication process and also return Peripheral Errors occurred during communication process
1126 (+) HAL_IRDA_GetState() API can be helpful to check in run-time the state
1127 of the IRDA peripheral.
1128 (+) HAL_IRDA_GetError() check in run-time errors that could be occurred during
1129 communication.
1130
1131 @endverbatim
1132 * @{
1133 */
1134
1135 /**
1136 * @brief Returns the IRDA state.
1137 * @param hirda: Pointer to a IRDA_HandleTypeDef structure that contains
1138 * the configuration information for the specified IRDA module.
1139 * @retval HAL state
1140 */
1141 HAL_IRDA_StateTypeDef HAL_IRDA_GetState(IRDA_HandleTypeDef *hirda)
1142 {
1143 return hirda->State;
1144 }
1145
1146 /**
1147 * @brief Return the IRDA error code
1148 * @param hirda: Pointer to a IRDA_HandleTypeDef structure that contains
1149 * the configuration information for the specified IRDA module.
1150 * @retval IRDA Error Code
1151 */
1152 uint32_t HAL_IRDA_GetError(IRDA_HandleTypeDef *hirda)
1153 {
1154 return hirda->ErrorCode;
1155 }
1156
1157 /**
1158 * @}
1159 */
1160
1161 /**
1162 * @}
1163 */
1164
1165 /** @defgroup IRDA_Private_Functions IRDA Private Functions
1166 * @brief IRDA Private functions
1167 * @{
1168 */
1169 /**
1170 * @brief DMA IRDA transmit process complete callback.
1171 * @param hdma: Pointer to a DMA_HandleTypeDef structure that contains
1172 * the configuration information for the specified DMA module.
1173 * @retval None
1174 */
1175 static void IRDA_DMATransmitCplt(DMA_HandleTypeDef *hdma)
1176 {
1177 IRDA_HandleTypeDef* hirda = ( IRDA_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
1178 /* DMA Normal mode */
1179 if ( HAL_IS_BIT_CLR(hdma->Instance->CCR, DMA_CCR_CIRC) )
1180 {
1181 hirda->TxXferCount = 0;
1182
1183 /* Disable the DMA transfer for transmit request by setting the DMAT bit
1184 in the IRDA CR3 register */
1185 CLEAR_BIT(hirda->Instance->CR3, USART_CR3_DMAT);
1186
1187 /* Enable the IRDA Transmit Complete Interrupt */
1188 __HAL_IRDA_ENABLE_IT(hirda, IRDA_IT_TC);
1189 }
1190 /* DMA Circular mode */
1191 else
1192 {
1193 HAL_IRDA_TxCpltCallback(hirda);
1194 }
1195 }
1196
1197 /**
1198 * @brief DMA IRDA receive process half complete callback
1199 * @param hdma: Pointer to a DMA_HandleTypeDef structure that contains
1200 * the configuration information for the specified DMA module.
1201 * @retval None
1202 */
1203 static void IRDA_DMATransmitHalfCplt(DMA_HandleTypeDef *hdma)
1204 {
1205 IRDA_HandleTypeDef* hirda = ( IRDA_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
1206
1207 HAL_IRDA_TxHalfCpltCallback(hirda);
1208 }
1209
1210 /**
1211 * @brief DMA IRDA receive process complete callback.
1212 * @param hdma: Pointer to a DMA_HandleTypeDef structure that contains
1213 * the configuration information for the specified DMA module.
1214 * @retval None
1215 */
1216 static void IRDA_DMAReceiveCplt(DMA_HandleTypeDef *hdma)
1217 {
1218 IRDA_HandleTypeDef* hirda = ( IRDA_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
1219 /* DMA Normal mode */
1220 if ( HAL_IS_BIT_CLR(hdma->Instance->CCR, DMA_CCR_CIRC) )
1221 {
1222 hirda->RxXferCount = 0;
1223
1224 /* Disable the DMA transfer for the receiver request by setting the DMAR bit
1225 in the IRDA CR3 register */
1226 CLEAR_BIT(hirda->Instance->CR3, USART_CR3_DMAR);
1227
1228 if(hirda->State == HAL_IRDA_STATE_BUSY_TX_RX)
1229 {
1230 hirda->State = HAL_IRDA_STATE_BUSY_TX;
1231 }
1232 else
1233 {
1234 hirda->State = HAL_IRDA_STATE_READY;
1235 }
1236 }
1237
1238 HAL_IRDA_RxCpltCallback(hirda);
1239 }
1240
1241 /**
1242 * @brief DMA IRDA receive process half complete callback
1243 * @param hdma: Pointer to a DMA_HandleTypeDef structure that contains
1244 * the configuration information for the specified DMA module.
1245 * @retval None
1246 */
1247 static void IRDA_DMAReceiveHalfCplt(DMA_HandleTypeDef *hdma)
1248 {
1249 IRDA_HandleTypeDef* hirda = ( IRDA_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
1250
1251 HAL_IRDA_RxHalfCpltCallback(hirda);
1252 }
1253
1254 /**
1255 * @brief DMA IRDA communication error callback.
1256 * @param hdma: Pointer to a DMA_HandleTypeDef structure that contains
1257 * the configuration information for the specified DMA module.
1258 * @retval None
1259 */
1260 static void IRDA_DMAError(DMA_HandleTypeDef *hdma)
1261 {
1262 IRDA_HandleTypeDef* hirda = ( IRDA_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
1263
1264 hirda->RxXferCount = 0;
1265 hirda->TxXferCount = 0;
1266 hirda->ErrorCode |= HAL_IRDA_ERROR_DMA;
1267 hirda->State= HAL_IRDA_STATE_READY;
1268
1269 HAL_IRDA_ErrorCallback(hirda);
1270 }
1271
1272 /**
1273 * @brief This function handles IRDA Communication Timeout.
1274 * @param hirda: Pointer to a IRDA_HandleTypeDef structure that contains
1275 * the configuration information for the specified IRDA module.
1276 * @param Flag: specifies the IRDA flag to check.
1277 * @param Status: The new Flag status (SET or RESET).
1278 * @param Timeout: Timeout duration
1279 * @retval HAL status
1280 */
1281 static HAL_StatusTypeDef IRDA_WaitOnFlagUntilTimeout(IRDA_HandleTypeDef *hirda, uint32_t Flag, FlagStatus Status, uint32_t Timeout)
1282 {
1283 uint32_t tickstart = 0;
1284
1285 /* Get tick */
1286 tickstart = HAL_GetTick();
1287
1288 /* Wait until flag is set */
1289 if(Status == RESET)
1290 {
1291 while(__HAL_IRDA_GET_FLAG(hirda, Flag) == RESET)
1292 {
1293 /* Check for the Timeout */
1294 if(Timeout != HAL_MAX_DELAY)
1295 {
1296 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
1297 {
1298 /* Disable TXE, RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts for the interrupt process */
1299 __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_TXE);
1300 __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_RXNE);
1301 __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_PE);
1302 __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_ERR);
1303
1304 hirda->State= HAL_IRDA_STATE_READY;
1305
1306 /* Process Unlocked */
1307 __HAL_UNLOCK(hirda);
1308
1309 return HAL_TIMEOUT;
1310 }
1311 }
1312 }
1313 }
1314 else
1315 {
1316 while(__HAL_IRDA_GET_FLAG(hirda, Flag) != RESET)
1317 {
1318 /* Check for the Timeout */
1319 if(Timeout != HAL_MAX_DELAY)
1320 {
1321 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
1322 {
1323 /* Disable TXE, RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts for the interrupt process */
1324 __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_TXE);
1325 __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_RXNE);
1326 __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_PE);
1327 __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_ERR);
1328
1329 hirda->State= HAL_IRDA_STATE_READY;
1330
1331 /* Process Unlocked */
1332 __HAL_UNLOCK(hirda);
1333
1334 return HAL_TIMEOUT;
1335 }
1336 }
1337 }
1338 }
1339 return HAL_OK;
1340 }
1341
1342 /**
1343 * @brief Send an amount of data in non-blocking mode.
1344 * Function called under interruption only, once
1345 * interruptions have been enabled by HAL_IRDA_Transmit_IT()
1346 * @param hirda: Pointer to a IRDA_HandleTypeDef structure that contains
1347 * the configuration information for the specified IRDA module.
1348 * @retval HAL status
1349 */
1350 static HAL_StatusTypeDef IRDA_Transmit_IT(IRDA_HandleTypeDef *hirda)
1351 {
1352 uint16_t* tmp = 0;
1353 uint32_t tmp_state = 0;
1354
1355 tmp_state = hirda->State;
1356 if((tmp_state == HAL_IRDA_STATE_BUSY_TX) || (tmp_state == HAL_IRDA_STATE_BUSY_TX_RX))
1357 {
1358 if(hirda->Init.WordLength == IRDA_WORDLENGTH_9B)
1359 {
1360 tmp = (uint16_t*) hirda->pTxBuffPtr;
1361 WRITE_REG(hirda->Instance->DR, (uint16_t)(*tmp & IRDA_DR_MASK_U16_9DATABITS));
1362 if(hirda->Init.Parity == IRDA_PARITY_NONE)
1363 {
1364 hirda->pTxBuffPtr += 2;
1365 }
1366 else
1367 {
1368 hirda->pTxBuffPtr += 1;
1369 }
1370 }
1371 else
1372 {
1373 WRITE_REG(hirda->Instance->DR, (uint8_t)(*hirda->pTxBuffPtr++ & IRDA_DR_MASK_U8_8DATABITS));
1374 }
1375
1376 if(--hirda->TxXferCount == 0)
1377 {
1378 /* Disable the IRDA Transmit Data Register Empty Interrupt */
1379 __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_TXE);
1380
1381 /* Enable the IRDA Transmit Complete Interrupt */
1382 __HAL_IRDA_ENABLE_IT(hirda, IRDA_IT_TC);
1383 }
1384
1385 return HAL_OK;
1386 }
1387 else
1388 {
1389 return HAL_BUSY;
1390 }
1391 }
1392
1393 /**
1394 * @brief Wraps up transmission in non blocking mode.
1395 * @param hirda: pointer to a IRDA_HandleTypeDef structure that contains
1396 * the configuration information for the specified IRDA module.
1397 * @retval HAL status
1398 */
1399 static HAL_StatusTypeDef IRDA_EndTransmit_IT(IRDA_HandleTypeDef *hirda)
1400 {
1401 /* Disable the IRDA Transmit Complete Interrupt */
1402 __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_TC);
1403
1404 /* Check if a receive process is ongoing or not */
1405 if(hirda->State == HAL_IRDA_STATE_BUSY_TX_RX)
1406 {
1407 hirda->State = HAL_IRDA_STATE_BUSY_RX;
1408 }
1409 else
1410 {
1411 /* Disable the IRDA Error Interrupt: (Frame error, noise error, overrun error) */
1412 __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_ERR);
1413
1414 hirda->State = HAL_IRDA_STATE_READY;
1415 }
1416
1417 HAL_IRDA_TxCpltCallback(hirda);
1418
1419 return HAL_OK;
1420 }
1421
1422
1423 /**
1424 * @brief Receive an amount of data in non-blocking mode.
1425 * @param hirda: Pointer to a IRDA_HandleTypeDef structure that contains
1426 * the configuration information for the specified IRDA module.
1427 * @retval HAL status
1428 */
1429 static HAL_StatusTypeDef IRDA_Receive_IT(IRDA_HandleTypeDef *hirda)
1430 {
1431 uint16_t* tmp = 0;
1432 uint32_t tmp_state = 0;
1433
1434 tmp_state = hirda->State;
1435 if((tmp_state == HAL_IRDA_STATE_BUSY_RX) || (tmp_state == HAL_IRDA_STATE_BUSY_TX_RX))
1436 {
1437 if(hirda->Init.WordLength == IRDA_WORDLENGTH_9B)
1438 {
1439 tmp = (uint16_t*) hirda->pRxBuffPtr;
1440 if(hirda->Init.Parity == IRDA_PARITY_NONE)
1441 {
1442 *tmp = (uint16_t)(hirda->Instance->DR & IRDA_DR_MASK_U16_9DATABITS);
1443 hirda->pRxBuffPtr += 2;
1444 }
1445 else
1446 {
1447 *tmp = (uint16_t)(hirda->Instance->DR & IRDA_DR_MASK_U16_8DATABITS);
1448 hirda->pRxBuffPtr += 1;
1449 }
1450 }
1451 else
1452 {
1453 if(hirda->Init.Parity == IRDA_PARITY_NONE)
1454 {
1455 *hirda->pRxBuffPtr++ = (uint8_t)(hirda->Instance->DR & IRDA_DR_MASK_U8_8DATABITS);
1456 }
1457 else
1458 {
1459 *hirda->pRxBuffPtr++ = (uint8_t)(hirda->Instance->DR & IRDA_DR_MASK_U8_7DATABITS);
1460 }
1461 }
1462
1463 if(--hirda->RxXferCount == 0)
1464 {
1465
1466 __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_RXNE);
1467
1468 if(hirda->State == HAL_IRDA_STATE_BUSY_TX_RX)
1469 {
1470 hirda->State = HAL_IRDA_STATE_BUSY_TX;
1471 }
1472 else
1473 {
1474 /* Disable the IRDA Parity Error Interrupt */
1475 __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_PE);
1476
1477 /* Disable the IRDA Error Interrupt: (Frame error, noise error, overrun error) */
1478 __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_ERR);
1479
1480 hirda->State = HAL_IRDA_STATE_READY;
1481 }
1482 HAL_IRDA_RxCpltCallback(hirda);
1483
1484 return HAL_OK;
1485 }
1486 return HAL_OK;
1487 }
1488 else
1489 {
1490 return HAL_BUSY;
1491 }
1492 }
1493
1494 /**
1495 * @brief Configures the IRDA peripheral.
1496 * @param hirda: Pointer to a IRDA_HandleTypeDef structure that contains
1497 * the configuration information for the specified IRDA module.
1498 * @retval None
1499 */
1500 static void IRDA_SetConfig(IRDA_HandleTypeDef *hirda)
1501 {
1502 /* Check the parameters */
1503 assert_param(IS_IRDA_BAUDRATE(hirda->Init.BaudRate));
1504 assert_param(IS_IRDA_WORD_LENGTH(hirda->Init.WordLength));
1505 assert_param(IS_IRDA_PARITY(hirda->Init.Parity));
1506 assert_param(IS_IRDA_MODE(hirda->Init.Mode));
1507
1508 /*------- IRDA-associated USART registers setting : CR2 Configuration ------*/
1509 /* Clear STOP[13:12] bits */
1510 CLEAR_BIT(hirda->Instance->CR2, USART_CR2_STOP);
1511
1512 /*------- IRDA-associated USART registers setting : CR1 Configuration ------*/
1513 /* Configure the USART Word Length, Parity and mode:
1514 Set the M bits according to hirda->Init.WordLength value
1515 Set PCE and PS bits according to hirda->Init.Parity value
1516 Set TE and RE bits according to hirda->Init.Mode value */
1517 MODIFY_REG(hirda->Instance->CR1,
1518 ((uint32_t)(USART_CR1_M | USART_CR1_PCE | USART_CR1_PS | USART_CR1_TE | USART_CR1_RE)),
1519 (uint32_t)hirda->Init.WordLength | hirda->Init.Parity | hirda->Init.Mode);
1520
1521 /*------- IRDA-associated USART registers setting : CR3 Configuration ------*/
1522 /* Clear CTSE and RTSE bits */
1523 CLEAR_BIT(hirda->Instance->CR3, (USART_CR3_RTSE | USART_CR3_CTSE));
1524
1525 /*------- IRDA-associated USART registers setting : BRR Configuration ------*/
1526 if(hirda->Instance == USART1)
1527 {
1528 hirda->Instance->BRR = IRDA_BRR(HAL_RCC_GetPCLK2Freq(), hirda->Init.BaudRate);
1529 }
1530 else
1531 {
1532 hirda->Instance->BRR = IRDA_BRR(HAL_RCC_GetPCLK1Freq(), hirda->Init.BaudRate);
1533 }
1534 }
1535 /**
1536 * @}
1537 */
1538
1539 #endif /* HAL_IRDA_MODULE_ENABLED */
1540 /**
1541 * @}
1542 */
1543
1544 /**
1545 * @}
1546 */
1547
1548 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
custom keymap for my minivan; forked from http://github.com/evangs/tmk_keyboard
Imprint / Impressum