1 /*
2 * This is a modified version of the file printf.c, which was distributed
3 * by Motorola as part of the M5407C3BOOT.zip package used to initialize
4 * the M5407C3 evaluation board.
5 *
6 * Copyright:
7 * 1999-2000 MOTOROLA, INC. All Rights Reserved.
8 * You are hereby granted a copyright license to use, modify, and
9 * distribute the SOFTWARE so long as this entire notice is
10 * retained without alteration in any modified and/or redistributed
11 * versions, and that such modified versions are clearly identified
12 * as such. No licenses are granted by implication, estoppel or
13 * otherwise under any patents or trademarks of Motorola, Inc. This
14 * software is provided on an "AS IS" basis and without warranty.
15 *
16 * To the maximum extent permitted by applicable law, MOTOROLA
17 * DISCLAIMS ALL WARRANTIES WHETHER EXPRESS OR IMPLIED, INCLUDING
18 * IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR
19 * PURPOSE AND ANY WARRANTY AGAINST INFRINGEMENT WITH REGARD TO THE
20 * SOFTWARE (INCLUDING ANY MODIFIED VERSIONS THEREOF) AND ANY
21 * ACCOMPANYING WRITTEN MATERIALS.
22 *
23 * To the maximum extent permitted by applicable law, IN NO EVENT
24 * SHALL MOTOROLA BE LIABLE FOR ANY DAMAGES WHATSOEVER (INCLUDING
25 * WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS, BUSINESS
26 * INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR OTHER PECUNIARY
27 * LOSS) ARISING OF THE USE OR INABILITY TO USE THE SOFTWARE.
28 *
29 * Motorola assumes no responsibility for the maintenance and support
30 * of this software
31
32 * Copyright (c) 2015, Freescale Semiconductor, Inc.
33 * Copyright 2016-2020, 2023 NXP
34 *
35 * SPDX-License-Identifier: BSD-3-Clause
36 */
37
38 #include <stdarg.h>
39 #include <stdlib.h>
40 #if defined(__CC_ARM) || defined(__ARMCC_VERSION)
41 #include <stdio.h>
42 #endif
43
44 #include "fsl_debug_console_conf.h"
45 #include "fsl_str.h"
46
47 #include "fsl_common.h"
48 #include "fsl_component_serial_manager.h"
49
50 #include "fsl_debug_console.h"
51
52 #ifdef SDK_OS_FREE_RTOS
53 #include "FreeRTOS.h"
54 #include "semphr.h"
55 #include "task.h"
56 #endif
57
58 /*******************************************************************************
59 * Definitions
60 ******************************************************************************/
61 #ifndef NDEBUG
62 #if (defined(DEBUG_CONSOLE_ASSERT_DISABLE) && (DEBUG_CONSOLE_ASSERT_DISABLE > 0U))
63 #undef assert
64 #define assert(n)
65 #else
66 /* MISRA C-2012 Rule 17.2 */
67 #undef assert
68 #define assert(n) \
69 while (!(n)) \
70 { \
71 ; \
72 }
73 #endif
74 #endif
75
76 #if (defined(SDK_DEBUGCONSOLE) && (SDK_DEBUGCONSOLE == DEBUGCONSOLE_REDIRECT_TO_SDK))
77 #define DEBUG_CONSOLE_FUNCTION_PREFIX
78 #else
79 #define DEBUG_CONSOLE_FUNCTION_PREFIX static
80 #endif
81
82 /*! @brief character backspace ASCII value */
83 #define DEBUG_CONSOLE_BACKSPACE 127U
84
85 /* lock definition */
86 #if (DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_FREERTOS)
87
88 static SemaphoreHandle_t s_debugConsoleReadSemaphore;
89 #if configSUPPORT_STATIC_ALLOCATION
90 static StaticSemaphore_t s_debugConsoleReadSemaphoreStatic;
91 #endif
92 #if (defined(DEBUG_CONSOLE_RX_ENABLE) && (DEBUG_CONSOLE_RX_ENABLE > 0U))
93 static SemaphoreHandle_t s_debugConsoleReadWaitSemaphore;
94 #if configSUPPORT_STATIC_ALLOCATION
95 static StaticSemaphore_t s_debugConsoleReadWaitSemaphoreStatic;
96 #endif
97 #endif
98
99 #elif (DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_BM)
100
101 #if (defined(DEBUG_CONSOLE_RX_ENABLE) && (DEBUG_CONSOLE_RX_ENABLE > 0U))
102 static volatile bool s_debugConsoleReadWaitSemaphore;
103 #endif
104
105 #else
106
107 #endif /* DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_FREERTOS */
108
109 /*! @brief get current runing environment is ISR or not */
110 #ifdef __CA7_REV
111 #define IS_RUNNING_IN_ISR() SystemGetIRQNestingLevel()
112 #else
113 #define IS_RUNNING_IN_ISR() __get_IPSR()
114 #endif /* __CA7_REV */
115
116 /* semaphore definition */
117 #if (DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_FREERTOS)
118
119 /* mutex semaphore */
120 /* clang-format off */
121 #if configSUPPORT_STATIC_ALLOCATION
122 #define DEBUG_CONSOLE_CREATE_MUTEX_SEMAPHORE(mutex, stack) ((mutex) = xSemaphoreCreateMutexStatic(stack))
123 #else
124 #define DEBUG_CONSOLE_CREATE_MUTEX_SEMAPHORE(mutex) ((mutex) = xSemaphoreCreateMutex())
125 #endif
126 #define DEBUG_CONSOLE_DESTROY_MUTEX_SEMAPHORE(mutex) \
127 do \
128 { \
129 if(NULL != (mutex)) \
130 { \
131 vSemaphoreDelete(mutex); \
132 (mutex) = NULL; \
133 } \
134 } while(false)
135
136 #define DEBUG_CONSOLE_GIVE_MUTEX_SEMAPHORE(mutex) \
137 { \
138 if (IS_RUNNING_IN_ISR() == 0U) \
139 { \
140 (void)xSemaphoreGive(mutex); \
141 } \
142 }
143
144 #define DEBUG_CONSOLE_TAKE_MUTEX_SEMAPHORE_BLOCKING(mutex) \
145 { \
146 if (IS_RUNNING_IN_ISR() == 0U) \
147 { \
148 (void)xSemaphoreTake(mutex, portMAX_DELAY); \
149 } \
150 }
151
152 #define DEBUG_CONSOLE_TAKE_MUTEX_SEMAPHORE_NONBLOCKING(mutex, result) \
153 { \
154 if (IS_RUNNING_IN_ISR() == 0U) \
155 { \
156 result = xSemaphoreTake(mutex, 0U); \
157 } \
158 else \
159 { \
160 result = 1U; \
161 } \
162 }
163
164 /* Binary semaphore */
165 #if configSUPPORT_STATIC_ALLOCATION
166 #define DEBUG_CONSOLE_CREATE_BINARY_SEMAPHORE(binary,stack) ((binary) = xSemaphoreCreateBinaryStatic(stack))
167 #else
168 #define DEBUG_CONSOLE_CREATE_BINARY_SEMAPHORE(binary) ((binary) = xSemaphoreCreateBinary())
169 #endif
170 #define DEBUG_CONSOLE_DESTROY_BINARY_SEMAPHORE(binary) \
171 do \
172 { \
173 if(NULL != (binary)) \
174 { \
175 vSemaphoreDelete((binary)); \
176 (binary) = NULL; \
177 } \
178 } while(false)
179 #define DEBUG_CONSOLE_TAKE_BINARY_SEMAPHORE_BLOCKING(binary) ((void)xSemaphoreTake((binary), portMAX_DELAY))
180 #define DEBUG_CONSOLE_GIVE_BINARY_SEMAPHORE_FROM_ISR(binary) ((void)xSemaphoreGiveFromISR((binary), NULL))
181
182 #elif (DEBUG_CONSOLE_SYNCHRONIZATION_BM == DEBUG_CONSOLE_SYNCHRONIZATION_MODE)
183
184 #define DEBUG_CONSOLE_CREATE_MUTEX_SEMAPHORE(mutex) (void)(mutex)
185 #define DEBUG_CONSOLE_DESTROY_MUTEX_SEMAPHORE(mutex) (void)(mutex)
186 #define DEBUG_CONSOLE_TAKE_MUTEX_SEMAPHORE_BLOCKING(mutex) (void)(mutex)
187 #define DEBUG_CONSOLE_GIVE_MUTEX_SEMAPHORE(mutex) (void)(mutex)
188 #define DEBUG_CONSOLE_TAKE_MUTEX_SEMAPHORE_NONBLOCKING(mutex, result) (result = 1U)
189
190 #define DEBUG_CONSOLE_CREATE_BINARY_SEMAPHORE(binary) (void)(binary)
191 #define DEBUG_CONSOLE_DESTROY_BINARY_SEMAPHORE(binary) (void)(binary)
192 #ifdef DEBUG_CONSOLE_TRANSFER_NON_BLOCKING
193 #define DEBUG_CONSOLE_TAKE_BINARY_SEMAPHORE_BLOCKING(binary) \
194 { \
195 while (!(binary)) \
196 { \
197 } \
198 (binary) = false; \
199 }
200 #define DEBUG_CONSOLE_GIVE_BINARY_SEMAPHORE_FROM_ISR(binary) \
201 do \
202 { \
203 (binary) = true; \
204 } while(false)
205 #else
206 #define DEBUG_CONSOLE_TAKE_BINARY_SEMAPHORE_BLOCKING(binary) (void)(binary)
207 #define DEBUG_CONSOLE_GIVE_BINARY_SEMAPHORE_FROM_ISR(binary) (void)(binary)
208 #endif /* DEBUG_CONSOLE_TRANSFER_NON_BLOCKING */
209 /* clang-format on */
210
211 /* add other implementation here
212 *such as :
213 * #elif(DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DDEBUG_CONSOLE_SYNCHRONIZATION_xxx)
214 */
215
216 #else
217
218 #error RTOS type is not defined by DEBUG_CONSOLE_SYNCHRONIZATION_MODE.
219
220 #endif /* DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_FREERTOS */
221
222 #ifdef DEBUG_CONSOLE_TRANSFER_NON_BLOCKING
223 /* receive state structure */
224 typedef struct _debug_console_write_ring_buffer
225 {
226 uint32_t ringBufferSize;
227 volatile uint32_t ringHead;
228 volatile uint32_t ringTail;
229 uint8_t ringBuffer[DEBUG_CONSOLE_TRANSMIT_BUFFER_LEN];
230 } debug_console_write_ring_buffer_t;
231 #endif
232
233 typedef struct _debug_console_state_struct
234 {
235 serial_handle_t serialHandle; /*!< serial manager handle */
236 #ifdef DEBUG_CONSOLE_TRANSFER_NON_BLOCKING
237 SERIAL_MANAGER_HANDLE_DEFINE(serialHandleBuffer);
238 debug_console_write_ring_buffer_t writeRingBuffer;
239 uint8_t readRingBuffer[DEBUG_CONSOLE_RECEIVE_BUFFER_LEN];
240 SERIAL_MANAGER_WRITE_HANDLE_DEFINE(serialWriteHandleBuffer);
241 SERIAL_MANAGER_WRITE_HANDLE_DEFINE(serialWriteHandleBuffer2);
242 SERIAL_MANAGER_READ_HANDLE_DEFINE(serialReadHandleBuffer);
243 #else
244 SERIAL_MANAGER_BLOCK_HANDLE_DEFINE(serialHandleBuffer);
245 SERIAL_MANAGER_WRITE_BLOCK_HANDLE_DEFINE(serialWriteHandleBuffer);
246 SERIAL_MANAGER_READ_BLOCK_HANDLE_DEFINE(serialReadHandleBuffer);
247 #endif
248 } debug_console_state_struct_t;
249
250 /*******************************************************************************
251 * Variables
252 ******************************************************************************/
253
254 /*! @brief Debug console state information. */
255 #if (defined(DATA_SECTION_IS_CACHEABLE) && (DATA_SECTION_IS_CACHEABLE > 0))
256 AT_NONCACHEABLE_SECTION(static debug_console_state_struct_t s_debugConsoleState);
257 #else
258 static debug_console_state_struct_t s_debugConsoleState;
259 #endif
260 serial_handle_t g_serialHandle; /*!< serial manager handle */
261
262 /*******************************************************************************
263 * Prototypes
264 ******************************************************************************/
265 /*!
266 * @brief This is a printf call back function which is used to relocate the log to buffer
267 * or print the log immediately when the local buffer is full.
268 *
269 * @param[in] buf Buffer to store log.
270 * @param[in] indicator Buffer index.
271 * @param[in] val Target character to store.
272 * @param[in] len length of the character
273 *
274 */
275 #if (defined(SDK_DEBUGCONSOLE) && (SDK_DEBUGCONSOLE == DEBUGCONSOLE_REDIRECT_TO_SDK))
276 static void DbgConsole_PrintCallback(char *buf, int32_t *indicator, char dbgVal, int len);
277 #endif
278
279 status_t DbgConsole_ReadOneCharacter(uint8_t *ch);
280 int DbgConsole_SendData(uint8_t *ch, size_t size);
281 int DbgConsole_SendDataReliable(uint8_t *ch, size_t size);
282 int DbgConsole_ReadLine(uint8_t *buf, size_t size);
283 int DbgConsole_ReadCharacter(uint8_t *ch);
284
285 #if ((SDK_DEBUGCONSOLE != DEBUGCONSOLE_REDIRECT_TO_SDK) && defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING) && \
286 (defined(DEBUG_CONSOLE_TX_RELIABLE_ENABLE) && (DEBUG_CONSOLE_TX_RELIABLE_ENABLE > 0U)))
287 DEBUG_CONSOLE_FUNCTION_PREFIX status_t DbgConsole_Flush(void);
288 #endif
289 /*******************************************************************************
290 * Code
291 ******************************************************************************/
292
293 #if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)
294
DbgConsole_SerialManagerPerformTransfer(debug_console_state_struct_t * ioState)295 static status_t DbgConsole_SerialManagerPerformTransfer(debug_console_state_struct_t *ioState)
296 {
297 serial_manager_status_t ret = kStatus_SerialManager_Error;
298 uint32_t sendDataLength;
299 uint32_t startIndex;
300 uint32_t regPrimask;
301
302 regPrimask = DisableGlobalIRQ();
303 if (ioState->writeRingBuffer.ringTail != ioState->writeRingBuffer.ringHead)
304 {
305 if (ioState->writeRingBuffer.ringHead > ioState->writeRingBuffer.ringTail)
306 {
307 sendDataLength = ioState->writeRingBuffer.ringHead - ioState->writeRingBuffer.ringTail;
308 startIndex = ioState->writeRingBuffer.ringTail;
309 }
310 else
311 {
312 sendDataLength = ioState->writeRingBuffer.ringBufferSize - ioState->writeRingBuffer.ringTail;
313 startIndex = ioState->writeRingBuffer.ringTail;
314 if (0U != ioState->writeRingBuffer.ringHead)
315 {
316 ret = SerialManager_WriteNonBlocking(((serial_write_handle_t)&ioState->serialWriteHandleBuffer2[0]),
317 &ioState->writeRingBuffer.ringBuffer[startIndex], sendDataLength);
318 sendDataLength = ioState->writeRingBuffer.ringHead - 0U;
319 startIndex = 0U;
320 }
321 }
322 ret = SerialManager_WriteNonBlocking(((serial_write_handle_t)&ioState->serialWriteHandleBuffer[0]),
323 &ioState->writeRingBuffer.ringBuffer[startIndex], sendDataLength);
324 }
325 EnableGlobalIRQ(regPrimask);
326 return (status_t)ret;
327 }
328
DbgConsole_SerialManagerTxCallback(void * callbackParam,serial_manager_callback_message_t * message,serial_manager_status_t serialManagerStatus)329 static void DbgConsole_SerialManagerTxCallback(void *callbackParam,
330 serial_manager_callback_message_t *message,
331 serial_manager_status_t serialManagerStatus)
332 {
333 debug_console_state_struct_t *ioState;
334
335 if ((NULL == callbackParam) || (NULL == message))
336 {
337 return;
338 }
339
340 ioState = (debug_console_state_struct_t *)callbackParam;
341
342 ioState->writeRingBuffer.ringTail += message->length;
343 if (ioState->writeRingBuffer.ringTail >= ioState->writeRingBuffer.ringBufferSize)
344 {
345 ioState->writeRingBuffer.ringTail = 0U;
346 }
347
348 if (kStatus_SerialManager_Success == serialManagerStatus)
349 {
350 (void)DbgConsole_SerialManagerPerformTransfer(ioState);
351 }
352 else if (kStatus_SerialManager_Canceled == serialManagerStatus)
353 {
354 ioState->writeRingBuffer.ringTail = 0U;
355 ioState->writeRingBuffer.ringHead = 0U;
356 }
357 else
358 {
359 /*MISRA rule 16.4*/
360 }
361 }
362
DbgConsole_SerialManagerTx2Callback(void * callbackParam,serial_manager_callback_message_t * message,serial_manager_status_t serialManagerStatus)363 static void DbgConsole_SerialManagerTx2Callback(void *callbackParam,
364 serial_manager_callback_message_t *message,
365 serial_manager_status_t serialManagerStatus)
366 {
367 debug_console_state_struct_t *ioState;
368
369 if ((NULL == callbackParam) || (NULL == message))
370 {
371 return;
372 }
373
374 ioState = (debug_console_state_struct_t *)callbackParam;
375
376 ioState->writeRingBuffer.ringTail += message->length;
377 if (ioState->writeRingBuffer.ringTail >= ioState->writeRingBuffer.ringBufferSize)
378 {
379 ioState->writeRingBuffer.ringTail = 0U;
380 }
381
382 if (kStatus_SerialManager_Success == serialManagerStatus)
383 {
384 /* Empty block*/
385 }
386 else if (kStatus_SerialManager_Canceled == serialManagerStatus)
387 {
388 /* Empty block*/
389 }
390 else
391 {
392 /*MISRA rule 16.4*/
393 }
394 }
395
396 #if (defined(DEBUG_CONSOLE_RX_ENABLE) && (DEBUG_CONSOLE_RX_ENABLE > 0U))
397
DbgConsole_SerialManagerRxCallback(void * callbackParam,serial_manager_callback_message_t * message,serial_manager_status_t serialManagerStatus)398 static void DbgConsole_SerialManagerRxCallback(void *callbackParam,
399 serial_manager_callback_message_t *message,
400 serial_manager_status_t serialManagerStatus)
401 {
402 if ((NULL == callbackParam) || (NULL == message))
403 {
404 return;
405 }
406
407 if (kStatus_SerialManager_Notify == serialManagerStatus)
408 {
409 }
410 else if (kStatus_SerialManager_Success == serialManagerStatus)
411 {
412 /* release s_debugConsoleReadWaitSemaphore from RX callback */
413 DEBUG_CONSOLE_GIVE_BINARY_SEMAPHORE_FROM_ISR(s_debugConsoleReadWaitSemaphore);
414 }
415 else
416 {
417 /*MISRA rule 16.4*/
418 }
419 }
420 #endif
421
422 #endif
423
DbgConsole_ReadOneCharacter(uint8_t * ch)424 status_t DbgConsole_ReadOneCharacter(uint8_t *ch)
425 {
426 #if (defined(DEBUG_CONSOLE_RX_ENABLE) && (DEBUG_CONSOLE_RX_ENABLE > 0U))
427
428 #if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING) && \
429 (DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_BM) && defined(OSA_USED)
430 return (status_t)kStatus_Fail;
431 #else /*defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING) && (DEBUG_CONSOLE_SYNCHRONIZATION_MODE == \
432 DEBUG_CONSOLE_SYNCHRONIZATION_BM) && defined(OSA_USED)*/
433 serial_manager_status_t serialManagerStatus = kStatus_SerialManager_Error;
434
435 /* recieve one char every time */
436 #if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)
437 serialManagerStatus =
438 SerialManager_ReadNonBlocking(((serial_read_handle_t)&s_debugConsoleState.serialReadHandleBuffer[0]), ch, 1);
439 #else /*defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)*/
440 serialManagerStatus =
441 SerialManager_ReadBlocking(((serial_read_handle_t)&s_debugConsoleState.serialReadHandleBuffer[0]), ch, 1);
442 #endif /*defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)*/
443 if (kStatus_SerialManager_Success != serialManagerStatus)
444 {
445 serialManagerStatus = (serial_manager_status_t)kStatus_Fail;
446 }
447 else
448 {
449 /* wait s_debugConsoleReadWaitSemaphore from RX callback */
450 DEBUG_CONSOLE_TAKE_BINARY_SEMAPHORE_BLOCKING(s_debugConsoleReadWaitSemaphore);
451 serialManagerStatus = (serial_manager_status_t)kStatus_Success;
452 }
453 return (status_t)serialManagerStatus;
454 #endif /*defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING) && (DEBUG_CONSOLE_SYNCHRONIZATION_MODE == \
455 DEBUG_CONSOLE_SYNCHRONIZATION_BM) && defined(OSA_USED)*/
456
457 #else /*(defined(DEBUG_CONSOLE_RX_ENABLE) && (DEBUG_CONSOLE_RX_ENABLE > 0U))*/
458
459 return (status_t)kStatus_Fail;
460
461 #endif /*(defined(DEBUG_CONSOLE_RX_ENABLE) && (DEBUG_CONSOLE_RX_ENABLE > 0U))*/
462 }
463
464 #if DEBUG_CONSOLE_ENABLE_ECHO_FUNCTION
DbgConsole_EchoCharacter(uint8_t * ch,bool isGetChar,int * index)465 static status_t DbgConsole_EchoCharacter(uint8_t *ch, bool isGetChar, int *index)
466 {
467 /* Due to scanf take \n and \r as end of string,should not echo */
468 if (((*ch != (uint8_t)'\r') && (*ch != (uint8_t)'\n')) || (isGetChar))
469 {
470 /* recieve one char every time */
471 if (1 != DbgConsole_SendDataReliable(ch, 1U))
472 {
473 return (status_t)kStatus_Fail;
474 }
475 }
476
477 if ((!isGetChar) && (index != NULL))
478 {
479 if (DEBUG_CONSOLE_BACKSPACE == *ch)
480 {
481 if ((*index >= 2))
482 {
483 *index -= 2;
484 }
485 else
486 {
487 *index = 0;
488 }
489 }
490 }
491
492 return (status_t)kStatus_Success;
493 }
494 #endif
495
DbgConsole_SendData(uint8_t * ch,size_t size)496 int DbgConsole_SendData(uint8_t *ch, size_t size)
497 {
498 status_t dbgConsoleStatus;
499 #if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)
500 uint32_t sendDataLength;
501 int txBusy = 0;
502 #endif
503 assert(NULL != ch);
504 assert(0U != size);
505
506 #if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)
507 uint32_t regPrimask = DisableGlobalIRQ();
508 if (s_debugConsoleState.writeRingBuffer.ringHead != s_debugConsoleState.writeRingBuffer.ringTail)
509 {
510 txBusy = 1;
511 sendDataLength =
512 (s_debugConsoleState.writeRingBuffer.ringHead + s_debugConsoleState.writeRingBuffer.ringBufferSize -
513 s_debugConsoleState.writeRingBuffer.ringTail) %
514 s_debugConsoleState.writeRingBuffer.ringBufferSize;
515 }
516 else
517 {
518 sendDataLength = 0U;
519 }
520 sendDataLength = s_debugConsoleState.writeRingBuffer.ringBufferSize - sendDataLength - 1U;
521 if (sendDataLength < size)
522 {
523 EnableGlobalIRQ(regPrimask);
524 return -1;
525 }
526 for (int i = 0; i < (int)size; i++)
527 {
528 s_debugConsoleState.writeRingBuffer.ringBuffer[s_debugConsoleState.writeRingBuffer.ringHead++] = ch[i];
529 if (s_debugConsoleState.writeRingBuffer.ringHead >= s_debugConsoleState.writeRingBuffer.ringBufferSize)
530 {
531 s_debugConsoleState.writeRingBuffer.ringHead = 0U;
532 }
533 }
534
535 dbgConsoleStatus = (status_t)kStatus_SerialManager_Success;
536
537 if (txBusy == 0)
538 {
539 dbgConsoleStatus = DbgConsole_SerialManagerPerformTransfer(&s_debugConsoleState);
540 }
541 EnableGlobalIRQ(regPrimask);
542 #else
543 dbgConsoleStatus = (status_t)SerialManager_WriteBlocking(
544 ((serial_write_handle_t)&s_debugConsoleState.serialWriteHandleBuffer[0]), ch, size);
545 #endif
546 return (((status_t)kStatus_Success == dbgConsoleStatus) ? (int)size : -1);
547 }
548
DbgConsole_SendDataReliable(uint8_t * ch,size_t size)549 int DbgConsole_SendDataReliable(uint8_t *ch, size_t size)
550 {
551 #if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)
552 #if (defined(DEBUG_CONSOLE_TX_RELIABLE_ENABLE) && (DEBUG_CONSOLE_TX_RELIABLE_ENABLE > 0U))
553 serial_manager_status_t serialManagerStatus = kStatus_SerialManager_Error;
554 uint32_t sendDataLength;
555 uint32_t totalLength = size;
556 int sentLength;
557 #endif /* DEBUG_CONSOLE_TX_RELIABLE_ENABLE */
558 #else /* DEBUG_CONSOLE_TRANSFER_NON_BLOCKING */
559 serial_manager_status_t serialManagerStatus;
560 #endif /* DEBUG_CONSOLE_TRANSFER_NON_BLOCKING */
561
562 assert(NULL != ch);
563
564 if (0U == size)
565 {
566 return 0;
567 }
568
569 if (NULL == g_serialHandle)
570 {
571 return 0;
572 }
573
574 #if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)
575
576 #if (defined(DEBUG_CONSOLE_TX_RELIABLE_ENABLE) && (DEBUG_CONSOLE_TX_RELIABLE_ENABLE > 0U))
577 do
578 {
579 uint32_t regPrimask = DisableGlobalIRQ();
580 if (s_debugConsoleState.writeRingBuffer.ringHead != s_debugConsoleState.writeRingBuffer.ringTail)
581 {
582 sendDataLength =
583 (s_debugConsoleState.writeRingBuffer.ringHead + s_debugConsoleState.writeRingBuffer.ringBufferSize -
584 s_debugConsoleState.writeRingBuffer.ringTail) %
585 s_debugConsoleState.writeRingBuffer.ringBufferSize;
586 }
587 else
588 {
589 sendDataLength = 0U;
590 }
591 sendDataLength = s_debugConsoleState.writeRingBuffer.ringBufferSize - sendDataLength - 1U;
592
593 if ((sendDataLength > 0U) && ((sendDataLength >= totalLength) ||
594 (totalLength >= (s_debugConsoleState.writeRingBuffer.ringBufferSize - 1U))))
595 {
596 if (sendDataLength > totalLength)
597 {
598 sendDataLength = totalLength;
599 }
600
601 sentLength = DbgConsole_SendData(&ch[size - totalLength], (size_t)sendDataLength);
602 if (sentLength > 0)
603 {
604 totalLength = totalLength - (uint32_t)sentLength;
605 }
606 }
607 EnableGlobalIRQ(regPrimask);
608
609 if (totalLength != 0U)
610 {
611 serialManagerStatus = (serial_manager_status_t)DbgConsole_Flush();
612 if (kStatus_SerialManager_Success != serialManagerStatus)
613 {
614 break;
615 }
616 }
617 } while (totalLength != 0U);
618 return ((int)size - (int)totalLength);
619 #else /* DEBUG_CONSOLE_TX_RELIABLE_ENABLE */
620 return DbgConsole_SendData(ch, size);
621 #endif /* DEBUG_CONSOLE_TX_RELIABLE_ENABLE */
622
623 #else /* DEBUG_CONSOLE_TRANSFER_NON_BLOCKING */
624 serialManagerStatus =
625 SerialManager_WriteBlocking(((serial_write_handle_t)&s_debugConsoleState.serialWriteHandleBuffer[0]), ch, size);
626 return ((kStatus_SerialManager_Success == serialManagerStatus) ? (int)size : -1);
627 #endif /* DEBUG_CONSOLE_TRANSFER_NON_BLOCKING */
628 }
629
DbgConsole_ReadLine(uint8_t * buf,size_t size)630 int DbgConsole_ReadLine(uint8_t *buf, size_t size)
631 {
632 int i = 0;
633
634 assert(buf != NULL);
635
636 if (NULL == g_serialHandle)
637 {
638 return -1;
639 }
640
641 /* take mutex lock function */
642 #if (DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_FREERTOS)
643 DEBUG_CONSOLE_TAKE_MUTEX_SEMAPHORE_BLOCKING(s_debugConsoleReadSemaphore);
644 #endif
645
646 do
647 {
648 /* recieve one char every time */
649 if ((status_t)kStatus_Success != DbgConsole_ReadOneCharacter(&buf[i]))
650 {
651 /* release mutex lock function */
652 #if (DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_FREERTOS)
653 DEBUG_CONSOLE_GIVE_MUTEX_SEMAPHORE(s_debugConsoleReadSemaphore);
654 #endif
655 i = -1;
656 break;
657 }
658 #if DEBUG_CONSOLE_ENABLE_ECHO_FUNCTION
659 (void)DbgConsole_EchoCharacter(&buf[i], false, &i);
660 #endif
661 /* analysis data */
662 if (((uint8_t)'\r' == buf[i]) || ((uint8_t)'\n' == buf[i]))
663 {
664 /* End of Line. */
665 if (0 == i)
666 {
667 buf[i] = (uint8_t)'\0';
668 continue;
669 }
670 else
671 {
672 break;
673 }
674 }
675 i++;
676 } while (i < (int)size);
677
678 /* get char should not add '\0'*/
679 if (i == (int)size)
680 {
681 buf[i] = (uint8_t)'\0';
682 }
683 else
684 {
685 buf[i + 1] = (uint8_t)'\0';
686 }
687
688 /* release mutex lock function */
689 #if (DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_FREERTOS)
690 DEBUG_CONSOLE_GIVE_MUTEX_SEMAPHORE(s_debugConsoleReadSemaphore);
691 #endif
692
693 return i;
694 }
695
DbgConsole_ReadCharacter(uint8_t * ch)696 int DbgConsole_ReadCharacter(uint8_t *ch)
697 {
698 int ret;
699
700 assert(ch);
701
702 if (NULL == g_serialHandle)
703 {
704 return -1;
705 }
706
707 /* take mutex lock function */
708 #if (DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_FREERTOS)
709 DEBUG_CONSOLE_TAKE_MUTEX_SEMAPHORE_BLOCKING(s_debugConsoleReadSemaphore);
710 #endif
711 /* read one character */
712 if ((status_t)kStatus_Success == DbgConsole_ReadOneCharacter(ch))
713 {
714 ret = 1;
715 #if DEBUG_CONSOLE_ENABLE_ECHO_FUNCTION
716 (void)DbgConsole_EchoCharacter(ch, true, NULL);
717 #endif
718 }
719 else
720 {
721 ret = -1;
722 }
723
724 /* release mutex lock function */
725 #if (DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_FREERTOS)
726 DEBUG_CONSOLE_GIVE_MUTEX_SEMAPHORE(s_debugConsoleReadSemaphore);
727 #endif
728
729 return ret;
730 }
731
732 #if (defined(SDK_DEBUGCONSOLE) && (SDK_DEBUGCONSOLE == DEBUGCONSOLE_REDIRECT_TO_SDK))
DbgConsole_PrintCallback(char * buf,int32_t * indicator,char dbgVal,int len)733 static void DbgConsole_PrintCallback(char *buf, int32_t *indicator, char dbgVal, int len)
734 {
735 int i = 0;
736
737 for (i = 0; i < len; i++)
738 {
739 if (((uint32_t)*indicator + 1UL) >= (uint32_t)DEBUG_CONSOLE_PRINTF_MAX_LOG_LEN)
740 {
741 (void)DbgConsole_SendDataReliable((uint8_t *)buf, (size_t)(*indicator));
742 *indicator = 0;
743 }
744
745 buf[*indicator] = dbgVal;
746 (*indicator)++;
747 }
748 }
749 #endif
750
751 /*************Code for DbgConsole Init, Deinit, Printf, Scanf *******************************/
752 #if ((SDK_DEBUGCONSOLE == DEBUGCONSOLE_REDIRECT_TO_SDK) || defined(SDK_DEBUGCONSOLE_UART))
753 #if (defined(SERIAL_USE_CONFIGURE_STRUCTURE) && (SERIAL_USE_CONFIGURE_STRUCTURE > 0U))
754 #include "board.h"
755 #if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))
756 static const serial_port_uart_config_t uartConfig = {.instance = BOARD_DEBUG_UART_INSTANCE,
757 .clockRate = BOARD_DEBUG_UART_CLK_FREQ,
758 .baudRate = BOARD_DEBUG_UART_BAUDRATE,
759 .parityMode = kSerialManager_UartParityDisabled,
760 .stopBitCount = kSerialManager_UartOneStopBit,
761 .enableRx = 1U,
762 .enableTx = 1U,
763 .enableRxRTS = 0U,
764 .enableTxCTS = 0U,
765 #if (defined(HAL_UART_ADAPTER_FIFO) && (HAL_UART_ADAPTER_FIFO > 0u))
766 .txFifoWatermark = 0U,
767 .rxFifoWatermark = 0U
768 #endif
769 };
770 #endif
771 #endif
772 /* See fsl_debug_console.h for documentation of this function. */
DbgConsole_Init(uint8_t instance,uint32_t baudRate,serial_port_type_t device,uint32_t clkSrcFreq)773 status_t DbgConsole_Init(uint8_t instance, uint32_t baudRate, serial_port_type_t device, uint32_t clkSrcFreq)
774 {
775 serial_manager_config_t serialConfig;
776 serial_manager_status_t serialManagerStatus = kStatus_SerialManager_Success;
777
778 #if (defined(SERIAL_USE_CONFIGURE_STRUCTURE) && (SERIAL_USE_CONFIGURE_STRUCTURE == 0U))
779 #if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))
780 serial_port_uart_config_t uartConfig = {
781 .instance = instance,
782 .clockRate = clkSrcFreq,
783 .baudRate = baudRate,
784 .parityMode = kSerialManager_UartParityDisabled,
785 .stopBitCount = kSerialManager_UartOneStopBit,
786 .enableRx = 1,
787 .enableTx = 1,
788 .enableRxRTS = 0U,
789 .enableTxCTS = 0U,
790 #if (defined(HAL_UART_ADAPTER_FIFO) && (HAL_UART_ADAPTER_FIFO > 0u))
791 .txFifoWatermark = 0U,
792 .rxFifoWatermark = 0U
793 #endif
794 };
795 #endif
796 #endif
797 (void)memset(&serialConfig, 0x0, sizeof(serial_manager_config_t));
798 #if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))
799 serial_port_usb_cdc_config_t usbCdcConfig = {
800 .controllerIndex = (serial_port_usb_cdc_controller_index_t)instance,
801 };
802 #endif
803
804 #if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))
805 serial_port_swo_config_t swoConfig = {
806 .clockRate = clkSrcFreq,
807 .baudRate = baudRate,
808 .port = instance,
809 .protocol = kSerialManager_SwoProtocolNrz,
810 };
811 #endif
812
813 #if (defined(SERIAL_PORT_TYPE_VIRTUAL) && (SERIAL_PORT_TYPE_VIRTUAL > 0U))
814 serial_port_virtual_config_t serialPortVirtualConfig = {
815 .controllerIndex = (serial_port_virtual_controller_index_t)instance,
816 };
817 #endif
818
819 serialConfig.type = device;
820 #if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)
821 serialConfig.ringBuffer = &s_debugConsoleState.readRingBuffer[0];
822 serialConfig.ringBufferSize = DEBUG_CONSOLE_RECEIVE_BUFFER_LEN;
823 serialConfig.blockType = kSerialManager_NonBlocking;
824 #else
825 serialConfig.blockType = kSerialManager_Blocking;
826 #endif
827
828 if (kSerialPort_Uart == device)
829 {
830 #if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))
831 #if (defined(SERIAL_USE_CONFIGURE_STRUCTURE) && (SERIAL_USE_CONFIGURE_STRUCTURE > 0U))
832 serialConfig.portConfig = (void *)&uartConfig;
833 #else
834 serialConfig.portConfig = &uartConfig;
835 #endif
836 #else
837 serialManagerStatus = kStatus_SerialManager_Error;
838 #endif
839 }
840 else if (kSerialPort_UsbCdc == device)
841 {
842 #if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))
843 serialConfig.portConfig = &usbCdcConfig;
844 #else
845 serialManagerStatus = kStatus_SerialManager_Error;
846 #endif
847 }
848 else if (kSerialPort_Swo == device)
849 {
850 #if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))
851 serialConfig.portConfig = &swoConfig;
852 #else
853 serialManagerStatus = kStatus_SerialManager_Error;
854 #endif
855 }
856 else if (kSerialPort_Virtual == device)
857 {
858 #if (defined(SERIAL_PORT_TYPE_VIRTUAL) && (SERIAL_PORT_TYPE_VIRTUAL > 0U))
859 serialConfig.portConfig = &serialPortVirtualConfig;
860 #else
861 serialManagerStatus = kStatus_SerialManager_Error;
862 #endif
863 }
864 else if (kSerialPort_BleWu == device)
865 {
866 #if (defined(SERIAL_PORT_TYPE_BLE_WU) && (SERIAL_PORT_TYPE_BLE_WU > 0U))
867 serialConfig.portConfig = NULL;
868 #else
869 serialManagerStatus = kStatus_SerialManager_Error;
870 #endif
871 }
872 else
873 {
874 serialManagerStatus = kStatus_SerialManager_Error;
875 }
876
877 if (kStatus_SerialManager_Error != serialManagerStatus)
878 {
879 (void)memset(&s_debugConsoleState, 0, sizeof(s_debugConsoleState));
880
881 #if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)
882 s_debugConsoleState.writeRingBuffer.ringBufferSize = DEBUG_CONSOLE_TRANSMIT_BUFFER_LEN;
883 #endif
884
885 s_debugConsoleState.serialHandle = (serial_handle_t)&s_debugConsoleState.serialHandleBuffer[0];
886 serialManagerStatus = SerialManager_Init(s_debugConsoleState.serialHandle, &serialConfig);
887
888 assert(kStatus_SerialManager_Success == serialManagerStatus);
889
890 #if (DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_FREERTOS)
891 #if configSUPPORT_STATIC_ALLOCATION
892 DEBUG_CONSOLE_CREATE_MUTEX_SEMAPHORE(s_debugConsoleReadSemaphore, &s_debugConsoleReadSemaphoreStatic);
893 #else
894 DEBUG_CONSOLE_CREATE_MUTEX_SEMAPHORE(s_debugConsoleReadSemaphore);
895 #endif
896 #endif
897 #if (defined(DEBUG_CONSOLE_RX_ENABLE) && (DEBUG_CONSOLE_RX_ENABLE > 0U))
898 #if (DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_FREERTOS) && configSUPPORT_STATIC_ALLOCATION
899 DEBUG_CONSOLE_CREATE_BINARY_SEMAPHORE(s_debugConsoleReadWaitSemaphore, &s_debugConsoleReadWaitSemaphoreStatic);
900 #else
901 DEBUG_CONSOLE_CREATE_BINARY_SEMAPHORE(s_debugConsoleReadWaitSemaphore);
902 #endif
903 #endif
904
905 {
906 serialManagerStatus =
907 SerialManager_OpenWriteHandle(s_debugConsoleState.serialHandle,
908 ((serial_write_handle_t)&s_debugConsoleState.serialWriteHandleBuffer[0]));
909 assert(kStatus_SerialManager_Success == serialManagerStatus);
910 #if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)
911 (void)SerialManager_InstallTxCallback(
912 ((serial_write_handle_t)&s_debugConsoleState.serialWriteHandleBuffer[0]),
913 DbgConsole_SerialManagerTxCallback, &s_debugConsoleState);
914 serialManagerStatus = SerialManager_OpenWriteHandle(
915 s_debugConsoleState.serialHandle,
916 ((serial_write_handle_t)&s_debugConsoleState.serialWriteHandleBuffer2[0]));
917 assert(kStatus_SerialManager_Success == serialManagerStatus);
918 (void)SerialManager_InstallTxCallback(
919 ((serial_write_handle_t)&s_debugConsoleState.serialWriteHandleBuffer2[0]),
920 DbgConsole_SerialManagerTx2Callback, &s_debugConsoleState);
921 #endif
922 }
923
924 #if (defined(DEBUG_CONSOLE_RX_ENABLE) && (DEBUG_CONSOLE_RX_ENABLE > 0U))
925 {
926 serialManagerStatus =
927 SerialManager_OpenReadHandle(s_debugConsoleState.serialHandle,
928 ((serial_read_handle_t)&s_debugConsoleState.serialReadHandleBuffer[0]));
929 assert(kStatus_SerialManager_Success == serialManagerStatus);
930 #if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)
931 (void)SerialManager_InstallRxCallback(
932 ((serial_read_handle_t)&s_debugConsoleState.serialReadHandleBuffer[0]),
933 DbgConsole_SerialManagerRxCallback, &s_debugConsoleState);
934 #endif
935 }
936 #endif
937
938 g_serialHandle = s_debugConsoleState.serialHandle;
939 }
940 return (status_t)serialManagerStatus;
941 }
942
943 /* See fsl_debug_console.h for documentation of this function. */
DbgConsole_EnterLowpower(void)944 status_t DbgConsole_EnterLowpower(void)
945 {
946 serial_manager_status_t serialManagerStatus = kStatus_SerialManager_Error;
947 if (s_debugConsoleState.serialHandle != NULL)
948 {
949 serialManagerStatus = SerialManager_EnterLowpower(s_debugConsoleState.serialHandle);
950 }
951 return (status_t)serialManagerStatus;
952 }
953
954 /* See fsl_debug_console.h for documentation of this function. */
DbgConsole_ExitLowpower(void)955 status_t DbgConsole_ExitLowpower(void)
956 {
957 serial_manager_status_t serialManagerStatus = kStatus_SerialManager_Error;
958
959 if (s_debugConsoleState.serialHandle != NULL)
960 {
961 serialManagerStatus = SerialManager_ExitLowpower(s_debugConsoleState.serialHandle);
962 }
963 return (status_t)serialManagerStatus;
964 }
965 /* See fsl_debug_console.h for documentation of this function. */
DbgConsole_Deinit(void)966 status_t DbgConsole_Deinit(void)
967 {
968 {
969 if (s_debugConsoleState.serialHandle != NULL)
970 {
971 #if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)
972 (void)SerialManager_CloseWriteHandle(
973 ((serial_write_handle_t)&s_debugConsoleState.serialWriteHandleBuffer2[0]));
974 #endif
975 (void)SerialManager_CloseWriteHandle(
976 ((serial_write_handle_t)&s_debugConsoleState.serialWriteHandleBuffer[0]));
977 }
978 }
979 #if (defined(DEBUG_CONSOLE_RX_ENABLE) && (DEBUG_CONSOLE_RX_ENABLE > 0U))
980 {
981 if (s_debugConsoleState.serialHandle != NULL)
982 {
983 (void)SerialManager_CloseReadHandle(((serial_read_handle_t)&s_debugConsoleState.serialReadHandleBuffer[0]));
984 }
985 }
986 #endif
987 if (NULL != s_debugConsoleState.serialHandle)
988 {
989 if (kStatus_SerialManager_Success == SerialManager_Deinit(s_debugConsoleState.serialHandle))
990 {
991 s_debugConsoleState.serialHandle = NULL;
992 g_serialHandle = NULL;
993 }
994 }
995 #if (defined(DEBUG_CONSOLE_RX_ENABLE) && (DEBUG_CONSOLE_RX_ENABLE > 0U))
996 DEBUG_CONSOLE_DESTROY_BINARY_SEMAPHORE(s_debugConsoleReadWaitSemaphore);
997 #endif
998 #if (DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_FREERTOS)
999 DEBUG_CONSOLE_DESTROY_MUTEX_SEMAPHORE(s_debugConsoleReadSemaphore);
1000 #endif
1001
1002 return (status_t)kStatus_Success;
1003 }
1004 #endif /* ((SDK_DEBUGCONSOLE == DEBUGCONSOLE_REDIRECT_TO_SDK) || defined(SDK_DEBUGCONSOLE_UART)) */
1005
1006 #if (((defined(SDK_DEBUGCONSOLE) && (SDK_DEBUGCONSOLE == DEBUGCONSOLE_REDIRECT_TO_SDK))) || \
1007 ((SDK_DEBUGCONSOLE != DEBUGCONSOLE_REDIRECT_TO_SDK) && defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING) && \
1008 (defined(DEBUG_CONSOLE_TX_RELIABLE_ENABLE) && (DEBUG_CONSOLE_TX_RELIABLE_ENABLE > 0U))))
DbgConsole_Flush(void)1009 DEBUG_CONSOLE_FUNCTION_PREFIX status_t DbgConsole_Flush(void)
1010 {
1011 #if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)
1012
1013 #if (DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_BM) && defined(OSA_USED)
1014
1015 if (s_debugConsoleState.writeRingBuffer.ringHead != s_debugConsoleState.writeRingBuffer.ringTail)
1016 {
1017 return (status_t)kStatus_Fail;
1018 }
1019
1020 #else
1021
1022 while (s_debugConsoleState.writeRingBuffer.ringHead != s_debugConsoleState.writeRingBuffer.ringTail)
1023 {
1024 #if (DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_FREERTOS)
1025 if (0U == IS_RUNNING_IN_ISR())
1026 {
1027 if (taskSCHEDULER_RUNNING == xTaskGetSchedulerState())
1028 {
1029 vTaskDelay(1);
1030 }
1031 }
1032 else
1033 {
1034 return (status_t)kStatus_Fail;
1035 }
1036 #endif
1037 }
1038
1039 #endif
1040
1041 #endif
1042 return (status_t)kStatus_Success;
1043 }
1044 #endif
1045
1046 #if (defined(SDK_DEBUGCONSOLE) && (SDK_DEBUGCONSOLE == DEBUGCONSOLE_REDIRECT_TO_SDK))
1047 /* See fsl_debug_console.h for documentation of this function. */
DbgConsole_Printf(const char * fmt_s,...)1048 int DbgConsole_Printf(const char *fmt_s, ...)
1049 {
1050 va_list ap;
1051 int result = 0;
1052
1053 va_start(ap, fmt_s);
1054 result = DbgConsole_Vprintf(fmt_s, ap);
1055 va_end(ap);
1056
1057 return result;
1058 }
1059
1060 /* See fsl_debug_console.h for documentation of this function. */
DbgConsole_Vprintf(const char * fmt_s,va_list formatStringArg)1061 int DbgConsole_Vprintf(const char *fmt_s, va_list formatStringArg)
1062 {
1063 int logLength = 0, result = 0;
1064 char printBuf[DEBUG_CONSOLE_PRINTF_MAX_LOG_LEN] = {'\0'};
1065
1066 if (NULL != g_serialHandle)
1067 {
1068 /* format print log first */
1069 logLength = StrFormatPrintf(fmt_s, formatStringArg, printBuf, DbgConsole_PrintCallback);
1070 /* print log */
1071 result = DbgConsole_SendDataReliable((uint8_t *)printBuf, (size_t)logLength);
1072 }
1073 return result;
1074 }
1075
1076 /* See fsl_debug_console.h for documentation of this function. */
DbgConsole_Putchar(int ch)1077 int DbgConsole_Putchar(int ch)
1078 {
1079 /* print char */
1080 return DbgConsole_SendDataReliable((uint8_t *)&ch, 1U);
1081 }
1082
1083 /* See fsl_debug_console.h for documentation of this function. */
DbgConsole_Scanf(char * fmt_s,...)1084 int DbgConsole_Scanf(char *fmt_s, ...)
1085 {
1086 va_list ap;
1087 int formatResult;
1088 char scanfBuf[DEBUG_CONSOLE_SCANF_MAX_LOG_LEN + 1U] = {'\0'};
1089
1090 /* scanf log */
1091 (void)DbgConsole_ReadLine((uint8_t *)scanfBuf, DEBUG_CONSOLE_SCANF_MAX_LOG_LEN);
1092 /* get va_list */
1093 va_start(ap, fmt_s);
1094 /* format scanf log */
1095 formatResult = StrFormatScanf(scanfBuf, fmt_s, ap);
1096
1097 va_end(ap);
1098
1099 return formatResult;
1100 }
1101
1102 /* See fsl_debug_console.h for documentation of this function. */
DbgConsole_BlockingPrintf(const char * fmt_s,...)1103 int DbgConsole_BlockingPrintf(const char *fmt_s, ...)
1104 {
1105 va_list ap;
1106 int result = 0;
1107
1108 va_start(ap, fmt_s);
1109 result = DbgConsole_BlockingVprintf(fmt_s, ap);
1110 va_end(ap);
1111
1112 return result;
1113 }
1114
1115 /* See fsl_debug_console.h for documentation of this function. */
DbgConsole_BlockingVprintf(const char * fmt_s,va_list formatStringArg)1116 int DbgConsole_BlockingVprintf(const char *fmt_s, va_list formatStringArg)
1117 {
1118 status_t dbgConsoleStatus;
1119 int logLength = 0, result = 0;
1120 char printBuf[DEBUG_CONSOLE_PRINTF_MAX_LOG_LEN] = {'\0'};
1121
1122 if (NULL == g_serialHandle)
1123 {
1124 return 0;
1125 }
1126
1127 /* format print log first */
1128 logLength = StrFormatPrintf(fmt_s, formatStringArg, printBuf, DbgConsole_PrintCallback);
1129
1130 #if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)
1131 (void)SerialManager_CancelWriting(((serial_write_handle_t)&s_debugConsoleState.serialWriteHandleBuffer[0]));
1132 #endif
1133 /* print log */
1134 dbgConsoleStatus =
1135 (status_t)SerialManager_WriteBlocking(((serial_write_handle_t)&s_debugConsoleState.serialWriteHandleBuffer[0]),
1136 (uint8_t *)printBuf, (size_t)logLength);
1137 result = (((status_t)kStatus_Success == dbgConsoleStatus) ? (int)logLength : -1);
1138
1139 return result;
1140 }
1141
1142 #ifdef DEBUG_CONSOLE_TRANSFER_NON_BLOCKING
DbgConsole_TryGetchar(char * ch)1143 status_t DbgConsole_TryGetchar(char *ch)
1144 {
1145 #if (defined(DEBUG_CONSOLE_RX_ENABLE) && (DEBUG_CONSOLE_RX_ENABLE > 0U))
1146 uint32_t length = 0;
1147 status_t dbgConsoleStatus = (status_t)kStatus_Fail;
1148
1149 assert(ch);
1150
1151 if (NULL == g_serialHandle)
1152 {
1153 return kStatus_Fail;
1154 }
1155
1156 /* take mutex lock function */
1157 #if (DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_FREERTOS)
1158 DEBUG_CONSOLE_TAKE_MUTEX_SEMAPHORE_BLOCKING(s_debugConsoleReadSemaphore);
1159 #endif
1160
1161 if (kStatus_SerialManager_Success ==
1162 SerialManager_TryRead(((serial_read_handle_t)&s_debugConsoleState.serialReadHandleBuffer[0]), (uint8_t *)ch, 1,
1163 &length))
1164 {
1165 if (length != 0U)
1166 {
1167 #if DEBUG_CONSOLE_ENABLE_ECHO_FUNCTION
1168 (void)DbgConsole_EchoCharacter((uint8_t *)ch, true, NULL);
1169 #endif
1170 dbgConsoleStatus = (status_t)kStatus_Success;
1171 }
1172 }
1173 /* release mutex lock function */
1174 #if (DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_FREERTOS)
1175 DEBUG_CONSOLE_GIVE_MUTEX_SEMAPHORE(s_debugConsoleReadSemaphore);
1176 #endif
1177 return dbgConsoleStatus;
1178 #else
1179 return (status_t)kStatus_Fail;
1180 #endif
1181 }
1182 #endif
1183
1184 /* See fsl_debug_console.h for documentation of this function. */
DbgConsole_Getchar(void)1185 int DbgConsole_Getchar(void)
1186 {
1187 int ret = -1;
1188 uint8_t ch = 0U;
1189
1190 /* Get char */
1191 if (DbgConsole_ReadCharacter(&ch) > 0)
1192 {
1193 ret = (int)ch;
1194 }
1195
1196 return ret;
1197 }
1198
1199 #endif /* SDK_DEBUGCONSOLE */
1200
1201 /*************Code to support toolchain's printf, scanf *******************************/
1202 /* These function __write and __read is used to support IAR toolchain to printf and scanf*/
1203 #if (defined(__ICCARM__))
1204 #if defined(SDK_DEBUGCONSOLE_UART)
1205 #pragma weak __write
1206 size_t __write(int handle, const unsigned char *buffer, size_t size);
__write(int handle,const unsigned char * buffer,size_t size)1207 size_t __write(int handle, const unsigned char *buffer, size_t size)
1208 {
1209 size_t ret;
1210 if (NULL == buffer)
1211 {
1212 /*
1213 * This means that we should flush internal buffers. Since we don't we just return.
1214 * (Remember, "handle" == -1 means that all handles should be flushed.)
1215 */
1216 ret = 0U;
1217 }
1218 else if ((handle != 1) && (handle != 2))
1219 {
1220 /* This function only writes to "standard out" and "standard err" for all other file handles it returns failure.
1221 */
1222 ret = (size_t)-1;
1223 }
1224 else
1225 {
1226 /* Send data. */
1227 uint8_t buff[512];
1228 (void)memcpy(buff, buffer, size);
1229 (void)DbgConsole_SendDataReliable((uint8_t *)buff, size);
1230
1231 ret = size;
1232 }
1233 return ret;
1234 }
1235
1236 #pragma weak __read
1237 size_t __read(int handle, unsigned char *buffer, size_t size);
__read(int handle,unsigned char * buffer,size_t size)1238 size_t __read(int handle, unsigned char *buffer, size_t size)
1239 {
1240 uint8_t ch = 0U;
1241 int actualSize = 0;
1242
1243 /* This function only reads from "standard in", for all other file handles it returns failure. */
1244 if (0 != handle)
1245 {
1246 actualSize = -1;
1247 }
1248 else
1249 {
1250 /* Receive data.*/
1251 for (; size > 0U; size--)
1252 {
1253 (void)DbgConsole_ReadCharacter(&ch);
1254 if (0U == ch)
1255 {
1256 break;
1257 }
1258
1259 *buffer++ = ch;
1260 actualSize++;
1261 }
1262 }
1263 return (size_t)actualSize;
1264 }
1265 #endif /* SDK_DEBUGCONSOLE_UART */
1266
1267 /* support LPC Xpresso with RedLib */
1268 #elif (defined(__REDLIB__))
1269
1270 #if (defined(SDK_DEBUGCONSOLE_UART))
__sys_write(int handle,char * buffer,int size)1271 int __attribute__((weak)) __sys_write(int handle, char *buffer, int size)
1272 {
1273 if (NULL == buffer)
1274 {
1275 /* return -1 if error. */
1276 return -1;
1277 }
1278
1279 /* This function only writes to "standard out" and "standard err" for all other file handles it returns failure. */
1280 if ((handle != 1) && (handle != 2))
1281 {
1282 return -1;
1283 }
1284
1285 /* Send data. */
1286 DbgConsole_SendDataReliable((uint8_t *)buffer, size);
1287
1288 return 0;
1289 }
1290
__sys_readc(void)1291 int __attribute__((weak)) __sys_readc(void)
1292 {
1293 char tmp;
1294
1295 /* Receive data. */
1296 DbgConsole_ReadCharacter((uint8_t *)&tmp);
1297
1298 return tmp;
1299 }
1300 #endif /* SDK_DEBUGCONSOLE_UART */
1301
1302 /* These function fputc and fgetc is used to support KEIL toolchain to printf and scanf*/
1303 #elif defined(__CC_ARM) || defined(__ARMCC_VERSION)
1304 #if defined(SDK_DEBUGCONSOLE_UART)
1305 #if defined(__CC_ARM)
1306 struct __FILE
1307 {
1308 int handle;
1309 /*
1310 * Whatever you require here. If the only file you are using is standard output using printf() for debugging,
1311 * no file handling is required.
1312 */
1313 };
1314 #endif
1315
1316 /* FILE is typedef in stdio.h. */
1317 #pragma weak __stdout
1318 #pragma weak __stdin
1319 FILE __stdout;
1320 FILE __stdin;
1321
1322 #pragma weak fputc
fputc(int ch,FILE * f)1323 int fputc(int ch, FILE *f)
1324 {
1325 /* Send data. */
1326 return DbgConsole_SendDataReliable((uint8_t *)(&ch), 1);
1327 }
1328
1329 #pragma weak fgetc
fgetc(FILE * f)1330 int fgetc(FILE *f)
1331 {
1332 char ch;
1333
1334 /* Receive data. */
1335 DbgConsole_ReadCharacter((uint8_t *)&ch);
1336
1337 return ch;
1338 }
1339
1340 /*
1341 * Terminate the program, passing a return code back to the user.
1342 * This function may not return.
1343 */
_sys_exit(int returncode)1344 void _sys_exit(int returncode)
1345 {
1346 while (1)
1347 {
1348 }
1349 }
1350
1351 /*
1352 * Writes a character to the output channel. This function is used
1353 * for last-resort error message output.
1354 */
_ttywrch(int ch)1355 void _ttywrch(int ch)
1356 {
1357 char ench = ch;
1358 DbgConsole_SendDataReliable((uint8_t *)(&ench), 1);
1359 }
1360
_sys_command_string(char * cmd,int len)1361 char *_sys_command_string(char *cmd, int len)
1362 {
1363 return (cmd);
1364 }
1365 #endif /* SDK_DEBUGCONSOLE_UART */
1366
1367 /* These function __write and __read is used to support ARM_GCC, KDS, Atollic toolchains to printf and scanf*/
1368 #elif (defined(__GNUC__))
1369
1370 #if ((defined(__GNUC__) && (!defined(__MCUXPRESSO)) && (defined(SDK_DEBUGCONSOLE_UART))) || \
1371 (defined(__MCUXPRESSO) && (defined(SDK_DEBUGCONSOLE_UART))))
1372 int __attribute__((weak)) _write(int handle, char *buffer, int size);
_write(int handle,char * buffer,int size)1373 int __attribute__((weak)) _write(int handle, char *buffer, int size)
1374 {
1375 if (NULL == buffer)
1376 {
1377 /* return -1 if error. */
1378 return -1;
1379 }
1380
1381 /* This function only writes to "standard out" and "standard err" for all other file handles it returns failure. */
1382 if ((handle != 1) && (handle != 2))
1383 {
1384 return -1;
1385 }
1386
1387 /* Send data. */
1388 (void)DbgConsole_SendDataReliable((uint8_t *)buffer, (size_t)size);
1389
1390 return size;
1391 }
1392
1393 int __attribute__((weak)) _read(int handle, char *buffer, int size);
_read(int handle,char * buffer,int size)1394 int __attribute__((weak)) _read(int handle, char *buffer, int size)
1395 {
1396 uint8_t ch = 0U;
1397 int actualSize = 0;
1398
1399 /* This function only reads from "standard in", for all other file handles it returns failure. */
1400 if (handle != 0)
1401 {
1402 return -1;
1403 }
1404
1405 /* Receive data. */
1406 for (; size > 0; size--)
1407 {
1408 if (DbgConsole_ReadCharacter(&ch) < 0)
1409 {
1410 break;
1411 }
1412
1413 *buffer++ = (char)ch;
1414 actualSize++;
1415
1416 if ((ch == 0U) || (ch == (uint8_t)'\n') || (ch == (uint8_t)'\r'))
1417 {
1418 break;
1419 }
1420 }
1421
1422 return (actualSize > 0) ? actualSize : -1;
1423 }
1424 #endif
1425
1426 #endif /* __ICCARM__ */
1427
