2 * This is a modified version of the file printf.c, which was distributed
\r
3 * by Motorola as part of the M5407C3BOOT.zip package used to initialize
\r
4 * the M5407C3 evaluation board.
\r
7 * 1999-2000 MOTOROLA, INC. All Rights Reserved.
\r
8 * You are hereby granted a copyright license to use, modify, and
\r
9 * distribute the SOFTWARE so long as this entire notice is
\r
10 * retained without alteration in any modified and/or redistributed
\r
11 * versions, and that such modified versions are clearly identified
\r
12 * as such. No licenses are granted by implication, estoppel or
\r
13 * otherwise under any patents or trademarks of Motorola, Inc. This
\r
14 * software is provided on an "AS IS" basis and without warranty.
\r
16 * To the maximum extent permitted by applicable law, MOTOROLA
\r
17 * DISCLAIMS ALL WARRANTIES WHETHER EXPRESS OR IMPLIED, INCLUDING
\r
18 * IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR
\r
19 * PURPOSE AND ANY WARRANTY AGAINST INFRINGEMENT WITH REGARD TO THE
\r
20 * SOFTWARE (INCLUDING ANY MODIFIED VERSIONS THEREOF) AND ANY
\r
21 * ACCOMPANYING WRITTEN MATERIALS.
\r
23 * To the maximum extent permitted by applicable law, IN NO EVENT
\r
24 * SHALL MOTOROLA BE LIABLE FOR ANY DAMAGES WHATSOEVER (INCLUDING
\r
25 * WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS, BUSINESS
\r
26 * INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR OTHER PECUNIARY
\r
27 * LOSS) ARISING OF THE USE OR INABILITY TO USE THE SOFTWARE.
\r
29 * Motorola assumes no responsibility for the maintenance and support
\r
32 * Copyright (c) 2015, Freescale Semiconductor, Inc.
\r
33 * Copyright 2016-2019 NXP
\r
35 * SPDX-License-Identifier: BSD-3-Clause
\r
40 #if defined(__CC_ARM) || defined(__ARMCC_VERSION)
\r
44 #ifdef FSL_RTOS_FREE_RTOS
\r
45 #include "FreeRTOS.h"
\r
50 #include "fsl_debug_console_conf.h"
\r
51 #include "fsl_str.h"
\r
53 #include "fsl_common.h"
\r
54 #include "serial_manager.h"
\r
56 #include "fsl_debug_console.h"
\r
58 /*******************************************************************************
\r
60 ******************************************************************************/
\r
62 #if (defined(DEBUG_CONSOLE_ASSERT_DISABLE) && (DEBUG_CONSOLE_ASSERT_DISABLE > 0U))
\r
68 #if SDK_DEBUGCONSOLE
\r
69 #define DEBUG_CONSOLE_FUNCTION_PREFIX
\r
71 #define DEBUG_CONSOLE_FUNCTION_PREFIX static
\r
74 /*! @brief character backspace ASCII value */
\r
75 #define DEBUG_CONSOLE_BACKSPACE 127U
\r
77 /* lock definition */
\r
78 #if (DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_FREERTOS)
\r
80 static SemaphoreHandle_t s_debugConsoleReadSemaphore;
\r
81 #if (defined(DEBUG_CONSOLE_RX_ENABLE) && (DEBUG_CONSOLE_RX_ENABLE > 0U))
\r
82 static SemaphoreHandle_t s_debugConsoleReadWaitSemaphore;
\r
85 #elif (DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_BM)
\r
87 #if (defined(DEBUG_CONSOLE_RX_ENABLE) && (DEBUG_CONSOLE_RX_ENABLE > 0U))
\r
88 static volatile uint8_t s_debugConsoleReadWaitSemaphore;
\r
93 #endif /* DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_FREERTOS */
\r
95 /*! @brief get current runing environment is ISR or not */
\r
97 #define IS_RUNNING_IN_ISR() SystemGetIRQNestingLevel()
\r
99 #define IS_RUNNING_IN_ISR() __get_IPSR()
\r
100 #endif /* __CA7_REV */
\r
102 /* semaphore definition */
\r
103 #if (DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_FREERTOS)
\r
105 /* mutex semaphore */
\r
106 #define DEBUG_CONSOLE_CREATE_MUTEX_SEMAPHORE(mutex) ((mutex) = xSemaphoreCreateMutex())
\r
108 /* clang-format off */
\r
109 #define DEBUG_CONSOLE_GIVE_MUTEX_SEMAPHORE(mutex) \
\r
111 if (IS_RUNNING_IN_ISR() == 0U) \
\r
113 (void)xSemaphoreGive(mutex); \
\r
117 #define DEBUG_CONSOLE_TAKE_MUTEX_SEMAPHORE_BLOCKING(mutex) \
\r
119 if (IS_RUNNING_IN_ISR() == 0U) \
\r
121 (void)xSemaphoreTake(mutex, portMAX_DELAY); \
\r
125 #define DEBUG_CONSOLE_TAKE_MUTEX_SEMAPHORE_NONBLOCKING(mutex, result) \
\r
127 if (IS_RUNNING_IN_ISR() == 0U) \
\r
129 result = xSemaphoreTake(mutex, 0U); \
\r
136 /* clang-format on */
\r
138 /* Binary semaphore */
\r
139 #define DEBUG_CONSOLE_CREATE_BINARY_SEMAPHORE(binary) ((binary) = xSemaphoreCreateBinary())
\r
140 #define DEBUG_CONSOLE_TAKE_BINARY_SEMAPHORE_BLOCKING(binary) ((void)xSemaphoreTake(binary, portMAX_DELAY))
\r
141 #define DEBUG_CONSOLE_GIVE_BINARY_SEMAPHORE_FROM_ISR(binary) ((void)xSemaphoreGiveFromISR(binary, NULL))
\r
143 #elif (DEBUG_CONSOLE_SYNCHRONIZATION_BM == DEBUG_CONSOLE_SYNCHRONIZATION_MODE)
\r
145 #define DEBUG_CONSOLE_CREATE_MUTEX_SEMAPHORE(mutex)
\r
146 #define DEBUG_CONSOLE_TAKE_MUTEX_SEMAPHORE_BLOCKING(mutex)
\r
147 #define DEBUG_CONSOLE_GIVE_MUTEX_SEMAPHORE(mutex)
\r
148 #define DEBUG_CONSOLE_TAKE_MUTEX_SEMAPHORE_NONBLOCKING(mutex, result) (result = 1U)
\r
150 #define DEBUG_CONSOLE_CREATE_BINARY_SEMAPHORE(binary)
\r
151 #ifdef DEBUG_CONSOLE_TRANSFER_NON_BLOCKING
\r
152 #define DEBUG_CONSOLE_TAKE_BINARY_SEMAPHORE_BLOCKING(binary) \
\r
159 #define DEBUG_CONSOLE_GIVE_BINARY_SEMAPHORE_FROM_ISR(binary) (binary = true)
\r
161 #define DEBUG_CONSOLE_TAKE_BINARY_SEMAPHORE_BLOCKING(binary)
\r
162 #define DEBUG_CONSOLE_GIVE_BINARY_SEMAPHORE_FROM_ISR(binary)
\r
163 #endif /* DEBUG_CONSOLE_TRANSFER_NON_BLOCKING */
\r
165 /* add other implementation here
\r
167 * #elif(DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DDEBUG_CONSOLE_SYNCHRONIZATION_xxx)
\r
172 #error RTOS type is not defined by DEBUG_CONSOLE_SYNCHRONIZATION_MODE.
\r
174 #endif /* DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_FREERTOS */
\r
176 #ifdef DEBUG_CONSOLE_TRANSFER_NON_BLOCKING
\r
177 /* receive state structure */
\r
178 typedef struct _debug_console_write_ring_buffer
\r
180 uint32_t ringBufferSize;
\r
181 volatile uint32_t ringHead;
\r
182 volatile uint32_t ringTail;
\r
183 uint8_t ringBuffer[DEBUG_CONSOLE_TRANSMIT_BUFFER_LEN];
\r
184 } debug_console_write_ring_buffer_t;
\r
187 typedef struct _debug_console_state_struct
\r
189 uint8_t serialHandleBuffer[SERIAL_MANAGER_HANDLE_SIZE];
\r
190 serial_handle_t serialHandle; /*!< serial manager handle */
\r
191 #ifdef DEBUG_CONSOLE_TRANSFER_NON_BLOCKING
\r
192 debug_console_write_ring_buffer_t writeRingBuffer;
\r
193 uint8_t readRingBuffer[DEBUG_CONSOLE_RECEIVE_BUFFER_LEN];
\r
195 uint8_t serialWriteHandleBuffer[SERIAL_MANAGER_WRITE_HANDLE_SIZE];
\r
196 uint8_t serialReadHandleBuffer[SERIAL_MANAGER_READ_HANDLE_SIZE];
\r
197 } debug_console_state_struct_t;
\r
199 /*******************************************************************************
\r
201 ******************************************************************************/
\r
203 /*! @brief Debug console state information. */
\r
204 static debug_console_state_struct_t s_debugConsoleState;
\r
205 serial_handle_t g_serialHandle; /*!< serial manager handle */
\r
207 /*******************************************************************************
\r
209 ******************************************************************************/
\r
211 * @brief This is a printf call back function which is used to relocate the log to buffer
\r
212 * or print the log immediately when the local buffer is full.
\r
214 * @param[in] buf Buffer to store log.
\r
215 * @param[in] indicator Buffer index.
\r
216 * @param[in] val Target character to store.
\r
217 * @param[in] len length of the character
\r
220 #if SDK_DEBUGCONSOLE
\r
221 static void DbgConsole_PrintCallback(char *buf, int32_t *indicator, char dbgVal, int len);
\r
224 status_t DbgConsole_ReadOneCharacter(uint8_t *ch);
\r
225 int DbgConsole_SendData(uint8_t *ch, size_t size);
\r
226 int DbgConsole_SendDataReliable(uint8_t *ch, size_t size);
\r
227 int DbgConsole_ReadLine(uint8_t *buf, size_t size);
\r
228 int DbgConsole_ReadCharacter(uint8_t *ch);
\r
230 #if ((SDK_DEBUGCONSOLE > 0U) || \
\r
231 ((SDK_DEBUGCONSOLE == 0U) && defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING) && \
\r
232 (defined(DEBUG_CONSOLE_TX_RELIABLE_ENABLE) && (DEBUG_CONSOLE_TX_RELIABLE_ENABLE > 0U))))
\r
233 DEBUG_CONSOLE_FUNCTION_PREFIX status_t DbgConsole_Flush(void);
\r
235 /*******************************************************************************
\r
237 ******************************************************************************/
\r
239 #if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)
\r
241 static void DbgConsole_SerialManagerTxCallback(void *callbackParam,
\r
242 serial_manager_callback_message_t *message,
\r
243 serial_manager_status_t status)
\r
245 debug_console_state_struct_t *ioState;
\r
246 uint32_t sendDataLength;
\r
248 if ((NULL == callbackParam) || (NULL == message))
\r
253 ioState = (debug_console_state_struct_t *)callbackParam;
\r
255 ioState->writeRingBuffer.ringTail += message->length;
\r
256 if (ioState->writeRingBuffer.ringTail >= ioState->writeRingBuffer.ringBufferSize)
\r
258 ioState->writeRingBuffer.ringTail = 0U;
\r
261 if (kStatus_SerialManager_Success == status)
\r
263 if (ioState->writeRingBuffer.ringTail != ioState->writeRingBuffer.ringHead)
\r
265 if (ioState->writeRingBuffer.ringHead > ioState->writeRingBuffer.ringTail)
\r
267 sendDataLength = ioState->writeRingBuffer.ringHead - ioState->writeRingBuffer.ringTail;
\r
271 sendDataLength = ioState->writeRingBuffer.ringBufferSize - ioState->writeRingBuffer.ringTail;
\r
274 (void)SerialManager_WriteNonBlocking(
\r
275 ((serial_write_handle_t)&ioState->serialWriteHandleBuffer[0]),
\r
276 &ioState->writeRingBuffer.ringBuffer[ioState->writeRingBuffer.ringTail], sendDataLength);
\r
279 else if (kStatus_SerialManager_Canceled == status)
\r
281 ioState->writeRingBuffer.ringTail = 0U;
\r
282 ioState->writeRingBuffer.ringHead = 0U;
\r
286 /*MISRA rule 16.4*/
\r
290 #if (defined(DEBUG_CONSOLE_RX_ENABLE) && (DEBUG_CONSOLE_RX_ENABLE > 0U))
\r
292 static void DbgConsole_SerialManagerRxCallback(void *callbackParam,
\r
293 serial_manager_callback_message_t *message,
\r
294 serial_manager_status_t status)
\r
296 if ((NULL == callbackParam) || (NULL == message))
\r
301 if (kStatus_SerialManager_Notify == status)
\r
304 else if (kStatus_SerialManager_Success == status)
\r
306 /* release s_debugConsoleReadWaitSemaphore from RX callback */
\r
307 DEBUG_CONSOLE_GIVE_BINARY_SEMAPHORE_FROM_ISR(s_debugConsoleReadWaitSemaphore);
\r
311 /*MISRA rule 16.4*/
\r
318 status_t DbgConsole_ReadOneCharacter(uint8_t *ch)
\r
320 #if (defined(DEBUG_CONSOLE_RX_ENABLE) && (DEBUG_CONSOLE_RX_ENABLE > 0U))
\r
322 #if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING) && \
\r
323 (DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_BM) && defined(OSA_USED)
\r
324 return kStatus_Fail;
\r
326 status_t status = (status_t)kStatus_SerialManager_Error;
\r
328 /* recieve one char every time */
\r
329 #if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)
\r
330 status = (status_t)SerialManager_ReadNonBlocking(
\r
331 ((serial_read_handle_t)&s_debugConsoleState.serialReadHandleBuffer[0]), ch, 1);
\r
333 status = (status_t)SerialManager_ReadBlocking(
\r
334 ((serial_read_handle_t)&s_debugConsoleState.serialReadHandleBuffer[0]), ch, 1);
\r
336 if ((status_t)kStatus_SerialManager_Success != status)
\r
338 return (status_t)kStatus_Fail;
\r
340 /* wait s_debugConsoleReadWaitSemaphore from RX callback */
\r
341 DEBUG_CONSOLE_TAKE_BINARY_SEMAPHORE_BLOCKING(s_debugConsoleReadWaitSemaphore);
\r
343 return (status_t)kStatus_Success;
\r
348 return (status_t)kStatus_Fail;
\r
353 #if DEBUG_CONSOLE_ENABLE_ECHO_FUNCTION
\r
354 static status_t DbgConsole_EchoCharacter(uint8_t *ch, bool isGetChar, int *index)
\r
356 /* Due to scanf take \n and \r as end of string,should not echo */
\r
357 if (((*ch != (uint8_t)'\r') && (*ch != (uint8_t)'\n')) || (isGetChar))
\r
359 /* recieve one char every time */
\r
360 if (1 != DbgConsole_SendDataReliable(ch, 1U))
\r
362 return (status_t)kStatus_Fail;
\r
366 if ((!isGetChar) && (index != NULL))
\r
368 if (DEBUG_CONSOLE_BACKSPACE == *ch)
\r
381 return (status_t)kStatus_Success;
\r
385 int DbgConsole_SendData(uint8_t *ch, size_t size)
\r
387 status_t status = (status_t)kStatus_SerialManager_Error;
\r
388 #if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)
\r
389 uint32_t sendDataLength;
\r
392 assert(NULL != ch);
\r
395 #if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)
\r
396 uint32_t regPrimask = DisableGlobalIRQ();
\r
397 if (s_debugConsoleState.writeRingBuffer.ringHead != s_debugConsoleState.writeRingBuffer.ringTail)
\r
401 (s_debugConsoleState.writeRingBuffer.ringHead + s_debugConsoleState.writeRingBuffer.ringBufferSize -
\r
402 s_debugConsoleState.writeRingBuffer.ringTail) %
\r
403 s_debugConsoleState.writeRingBuffer.ringBufferSize;
\r
407 sendDataLength = 0U;
\r
409 sendDataLength = s_debugConsoleState.writeRingBuffer.ringBufferSize - sendDataLength - 1;
\r
410 if (sendDataLength <= size)
\r
412 EnableGlobalIRQ(regPrimask);
\r
415 for (int i = 0; i < (int)size; i++)
\r
417 s_debugConsoleState.writeRingBuffer.ringBuffer[s_debugConsoleState.writeRingBuffer.ringHead++] = ch[i];
\r
418 if (s_debugConsoleState.writeRingBuffer.ringHead >= s_debugConsoleState.writeRingBuffer.ringBufferSize)
\r
420 s_debugConsoleState.writeRingBuffer.ringHead = 0U;
\r
424 status = (status_t)kStatus_SerialManager_Success;
\r
428 if (s_debugConsoleState.writeRingBuffer.ringHead > s_debugConsoleState.writeRingBuffer.ringTail)
\r
431 s_debugConsoleState.writeRingBuffer.ringHead - s_debugConsoleState.writeRingBuffer.ringTail;
\r
436 s_debugConsoleState.writeRingBuffer.ringBufferSize - s_debugConsoleState.writeRingBuffer.ringTail;
\r
439 status = (status_t)SerialManager_WriteNonBlocking(
\r
440 ((serial_write_handle_t)&s_debugConsoleState.serialWriteHandleBuffer[0]),
\r
441 &s_debugConsoleState.writeRingBuffer.ringBuffer[s_debugConsoleState.writeRingBuffer.ringTail],
\r
444 EnableGlobalIRQ(regPrimask);
\r
446 status = (status_t)SerialManager_WriteBlocking(
\r
447 ((serial_write_handle_t)&s_debugConsoleState.serialWriteHandleBuffer[0]), ch, size);
\r
449 return (((status_t)kStatus_Success == status) ? (int)size : -1);
\r
452 int DbgConsole_SendDataReliable(uint8_t *ch, size_t size)
\r
454 #if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)
\r
455 #if (defined(DEBUG_CONSOLE_TX_RELIABLE_ENABLE) && (DEBUG_CONSOLE_TX_RELIABLE_ENABLE > 0U))
\r
456 status_t status = kStatus_SerialManager_Error;
\r
457 uint32_t sendDataLength;
\r
458 uint32_t totalLength = size;
\r
460 #endif /* DEBUG_CONSOLE_TX_RELIABLE_ENABLE */
\r
462 status_t status = kStatus_SerialManager_Error;
\r
463 #endif /* DEBUG_CONSOLE_TRANSFER_NON_BLOCKING */
\r
465 assert(NULL != ch);
\r
468 #if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)
\r
470 #if (defined(DEBUG_CONSOLE_TX_RELIABLE_ENABLE) && (DEBUG_CONSOLE_TX_RELIABLE_ENABLE > 0U))
\r
473 uint32_t regPrimask = DisableGlobalIRQ();
\r
474 if (s_debugConsoleState.writeRingBuffer.ringHead != s_debugConsoleState.writeRingBuffer.ringTail)
\r
477 (s_debugConsoleState.writeRingBuffer.ringHead + s_debugConsoleState.writeRingBuffer.ringBufferSize -
\r
478 s_debugConsoleState.writeRingBuffer.ringTail) %
\r
479 s_debugConsoleState.writeRingBuffer.ringBufferSize;
\r
483 sendDataLength = 0U;
\r
485 sendDataLength = s_debugConsoleState.writeRingBuffer.ringBufferSize - sendDataLength - 1U;
\r
487 if (sendDataLength > 0U)
\r
489 if (sendDataLength > totalLength)
\r
491 sendDataLength = totalLength;
\r
494 sentLength = DbgConsole_SendData(&ch[size - totalLength], sendDataLength);
\r
495 if (sentLength > 0)
\r
497 totalLength = totalLength - (uint32_t)sentLength;
\r
500 EnableGlobalIRQ(regPrimask);
\r
502 if (totalLength != 0U)
\r
504 status = DbgConsole_Flush();
\r
505 if ((status_t)kStatus_Success != status)
\r
510 } while (totalLength != 0U);
\r
511 return (status_t)(uint32_t)((uint32_t)size - totalLength);
\r
513 return DbgConsole_SendData(ch, size);
\r
514 #endif /* DEBUG_CONSOLE_TX_RELIABLE_ENABLE */
\r
517 status = (status_t)SerialManager_WriteBlocking(
\r
518 ((serial_write_handle_t)&s_debugConsoleState.serialWriteHandleBuffer[0]), ch, size);
\r
519 return (((status_t)kStatus_Success == status) ? (int)size : -1);
\r
520 #endif /* DEBUG_CONSOLE_TRANSFER_NON_BLOCKING */
\r
523 int DbgConsole_ReadLine(uint8_t *buf, size_t size)
\r
527 assert(buf != NULL);
\r
529 /* take mutex lock function */
\r
530 DEBUG_CONSOLE_TAKE_MUTEX_SEMAPHORE_BLOCKING(s_debugConsoleReadSemaphore);
\r
534 /* recieve one char every time */
\r
535 if ((status_t)kStatus_Success != DbgConsole_ReadOneCharacter(&buf[i]))
\r
537 /* release mutex lock function */
\r
538 DEBUG_CONSOLE_GIVE_MUTEX_SEMAPHORE(s_debugConsoleReadSemaphore);
\r
542 #if DEBUG_CONSOLE_ENABLE_ECHO_FUNCTION
\r
543 (void)DbgConsole_EchoCharacter(&buf[i], false, &i);
\r
545 /* analysis data */
\r
546 if (((uint8_t)'\r' == buf[i]) || ((uint8_t)'\n' == buf[i]))
\r
551 buf[i] = (uint8_t)'\0';
\r
560 } while (i < (int)size);
\r
562 /* get char should not add '\0'*/
\r
563 if (i == (int)size)
\r
565 buf[i] = (uint8_t)'\0';
\r
569 buf[i + 1] = (uint8_t)'\0';
\r
572 /* release mutex lock function */
\r
573 DEBUG_CONSOLE_GIVE_MUTEX_SEMAPHORE(s_debugConsoleReadSemaphore);
\r
578 int DbgConsole_ReadCharacter(uint8_t *ch)
\r
584 /* take mutex lock function */
\r
585 DEBUG_CONSOLE_TAKE_MUTEX_SEMAPHORE_BLOCKING(s_debugConsoleReadSemaphore);
\r
586 /* read one character */
\r
587 if ((status_t)kStatus_Success == DbgConsole_ReadOneCharacter(ch))
\r
590 #if DEBUG_CONSOLE_ENABLE_ECHO_FUNCTION
\r
591 (void)DbgConsole_EchoCharacter(ch, true, NULL);
\r
599 /* release mutex lock function */
\r
600 DEBUG_CONSOLE_GIVE_MUTEX_SEMAPHORE(s_debugConsoleReadSemaphore);
\r
605 #if SDK_DEBUGCONSOLE
\r
606 static void DbgConsole_PrintCallback(char *buf, int32_t *indicator, char dbgVal, int len)
\r
610 for (i = 0; i < len; i++)
\r
612 if (((uint32_t)*indicator + 1UL) >= DEBUG_CONSOLE_PRINTF_MAX_LOG_LEN)
\r
614 (void)DbgConsole_SendDataReliable((uint8_t *)buf, (uint32_t)(*indicator));
\r
618 buf[*indicator] = dbgVal;
\r
624 /*************Code for DbgConsole Init, Deinit, Printf, Scanf *******************************/
\r
626 /* See fsl_debug_console.h for documentation of this function. */
\r
627 status_t DbgConsole_Init(uint8_t instance, uint32_t baudRate, serial_port_type_t device, uint32_t clkSrcFreq)
\r
629 serial_manager_config_t serialConfig;
\r
630 status_t status = (status_t)kStatus_SerialManager_Error;
\r
632 #if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))
\r
633 serial_port_uart_config_t uartConfig = {
\r
634 .instance = instance,
\r
635 .clockRate = clkSrcFreq,
\r
636 .baudRate = baudRate,
\r
637 .parityMode = kSerialManager_UartParityDisabled,
\r
638 .stopBitCount = kSerialManager_UartOneStopBit,
\r
644 #if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))
\r
645 serial_port_usb_cdc_config_t usbCdcConfig = {
\r
646 .controllerIndex = (serial_port_usb_cdc_controller_index_t)instance,
\r
650 #if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))
\r
651 serial_port_swo_config_t swoConfig = {
\r
652 .clockRate = clkSrcFreq,
\r
653 .baudRate = baudRate,
\r
655 .protocol = kSerialManager_SwoProtocolNrz,
\r
659 #if (defined(SERIAL_PORT_TYPE_USBCDC_VIRTUAL) && (SERIAL_PORT_TYPE_USBCDC_VIRTUAL > 0U))
\r
660 serial_port_usb_cdc_virtual_config_t usbCdcVirtualConfig = {
\r
661 .controllerIndex = (serial_port_usb_cdc_virtual_controller_index_t)instance,
\r
664 serialConfig.type = device;
\r
665 #if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)
\r
666 serialConfig.ringBuffer = &s_debugConsoleState.readRingBuffer[0];
\r
667 serialConfig.ringBufferSize = DEBUG_CONSOLE_RECEIVE_BUFFER_LEN;
\r
670 if (kSerialPort_Uart == device)
\r
672 #if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))
\r
673 serialConfig.portConfig = &uartConfig;
\r
678 else if (kSerialPort_UsbCdc == device)
\r
680 #if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))
\r
681 serialConfig.portConfig = &usbCdcConfig;
\r
686 else if (kSerialPort_Swo == device)
\r
688 #if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))
\r
689 serialConfig.portConfig = &swoConfig;
\r
694 else if (kSerialPort_UsbCdcVirtual == device)
\r
696 #if (defined(SERIAL_PORT_TYPE_USBCDC_VIRTUAL) && (SERIAL_PORT_TYPE_USBCDC_VIRTUAL > 0U))
\r
697 serialConfig.portConfig = &usbCdcVirtualConfig;
\r
707 (void)memset(&s_debugConsoleState, 0, sizeof(s_debugConsoleState));
\r
709 #if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)
\r
710 s_debugConsoleState.writeRingBuffer.ringBufferSize = DEBUG_CONSOLE_TRANSMIT_BUFFER_LEN;
\r
713 s_debugConsoleState.serialHandle = (serial_handle_t)&s_debugConsoleState.serialHandleBuffer[0];
\r
714 status = (status_t)SerialManager_Init(s_debugConsoleState.serialHandle, &serialConfig);
\r
716 assert(kStatus_SerialManager_Success == status);
\r
718 DEBUG_CONSOLE_CREATE_MUTEX_SEMAPHORE(s_debugConsoleReadSemaphore);
\r
719 #if (defined(DEBUG_CONSOLE_RX_ENABLE) && (DEBUG_CONSOLE_RX_ENABLE > 0U))
\r
720 DEBUG_CONSOLE_CREATE_BINARY_SEMAPHORE(s_debugConsoleReadWaitSemaphore);
\r
724 status = (status_t)SerialManager_OpenWriteHandle(
\r
725 s_debugConsoleState.serialHandle, ((serial_write_handle_t)&s_debugConsoleState.serialWriteHandleBuffer[0]));
\r
726 assert(kStatus_SerialManager_Success == status);
\r
727 #if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)
\r
728 (void)SerialManager_InstallTxCallback(((serial_write_handle_t)&s_debugConsoleState.serialWriteHandleBuffer[0]),
\r
729 DbgConsole_SerialManagerTxCallback, &s_debugConsoleState);
\r
733 #if (defined(DEBUG_CONSOLE_RX_ENABLE) && (DEBUG_CONSOLE_RX_ENABLE > 0U))
\r
735 status = (status_t)SerialManager_OpenReadHandle(
\r
736 s_debugConsoleState.serialHandle, ((serial_read_handle_t)&s_debugConsoleState.serialReadHandleBuffer[0]));
\r
737 assert(kStatus_SerialManager_Success == status);
\r
738 #if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)
\r
739 (void)SerialManager_InstallRxCallback(((serial_read_handle_t)&s_debugConsoleState.serialReadHandleBuffer[0]),
\r
740 DbgConsole_SerialManagerRxCallback, &s_debugConsoleState);
\r
745 g_serialHandle = s_debugConsoleState.serialHandle;
\r
747 return kStatus_Success;
\r
750 /* See fsl_debug_console.h for documentation of this function. */
\r
751 status_t DbgConsole_Deinit(void)
\r
754 if (s_debugConsoleState.serialHandle != NULL)
\r
756 (void)SerialManager_CloseWriteHandle(
\r
757 ((serial_write_handle_t)&s_debugConsoleState.serialWriteHandleBuffer[0]));
\r
760 #if (defined(DEBUG_CONSOLE_RX_ENABLE) && (DEBUG_CONSOLE_RX_ENABLE > 0U))
\r
762 if (s_debugConsoleState.serialHandle != NULL)
\r
764 (void)SerialManager_CloseReadHandle(((serial_read_handle_t)&s_debugConsoleState.serialReadHandleBuffer[0]));
\r
768 return (status_t)kStatus_Success;
\r
771 #if ((SDK_DEBUGCONSOLE > 0U) || \
\r
772 ((SDK_DEBUGCONSOLE == 0U) && defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING) && \
\r
773 (defined(DEBUG_CONSOLE_TX_RELIABLE_ENABLE) && (DEBUG_CONSOLE_TX_RELIABLE_ENABLE > 0U))))
\r
774 DEBUG_CONSOLE_FUNCTION_PREFIX status_t DbgConsole_Flush(void)
\r
776 #if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)
\r
778 #if (DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_BM) && defined(OSA_USED)
\r
780 if (s_debugConsoleState.writeRingBuffer.ringHead != s_debugConsoleState.writeRingBuffer.ringTail)
\r
782 return (status_t)kStatus_Fail;
\r
787 while (s_debugConsoleState.writeRingBuffer.ringHead != s_debugConsoleState.writeRingBuffer.ringTail)
\r
789 #if (DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_FREERTOS)
\r
790 if (0U == IS_RUNNING_IN_ISR())
\r
792 if (taskSCHEDULER_RUNNING == xTaskGetSchedulerState())
\r
799 return (status_t)kStatus_Fail;
\r
807 return (status_t)kStatus_Success;
\r
811 #if SDK_DEBUGCONSOLE
\r
812 /* See fsl_debug_console.h for documentation of this function. */
\r
813 int DbgConsole_Printf(const char *formatString, ...)
\r
816 int logLength = 0, dbgResult = 0;
\r
817 char printBuf[DEBUG_CONSOLE_PRINTF_MAX_LOG_LEN] = {'\0'};
\r
819 if (NULL == g_serialHandle)
\r
824 va_start(ap, formatString);
\r
825 /* format print log first */
\r
826 logLength = StrFormatPrintf(formatString, ap, printBuf, DbgConsole_PrintCallback);
\r
828 dbgResult = DbgConsole_SendDataReliable((uint8_t *)printBuf, (size_t)logLength);
\r
835 /* See fsl_debug_console.h for documentation of this function. */
\r
836 int DbgConsole_Putchar(int ch)
\r
839 return DbgConsole_SendDataReliable((uint8_t *)&ch, 1U);
\r
842 /* See fsl_debug_console.h for documentation of this function. */
\r
843 int DbgConsole_Scanf(char *formatString, ...)
\r
847 char scanfBuf[DEBUG_CONSOLE_SCANF_MAX_LOG_LEN + 1U] = {'\0'};
\r
850 (void)DbgConsole_ReadLine((uint8_t *)scanfBuf, DEBUG_CONSOLE_SCANF_MAX_LOG_LEN);
\r
852 va_start(ap, formatString);
\r
853 /* format scanf log */
\r
854 formatResult = StrFormatScanf(scanfBuf, formatString, ap);
\r
858 return formatResult;
\r
861 #ifdef DEBUG_CONSOLE_TRANSFER_NON_BLOCKING
\r
862 status_t DbgConsole_TryGetchar(char *ch)
\r
864 #if (defined(DEBUG_CONSOLE_RX_ENABLE) && (DEBUG_CONSOLE_RX_ENABLE > 0U))
\r
865 uint32_t length = 0;
\r
866 status_t status = (status_t)kStatus_Fail;
\r
870 /* take mutex lock function */
\r
871 DEBUG_CONSOLE_TAKE_MUTEX_SEMAPHORE_BLOCKING(s_debugConsoleReadSemaphore);
\r
873 if (kStatus_SerialManager_Success ==
\r
874 SerialManager_TryRead(((serial_read_handle_t)&s_debugConsoleState.serialReadHandleBuffer[0]), (uint8_t *)ch, 1,
\r
879 #if DEBUG_CONSOLE_ENABLE_ECHO_FUNCTION
\r
880 (void)DbgConsole_EchoCharacter((uint8_t *)ch, true, NULL);
\r
882 status = (status_t)kStatus_Success;
\r
885 /* release mutex lock function */
\r
886 DEBUG_CONSOLE_GIVE_MUTEX_SEMAPHORE(s_debugConsoleReadSemaphore);
\r
889 return (status_t)kStatus_Fail;
\r
894 /* See fsl_debug_console.h for documentation of this function. */
\r
895 int DbgConsole_Getchar(void)
\r
900 (void)DbgConsole_ReadCharacter(&ch);
\r
905 #endif /* SDK_DEBUGCONSOLE */
\r
907 /*************Code to support toolchain's printf, scanf *******************************/
\r
908 /* These function __write and __read is used to support IAR toolchain to printf and scanf*/
\r
909 #if (defined(__ICCARM__))
\r
910 #if defined(SDK_DEBUGCONSOLE_UART)
\r
911 #pragma weak __write
\r
912 size_t __write(int handle, const unsigned char *buffer, size_t size)
\r
917 * This means that we should flush internal buffers. Since we don't we just return.
\r
918 * (Remember, "handle" == -1 means that all handles should be flushed.)
\r
923 /* This function only writes to "standard out" and "standard err" for all other file handles it returns failure. */
\r
924 if ((handle != 1) && (handle != 2))
\r
926 return ((size_t)-1);
\r
930 DbgConsole_SendDataReliable((uint8_t *)buffer, size);
\r
935 #pragma weak __read
\r
936 size_t __read(int handle, unsigned char *buffer, size_t size)
\r
939 int actualSize = 0U;
\r
941 /* This function only reads from "standard in", for all other file handles it returns failure. */
\r
944 return ((size_t)-1);
\r
948 for (; size > 0; size--)
\r
950 DbgConsole_ReadCharacter(&ch);
\r
962 #endif /* SDK_DEBUGCONSOLE_UART */
\r
964 /* support LPC Xpresso with RedLib */
\r
965 #elif (defined(__REDLIB__))
\r
967 #if (!SDK_DEBUGCONSOLE) && (defined(SDK_DEBUGCONSOLE_UART))
\r
968 int __attribute__((weak)) __sys_write(int handle, char *buffer, int size)
\r
972 /* return -1 if error. */
\r
976 /* This function only writes to "standard out" and "standard err" for all other file handles it returns failure. */
\r
977 if ((handle != 1) && (handle != 2))
\r
983 DbgConsole_SendDataReliable((uint8_t *)buffer, size);
\r
988 int __attribute__((weak)) __sys_readc(void)
\r
992 /* Receive data. */
\r
993 DbgConsole_ReadCharacter((uint8_t *)&tmp);
\r
999 /* These function fputc and fgetc is used to support KEIL toolchain to printf and scanf*/
\r
1000 #elif defined(__CC_ARM) || defined(__ARMCC_VERSION)
\r
1001 #if defined(SDK_DEBUGCONSOLE_UART)
\r
1002 #if defined(__CC_ARM)
\r
1007 * Whatever you require here. If the only file you are using is standard output using printf() for debugging,
\r
1008 * no file handling is required.
\r
1013 /* FILE is typedef in stdio.h. */
\r
1014 #pragma weak __stdout
\r
1015 #pragma weak __stdin
\r
1019 #pragma weak fputc
\r
1020 int fputc(int ch, FILE *f)
\r
1023 return DbgConsole_SendDataReliable((uint8_t *)(&ch), 1);
\r
1026 #pragma weak fgetc
\r
1027 int fgetc(FILE *f)
\r
1031 /* Receive data. */
\r
1032 DbgConsole_ReadCharacter((uint8_t *)&ch);
\r
1038 * Terminate the program, passing a return code back to the user.
\r
1039 * This function may not return.
\r
1041 void _sys_exit(int returncode)
\r
1049 * Writes a character to the output channel. This function is used
\r
1050 * for last-resort error message output.
\r
1052 void _ttywrch(int ch)
\r
1055 DbgConsole_SendDataReliable((uint8_t *)(&ench), 1);
\r
1058 char *_sys_command_string(char *cmd, int len)
\r
1062 #endif /* SDK_DEBUGCONSOLE_UART */
\r
1064 /* These function __write and __read is used to support ARM_GCC, KDS, Atollic toolchains to printf and scanf*/
\r
1065 #elif (defined(__GNUC__))
\r
1067 #if ((defined(__GNUC__) && (!defined(__MCUXPRESSO)) && (defined(SDK_DEBUGCONSOLE_UART))) || \
\r
1068 (defined(__MCUXPRESSO) && (!SDK_DEBUGCONSOLE) && (defined(SDK_DEBUGCONSOLE_UART))))
\r
1069 int __attribute__((weak)) _write(int handle, char *buffer, int size);
\r
1070 int __attribute__((weak)) _write(int handle, char *buffer, int size)
\r
1072 if (buffer == NULL)
\r
1074 /* return -1 if error. */
\r
1078 /* This function only writes to "standard out" and "standard err" for all other file handles it returns failure. */
\r
1079 if ((handle != 1) && (handle != 2))
\r
1085 (void)DbgConsole_SendDataReliable((uint8_t *)buffer, (size_t)size);
\r
1090 int __attribute__((weak)) _read(int handle, char *buffer, int size);
\r
1091 int __attribute__((weak)) _read(int handle, char *buffer, int size)
\r
1094 int actualSize = 0;
\r
1096 /* This function only reads from "standard in", for all other file handles it returns failure. */
\r
1102 /* Receive data. */
\r
1103 for (; size > 0; size--)
\r
1105 if (DbgConsole_ReadCharacter(&ch) < 0)
\r
1110 *buffer++ = (char)ch;
\r
1113 if ((ch == 0U) || (ch == (uint8_t)'\n') || (ch == (uint8_t)'\r'))
\r
1119 return (actualSize > 0) ? actualSize : -1;
\r
1123 #endif /* __ICCARM__ */
\r