1 /**************************************************************************//**
2 * @file uart.c
3 * @version V3.00
4 * @brief M460 series UART driver source file
5 *
6 * @copyright SPDX-License-Identifier: Apache-2.0
7 * @copyright Copyright (C) 2021 Nuvoton Technology Corp. All rights reserved.
8 *****************************************************************************/
9
10 #include <stdio.h>
11 #include "NuMicro.h"
12
13 /** @addtogroup Standard_Driver Standard Driver
14 @{
15 */
16
17 /** @addtogroup UART_Driver UART Driver
18 @{
19 */
20
21 /** @addtogroup UART_EXPORTED_FUNCTIONS UART Exported Functions
22 @{
23 */
24
25 /**
26 * @brief Clear UART specified interrupt flag
27 *
28 * @param[in] uart The pointer of the specified UART module.
29 * @param[in] u32InterruptFlag The specified interrupt of UART module.
30 * - \ref UART_INTSTS_SWBEINT_Msk : Single-wire Bit Error Detect Interrupt Indicator
31 * - \ref UART_INTSTS_LININT_Msk : LIN Bus Interrupt Indicator
32 * - \ref UART_INTSTS_WKINT_Msk : Wake-up Interrupt Indicator
33 * - \ref UART_INTSTS_BUFERRINT_Msk : Buffer Error Interrupt Indicator
34 * - \ref UART_INTSTS_MODEMINT_Msk : Modem Status Interrupt Indicator
35 * - \ref UART_INTSTS_RLSINT_Msk : Receive Line Status Interrupt Indicator
36 *
37 * @return None
38 *
39 * @details The function is used to clear UART specified interrupt flag.
40 */
41
UART_ClearIntFlag(UART_T * uart,uint32_t u32InterruptFlag)42 void UART_ClearIntFlag(UART_T* uart, uint32_t u32InterruptFlag)
43 {
44 if(u32InterruptFlag & UART_INTSTS_SWBEINT_Msk) /* Clear Single-wire Bit Error Detect Interrupt */
45 {
46 uart->FIFOSTS = UART_INTSTS_SWBEIF_Msk;
47 }
48
49 if(u32InterruptFlag & UART_INTSTS_RLSINT_Msk) /* Clear Receive Line Status Interrupt */
50 {
51 uart->FIFOSTS = UART_FIFOSTS_BIF_Msk | UART_FIFOSTS_FEF_Msk | UART_FIFOSTS_PEF_Msk | UART_FIFOSTS_ADDRDETF_Msk;
52 }
53
54 if(u32InterruptFlag & UART_INTSTS_MODEMINT_Msk) /* Clear Modem Status Interrupt */
55 {
56 uart->MODEMSTS |= UART_MODEMSTS_CTSDETF_Msk;
57 }
58
59 if(u32InterruptFlag & UART_INTSTS_BUFERRINT_Msk) /* Clear Buffer Error Interrupt */
60 {
61 uart->FIFOSTS = UART_FIFOSTS_RXOVIF_Msk | UART_FIFOSTS_TXOVIF_Msk;
62 }
63
64 if(u32InterruptFlag & UART_INTSTS_WKINT_Msk) /* Clear Wake-up Interrupt */
65 {
66 uart->WKSTS = UART_WKSTS_CTSWKF_Msk | UART_WKSTS_DATWKF_Msk |
67 UART_WKSTS_RFRTWKF_Msk |UART_WKSTS_RS485WKF_Msk |
68 UART_WKSTS_TOUTWKF_Msk;
69 }
70
71 if(u32InterruptFlag & UART_INTSTS_LININT_Msk) /* Clear LIN Bus Interrupt */
72 {
73 uart->INTSTS = UART_INTSTS_LINIF_Msk;
74 uart->LINSTS = UART_LINSTS_BITEF_Msk | UART_LINSTS_BRKDETF_Msk |
75 UART_LINSTS_SLVSYNCF_Msk | UART_LINSTS_SLVIDPEF_Msk |
76 UART_LINSTS_SLVHEF_Msk | UART_LINSTS_SLVHDETF_Msk ;
77 }
78 }
79
80
81 /**
82 * @brief Disable UART interrupt
83 *
84 * @param[in] uart The pointer of the specified UART module.
85 *
86 * @return None
87 *
88 * @details The function is used to disable UART interrupt.
89 */
UART_Close(UART_T * uart)90 void UART_Close(UART_T* uart)
91 {
92 uart->INTEN = 0ul;
93 }
94
95
96 /**
97 * @brief Disable UART auto flow control function
98 *
99 * @param[in] uart The pointer of the specified UART module.
100 *
101 * @return None
102 *
103 * @details The function is used to disable UART auto flow control.
104 */
UART_DisableFlowCtrl(UART_T * uart)105 void UART_DisableFlowCtrl(UART_T* uart)
106 {
107 uart->INTEN &= ~(UART_INTEN_ATORTSEN_Msk | UART_INTEN_ATOCTSEN_Msk);
108 }
109
110
111 /**
112 * @brief Disable UART specified interrupt
113 *
114 * @param[in] uart The pointer of the specified UART module.
115 * @param[in] u32InterruptFlag The specified interrupt of UART module.
116 * - \ref UART_INTEN_TXENDIEN_Msk : Transmitter Empty Interrupt
117 * - \ref UART_INTEN_ABRIEN_Msk : Auto-baud Rate Interrupt
118 * - \ref UART_INTEN_SWBEIEN_Msk : Single-wire Bit Error Detect Interrupt
119 * - \ref UART_INTEN_LINIEN_Msk : Lin Bus interrupt
120 * - \ref UART_INTEN_WKIEN_Msk : Wake-up interrupt
121 * - \ref UART_INTEN_BUFERRIEN_Msk : Buffer Error interrupt
122 * - \ref UART_INTEN_RXTOIEN_Msk : Rx Time-out Interrupt
123 * - \ref UART_INTEN_MODEMIEN_Msk : MODEM Status Interrupt
124 * - \ref UART_INTEN_RLSIEN_Msk : Receive Line Status Interrupt
125 * - \ref UART_INTEN_THREIEN_Msk : Transmit Holding Register Empty Interrupt
126 * - \ref UART_INTEN_RDAIEN_Msk : Receive Data Available Interrupt
127 *
128 * @return None
129 *
130 * @details The function is used to disable UART specified interrupt.
131 */
UART_DisableInt(UART_T * uart,uint32_t u32InterruptFlag)132 void UART_DisableInt(UART_T* uart, uint32_t u32InterruptFlag)
133 {
134 /* Disable UART specified interrupt */
135 UART_DISABLE_INT(uart, u32InterruptFlag);
136 }
137
138
139 /**
140 * @brief Enable UART auto flow control function
141 *
142 * @param[in] uart The pointer of the specified UART module.
143 *
144 * @return None
145 *
146 * @details The function is used to enable UART auto flow control.
147 */
UART_EnableFlowCtrl(UART_T * uart)148 void UART_EnableFlowCtrl(UART_T* uart)
149 {
150 /* Set RTS pin output is low level active */
151 uart->MODEM |= UART_MODEM_RTSACTLV_Msk;
152
153 /* Set CTS pin input is low level active */
154 uart->MODEMSTS |= UART_MODEMSTS_CTSACTLV_Msk;
155
156 /* Set RTS and CTS auto flow control enable */
157 uart->INTEN |= UART_INTEN_ATORTSEN_Msk | UART_INTEN_ATOCTSEN_Msk;
158 }
159
160
161 /**
162 * @brief Enable UART specified interrupt
163 *
164 * @param[in] uart The pointer of the specified UART module.
165 * @param[in] u32InterruptFlag The specified interrupt of UART module:
166 * - \ref UART_INTEN_TXENDIEN_Msk : Transmitter Empty Interrupt
167 * - \ref UART_INTEN_ABRIEN_Msk : Auto-baud Rate Interrupt
168 * - \ref UART_INTEN_SWBEIEN_Msk : Single-wire Bit Error Detect Interrupt
169 * - \ref UART_INTEN_LINIEN_Msk : Lin Bus interrupt
170 * - \ref UART_INTEN_WKIEN_Msk : Wake-up interrupt
171 * - \ref UART_INTEN_BUFERRIEN_Msk : Buffer Error interrupt
172 * - \ref UART_INTEN_RXTOIEN_Msk : Rx Time-out Interrupt
173 * - \ref UART_INTEN_MODEMIEN_Msk : MODEM Status Interrupt
174 * - \ref UART_INTEN_RLSIEN_Msk : Receive Line Status Interrupt
175 * - \ref UART_INTEN_THREIEN_Msk : Transmit Holding Register Empty Interrupt
176 * - \ref UART_INTEN_RDAIEN_Msk : Receive Data Available Interrupt
177 *
178 * @return None
179 *
180 * @details The function is used to enable UART specified interrupt.
181 */
UART_EnableInt(UART_T * uart,uint32_t u32InterruptFlag)182 void UART_EnableInt(UART_T* uart, uint32_t u32InterruptFlag)
183 {
184 /* Enable UART specified interrupt */
185 UART_ENABLE_INT(uart, u32InterruptFlag);
186 }
187
188
189 /**
190 * @brief Open and set UART function
191 *
192 * @param[in] uart The pointer of the specified UART module.
193 * @param[in] u32baudrate The baudrate of UART module.
194 *
195 * @return None
196 *
197 * @details This function use to enable UART function and set baud-rate.
198 */
UART_Open(UART_T * uart,uint32_t u32baudrate)199 void UART_Open(UART_T* uart, uint32_t u32baudrate)
200 {
201 uint32_t u32UartClkSrcSel = 0ul, u32UartClkDivNum = 0ul;
202 uint32_t au32ClkTbl[4] = {__HXT, 0ul, __LXT, __HIRC};
203 uint32_t u32BaudDiv = 0ul;
204
205 /* Get UART clock source selection and UART clock divider number */
206 switch((uint32_t)uart)
207 {
208 case UART0_BASE:
209 u32UartClkSrcSel = (CLK->CLKSEL1 & CLK_CLKSEL1_UART0SEL_Msk) >> CLK_CLKSEL1_UART0SEL_Pos;
210 u32UartClkDivNum = (CLK->CLKDIV0 & CLK_CLKDIV0_UART0DIV_Msk) >> CLK_CLKDIV0_UART0DIV_Pos;
211 break;
212 case UART1_BASE:
213 u32UartClkSrcSel = (CLK->CLKSEL1 & CLK_CLKSEL1_UART1SEL_Msk) >> CLK_CLKSEL1_UART1SEL_Pos;
214 u32UartClkDivNum = (CLK->CLKDIV0 & CLK_CLKDIV0_UART1DIV_Msk) >> CLK_CLKDIV0_UART1DIV_Pos;
215 break;
216 case UART2_BASE:
217 u32UartClkSrcSel = (CLK->CLKSEL3 & CLK_CLKSEL3_UART2SEL_Msk) >> CLK_CLKSEL3_UART2SEL_Pos;
218 u32UartClkDivNum = (CLK->CLKDIV4 & CLK_CLKDIV4_UART2DIV_Msk) >> CLK_CLKDIV4_UART2DIV_Pos;
219 break;
220 case UART3_BASE:
221 u32UartClkSrcSel = (CLK->CLKSEL3 & CLK_CLKSEL3_UART3SEL_Msk) >> CLK_CLKSEL3_UART3SEL_Pos;
222 u32UartClkDivNum = (CLK->CLKDIV4 & CLK_CLKDIV4_UART3DIV_Msk) >> CLK_CLKDIV4_UART3DIV_Pos;
223 break;
224 case UART4_BASE:
225 u32UartClkSrcSel = (CLK->CLKSEL3 & CLK_CLKSEL3_UART4SEL_Msk) >> CLK_CLKSEL3_UART4SEL_Pos;
226 u32UartClkDivNum = (CLK->CLKDIV4 & CLK_CLKDIV4_UART4DIV_Msk) >> CLK_CLKDIV4_UART4DIV_Pos;
227 break;
228 case UART5_BASE:
229 u32UartClkSrcSel = (CLK->CLKSEL3 & CLK_CLKSEL3_UART5SEL_Msk) >> CLK_CLKSEL3_UART5SEL_Pos;
230 u32UartClkDivNum = (CLK->CLKDIV4 & CLK_CLKDIV4_UART5DIV_Msk) >> CLK_CLKDIV4_UART5DIV_Pos;
231 break;
232 case UART6_BASE:
233 u32UartClkSrcSel = (CLK->CLKSEL3 & CLK_CLKSEL3_UART6SEL_Msk) >> CLK_CLKSEL3_UART6SEL_Pos;
234 u32UartClkDivNum = (CLK->CLKDIV4 & CLK_CLKDIV4_UART6DIV_Msk) >> CLK_CLKDIV4_UART6DIV_Pos;
235 break;
236 case UART7_BASE:
237 u32UartClkSrcSel = (CLK->CLKSEL3 & CLK_CLKSEL3_UART7SEL_Msk) >> CLK_CLKSEL3_UART7SEL_Pos;
238 u32UartClkDivNum = (CLK->CLKDIV4 & CLK_CLKDIV4_UART7DIV_Msk) >> CLK_CLKDIV4_UART7DIV_Pos;
239 break;
240 case UART8_BASE:
241 u32UartClkSrcSel = (CLK->CLKSEL2 & CLK_CLKSEL2_UART8SEL_Msk) >> CLK_CLKSEL2_UART8SEL_Pos;
242 u32UartClkDivNum = (CLK->CLKDIV5 & CLK_CLKDIV5_UART8DIV_Msk) >> CLK_CLKDIV5_UART8DIV_Pos;
243 break;
244 case UART9_BASE:
245 u32UartClkSrcSel = (CLK->CLKSEL2 & CLK_CLKSEL2_UART9SEL_Msk) >> CLK_CLKSEL2_UART9SEL_Pos;
246 u32UartClkDivNum = (CLK->CLKDIV5 & CLK_CLKDIV5_UART9DIV_Msk) >> CLK_CLKDIV5_UART9DIV_Pos;
247 break;
248 default:
249 return;
250 }
251
252 /* Select UART function */
253 uart->FUNCSEL = UART_FUNCSEL_UART;
254
255 /* Set UART line configuration */
256 uart->LINE = UART_WORD_LEN_8 | UART_PARITY_NONE | UART_STOP_BIT_1;
257
258 /* Set UART Rx and RTS trigger level */
259 uart->FIFO &= ~(UART_FIFO_RFITL_Msk | UART_FIFO_RTSTRGLV_Msk);
260
261 /* Get PLL/2 clock frequency if UART clock source selection is PLL/2 */
262 if(u32UartClkSrcSel == 1ul)
263 {
264 au32ClkTbl[1] = CLK_GetPLLClockFreq()>>1;
265 }
266
267 /* Set UART baud rate */
268 if(u32baudrate != 0ul)
269 {
270 u32BaudDiv = UART_BAUD_MODE2_DIVIDER((au32ClkTbl[u32UartClkSrcSel]) / (u32UartClkDivNum + 1ul), u32baudrate);
271
272 if(u32BaudDiv > 0xFFFFul)
273 {
274 uart->BAUD = (UART_BAUD_MODE0 | UART_BAUD_MODE0_DIVIDER((au32ClkTbl[u32UartClkSrcSel]) / (u32UartClkDivNum + 1ul), u32baudrate));
275 }
276 else
277 {
278 uart->BAUD = (UART_BAUD_MODE2 | u32BaudDiv);
279 }
280 }
281 }
282
283
284 /**
285 * @brief Read UART data
286 *
287 * @param[in] uart The pointer of the specified UART module.
288 * @param[in] pu8RxBuf The buffer to receive the data of receive FIFO.
289 * @param[in] u32ReadBytes The read bytes number of data.
290 *
291 * @return u32Count Receive byte count
292 *
293 * @details The function is used to read Rx data from RX FIFO and the data will be stored in pu8RxBuf.
294 */
UART_Read(UART_T * uart,uint8_t pu8RxBuf[],uint32_t u32ReadBytes)295 uint32_t UART_Read(UART_T* uart, uint8_t pu8RxBuf[], uint32_t u32ReadBytes)
296 {
297 uint32_t u32Count, u32delayno;
298 uint32_t u32Exit = 0ul;
299
300 for(u32Count = 0ul; u32Count < u32ReadBytes; u32Count++)
301 {
302 u32delayno = 0ul;
303
304 while(uart->FIFOSTS & UART_FIFOSTS_RXEMPTY_Msk) /* Check RX empty => failed */
305 {
306 u32delayno++;
307 if(u32delayno >= 0x40000000ul)
308 {
309 u32Exit = 1ul;
310 break;
311 }
312 else
313 {
314 }
315 }
316
317 if(u32Exit == 1ul)
318 {
319 break;
320 }
321 else
322 {
323 pu8RxBuf[u32Count] = (uint8_t)uart->DAT; /* Get Data from UART RX */
324 }
325 }
326
327 return u32Count;
328 }
329
330
331 /**
332 * @brief Set UART line configuration
333 *
334 * @param[in] uart The pointer of the specified UART module.
335 * @param[in] u32baudrate The baudrate of UART module.
336 * If u32baudrate = 0, UART baudrate will not change.
337 * @param[in] u32data_width The data length of UART module.
338 * - \ref UART_WORD_LEN_5
339 * - \ref UART_WORD_LEN_6
340 * - \ref UART_WORD_LEN_7
341 * - \ref UART_WORD_LEN_8
342 * @param[in] u32parity The parity setting (none/odd/even/mark/space) of UART module.
343 * - \ref UART_PARITY_NONE
344 * - \ref UART_PARITY_ODD
345 * - \ref UART_PARITY_EVEN
346 * - \ref UART_PARITY_MARK
347 * - \ref UART_PARITY_SPACE
348 * @param[in] u32stop_bits The stop bit length (1/1.5/2 bit) of UART module.
349 * - \ref UART_STOP_BIT_1
350 * - \ref UART_STOP_BIT_1_5
351 * - \ref UART_STOP_BIT_2
352 *
353 * @return None
354 *
355 * @details This function use to config UART line setting.
356 */
UART_SetLineConfig(UART_T * uart,uint32_t u32baudrate,uint32_t u32data_width,uint32_t u32parity,uint32_t u32stop_bits)357 void UART_SetLineConfig(UART_T* uart, uint32_t u32baudrate, uint32_t u32data_width, uint32_t u32parity, uint32_t u32stop_bits)
358 {
359 uint32_t u32UartClkSrcSel = 0ul, u32UartClkDivNum = 0ul;
360 uint32_t au32ClkTbl[4] = {__HXT, 0ul, __LXT, __HIRC};
361 uint32_t u32BaudDiv = 0ul;
362
363 /* Get UART clock source selection and UART clock divider number */
364 switch((uint32_t)uart)
365 {
366 case UART0_BASE:
367 u32UartClkSrcSel = (CLK->CLKSEL1 & CLK_CLKSEL1_UART0SEL_Msk) >> CLK_CLKSEL1_UART0SEL_Pos;
368 u32UartClkDivNum = (CLK->CLKDIV0 & CLK_CLKDIV0_UART0DIV_Msk) >> CLK_CLKDIV0_UART0DIV_Pos;
369 break;
370 case UART1_BASE:
371 u32UartClkSrcSel = (CLK->CLKSEL1 & CLK_CLKSEL1_UART1SEL_Msk) >> CLK_CLKSEL1_UART1SEL_Pos;
372 u32UartClkDivNum = (CLK->CLKDIV0 & CLK_CLKDIV0_UART1DIV_Msk) >> CLK_CLKDIV0_UART1DIV_Pos;
373 break;
374 case UART2_BASE:
375 u32UartClkSrcSel = (CLK->CLKSEL3 & CLK_CLKSEL3_UART2SEL_Msk) >> CLK_CLKSEL3_UART2SEL_Pos;
376 u32UartClkDivNum = (CLK->CLKDIV4 & CLK_CLKDIV4_UART2DIV_Msk) >> CLK_CLKDIV4_UART2DIV_Pos;
377 break;
378 case UART3_BASE:
379 u32UartClkSrcSel = (CLK->CLKSEL3 & CLK_CLKSEL3_UART3SEL_Msk) >> CLK_CLKSEL3_UART3SEL_Pos;
380 u32UartClkDivNum = (CLK->CLKDIV4 & CLK_CLKDIV4_UART3DIV_Msk) >> CLK_CLKDIV4_UART3DIV_Pos;
381 break;
382 case UART4_BASE:
383 u32UartClkSrcSel = (CLK->CLKSEL3 & CLK_CLKSEL3_UART4SEL_Msk) >> CLK_CLKSEL3_UART4SEL_Pos;
384 u32UartClkDivNum = (CLK->CLKDIV4 & CLK_CLKDIV4_UART4DIV_Msk) >> CLK_CLKDIV4_UART4DIV_Pos;
385 break;
386 case UART5_BASE:
387 u32UartClkSrcSel = (CLK->CLKSEL3 & CLK_CLKSEL3_UART5SEL_Msk) >> CLK_CLKSEL3_UART5SEL_Pos;
388 u32UartClkDivNum = (CLK->CLKDIV4 & CLK_CLKDIV4_UART5DIV_Msk) >> CLK_CLKDIV4_UART5DIV_Pos;
389 break;
390 case UART6_BASE:
391 u32UartClkSrcSel = (CLK->CLKSEL3 & CLK_CLKSEL3_UART6SEL_Msk) >> CLK_CLKSEL3_UART6SEL_Pos;
392 u32UartClkDivNum = (CLK->CLKDIV4 & CLK_CLKDIV4_UART6DIV_Msk) >> CLK_CLKDIV4_UART6DIV_Pos;
393 break;
394 case UART7_BASE:
395 u32UartClkSrcSel = (CLK->CLKSEL3 & CLK_CLKSEL3_UART7SEL_Msk) >> CLK_CLKSEL3_UART7SEL_Pos;
396 u32UartClkDivNum = (CLK->CLKDIV4 & CLK_CLKDIV4_UART7DIV_Msk) >> CLK_CLKDIV4_UART7DIV_Pos;
397 break;
398 case UART8_BASE:
399 u32UartClkSrcSel = (CLK->CLKSEL2 & CLK_CLKSEL2_UART8SEL_Msk) >> CLK_CLKSEL2_UART8SEL_Pos;
400 u32UartClkDivNum = (CLK->CLKDIV5 & CLK_CLKDIV5_UART8DIV_Msk) >> CLK_CLKDIV5_UART8DIV_Pos;
401 break;
402 case UART9_BASE:
403 u32UartClkSrcSel = (CLK->CLKSEL2 & CLK_CLKSEL2_UART9SEL_Msk) >> CLK_CLKSEL2_UART9SEL_Pos;
404 u32UartClkDivNum = (CLK->CLKDIV5 & CLK_CLKDIV5_UART9DIV_Msk) >> CLK_CLKDIV5_UART9DIV_Pos;
405 break;
406 default:
407 return;
408 }
409
410 /* Get PLL/2 clock frequency if UART clock source selection is PLL/2 */
411 if(u32UartClkSrcSel == 1ul)
412 {
413 au32ClkTbl[1] = CLK_GetPLLClockFreq()>>1;
414 }
415
416 /* Set UART baud rate */
417 if(u32baudrate != 0ul)
418 {
419 u32BaudDiv = UART_BAUD_MODE2_DIVIDER((au32ClkTbl[u32UartClkSrcSel]) / (u32UartClkDivNum + 1ul), u32baudrate);
420
421 if(u32BaudDiv > 0xFFFFul)
422 {
423 uart->BAUD = (UART_BAUD_MODE0 | UART_BAUD_MODE0_DIVIDER((au32ClkTbl[u32UartClkSrcSel]) / (u32UartClkDivNum + 1ul), u32baudrate));
424 }
425 else
426 {
427 uart->BAUD = (UART_BAUD_MODE2 | u32BaudDiv);
428 }
429 }
430
431 /* Set UART line configuration */
432 uart->LINE = u32data_width | u32parity | u32stop_bits;
433 }
434
435
436 /**
437 * @brief Set Rx timeout count
438 *
439 * @param[in] uart The pointer of the specified UART module.
440 * @param[in] u32TOC Rx timeout counter.
441 *
442 * @return None
443 *
444 * @details This function use to set Rx timeout count.
445 */
UART_SetTimeoutCnt(UART_T * uart,uint32_t u32TOC)446 void UART_SetTimeoutCnt(UART_T* uart, uint32_t u32TOC)
447 {
448 /* Set time-out interrupt comparator */
449 uart->TOUT = (uart->TOUT & ~UART_TOUT_TOIC_Msk) | (u32TOC);
450
451 /* Set time-out counter enable */
452 uart->INTEN |= UART_INTEN_TOCNTEN_Msk;
453 }
454
455
456 /**
457 * @brief Select and configure IrDA function
458 *
459 * @param[in] uart The pointer of the specified UART module.
460 * @param[in] u32Buadrate The baudrate of UART module.
461 * @param[in] u32Direction The direction of UART module in IrDA mode:
462 * - \ref UART_IRDA_TXEN
463 * - \ref UART_IRDA_RXEN
464 *
465 * @return None
466 *
467 * @details The function is used to configure IrDA relative settings. It consists of TX or RX mode and baudrate.
468 */
UART_SelectIrDAMode(UART_T * uart,uint32_t u32Buadrate,uint32_t u32Direction)469 void UART_SelectIrDAMode(UART_T* uart, uint32_t u32Buadrate, uint32_t u32Direction)
470 {
471 uint32_t u32UartClkSrcSel = 0ul, u32UartClkDivNum = 0ul;
472 uint32_t au32ClkTbl[4] = {__HXT, 0ul, __LXT, __HIRC};
473 uint32_t u32BaudDiv = 0ul;
474
475 /* Select IrDA function mode */
476 uart->FUNCSEL = UART_FUNCSEL_IrDA;
477
478 /* Get UART clock source selection and UART clock divider number */
479 switch((uint32_t)uart)
480 {
481 case UART0_BASE:
482 u32UartClkSrcSel = (CLK->CLKSEL1 & CLK_CLKSEL1_UART0SEL_Msk) >> CLK_CLKSEL1_UART0SEL_Pos;
483 u32UartClkDivNum = (CLK->CLKDIV0 & CLK_CLKDIV0_UART0DIV_Msk) >> CLK_CLKDIV0_UART0DIV_Pos;
484 break;
485 case UART1_BASE:
486 u32UartClkSrcSel = (CLK->CLKSEL1 & CLK_CLKSEL1_UART1SEL_Msk) >> CLK_CLKSEL1_UART1SEL_Pos;
487 u32UartClkDivNum = (CLK->CLKDIV0 & CLK_CLKDIV0_UART1DIV_Msk) >> CLK_CLKDIV0_UART1DIV_Pos;
488 break;
489 case UART2_BASE:
490 u32UartClkSrcSel = (CLK->CLKSEL3 & CLK_CLKSEL3_UART2SEL_Msk) >> CLK_CLKSEL3_UART2SEL_Pos;
491 u32UartClkDivNum = (CLK->CLKDIV4 & CLK_CLKDIV4_UART2DIV_Msk) >> CLK_CLKDIV4_UART2DIV_Pos;
492 break;
493 case UART3_BASE:
494 u32UartClkSrcSel = (CLK->CLKSEL3 & CLK_CLKSEL3_UART3SEL_Msk) >> CLK_CLKSEL3_UART3SEL_Pos;
495 u32UartClkDivNum = (CLK->CLKDIV4 & CLK_CLKDIV4_UART3DIV_Msk) >> CLK_CLKDIV4_UART3DIV_Pos;
496 break;
497 case UART4_BASE:
498 u32UartClkSrcSel = (CLK->CLKSEL3 & CLK_CLKSEL3_UART4SEL_Msk) >> CLK_CLKSEL3_UART4SEL_Pos;
499 u32UartClkDivNum = (CLK->CLKDIV4 & CLK_CLKDIV4_UART4DIV_Msk) >> CLK_CLKDIV4_UART4DIV_Pos;
500 break;
501 case UART5_BASE:
502 u32UartClkSrcSel = (CLK->CLKSEL3 & CLK_CLKSEL3_UART5SEL_Msk) >> CLK_CLKSEL3_UART5SEL_Pos;
503 u32UartClkDivNum = (CLK->CLKDIV4 & CLK_CLKDIV4_UART5DIV_Msk) >> CLK_CLKDIV4_UART5DIV_Pos;
504 break;
505 case UART6_BASE:
506 u32UartClkSrcSel = (CLK->CLKSEL3 & CLK_CLKSEL3_UART6SEL_Msk) >> CLK_CLKSEL3_UART6SEL_Pos;
507 u32UartClkDivNum = (CLK->CLKDIV4 & CLK_CLKDIV4_UART6DIV_Msk) >> CLK_CLKDIV4_UART6DIV_Pos;
508 break;
509 case UART7_BASE:
510 u32UartClkSrcSel = (CLK->CLKSEL3 & CLK_CLKSEL3_UART7SEL_Msk) >> CLK_CLKSEL3_UART7SEL_Pos;
511 u32UartClkDivNum = (CLK->CLKDIV4 & CLK_CLKDIV4_UART7DIV_Msk) >> CLK_CLKDIV4_UART7DIV_Pos;
512 break;
513 case UART8_BASE:
514 u32UartClkSrcSel = (CLK->CLKSEL2 & CLK_CLKSEL2_UART8SEL_Msk) >> CLK_CLKSEL2_UART8SEL_Pos;
515 u32UartClkDivNum = (CLK->CLKDIV5 & CLK_CLKDIV5_UART8DIV_Msk) >> CLK_CLKDIV5_UART8DIV_Pos;
516 break;
517 case UART9_BASE:
518 u32UartClkSrcSel = (CLK->CLKSEL2 & CLK_CLKSEL2_UART9SEL_Msk) >> CLK_CLKSEL2_UART9SEL_Pos;
519 u32UartClkDivNum = (CLK->CLKDIV5 & CLK_CLKDIV5_UART9DIV_Msk) >> CLK_CLKDIV5_UART9DIV_Pos;
520 break;
521 default:
522 return;
523 }
524
525 /* Get PLL/2 clock frequency if UART clock source selection is PLL/2 */
526 if(u32UartClkSrcSel == 1ul)
527 {
528 au32ClkTbl[1] = CLK_GetPLLClockFreq()>>1;
529 }
530
531 /* Set UART IrDA baud rate in mode 0 */
532 if(u32Buadrate != 0ul)
533 {
534 u32BaudDiv = UART_BAUD_MODE0_DIVIDER((au32ClkTbl[u32UartClkSrcSel]) / (u32UartClkDivNum + 1ul), u32Buadrate);
535
536 if(u32BaudDiv < 0xFFFFul)
537 {
538 uart->BAUD = (UART_BAUD_MODE0 | u32BaudDiv);
539 }
540 }
541
542 /* Configure IrDA relative settings */
543 if(u32Direction == UART_IRDA_RXEN)
544 {
545 uart->IRDA |= UART_IRDA_RXINV_Msk; /* Rx signal is inverse */
546 uart->IRDA &= ~UART_IRDA_TXEN_Msk;
547 }
548 else
549 {
550 uart->IRDA &= ~UART_IRDA_TXINV_Msk; /* Tx signal is not inverse */
551 uart->IRDA |= UART_IRDA_TXEN_Msk;
552 }
553
554 }
555
556
557 /**
558 * @brief Select and configure RS485 function
559 *
560 * @param[in] uart The pointer of the specified UART module.
561 * @param[in] u32Mode The operation mode(NMM/AUD/AAD).
562 * - \ref UART_ALTCTL_RS485NMM_Msk
563 * - \ref UART_ALTCTL_RS485AUD_Msk
564 * - \ref UART_ALTCTL_RS485AAD_Msk
565 * @param[in] u32Addr The RS485 address.
566 *
567 * @return None
568 *
569 * @details The function is used to set RS485 relative setting.
570 */
UART_SelectRS485Mode(UART_T * uart,uint32_t u32Mode,uint32_t u32Addr)571 void UART_SelectRS485Mode(UART_T* uart, uint32_t u32Mode, uint32_t u32Addr)
572 {
573 /* Select UART RS485 function mode */
574 uart->FUNCSEL = UART_FUNCSEL_RS485;
575
576 /* Set RS485 configuration */
577 uart->ALTCTL &= ~(UART_ALTCTL_RS485NMM_Msk | UART_ALTCTL_RS485AUD_Msk | UART_ALTCTL_RS485AAD_Msk | UART_ALTCTL_ADDRMV_Msk);
578 uart->ALTCTL |= (u32Mode | (u32Addr << UART_ALTCTL_ADDRMV_Pos));
579 }
580
581
582 /**
583 * @brief Select and configure LIN function
584 *
585 * @param[in] uart The pointer of the specified UART module.
586 * @param[in] u32Mode The LIN direction :
587 * - \ref UART_ALTCTL_LINTXEN_Msk
588 * - \ref UART_ALTCTL_LINRXEN_Msk
589 * @param[in] u32BreakLength The break field length.
590 *
591 * @return None
592 *
593 * @details The function is used to set LIN relative setting.
594 */
UART_SelectLINMode(UART_T * uart,uint32_t u32Mode,uint32_t u32BreakLength)595 void UART_SelectLINMode(UART_T* uart, uint32_t u32Mode, uint32_t u32BreakLength)
596 {
597 /* Select LIN function mode */
598 uart->FUNCSEL = UART_FUNCSEL_LIN;
599
600 /* Select LIN function setting : Tx enable, Rx enable and break field length */
601 uart->ALTCTL &= ~(UART_ALTCTL_LINTXEN_Msk | UART_ALTCTL_LINRXEN_Msk | UART_ALTCTL_BRKFL_Msk);
602 uart->ALTCTL |= (u32Mode | (u32BreakLength << UART_ALTCTL_BRKFL_Pos));
603 }
604
605
606 /**
607 * @brief Write UART data
608 *
609 * @param[in] uart The pointer of the specified UART module.
610 * @param[in] pu8TxBuf The buffer to send the data to UART transmission FIFO.
611 * @param[out] u32WriteBytes The byte number of data.
612 *
613 * @return u32Count transfer byte count
614 *
615 * @details The function is to write data into TX buffer to transmit data by UART.
616 */
UART_Write(UART_T * uart,uint8_t pu8TxBuf[],uint32_t u32WriteBytes)617 uint32_t UART_Write(UART_T* uart, uint8_t pu8TxBuf[], uint32_t u32WriteBytes)
618 {
619 uint32_t u32Count, u32delayno;
620 uint32_t u32Exit = 0ul;
621
622 for(u32Count = 0ul; u32Count != u32WriteBytes; u32Count++)
623 {
624 u32delayno = 0ul;
625 while(uart->FIFOSTS & UART_FIFOSTS_TXFULL_Msk) /* Wait Tx not full or Time-out manner */
626 {
627 u32delayno++;
628 if(u32delayno >= 0x40000000ul)
629 {
630 u32Exit = 1ul;
631 break;
632 }
633 else
634 {
635 }
636 }
637
638 if(u32Exit == 1ul)
639 {
640 break;
641 }
642 else
643 {
644 uart->DAT = pu8TxBuf[u32Count]; /* Send UART Data from buffer */
645 }
646 }
647
648 return u32Count;
649 }
650
651 /**
652 * @brief Select Single Wire mode function
653 *
654 * @param[in] uart The pointer of the specified UART module.
655 *
656 * @return None
657 *
658 * @details The function is used to select Single Wire mode.
659 */
UART_SelectSingleWireMode(UART_T * uart)660 void UART_SelectSingleWireMode(UART_T *uart)
661 {
662 /* Select UART Single Wire function mode */
663 uart->FUNCSEL = ((uart->FUNCSEL & (~UART_FUNCSEL_FUNCSEL_Msk)) | UART_FUNCSEL_SINGLE_WIRE);
664 }
665
666 /*@}*/ /* end of group UART_EXPORTED_FUNCTIONS */
667
668 /*@}*/ /* end of group UART_Driver */
669
670 /*@}*/ /* end of group Standard_Driver */
671
