git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/CORTEX_M0+_LPC51U68_LPCXpresso/utilities/fsl_debug_console.c

   1 /*\r
   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
   5  *\r
   6  * Copyright:\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
  15  *\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
  22  *\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
  28  *\r
  29  *  Motorola assumes no responsibility for the maintenance and support\r
  30  *  of this software\r
  31 \r
  32  * Copyright (c) 2015, Freescale Semiconductor, Inc.\r
  33  * Copyright 2016-2019 NXP\r
  34  *\r
  35  * SPDX-License-Identifier: BSD-3-Clause\r
  36  */\r
  37 \r
  38 #include <stdarg.h>\r
  39 #include <stdlib.h>\r
  40 #if defined(__CC_ARM) || defined(__ARMCC_VERSION)\r
  41 #include <stdio.h>\r
  42 #endif\r
  43 \r
  44 #ifdef FSL_RTOS_FREE_RTOS\r
  45 #include "FreeRTOS.h"\r
  46 #include "semphr.h"\r
  47 #include "task.h"\r
  48 #endif\r
  49 \r
  50 #include "fsl_debug_console_conf.h"\r
  51 #include "fsl_str.h"\r
  52 \r
  53 #include "fsl_common.h"\r
  54 #include "serial_manager.h"\r
  55 \r
  56 #include "fsl_debug_console.h"\r
  57 \r
  58 /*******************************************************************************\r
  59  * Definitions\r
  60  ******************************************************************************/\r
  61 #ifndef NDEBUG\r
  62 #if (defined(DEBUG_CONSOLE_ASSERT_DISABLE) && (DEBUG_CONSOLE_ASSERT_DISABLE > 0U))\r
  63 #undef assert\r
  64 #define assert(n)\r
  65 #endif\r
  66 #endif\r
  67 \r
  68 #if SDK_DEBUGCONSOLE\r
  69 #define DEBUG_CONSOLE_FUNCTION_PREFIX\r
  70 #else\r
  71 #define DEBUG_CONSOLE_FUNCTION_PREFIX static\r
  72 #endif\r
  73 \r
  74 /*! @brief character backspace ASCII value */\r
  75 #define DEBUG_CONSOLE_BACKSPACE 127U\r
  76 \r
  77 /* lock definition */\r
  78 #if (DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_FREERTOS)\r
  79 \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
  83 #endif\r
  84 \r
  85 #elif (DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_BM)\r
  86 \r
  87 #if (defined(DEBUG_CONSOLE_RX_ENABLE) && (DEBUG_CONSOLE_RX_ENABLE > 0U))\r
  88 static volatile uint8_t s_debugConsoleReadWaitSemaphore;\r
  89 #endif\r
  90 \r
  91 #else\r
  92 \r
  93 #endif /* DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_FREERTOS */\r
  94 \r
  95 /*! @brief get current runing environment is ISR or not */\r
  96 #ifdef __CA7_REV\r
  97 #define IS_RUNNING_IN_ISR() SystemGetIRQNestingLevel()\r
  98 #else\r
  99 #define IS_RUNNING_IN_ISR() __get_IPSR()\r
 100 #endif /* __CA7_REV */\r
 101 \r
 102 /* semaphore definition */\r
 103 #if (DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_FREERTOS)\r
 104 \r
 105 /* mutex semaphore */\r
 106 #define DEBUG_CONSOLE_CREATE_MUTEX_SEMAPHORE(mutex) ((mutex) = xSemaphoreCreateMutex())\r
 107 \r
 108 /* clang-format off */\r
 109 #define DEBUG_CONSOLE_GIVE_MUTEX_SEMAPHORE(mutex) \\r
 110 {                                                 \\r
 111         if (IS_RUNNING_IN_ISR() == 0U)            \\r
 112         {                                         \\r
 113             (void)xSemaphoreGive(mutex);                \\r
 114         }                                         \\r
 115 }\r
 116 \r
 117 #define DEBUG_CONSOLE_TAKE_MUTEX_SEMAPHORE_BLOCKING(mutex) \\r
 118 {                                                          \\r
 119         if (IS_RUNNING_IN_ISR() == 0U)                     \\r
 120         {                                                  \\r
 121             (void)xSemaphoreTake(mutex, portMAX_DELAY);          \\r
 122         }                                                  \\r
 123 }\r
 124 \r
 125 #define DEBUG_CONSOLE_TAKE_MUTEX_SEMAPHORE_NONBLOCKING(mutex, result) \\r
 126 {                                                                     \\r
 127         if (IS_RUNNING_IN_ISR() == 0U)                                \\r
 128         {                                                             \\r
 129             result = xSemaphoreTake(mutex, 0U);                       \\r
 130         }                                                             \\r
 131         else                                                          \\r
 132         {                                                             \\r
 133             result = 1U;                                              \\r
 134         }                                                             \\r
 135 }\r
 136 /* clang-format on */\r
 137 \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
 142 \r
 143 #elif (DEBUG_CONSOLE_SYNCHRONIZATION_BM == DEBUG_CONSOLE_SYNCHRONIZATION_MODE)\r
 144 \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
 149 \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
 153     {                                                        \\r
 154         while (!binary)                                      \\r
 155         {                                                    \\r
 156         }                                                    \\r
 157         binary = false;                                      \\r
 158     }\r
 159 #define DEBUG_CONSOLE_GIVE_BINARY_SEMAPHORE_FROM_ISR(binary) (binary = true)\r
 160 #else\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
 164 \r
 165 /* add other implementation here\r
 166  *such as :\r
 167  * #elif(DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DDEBUG_CONSOLE_SYNCHRONIZATION_xxx)\r
 168  */\r
 169 \r
 170 #else\r
 171 \r
 172 #error RTOS type is not defined by DEBUG_CONSOLE_SYNCHRONIZATION_MODE.\r
 173 \r
 174 #endif /* DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_FREERTOS */\r
 175 \r
 176 #ifdef DEBUG_CONSOLE_TRANSFER_NON_BLOCKING\r
 177 /* receive state structure */\r
 178 typedef struct _debug_console_write_ring_buffer\r
 179 {\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
 185 #endif\r
 186 \r
 187 typedef struct _debug_console_state_struct\r
 188 {\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
 194 #endif\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
 198 \r
 199 /*******************************************************************************\r
 200  * Variables\r
 201  ******************************************************************************/\r
 202 \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
 206 \r
 207 /*******************************************************************************\r
 208  * Prototypes\r
 209  ******************************************************************************/\r
 210 /*!\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
 213  *\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
 218  *\r
 219  */\r
 220 #if SDK_DEBUGCONSOLE\r
 221 static void DbgConsole_PrintCallback(char *buf, int32_t *indicator, char dbgVal, int len);\r
 222 #endif\r
 223 \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
 229 \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
 234 #endif\r
 235 /*******************************************************************************\r
 236  * Code\r
 237  ******************************************************************************/\r
 238 \r
 239 #if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)\r
 240 \r
 241 static void DbgConsole_SerialManagerTxCallback(void *callbackParam,\r
 242                                                serial_manager_callback_message_t *message,\r
 243                                                serial_manager_status_t status)\r
 244 {\r
 245     debug_console_state_struct_t *ioState;\r
 246     uint32_t sendDataLength;\r
 247 \r
 248     if ((NULL == callbackParam) || (NULL == message))\r
 249     {\r
 250         return;\r
 251     }\r
 252 \r
 253     ioState = (debug_console_state_struct_t *)callbackParam;\r
 254 \r
 255     ioState->writeRingBuffer.ringTail += message->length;\r
 256     if (ioState->writeRingBuffer.ringTail >= ioState->writeRingBuffer.ringBufferSize)\r
 257     {\r
 258         ioState->writeRingBuffer.ringTail = 0U;\r
 259     }\r
 260 \r
 261     if (kStatus_SerialManager_Success == status)\r
 262     {\r
 263         if (ioState->writeRingBuffer.ringTail != ioState->writeRingBuffer.ringHead)\r
 264         {\r
 265             if (ioState->writeRingBuffer.ringHead > ioState->writeRingBuffer.ringTail)\r
 266             {\r
 267                 sendDataLength = ioState->writeRingBuffer.ringHead - ioState->writeRingBuffer.ringTail;\r
 268             }\r
 269             else\r
 270             {\r
 271                 sendDataLength = ioState->writeRingBuffer.ringBufferSize - ioState->writeRingBuffer.ringTail;\r
 272             }\r
 273 \r
 274             (void)SerialManager_WriteNonBlocking(\r
 275                 ((serial_write_handle_t)&ioState->serialWriteHandleBuffer[0]),\r
 276                 &ioState->writeRingBuffer.ringBuffer[ioState->writeRingBuffer.ringTail], sendDataLength);\r
 277         }\r
 278     }\r
 279     else if (kStatus_SerialManager_Canceled == status)\r
 280     {\r
 281         ioState->writeRingBuffer.ringTail = 0U;\r
 282         ioState->writeRingBuffer.ringHead = 0U;\r
 283     }\r
 284     else\r
 285     {\r
 286         /*MISRA rule 16.4*/\r
 287     }\r
 288 }\r
 289 \r
 290 #if (defined(DEBUG_CONSOLE_RX_ENABLE) && (DEBUG_CONSOLE_RX_ENABLE > 0U))\r
 291 \r
 292 static void DbgConsole_SerialManagerRxCallback(void *callbackParam,\r
 293                                                serial_manager_callback_message_t *message,\r
 294                                                serial_manager_status_t status)\r
 295 {\r
 296     if ((NULL == callbackParam) || (NULL == message))\r
 297     {\r
 298         return;\r
 299     }\r
 300 \r
 301     if (kStatus_SerialManager_Notify == status)\r
 302     {\r
 303     }\r
 304     else if (kStatus_SerialManager_Success == status)\r
 305     {\r
 306         /* release s_debugConsoleReadWaitSemaphore from RX callback */\r
 307         DEBUG_CONSOLE_GIVE_BINARY_SEMAPHORE_FROM_ISR(s_debugConsoleReadWaitSemaphore);\r
 308     }\r
 309     else\r
 310     {\r
 311         /*MISRA rule 16.4*/\r
 312     }\r
 313 }\r
 314 #endif\r
 315 \r
 316 #endif\r
 317 \r
 318 status_t DbgConsole_ReadOneCharacter(uint8_t *ch)\r
 319 {\r
 320 #if (defined(DEBUG_CONSOLE_RX_ENABLE) && (DEBUG_CONSOLE_RX_ENABLE > 0U))\r
 321 \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
 325 #else\r
 326     status_t status = (status_t)kStatus_SerialManager_Error;\r
 327 \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
 332 #else\r
 333     status = (status_t)SerialManager_ReadBlocking(\r
 334         ((serial_read_handle_t)&s_debugConsoleState.serialReadHandleBuffer[0]), ch, 1);\r
 335 #endif\r
 336     if ((status_t)kStatus_SerialManager_Success != status)\r
 337     {\r
 338         return (status_t)kStatus_Fail;\r
 339     }\r
 340     /* wait s_debugConsoleReadWaitSemaphore from RX callback */\r
 341     DEBUG_CONSOLE_TAKE_BINARY_SEMAPHORE_BLOCKING(s_debugConsoleReadWaitSemaphore);\r
 342 \r
 343     return (status_t)kStatus_Success;\r
 344 #endif\r
 345 \r
 346 #else\r
 347 \r
 348     return (status_t)kStatus_Fail;\r
 349 \r
 350 #endif\r
 351 }\r
 352 \r
 353 #if DEBUG_CONSOLE_ENABLE_ECHO_FUNCTION\r
 354 static status_t DbgConsole_EchoCharacter(uint8_t *ch, bool isGetChar, int *index)\r
 355 {\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
 358     {\r
 359         /* recieve one char every time */\r
 360         if (1 != DbgConsole_SendDataReliable(ch, 1U))\r
 361         {\r
 362             return (status_t)kStatus_Fail;\r
 363         }\r
 364     }\r
 365 \r
 366     if ((!isGetChar) && (index != NULL))\r
 367     {\r
 368         if (DEBUG_CONSOLE_BACKSPACE == *ch)\r
 369         {\r
 370             if ((*index >= 2))\r
 371             {\r
 372                 *index -= 2;\r
 373             }\r
 374             else\r
 375             {\r
 376                 *index = 0;\r
 377             }\r
 378         }\r
 379     }\r
 380 \r
 381     return (status_t)kStatus_Success;\r
 382 }\r
 383 #endif\r
 384 \r
 385 int DbgConsole_SendData(uint8_t *ch, size_t size)\r
 386 {\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
 390     int txBusy = 0;\r
 391 #endif\r
 392     assert(NULL != ch);\r
 393     assert(0 != size);\r
 394 \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
 398     {\r
 399         txBusy = 1;\r
 400         sendDataLength =\r
 401             (s_debugConsoleState.writeRingBuffer.ringHead + s_debugConsoleState.writeRingBuffer.ringBufferSize -\r
 402              s_debugConsoleState.writeRingBuffer.ringTail) %\r
 403             s_debugConsoleState.writeRingBuffer.ringBufferSize;\r
 404     }\r
 405     else\r
 406     {\r
 407         sendDataLength = 0U;\r
 408     }\r
 409     sendDataLength = s_debugConsoleState.writeRingBuffer.ringBufferSize - sendDataLength - 1;\r
 410     if (sendDataLength <= size)\r
 411     {\r
 412         EnableGlobalIRQ(regPrimask);\r
 413         return -1;\r
 414     }\r
 415     for (int i = 0; i < (int)size; i++)\r
 416     {\r
 417         s_debugConsoleState.writeRingBuffer.ringBuffer[s_debugConsoleState.writeRingBuffer.ringHead++] = ch[i];\r
 418         if (s_debugConsoleState.writeRingBuffer.ringHead >= s_debugConsoleState.writeRingBuffer.ringBufferSize)\r
 419         {\r
 420             s_debugConsoleState.writeRingBuffer.ringHead = 0U;\r
 421         }\r
 422     }\r
 423 \r
 424     status = (status_t)kStatus_SerialManager_Success;\r
 425 \r
 426     if (txBusy == 0)\r
 427     {\r
 428         if (s_debugConsoleState.writeRingBuffer.ringHead > s_debugConsoleState.writeRingBuffer.ringTail)\r
 429         {\r
 430             sendDataLength =\r
 431                 s_debugConsoleState.writeRingBuffer.ringHead - s_debugConsoleState.writeRingBuffer.ringTail;\r
 432         }\r
 433         else\r
 434         {\r
 435             sendDataLength =\r
 436                 s_debugConsoleState.writeRingBuffer.ringBufferSize - s_debugConsoleState.writeRingBuffer.ringTail;\r
 437         }\r
 438 \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
 442             sendDataLength);\r
 443     }\r
 444     EnableGlobalIRQ(regPrimask);\r
 445 #else\r
 446     status = (status_t)SerialManager_WriteBlocking(\r
 447         ((serial_write_handle_t)&s_debugConsoleState.serialWriteHandleBuffer[0]), ch, size);\r
 448 #endif\r
 449     return (((status_t)kStatus_Success == status) ? (int)size : -1);\r
 450 }\r
 451 \r
 452 int DbgConsole_SendDataReliable(uint8_t *ch, size_t size)\r
 453 {\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
 459     int sentLength;\r
 460 #endif /* DEBUG_CONSOLE_TX_RELIABLE_ENABLE */\r
 461 #else\r
 462     status_t status = kStatus_SerialManager_Error;\r
 463 #endif /* DEBUG_CONSOLE_TRANSFER_NON_BLOCKING */\r
 464 \r
 465     assert(NULL != ch);\r
 466     assert(0 != size);\r
 467 \r
 468 #if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)\r
 469 \r
 470 #if (defined(DEBUG_CONSOLE_TX_RELIABLE_ENABLE) && (DEBUG_CONSOLE_TX_RELIABLE_ENABLE > 0U))\r
 471     do\r
 472     {\r
 473         uint32_t regPrimask = DisableGlobalIRQ();\r
 474         if (s_debugConsoleState.writeRingBuffer.ringHead != s_debugConsoleState.writeRingBuffer.ringTail)\r
 475         {\r
 476             sendDataLength =\r
 477                 (s_debugConsoleState.writeRingBuffer.ringHead + s_debugConsoleState.writeRingBuffer.ringBufferSize -\r
 478                  s_debugConsoleState.writeRingBuffer.ringTail) %\r
 479                 s_debugConsoleState.writeRingBuffer.ringBufferSize;\r
 480         }\r
 481         else\r
 482         {\r
 483             sendDataLength = 0U;\r
 484         }\r
 485         sendDataLength = s_debugConsoleState.writeRingBuffer.ringBufferSize - sendDataLength - 1U;\r
 486 \r
 487         if (sendDataLength > 0U)\r
 488         {\r
 489             if (sendDataLength > totalLength)\r
 490             {\r
 491                 sendDataLength = totalLength;\r
 492             }\r
 493 \r
 494             sentLength = DbgConsole_SendData(&ch[size - totalLength], sendDataLength);\r
 495             if (sentLength > 0)\r
 496             {\r
 497                 totalLength = totalLength - (uint32_t)sentLength;\r
 498             }\r
 499         }\r
 500         EnableGlobalIRQ(regPrimask);\r
 501 \r
 502         if (totalLength != 0U)\r
 503         {\r
 504             status = DbgConsole_Flush();\r
 505             if ((status_t)kStatus_Success != status)\r
 506             {\r
 507                 break;\r
 508             }\r
 509         }\r
 510     } while (totalLength != 0U);\r
 511     return (status_t)(uint32_t)((uint32_t)size - totalLength);\r
 512 #else\r
 513     return DbgConsole_SendData(ch, size);\r
 514 #endif /* DEBUG_CONSOLE_TX_RELIABLE_ENABLE */\r
 515 \r
 516 #else\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
 521 }\r
 522 \r
 523 int DbgConsole_ReadLine(uint8_t *buf, size_t size)\r
 524 {\r
 525     int i = 0;\r
 526 \r
 527     assert(buf != NULL);\r
 528 \r
 529     /* take mutex lock function */\r
 530     DEBUG_CONSOLE_TAKE_MUTEX_SEMAPHORE_BLOCKING(s_debugConsoleReadSemaphore);\r
 531 \r
 532     do\r
 533     {\r
 534         /* recieve one char every time */\r
 535         if ((status_t)kStatus_Success != DbgConsole_ReadOneCharacter(&buf[i]))\r
 536         {\r
 537             /* release mutex lock function */\r
 538             DEBUG_CONSOLE_GIVE_MUTEX_SEMAPHORE(s_debugConsoleReadSemaphore);\r
 539             i = -1;\r
 540             break;\r
 541         }\r
 542 #if DEBUG_CONSOLE_ENABLE_ECHO_FUNCTION\r
 543         (void)DbgConsole_EchoCharacter(&buf[i], false, &i);\r
 544 #endif\r
 545         /* analysis data */\r
 546         if (((uint8_t)'\r' == buf[i]) || ((uint8_t)'\n' == buf[i]))\r
 547         {\r
 548             /* End of Line. */\r
 549             if (0 == i)\r
 550             {\r
 551                 buf[i] = (uint8_t)'\0';\r
 552                 continue;\r
 553             }\r
 554             else\r
 555             {\r
 556                 break;\r
 557             }\r
 558         }\r
 559         i++;\r
 560     } while (i < (int)size);\r
 561 \r
 562     /* get char should not add '\0'*/\r
 563     if (i == (int)size)\r
 564     {\r
 565         buf[i] = (uint8_t)'\0';\r
 566     }\r
 567     else\r
 568     {\r
 569         buf[i + 1] = (uint8_t)'\0';\r
 570     }\r
 571 \r
 572     /* release mutex lock function */\r
 573     DEBUG_CONSOLE_GIVE_MUTEX_SEMAPHORE(s_debugConsoleReadSemaphore);\r
 574 \r
 575     return i;\r
 576 }\r
 577 \r
 578 int DbgConsole_ReadCharacter(uint8_t *ch)\r
 579 {\r
 580     int ret;\r
 581 \r
 582     assert(ch);\r
 583 \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
 588     {\r
 589         ret = 1;\r
 590 #if DEBUG_CONSOLE_ENABLE_ECHO_FUNCTION\r
 591         (void)DbgConsole_EchoCharacter(ch, true, NULL);\r
 592 #endif\r
 593     }\r
 594     else\r
 595     {\r
 596         ret = -1;\r
 597     }\r
 598 \r
 599     /* release mutex lock function */\r
 600     DEBUG_CONSOLE_GIVE_MUTEX_SEMAPHORE(s_debugConsoleReadSemaphore);\r
 601 \r
 602     return ret;\r
 603 }\r
 604 \r
 605 #if SDK_DEBUGCONSOLE\r
 606 static void DbgConsole_PrintCallback(char *buf, int32_t *indicator, char dbgVal, int len)\r
 607 {\r
 608     int i = 0;\r
 609 \r
 610     for (i = 0; i < len; i++)\r
 611     {\r
 612         if (((uint32_t)*indicator + 1UL) >= DEBUG_CONSOLE_PRINTF_MAX_LOG_LEN)\r
 613         {\r
 614             (void)DbgConsole_SendDataReliable((uint8_t *)buf, (uint32_t)(*indicator));\r
 615             *indicator = 0;\r
 616         }\r
 617 \r
 618         buf[*indicator] = dbgVal;\r
 619         (*indicator)++;\r
 620     }\r
 621 }\r
 622 #endif\r
 623 \r
 624 /*************Code for DbgConsole Init, Deinit, Printf, Scanf *******************************/\r
 625 \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
 628 {\r
 629     serial_manager_config_t serialConfig;\r
 630     status_t status = (status_t)kStatus_SerialManager_Error;\r
 631 \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
 639         .enableRx     = 1,\r
 640         .enableTx     = 1,\r
 641     };\r
 642 #endif\r
 643 \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
 647     };\r
 648 #endif\r
 649 \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
 654         .port      = instance,\r
 655         .protocol  = kSerialManager_SwoProtocolNrz,\r
 656     };\r
 657 #endif\r
 658 \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
 662     };\r
 663 #endif\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
 668 #endif\r
 669 \r
 670     if (kSerialPort_Uart == device)\r
 671     {\r
 672 #if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))\r
 673         serialConfig.portConfig = &uartConfig;\r
 674 #else\r
 675         return status;\r
 676 #endif\r
 677     }\r
 678     else if (kSerialPort_UsbCdc == device)\r
 679     {\r
 680 #if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))\r
 681         serialConfig.portConfig = &usbCdcConfig;\r
 682 #else\r
 683         return status;\r
 684 #endif\r
 685     }\r
 686     else if (kSerialPort_Swo == device)\r
 687     {\r
 688 #if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))\r
 689         serialConfig.portConfig = &swoConfig;\r
 690 #else\r
 691         return status;\r
 692 #endif\r
 693     }\r
 694     else if (kSerialPort_UsbCdcVirtual == device)\r
 695     {\r
 696 #if (defined(SERIAL_PORT_TYPE_USBCDC_VIRTUAL) && (SERIAL_PORT_TYPE_USBCDC_VIRTUAL > 0U))\r
 697         serialConfig.portConfig = &usbCdcVirtualConfig;\r
 698 #else\r
 699         return status;\r
 700 #endif\r
 701     }\r
 702     else\r
 703     {\r
 704         return status;\r
 705     }\r
 706 \r
 707     (void)memset(&s_debugConsoleState, 0, sizeof(s_debugConsoleState));\r
 708 \r
 709 #if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)\r
 710     s_debugConsoleState.writeRingBuffer.ringBufferSize = DEBUG_CONSOLE_TRANSMIT_BUFFER_LEN;\r
 711 #endif\r
 712 \r
 713     s_debugConsoleState.serialHandle = (serial_handle_t)&s_debugConsoleState.serialHandleBuffer[0];\r
 714     status                           = (status_t)SerialManager_Init(s_debugConsoleState.serialHandle, &serialConfig);\r
 715 \r
 716     assert(kStatus_SerialManager_Success == status);\r
 717 \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
 721 #endif\r
 722 \r
 723     {\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
 730 #endif\r
 731     }\r
 732 \r
 733 #if (defined(DEBUG_CONSOLE_RX_ENABLE) && (DEBUG_CONSOLE_RX_ENABLE > 0U))\r
 734     {\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
 741 #endif\r
 742     }\r
 743 #endif\r
 744 \r
 745     g_serialHandle = s_debugConsoleState.serialHandle;\r
 746 \r
 747     return kStatus_Success;\r
 748 }\r
 749 \r
 750 /* See fsl_debug_console.h for documentation of this function. */\r
 751 status_t DbgConsole_Deinit(void)\r
 752 {\r
 753     {\r
 754         if (s_debugConsoleState.serialHandle != NULL)\r
 755         {\r
 756             (void)SerialManager_CloseWriteHandle(\r
 757                 ((serial_write_handle_t)&s_debugConsoleState.serialWriteHandleBuffer[0]));\r
 758         }\r
 759     }\r
 760 #if (defined(DEBUG_CONSOLE_RX_ENABLE) && (DEBUG_CONSOLE_RX_ENABLE > 0U))\r
 761     {\r
 762         if (s_debugConsoleState.serialHandle != NULL)\r
 763         {\r
 764             (void)SerialManager_CloseReadHandle(((serial_read_handle_t)&s_debugConsoleState.serialReadHandleBuffer[0]));\r
 765         }\r
 766     }\r
 767 #endif\r
 768     return (status_t)kStatus_Success;\r
 769 }\r
 770 \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
 775 {\r
 776 #if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)\r
 777 \r
 778 #if (DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_BM) && defined(OSA_USED)\r
 779 \r
 780     if (s_debugConsoleState.writeRingBuffer.ringHead != s_debugConsoleState.writeRingBuffer.ringTail)\r
 781     {\r
 782         return (status_t)kStatus_Fail;\r
 783     }\r
 784 \r
 785 #else\r
 786 \r
 787     while (s_debugConsoleState.writeRingBuffer.ringHead != s_debugConsoleState.writeRingBuffer.ringTail)\r
 788     {\r
 789 #if (DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_FREERTOS)\r
 790         if (0U == IS_RUNNING_IN_ISR())\r
 791         {\r
 792             if (taskSCHEDULER_RUNNING == xTaskGetSchedulerState())\r
 793             {\r
 794                 vTaskDelay(1);\r
 795             }\r
 796         }\r
 797         else\r
 798         {\r
 799             return (status_t)kStatus_Fail;\r
 800         }\r
 801 #endif\r
 802     }\r
 803 \r
 804 #endif\r
 805 \r
 806 #endif\r
 807     return (status_t)kStatus_Success;\r
 808 }\r
 809 #endif\r
 810 \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
 814 {\r
 815     va_list ap;\r
 816     int logLength = 0, dbgResult = 0;\r
 817     char printBuf[DEBUG_CONSOLE_PRINTF_MAX_LOG_LEN] = {'\0'};\r
 818 \r
 819     if (NULL == g_serialHandle)\r
 820     {\r
 821         return 0;\r
 822     }\r
 823 \r
 824     va_start(ap, formatString);\r
 825     /* format print log first */\r
 826     logLength = StrFormatPrintf(formatString, ap, printBuf, DbgConsole_PrintCallback);\r
 827     /* print log */\r
 828     dbgResult = DbgConsole_SendDataReliable((uint8_t *)printBuf, (size_t)logLength);\r
 829 \r
 830     va_end(ap);\r
 831 \r
 832     return dbgResult;\r
 833 }\r
 834 \r
 835 /* See fsl_debug_console.h for documentation of this function. */\r
 836 int DbgConsole_Putchar(int ch)\r
 837 {\r
 838     /* print char */\r
 839     return DbgConsole_SendDataReliable((uint8_t *)&ch, 1U);\r
 840 }\r
 841 \r
 842 /* See fsl_debug_console.h for documentation of this function. */\r
 843 int DbgConsole_Scanf(char *formatString, ...)\r
 844 {\r
 845     va_list ap;\r
 846     int formatResult;\r
 847     char scanfBuf[DEBUG_CONSOLE_SCANF_MAX_LOG_LEN + 1U] = {'\0'};\r
 848 \r
 849     /* scanf log */\r
 850     (void)DbgConsole_ReadLine((uint8_t *)scanfBuf, DEBUG_CONSOLE_SCANF_MAX_LOG_LEN);\r
 851     /* get va_list */\r
 852     va_start(ap, formatString);\r
 853     /* format scanf log */\r
 854     formatResult = StrFormatScanf(scanfBuf, formatString, ap);\r
 855 \r
 856     va_end(ap);\r
 857 \r
 858     return formatResult;\r
 859 }\r
 860 \r
 861 #ifdef DEBUG_CONSOLE_TRANSFER_NON_BLOCKING\r
 862 status_t DbgConsole_TryGetchar(char *ch)\r
 863 {\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
 867 \r
 868     assert(ch);\r
 869 \r
 870     /* take mutex lock function */\r
 871     DEBUG_CONSOLE_TAKE_MUTEX_SEMAPHORE_BLOCKING(s_debugConsoleReadSemaphore);\r
 872 \r
 873     if (kStatus_SerialManager_Success ==\r
 874         SerialManager_TryRead(((serial_read_handle_t)&s_debugConsoleState.serialReadHandleBuffer[0]), (uint8_t *)ch, 1,\r
 875                               &length))\r
 876     {\r
 877         if (length != 0U)\r
 878         {\r
 879 #if DEBUG_CONSOLE_ENABLE_ECHO_FUNCTION\r
 880             (void)DbgConsole_EchoCharacter((uint8_t *)ch, true, NULL);\r
 881 #endif\r
 882             status = (status_t)kStatus_Success;\r
 883         }\r
 884     }\r
 885     /* release mutex lock function */\r
 886     DEBUG_CONSOLE_GIVE_MUTEX_SEMAPHORE(s_debugConsoleReadSemaphore);\r
 887     return status;\r
 888 #else\r
 889     return (status_t)kStatus_Fail;\r
 890 #endif\r
 891 }\r
 892 #endif\r
 893 \r
 894 /* See fsl_debug_console.h for documentation of this function. */\r
 895 int DbgConsole_Getchar(void)\r
 896 {\r
 897     uint8_t ch = 0U;\r
 898 \r
 899     /* Get char */\r
 900     (void)DbgConsole_ReadCharacter(&ch);\r
 901 \r
 902     return (int)ch;\r
 903 }\r
 904 \r
 905 #endif /* SDK_DEBUGCONSOLE */\r
 906 \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
 913 {\r
 914     if (buffer == 0)\r
 915     {\r
 916         /*\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
 919          */\r
 920         return 0;\r
 921     }\r
 922 \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
 925     {\r
 926         return ((size_t)-1);\r
 927     }\r
 928 \r
 929     /* Send data. */\r
 930     DbgConsole_SendDataReliable((uint8_t *)buffer, size);\r
 931 \r
 932     return size;\r
 933 }\r
 934 \r
 935 #pragma weak __read\r
 936 size_t __read(int handle, unsigned char *buffer, size_t size)\r
 937 {\r
 938     uint8_t ch     = 0U;\r
 939     int actualSize = 0U;\r
 940 \r
 941     /* This function only reads from "standard in", for all other file  handles it returns failure. */\r
 942     if (handle != 0)\r
 943     {\r
 944         return ((size_t)-1);\r
 945     }\r
 946 \r
 947     /* Receive data.*/\r
 948     for (; size > 0; size--)\r
 949     {\r
 950         DbgConsole_ReadCharacter(&ch);\r
 951         if (ch == 0)\r
 952         {\r
 953             break;\r
 954         }\r
 955 \r
 956         *buffer++ = ch;\r
 957         actualSize++;\r
 958     }\r
 959 \r
 960     return actualSize;\r
 961 }\r
 962 #endif /* SDK_DEBUGCONSOLE_UART */\r
 963 \r
 964 /* support LPC Xpresso with RedLib */\r
 965 #elif (defined(__REDLIB__))\r
 966 \r
 967 #if (!SDK_DEBUGCONSOLE) && (defined(SDK_DEBUGCONSOLE_UART))\r
 968 int __attribute__((weak)) __sys_write(int handle, char *buffer, int size)\r
 969 {\r
 970     if (buffer == 0)\r
 971     {\r
 972         /* return -1 if error. */\r
 973         return -1;\r
 974     }\r
 975 \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
 978     {\r
 979         return -1;\r
 980     }\r
 981 \r
 982     /* Send data. */\r
 983     DbgConsole_SendDataReliable((uint8_t *)buffer, size);\r
 984 \r
 985     return 0;\r
 986 }\r
 987 \r
 988 int __attribute__((weak)) __sys_readc(void)\r
 989 {\r
 990     char tmp;\r
 991 \r
 992     /* Receive data. */\r
 993     DbgConsole_ReadCharacter((uint8_t *)&tmp);\r
 994 \r
 995     return tmp;\r
 996 }\r
 997 #endif\r
 998 \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
1003 struct __FILE\r
1004 {\r
1005     int handle;\r
1006     /*\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
1009      */\r
1010 };\r
1011 #endif\r
1012 \r
1013 /* FILE is typedef in stdio.h. */\r
1014 #pragma weak __stdout\r
1015 #pragma weak __stdin\r
1016 FILE __stdout;\r
1017 FILE __stdin;\r
1018 \r
1019 #pragma weak fputc\r
1020 int fputc(int ch, FILE *f)\r
1021 {\r
1022     /* Send data. */\r
1023     return DbgConsole_SendDataReliable((uint8_t *)(&ch), 1);\r
1024 }\r
1025 \r
1026 #pragma weak fgetc\r
1027 int fgetc(FILE *f)\r
1028 {\r
1029     char ch;\r
1030 \r
1031     /* Receive data. */\r
1032     DbgConsole_ReadCharacter((uint8_t *)&ch);\r
1033 \r
1034     return ch;\r
1035 }\r
1036 \r
1037 /*\r
1038  * Terminate the program, passing a return code back to the user.\r
1039  * This function may not return.\r
1040  */\r
1041 void _sys_exit(int returncode)\r
1042 {\r
1043     while (1)\r
1044     {\r
1045     }\r
1046 }\r
1047 \r
1048 /*\r
1049  * Writes a character to the output channel. This function is used\r
1050  * for last-resort error message output.\r
1051  */\r
1052 void _ttywrch(int ch)\r
1053 {\r
1054     char ench = ch;\r
1055     DbgConsole_SendDataReliable((uint8_t *)(&ench), 1);\r
1056 }\r
1057 \r
1058 char *_sys_command_string(char *cmd, int len)\r
1059 {\r
1060     return (cmd);\r
1061 }\r
1062 #endif /* SDK_DEBUGCONSOLE_UART */\r
1063 \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
1066 \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
1071 {\r
1072     if (buffer == NULL)\r
1073     {\r
1074         /* return -1 if error. */\r
1075         return -1;\r
1076     }\r
1077 \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
1080     {\r
1081         return -1;\r
1082     }\r
1083 \r
1084     /* Send data. */\r
1085     (void)DbgConsole_SendDataReliable((uint8_t *)buffer, (size_t)size);\r
1086 \r
1087     return size;\r
1088 }\r
1089 \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
1092 {\r
1093     uint8_t ch     = 0U;\r
1094     int actualSize = 0;\r
1095 \r
1096     /* This function only reads from "standard in", for all other file handles it returns failure. */\r
1097     if (handle != 0)\r
1098     {\r
1099         return -1;\r
1100     }\r
1101 \r
1102     /* Receive data. */\r
1103     for (; size > 0; size--)\r
1104     {\r
1105         if (DbgConsole_ReadCharacter(&ch) < 0)\r
1106         {\r
1107             break;\r
1108         }\r
1109 \r
1110         *buffer++ = (char)ch;\r
1111         actualSize++;\r
1112 \r
1113         if ((ch == 0U) || (ch == (uint8_t)'\n') || (ch == (uint8_t)'\r'))\r
1114         {\r
1115             break;\r
1116         }\r
1117     }\r
1118 \r
1119     return (actualSize > 0) ? actualSize : -1;\r
1120 }\r
1121 #endif\r
1122 \r
1123 #endif /* __ICCARM__ */\r