1 /*
2  * Copyright 2017 NXP
3  * All rights reserved.
4  *
5  *
6  * SPDX-License-Identifier: BSD-3-Clause
7  *
8  */
9 #include "fsl_io.h"
10 #include "fsl_debug_console_conf.h"
11 
12 /*******************************************************************************
13  * Definitions
14  ******************************************************************************/
15 /* check avaliable device  */
16 #if (defined(FSL_FEATURE_SOC_UART_COUNT) && (FSL_FEATURE_SOC_UART_COUNT != 0))
17 #define DEBUG_CONSOLE_IO_UART
18 #endif
19 
20 #if (defined(FSL_FEATURE_SOC_IUART_COUNT) && (FSL_FEATURE_SOC_IUART_COUNT != 0))
21 #define DEBUG_CONSOLE_IO_IUART
22 #endif
23 
24 #if (defined(FSL_FEATURE_SOC_LPUART_COUNT) && (FSL_FEATURE_SOC_LPUART_COUNT != 0))
25 #define DEBUG_CONSOLE_IO_LPUART
26 #endif
27 
28 #if (defined(FSL_FEATURE_SOC_LPSCI_COUNT) && (FSL_FEATURE_SOC_LPSCI_COUNT != 0))
29 #define DEBUG_CONSOLE_IO_LPSCI
30 #endif
31 
32 #if ((defined(FSL_FEATURE_SOC_USB_COUNT) && (FSL_FEATURE_SOC_USB_COUNT == 0)) && defined(BOARD_USE_VIRTUALCOM))
33 #define DEBUG_CONSOLE_IO_USBCDC
34 #endif
35 
36 #if (defined(FSL_FEATURE_SOC_FLEXCOMM_COUNT) && (FSL_FEATURE_SOC_FLEXCOMM_COUNT != 0))
37 #define DEBUG_CONSOLE_IO_FLEXCOMM
38 #endif
39 
40 #if (defined(FSL_FEATURE_SOC_VFIFO_COUNT) && (FSL_FEATURE_SOC_VFIFO_COUNT != 0))
41 #define DEBUG_CONSOLE_IO_VUSART
42 #endif
43 
44 /* configuration for debug console device */
45 /* If new device is required as the low level device for debug console,
46  * Add the #elif branch and add the preprocessor macro to judge whether
47  * this kind of device exist in this SOC. */
48 #if (defined DEBUG_CONSOLE_IO_UART) || (defined DEBUG_CONSOLE_IO_IUART)
49 #include "fsl_uart.h"
50 #ifdef DEBUG_CONSOLE_TRANSFER_NON_BLOCKING
51 static uart_handle_t s_ioUartHandler;
52 #endif /* DEBUG_CONSOLE_TRANSFER_NON_BLOCKING */
53 #endif /* defined DEBUG_CONSOLE_IO_UART) || (defined DEBUG_CONSOLE_IO_IUART */
54 
55 #if defined DEBUG_CONSOLE_IO_LPUART
56 #include "fsl_lpuart.h"
57 #ifdef DEBUG_CONSOLE_TRANSFER_NON_BLOCKING
58 static lpuart_handle_t s_ioLpuartHandler;
59 #endif /* DEBUG_CONSOLE_TRANSFER_NON_BLOCKING */
60 #endif /* DEBUG_CONSOLE_IO_LPUART */
61 
62 #if defined DEBUG_CONSOLE_IO_LPSCI
63 #include "fsl_lpsci.h"
64 #ifdef DEBUG_CONSOLE_TRANSFER_NON_BLOCKING
65 static lpsci_handle_t s_ioLpsciHandler;
66 #endif /* DEBUG_CONSOLE_TRANSFER_NON_BLOCKING */
67 #endif /* DEBUG_CONSOLE_IO_LPSCI */
68 
69 #if defined DEBUG_CONSOLE_IO_USBCDC
70 #include "usb_device_config.h"
71 #include "usb.h"
72 #include "usb_device_cdc_acm.h"
73 #include "usb_device_ch9.h"
74 #include "virtual_com.h"
75 #endif /* DEBUG_CONSOLE_IO_USBCDC */
76 
77 #if (defined DEBUG_CONSOLE_IO_FLEXCOMM) || (defined DEBUG_CONSOLE_IO_VUSART)
78 #include "fsl_usart.h"
79 #ifdef DEBUG_CONSOLE_TRANSFER_NON_BLOCKING
80 static usart_handle_t s_ioUsartHandler;
81 #endif /* DEBUG_CONSOLE_TRANSFER_NON_BLOCKING */
82 #endif /* defined DEBUG_CONSOLE_IO_FLEXCOMM) || (defined DEBUG_CONSOLE_IO_VUSART */
83 
84 /*******************************************************************************
85  * Variables
86  ******************************************************************************/
87 
88 /*! @brief Debug console IO state information. */
89 static io_state_t s_debugConsoleIO = {
90     .ioBase = NULL,
91     .ioType = DEBUG_CONSOLE_DEVICE_TYPE_NONE,
92 #ifdef DEBUG_CONSOLE_TRANSFER_NON_BLOCKING
93     .callBack = NULL,
94 #endif /* DEBUG_CONSOLE_TRANSFER_NON_BLOCKING */
95 };
96 
97 /*******************************************************************************
98  * Code
99  ******************************************************************************/
100 
101 #ifdef DEBUG_CONSOLE_TRANSFER_NON_BLOCKING
102 
103 #if (defined DEBUG_CONSOLE_IO_UART) || (defined DEBUG_CONSOLE_IO_IUART)
UART_Callback(UART_Type * base,uart_handle_t * handle,status_t status,void * userData)104 static void UART_Callback(UART_Type *base, uart_handle_t *handle, status_t status, void *userData)
105 {
106     bool tx = false, rx = false;
107     size_t size = 0U;
108 
109     if (status == kStatus_UART_RxIdle)
110     {
111         rx = true;
112         size = handle->txDataSizeAll;
113     }
114 
115     if (status == kStatus_UART_TxIdle)
116     {
117         tx = true;
118         size = handle->txDataSizeAll;
119     }
120 
121     /* inform the buffer layer that transfer is complete */
122     if (s_debugConsoleIO.callBack != NULL)
123     {
124         /* call buffer callback function */
125         s_debugConsoleIO.callBack(&size, rx, tx);
126     }
127 }
128 #endif /* defined DEBUG_CONSOLE_IO_UART) || (defined DEBUG_CONSOLE_IO_IUART */
129 
130 #if defined DEBUG_CONSOLE_IO_LPSCI
LPSCI_Callback(UART0_Type * base,lpsci_handle_t * handle,status_t status,void * userData)131 static void LPSCI_Callback(UART0_Type *base, lpsci_handle_t *handle, status_t status, void *userData)
132 {
133     bool tx = false, rx = false;
134     size_t size = 0U;
135 
136     if (status == kStatus_LPSCI_RxIdle)
137     {
138         rx = true;
139         size = handle->txDataSizeAll;
140     }
141 
142     if (status == kStatus_LPSCI_TxIdle)
143     {
144         tx = true;
145         size = handle->txDataSizeAll;
146     }
147 
148     /* inform the buffer layer that transfer is complete */
149     if (s_debugConsoleIO.callBack != NULL)
150     {
151         /* call buffer callback function */
152         s_debugConsoleIO.callBack(&size, rx, tx);
153     }
154 }
155 #endif /* DEBUG_CONSOLE_IO_LPSCI */
156 
157 #if defined DEBUG_CONSOLE_IO_LPUART
LPUART_Callback(LPUART_Type * base,lpuart_handle_t * handle,status_t status,void * userData)158 static void LPUART_Callback(LPUART_Type *base, lpuart_handle_t *handle, status_t status, void *userData)
159 {
160     bool tx = false, rx = false;
161     size_t size = 0U;
162 
163     if (status == kStatus_LPUART_RxIdle)
164     {
165         rx = true;
166         size = handle->txDataSizeAll;
167     }
168 
169     if (status == kStatus_LPUART_TxIdle)
170     {
171         tx = true;
172         size = handle->txDataSizeAll;
173     }
174 
175     /* inform the buffer layer that transfer is complete */
176     if (s_debugConsoleIO.callBack != NULL)
177     {
178         /* call buffer callback function */
179         s_debugConsoleIO.callBack(&size, rx, tx);
180     }
181 }
182 #endif /* DEBUG_CONSOLE_IO_LPUART */
183 
184 #if (defined DEBUG_CONSOLE_IO_FLEXCOMM) || (defined DEBUG_CONSOLE_IO_VUSART)
USART_Callback(USART_Type * base,usart_handle_t * handle,status_t status,void * userData)185 static void USART_Callback(USART_Type *base, usart_handle_t *handle, status_t status, void *userData)
186 {
187     bool tx = false, rx = false;
188     size_t size = 0U;
189 
190     if (status == kStatus_USART_RxIdle)
191     {
192         rx = true;
193         size = handle->txDataSizeAll;
194     }
195 
196     if (status == kStatus_USART_TxIdle)
197     {
198         tx = true;
199         size = handle->txDataSizeAll;
200     }
201 
202     /* inform the buffer layer that transfer is complete */
203     if (s_debugConsoleIO.callBack != NULL)
204     {
205         /* call buffer callback function */
206         s_debugConsoleIO.callBack(&size, rx, tx);
207     }
208 }
209 #endif /* defined DEBUG_CONSOLE_IO_FLEXCOMM) || (defined DEBUG_CONSOLE_IO_VUSART */
210 #endif /* DEBUG_CONSOLE_TRANSFER_NON_BLOCKING */
211 
IO_Init(io_state_t * io,uint32_t baudRate,uint32_t clkSrcFreq,uint8_t * ringBuffer)212 void IO_Init(io_state_t *io, uint32_t baudRate, uint32_t clkSrcFreq, uint8_t *ringBuffer)
213 {
214     assert(NULL != io);
215 
216     /* record device type/base */
217     s_debugConsoleIO.ioType = io->ioType;
218     s_debugConsoleIO.ioBase = (void *)(io->ioBase);
219 
220     switch (s_debugConsoleIO.ioType)
221     {
222 #if (defined DEBUG_CONSOLE_IO_UART) || (defined DEBUG_CONSOLE_IO_IUART)
223         case DEBUG_CONSOLE_DEVICE_TYPE_UART:
224         case DEBUG_CONSOLE_DEVICE_TYPE_IUART:
225         {
226             uart_config_t uart_config;
227             UART_GetDefaultConfig(&uart_config);
228             uart_config.baudRate_Bps = baudRate;
229             /* Enable clock and initial UART module follow user configure structure. */
230             UART_Init((UART_Type *)s_debugConsoleIO.ioBase, &uart_config, clkSrcFreq);
231             UART_EnableTx(s_debugConsoleIO.ioBase, true);
232             UART_EnableRx(s_debugConsoleIO.ioBase, true);
233 #ifdef DEBUG_CONSOLE_TRANSFER_NON_BLOCKING
234             s_debugConsoleIO.callBack = io->callBack;
235             /* create handler for interrupt transfer */
236             UART_TransferCreateHandle(s_debugConsoleIO.ioBase, &s_ioUartHandler, UART_Callback, NULL);
237             /* start ring buffer */
238             UART_TransferStartRingBuffer(s_debugConsoleIO.ioBase, &s_ioUartHandler, ringBuffer,
239                                          DEBUG_CONSOLE_RECEIVE_BUFFER_LEN);
240 #endif
241         }
242         break;
243 #endif
244 
245 #if defined DEBUG_CONSOLE_IO_LPUART
246         case DEBUG_CONSOLE_DEVICE_TYPE_LPUART:
247         {
248             lpuart_config_t lpuart_config;
249             LPUART_GetDefaultConfig(&lpuart_config);
250             lpuart_config.baudRate_Bps = baudRate;
251             /* Enable clock and initial UART module follow user configure structure. */
252             LPUART_Init((LPUART_Type *)s_debugConsoleIO.ioBase, &lpuart_config, clkSrcFreq);
253             LPUART_EnableTx(s_debugConsoleIO.ioBase, true);
254             LPUART_EnableRx(s_debugConsoleIO.ioBase, true);
255 #ifdef DEBUG_CONSOLE_TRANSFER_NON_BLOCKING
256             s_debugConsoleIO.callBack = io->callBack;
257             /* create handler for interrupt transfer */
258             LPUART_TransferCreateHandle(s_debugConsoleIO.ioBase, &s_ioLpuartHandler, LPUART_Callback, NULL);
259             /* start ring buffer */
260             LPUART_TransferStartRingBuffer(s_debugConsoleIO.ioBase, &s_ioLpuartHandler, ringBuffer,
261                                            DEBUG_CONSOLE_RECEIVE_BUFFER_LEN);
262 #endif
263         }
264         break;
265 #endif
266 #if defined DEBUG_CONSOLE_IO_LPSCI
267         case DEBUG_CONSOLE_DEVICE_TYPE_LPSCI:
268         {
269             lpsci_config_t lpsci_config;
270             LPSCI_GetDefaultConfig(&lpsci_config);
271             lpsci_config.baudRate_Bps = baudRate;
272             /* Enable clock and initial UART module follow user configure structure. */
273             LPSCI_Init((UART0_Type *)s_debugConsoleIO.ioBase, &lpsci_config, clkSrcFreq);
274             LPSCI_EnableTx(s_debugConsoleIO.ioBase, true);
275             LPSCI_EnableRx(s_debugConsoleIO.ioBase, true);
276 #ifdef DEBUG_CONSOLE_TRANSFER_NON_BLOCKING
277             s_debugConsoleIO.callBack = io->callBack;
278             /* create handler for interrupt transfer */
279             LPSCI_TransferCreateHandle(s_debugConsoleIO.ioBase, &s_ioLpsciHandler, LPSCI_Callback, NULL);
280             /* start ring buffer */
281             LPSCI_TransferStartRingBuffer(s_debugConsoleIO.ioBase, &s_ioLpsciHandler, ringBuffer,
282                                           DEBUG_CONSOLE_RECEIVE_BUFFER_LEN);
283 #endif
284         }
285         break;
286 #endif
287 #if defined DEBUG_CONSOLE_IO_USBCDC
288         case DEBUG_CONSOLE_DEVICE_TYPE_USBCDC:
289         {
290             s_debugConsoleIO.ioBase = USB_VcomInit();
291         }
292         break;
293 #endif
294 #if defined DEBUG_CONSOLE_IO_FLEXCOMM
295         case DEBUG_CONSOLE_DEVICE_TYPE_FLEXCOMM:
296         {
297             usart_config_t usart_config;
298             USART_GetDefaultConfig(&usart_config);
299             usart_config.baudRate_Bps = baudRate;
300             /* Enable clock and initial UART module follow user configure structure. */
301             USART_Init((USART_Type *)s_debugConsoleIO.ioBase, &usart_config, clkSrcFreq);
302 #ifdef DEBUG_CONSOLE_TRANSFER_NON_BLOCKING
303             s_debugConsoleIO.callBack = io->callBack;
304             /* create handler for interrupt transfer */
305             USART_TransferCreateHandle(s_debugConsoleIO.ioBase, &s_ioUsartHandler, USART_Callback, NULL);
306             /* start ring buffer */
307             USART_TransferStartRingBuffer(s_debugConsoleIO.ioBase, &s_ioUsartHandler, ringBuffer,
308                                           DEBUG_CONSOLE_RECEIVE_BUFFER_LEN);
309 #endif
310         }
311         break;
312 #endif
313 #if defined DEBUG_CONSOLE_IO_VUSART
314         case DEBUG_CONSOLE_DEVICE_TYPE_VUSART:
315         {
316             usart_config_t usart_config;
317             USART_GetDefaultConfig(&usart_config);
318             usart_config.baudRate_Bps = baudRate;
319             usart_config.enableRx = true;
320             usart_config.enableTx = true;
321             /* Enable clock and initial UART module follow user configure structure. */
322             USART_Init((USART_Type *)s_debugConsoleIO.ioBase, &usart_config, clkSrcFreq);
323 #ifdef DEBUG_CONSOLE_TRANSFER_NON_BLOCKING
324             s_debugConsoleIO.callBack = io->callBack;
325             /* create handler for interrupt transfer */
326             USART_TransferCreateHandle(s_debugConsoleIO.ioBase, &s_ioUsartHandler, USART_Callback, NULL);
327             /* start ring buffer */
328             USART_TransferStartRingBuffer(s_debugConsoleIO.ioBase, &s_ioUsartHandler, ringBuffer,
329                                           DEBUG_CONSOLE_RECEIVE_BUFFER_LEN);
330 #endif
331         }
332         break;
333 #endif
334     }
335 }
336 
IO_Deinit(void)337 status_t IO_Deinit(void)
338 {
339     if (s_debugConsoleIO.ioType == DEBUG_CONSOLE_DEVICE_TYPE_NONE)
340     {
341         return kStatus_Success;
342     }
343 
344     switch (s_debugConsoleIO.ioType)
345     {
346 #if (defined DEBUG_CONSOLE_IO_UART) || (defined DEBUG_CONSOLE_IO_IUART)
347         case DEBUG_CONSOLE_DEVICE_TYPE_UART:
348         case DEBUG_CONSOLE_DEVICE_TYPE_IUART:
349 #ifdef DEBUG_CONSOLE_TRANSFER_NON_BLOCKING
350             /* stop ring buffer */
351             UART_TransferStopRingBuffer(s_debugConsoleIO.ioBase, &s_ioUartHandler);
352 #endif
353             /* Disable UART module. */
354             UART_Deinit((UART_Type *)s_debugConsoleIO.ioBase);
355 
356             break;
357 #endif
358 #if defined DEBUG_CONSOLE_IO_LPSCI
359         case DEBUG_CONSOLE_DEVICE_TYPE_LPSCI:
360 #ifdef DEBUG_CONSOLE_TRANSFER_NON_BLOCKING
361             /* stop ring buffer */
362             LPSCI_TransferStopRingBuffer(s_debugConsoleIO.ioBase, &s_ioLpsciHandler);
363 #endif
364             /* Disable LPSCI module. */
365             LPSCI_Deinit((UART0_Type *)s_debugConsoleIO.ioBase);
366 
367             break;
368 #endif
369 #if defined DEBUG_CONSOLE_IO_LPUART
370         case DEBUG_CONSOLE_DEVICE_TYPE_LPUART:
371 #ifdef DEBUG_CONSOLE_TRANSFER_NON_BLOCKING
372             /* stop ring buffer */
373             LPUART_TransferStopRingBuffer(s_debugConsoleIO.ioBase, &s_ioLpuartHandler);
374 #endif
375             /* Disable LPUART module. */
376             LPUART_Deinit((LPUART_Type *)s_debugConsoleIO.ioBase);
377 
378             break;
379 #endif
380 #if defined DEBUG_CONSOLE_IO_USBCDC
381         case DEBUG_CONSOLE_DEVICE_TYPE_USBCDC:
382             /* Disable USBCDC module. */
383             USB_VcomDeinit(s_debugConsoleIO.ioBase);
384             break;
385 #endif
386 #if (defined DEBUG_CONSOLE_IO_FLEXCOMM) || (defined DEBUG_CONSOLE_IO_VUSART)
387         case DEBUG_CONSOLE_DEVICE_TYPE_FLEXCOMM:
388         case DEBUG_CONSOLE_DEVICE_TYPE_VUSART:
389 #ifdef DEBUG_CONSOLE_TRANSFER_NON_BLOCKING
390             /* stop ring buffer */
391             USART_TransferStopRingBuffer(s_debugConsoleIO.ioBase, &s_ioUsartHandler);
392 #endif
393             /* deinit IO */
394             USART_Deinit((USART_Type *)s_debugConsoleIO.ioBase);
395 
396             break;
397 #endif
398         default:
399             s_debugConsoleIO.ioType = DEBUG_CONSOLE_DEVICE_TYPE_NONE;
400             break;
401     }
402 
403     s_debugConsoleIO.ioType = DEBUG_CONSOLE_DEVICE_TYPE_NONE;
404 
405     return kStatus_Success;
406 }
407 
IO_WaitIdle(void)408 status_t IO_WaitIdle(void)
409 {
410     switch (s_debugConsoleIO.ioType)
411     {
412 #if (defined DEBUG_CONSOLE_IO_UART)
413         case DEBUG_CONSOLE_DEVICE_TYPE_UART:
414             /* wait transfer complete flag */
415             while (!(UART_GetStatusFlags(s_debugConsoleIO.ioBase) & kUART_TransmissionCompleteFlag))
416                 ;
417             break;
418 #endif
419 
420 #if (defined DEBUG_CONSOLE_IO_IUART)
421         case DEBUG_CONSOLE_DEVICE_TYPE_IUART:
422             /* wait transfer complete flag */
423             while (!(UART_GetStatusFlag(s_debugConsoleIO.ioBase, kUART_TxCompleteFlag)))
424                 ;
425             break;
426 #endif
427 
428 #if defined DEBUG_CONSOLE_IO_LPSCI
429         case DEBUG_CONSOLE_DEVICE_TYPE_LPSCI:
430             /* wait transfer complete flag */
431             while (!(LPSCI_GetStatusFlags(s_debugConsoleIO.ioBase) & kLPSCI_TransmissionCompleteFlag))
432                 ;
433             break;
434 #endif
435 
436 #if defined DEBUG_CONSOLE_IO_LPUART
437         case DEBUG_CONSOLE_DEVICE_TYPE_LPUART:
438             /* wait transfer complete flag */
439             while (!(LPUART_GetStatusFlags(s_debugConsoleIO.ioBase) & kLPUART_TransmissionCompleteFlag))
440                 ;
441             break;
442 #endif
443 
444 #if (defined DEBUG_CONSOLE_IO_FLEXCOMM) || (defined DEBUG_CONSOLE_IO_VUSART)
445         case DEBUG_CONSOLE_DEVICE_TYPE_FLEXCOMM:
446         case DEBUG_CONSOLE_DEVICE_TYPE_VUSART:
447             /* wait transfer complete flag */
448             while (!(USART_GetStatusFlags(s_debugConsoleIO.ioBase) & kUSART_TxFifoEmptyFlag))
449                 ;
450             break;
451 #endif
452         default:
453             break;
454     }
455 
456     return kStatus_Success;
457 }
458 
459 #ifdef DEBUG_CONSOLE_TRANSFER_NON_BLOCKING
460 
IO_Transfer(uint8_t * ch,size_t size,bool tx)461 status_t IO_Transfer(uint8_t *ch, size_t size, bool tx)
462 {
463     status_t status = kStatus_Fail;
464 
465     switch (s_debugConsoleIO.ioType)
466     {
467 #if (defined DEBUG_CONSOLE_IO_UART) || (defined DEBUG_CONSOLE_IO_IUART)
468         case DEBUG_CONSOLE_DEVICE_TYPE_UART:
469         case DEBUG_CONSOLE_DEVICE_TYPE_IUART:
470         {
471             uart_transfer_t transfer = {0U};
472             transfer.data = ch;
473             transfer.dataSize = size;
474             /* transfer data */
475             if (tx)
476             {
477                 status = UART_TransferSendNonBlocking(s_debugConsoleIO.ioBase, &s_ioUartHandler, &transfer);
478             }
479             else
480             {
481                 status = UART_TransferReceiveNonBlocking(s_debugConsoleIO.ioBase, &s_ioUartHandler, &transfer, NULL);
482             }
483         }
484         break;
485 #endif
486 #if defined DEBUG_CONSOLE_IO_LPSCI
487         case DEBUG_CONSOLE_DEVICE_TYPE_LPSCI:
488         {
489             lpsci_transfer_t transfer = {0U};
490             transfer.data = ch;
491             transfer.dataSize = size;
492             /* transfer data */
493             if (tx)
494             {
495                 status = LPSCI_TransferSendNonBlocking(s_debugConsoleIO.ioBase, &s_ioLpsciHandler, &transfer);
496             }
497             else
498             {
499                 status = LPSCI_TransferReceiveNonBlocking(s_debugConsoleIO.ioBase, &s_ioLpsciHandler, &transfer, NULL);
500             }
501         }
502         break;
503 #endif
504 
505 #if defined DEBUG_CONSOLE_IO_LPUART
506         case DEBUG_CONSOLE_DEVICE_TYPE_LPUART:
507         {
508             lpuart_transfer_t transfer = {0U};
509             transfer.data = ch;
510             transfer.dataSize = size;
511             /* transfer data */
512             if (tx)
513             {
514                 status = LPUART_TransferSendNonBlocking(s_debugConsoleIO.ioBase, &s_ioLpuartHandler, &transfer);
515             }
516             else
517             {
518                 status =
519                     LPUART_TransferReceiveNonBlocking(s_debugConsoleIO.ioBase, &s_ioLpuartHandler, &transfer, NULL);
520             }
521         }
522         break;
523 #endif
524 
525 #if defined DEBUG_CONSOLE_IO_USBCDC
526         case DEBUG_CONSOLE_DEVICE_TYPE_USBCDC:
527         {
528             if (tx)
529             {
530                 USB_VcomWriteBlocking(s_debugConsoleIO.ioBase, ch, size);
531             }
532             else
533             {
534                 USB_VcomReadBlocking(s_debugConsoleIO.ioBase, ch, size);
535             }
536         }
537         break;
538 #endif
539 
540 #if (defined DEBUG_CONSOLE_IO_FLEXCOMM) || (defined DEBUG_CONSOLE_IO_VUSART)
541         case DEBUG_CONSOLE_DEVICE_TYPE_FLEXCOMM:
542         case DEBUG_CONSOLE_DEVICE_TYPE_VUSART:
543         {
544             usart_transfer_t transfer = {0U};
545             transfer.data = ch;
546             transfer.dataSize = size;
547             /* transfer data */
548             if (tx)
549             {
550                 status = USART_TransferSendNonBlocking(s_debugConsoleIO.ioBase, &s_ioUsartHandler, &transfer);
551             }
552             else
553             {
554                 status = USART_TransferReceiveNonBlocking(s_debugConsoleIO.ioBase, &s_ioUsartHandler, &transfer, NULL);
555             }
556         }
557         break;
558 #endif
559         default:
560             break;
561     }
562 
563     return status;
564 }
565 
566 #else
567 
IO_Transfer(uint8_t * ch,size_t size,bool tx)568 status_t IO_Transfer(uint8_t *ch, size_t size, bool tx)
569 {
570     status_t status = kStatus_Success;
571     switch (s_debugConsoleIO.ioType)
572     {
573 #if (defined DEBUG_CONSOLE_IO_UART) || (defined DEBUG_CONSOLE_IO_IUART)
574         case DEBUG_CONSOLE_DEVICE_TYPE_UART:
575         case DEBUG_CONSOLE_DEVICE_TYPE_IUART:
576         {
577             if (tx)
578             {
579                 UART_WriteBlocking(s_debugConsoleIO.ioBase, ch, size);
580             }
581             else
582             {
583                 status = UART_ReadBlocking(s_debugConsoleIO.ioBase, ch, size);
584             }
585         }
586         break;
587 #endif
588 #if defined DEBUG_CONSOLE_IO_LPSCI
589         case DEBUG_CONSOLE_DEVICE_TYPE_LPSCI:
590         {
591             if (tx)
592             {
593                 LPSCI_WriteBlocking(s_debugConsoleIO.ioBase, ch, size);
594             }
595             else
596             {
597                 status = LPSCI_ReadBlocking(s_debugConsoleIO.ioBase, ch, size);
598             }
599         }
600         break;
601 #endif
602 
603 #if defined DEBUG_CONSOLE_IO_LPUART
604         case DEBUG_CONSOLE_DEVICE_TYPE_LPUART:
605         {
606             if (tx)
607             {
608                 LPUART_WriteBlocking(s_debugConsoleIO.ioBase, ch, size);
609             }
610             else
611             {
612                 status = LPUART_ReadBlocking(s_debugConsoleIO.ioBase, ch, size);
613             }
614         }
615         break;
616 #endif
617 
618 #if defined DEBUG_CONSOLE_IO_USBCDC
619         case DEBUG_CONSOLE_DEVICE_TYPE_USBCDC:
620         {
621             if (tx)
622             {
623                 USB_VcomWriteBlocking(s_debugConsoleIO.ioBase, ch, size);
624             }
625             else
626             {
627                 status = USB_VcomReadBlocking(s_debugConsoleIO.ioBase, ch, size);
628             }
629         }
630         break;
631 #endif
632 
633 #if (defined DEBUG_CONSOLE_IO_FLEXCOMM) || (defined DEBUG_CONSOLE_IO_VUSART)
634         case DEBUG_CONSOLE_DEVICE_TYPE_FLEXCOMM:
635         case DEBUG_CONSOLE_DEVICE_TYPE_VUSART:
636         {
637             if (tx)
638             {
639                 USART_WriteBlocking(s_debugConsoleIO.ioBase, ch, size);
640             }
641             else
642             {
643                 status = USART_ReadBlocking(s_debugConsoleIO.ioBase, ch, size);
644             }
645         }
646         break;
647 #endif
648         default:
649             status = kStatus_Fail;
650             break;
651     }
652 
653     return status;
654 }
655 #endif /* DEBUG_CONSOLE_TRANSFER_NON_BLOCKING */
656