git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/CORTEX_MPU_M33F_NXP_LPC55S69_MCUXpresso/NXP_Code/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 /* clang-format off */\r
 107 #define DEBUG_CONSOLE_CREATE_MUTEX_SEMAPHORE(mutex) ((mutex) = xSemaphoreCreateMutex())\r
 108 #define DEBUG_CONSOLE_DESTROY_MUTEX_SEMAPHORE(mutex)   \\r
 109         do                                             \\r
 110         {                                              \\r
 111             if(NULL != mutex)                          \\r
 112             {                                          \\r
 113                 vSemaphoreDelete(mutex);               \\r
 114                 mutex = NULL;                          \\r
 115             }                                          \\r
 116         } while(0)\r
 117 \r
 118 #define DEBUG_CONSOLE_GIVE_MUTEX_SEMAPHORE(mutex) \\r
 119 {                                                 \\r
 120         if (IS_RUNNING_IN_ISR() == 0U)            \\r
 121         {                                         \\r
 122             (void)xSemaphoreGive(mutex);          \\r
 123         }                                         \\r
 124 }\r
 125 \r
 126 #define DEBUG_CONSOLE_TAKE_MUTEX_SEMAPHORE_BLOCKING(mutex) \\r
 127 {                                                          \\r
 128         if (IS_RUNNING_IN_ISR() == 0U)                     \\r
 129         {                                                  \\r
 130             (void)xSemaphoreTake(mutex, portMAX_DELAY);    \\r
 131         }                                                  \\r
 132 }\r
 133 \r
 134 #define DEBUG_CONSOLE_TAKE_MUTEX_SEMAPHORE_NONBLOCKING(mutex, result) \\r
 135 {                                                                     \\r
 136         if (IS_RUNNING_IN_ISR() == 0U)                                \\r
 137         {                                                             \\r
 138             result = xSemaphoreTake(mutex, 0U);                       \\r
 139         }                                                             \\r
 140         else                                                          \\r
 141         {                                                             \\r
 142             result = 1U;                                              \\r
 143         }                                                             \\r
 144 }\r
 145 \r
 146 /* Binary semaphore */\r
 147 #define DEBUG_CONSOLE_CREATE_BINARY_SEMAPHORE(binary) ((binary) = xSemaphoreCreateBinary())\r
 148 #define DEBUG_CONSOLE_DESTROY_BINARY_SEMAPHORE(binary) \\r
 149         do                                             \\r
 150         {                                              \\r
 151             if(NULL != binary)                         \\r
 152             {                                          \\r
 153                 vSemaphoreDelete(binary);              \\r
 154                 binary = NULL;                         \\r
 155             }                                          \\r
 156         } while(0)\r
 157 #define DEBUG_CONSOLE_TAKE_BINARY_SEMAPHORE_BLOCKING(binary) ((void)xSemaphoreTake(binary, portMAX_DELAY))\r
 158 #define DEBUG_CONSOLE_GIVE_BINARY_SEMAPHORE_FROM_ISR(binary) ((void)xSemaphoreGiveFromISR(binary, NULL))\r
 159 \r
 160 #elif (DEBUG_CONSOLE_SYNCHRONIZATION_BM == DEBUG_CONSOLE_SYNCHRONIZATION_MODE)\r
 161 \r
 162 #define DEBUG_CONSOLE_CREATE_MUTEX_SEMAPHORE(mutex)\r
 163 #define DEBUG_CONSOLE_DESTROY_MUTEX_SEMAPHORE(mutex)\r
 164 #define DEBUG_CONSOLE_TAKE_MUTEX_SEMAPHORE_BLOCKING(mutex)\r
 165 #define DEBUG_CONSOLE_GIVE_MUTEX_SEMAPHORE(mutex)\r
 166 #define DEBUG_CONSOLE_TAKE_MUTEX_SEMAPHORE_NONBLOCKING(mutex, result) (result = 1U)\r
 167 \r
 168 #define DEBUG_CONSOLE_CREATE_BINARY_SEMAPHORE(binary)\r
 169 #define DEBUG_CONSOLE_DESTROY_BINARY_SEMAPHORE(binary)\r
 170 #ifdef DEBUG_CONSOLE_TRANSFER_NON_BLOCKING\r
 171 #define DEBUG_CONSOLE_TAKE_BINARY_SEMAPHORE_BLOCKING(binary) \\r
 172     {                                                        \\r
 173         while (!binary)                                      \\r
 174         {                                                    \\r
 175         }                                                    \\r
 176         binary = false;                                      \\r
 177     }\r
 178 #define DEBUG_CONSOLE_GIVE_BINARY_SEMAPHORE_FROM_ISR(binary) (binary = true)\r
 179 #else\r
 180 #define DEBUG_CONSOLE_TAKE_BINARY_SEMAPHORE_BLOCKING(binary)\r
 181 #define DEBUG_CONSOLE_GIVE_BINARY_SEMAPHORE_FROM_ISR(binary)\r
 182 #endif /* DEBUG_CONSOLE_TRANSFER_NON_BLOCKING */\r
 183 /* clang-format on */\r
 184 \r
 185 /* add other implementation here\r
 186  *such as :\r
 187  * #elif(DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DDEBUG_CONSOLE_SYNCHRONIZATION_xxx)\r
 188  */\r
 189 \r
 190 #else\r
 191 \r
 192 #error RTOS type is not defined by DEBUG_CONSOLE_SYNCHRONIZATION_MODE.\r
 193 \r
 194 #endif /* DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_FREERTOS */\r
 195 \r
 196 #ifdef DEBUG_CONSOLE_TRANSFER_NON_BLOCKING\r
 197 /* receive state structure */\r
 198 typedef struct _debug_console_write_ring_buffer\r
 199 {\r
 200     uint32_t ringBufferSize;\r
 201     volatile uint32_t ringHead;\r
 202     volatile uint32_t ringTail;\r
 203     uint8_t ringBuffer[DEBUG_CONSOLE_TRANSMIT_BUFFER_LEN];\r
 204 } debug_console_write_ring_buffer_t;\r
 205 #endif\r
 206 \r
 207 typedef struct _debug_console_state_struct\r
 208 {\r
 209     uint8_t serialHandleBuffer[SERIAL_MANAGER_HANDLE_SIZE];\r
 210     serial_handle_t serialHandle; /*!< serial manager handle */\r
 211 #ifdef DEBUG_CONSOLE_TRANSFER_NON_BLOCKING\r
 212     debug_console_write_ring_buffer_t writeRingBuffer;\r
 213     uint8_t readRingBuffer[DEBUG_CONSOLE_RECEIVE_BUFFER_LEN];\r
 214 #endif\r
 215     uint8_t serialWriteHandleBuffer[SERIAL_MANAGER_WRITE_HANDLE_SIZE];\r
 216     uint8_t serialReadHandleBuffer[SERIAL_MANAGER_READ_HANDLE_SIZE];\r
 217 } debug_console_state_struct_t;\r
 218 \r
 219 /*******************************************************************************\r
 220  * Variables\r
 221  ******************************************************************************/\r
 222 \r
 223 /*! @brief Debug console state information. */\r
 224 #if (defined(DATA_SECTION_IS_CACHEABLE) && (DATA_SECTION_IS_CACHEABLE > 0))\r
 225 AT_NONCACHEABLE_SECTION(static debug_console_state_struct_t s_debugConsoleState);\r
 226 #else\r
 227 static debug_console_state_struct_t s_debugConsoleState;\r
 228 #endif\r
 229 serial_handle_t g_serialHandle; /*!< serial manager handle */\r
 230 \r
 231 /*******************************************************************************\r
 232  * Prototypes\r
 233  ******************************************************************************/\r
 234 /*!\r
 235  * @brief This is a printf call back function which is used to relocate the log to buffer\r
 236  * or print the log immediately when the local buffer is full.\r
 237  *\r
 238  * @param[in] buf   Buffer to store log.\r
 239  * @param[in] indicator Buffer index.\r
 240  * @param[in] val Target character to store.\r
 241  * @param[in] len length of the character\r
 242  *\r
 243  */\r
 244 #if SDK_DEBUGCONSOLE\r
 245 static void DbgConsole_PrintCallback(char *buf, int32_t *indicator, char dbgVal, int len);\r
 246 #endif\r
 247 \r
 248 status_t DbgConsole_ReadOneCharacter(uint8_t *ch);\r
 249 int DbgConsole_SendData(uint8_t *ch, size_t size);\r
 250 int DbgConsole_SendDataReliable(uint8_t *ch, size_t size);\r
 251 int DbgConsole_ReadLine(uint8_t *buf, size_t size);\r
 252 int DbgConsole_ReadCharacter(uint8_t *ch);\r
 253 \r
 254 #if ((SDK_DEBUGCONSOLE > 0U) ||                                                   \\r
 255      ((SDK_DEBUGCONSOLE == 0U) && defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING) && \\r
 256       (defined(DEBUG_CONSOLE_TX_RELIABLE_ENABLE) && (DEBUG_CONSOLE_TX_RELIABLE_ENABLE > 0U))))\r
 257 DEBUG_CONSOLE_FUNCTION_PREFIX status_t DbgConsole_Flush(void);\r
 258 #endif\r
 259 /*******************************************************************************\r
 260  * Code\r
 261  ******************************************************************************/\r
 262 \r
 263 #if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)\r
 264 \r
 265 static void DbgConsole_SerialManagerTxCallback(void *callbackParam,\r
 266                                                serial_manager_callback_message_t *message,\r
 267                                                serial_manager_status_t status)\r
 268 {\r
 269     debug_console_state_struct_t *ioState;\r
 270     uint32_t sendDataLength;\r
 271 \r
 272     if ((NULL == callbackParam) || (NULL == message))\r
 273     {\r
 274         return;\r
 275     }\r
 276 \r
 277     ioState = (debug_console_state_struct_t *)callbackParam;\r
 278 \r
 279     ioState->writeRingBuffer.ringTail += message->length;\r
 280     if (ioState->writeRingBuffer.ringTail >= ioState->writeRingBuffer.ringBufferSize)\r
 281     {\r
 282         ioState->writeRingBuffer.ringTail = 0U;\r
 283     }\r
 284 \r
 285     if (kStatus_SerialManager_Success == status)\r
 286     {\r
 287         if (ioState->writeRingBuffer.ringTail != ioState->writeRingBuffer.ringHead)\r
 288         {\r
 289             if (ioState->writeRingBuffer.ringHead > ioState->writeRingBuffer.ringTail)\r
 290             {\r
 291                 sendDataLength = ioState->writeRingBuffer.ringHead - ioState->writeRingBuffer.ringTail;\r
 292             }\r
 293             else\r
 294             {\r
 295                 sendDataLength = ioState->writeRingBuffer.ringBufferSize - ioState->writeRingBuffer.ringTail;\r
 296             }\r
 297 \r
 298             (void)SerialManager_WriteNonBlocking(\r
 299                 ((serial_write_handle_t)&ioState->serialWriteHandleBuffer[0]),\r
 300                 &ioState->writeRingBuffer.ringBuffer[ioState->writeRingBuffer.ringTail], sendDataLength);\r
 301         }\r
 302     }\r
 303     else if (kStatus_SerialManager_Canceled == status)\r
 304     {\r
 305         ioState->writeRingBuffer.ringTail = 0U;\r
 306         ioState->writeRingBuffer.ringHead = 0U;\r
 307     }\r
 308     else\r
 309     {\r
 310         /*MISRA rule 16.4*/\r
 311     }\r
 312 }\r
 313 \r
 314 #if (defined(DEBUG_CONSOLE_RX_ENABLE) && (DEBUG_CONSOLE_RX_ENABLE > 0U))\r
 315 \r
 316 static void DbgConsole_SerialManagerRxCallback(void *callbackParam,\r
 317                                                serial_manager_callback_message_t *message,\r
 318                                                serial_manager_status_t status)\r
 319 {\r
 320     if ((NULL == callbackParam) || (NULL == message))\r
 321     {\r
 322         return;\r
 323     }\r
 324 \r
 325     if (kStatus_SerialManager_Notify == status)\r
 326     {\r
 327     }\r
 328     else if (kStatus_SerialManager_Success == status)\r
 329     {\r
 330         /* release s_debugConsoleReadWaitSemaphore from RX callback */\r
 331         DEBUG_CONSOLE_GIVE_BINARY_SEMAPHORE_FROM_ISR(s_debugConsoleReadWaitSemaphore);\r
 332     }\r
 333     else\r
 334     {\r
 335         /*MISRA rule 16.4*/\r
 336     }\r
 337 }\r
 338 #endif\r
 339 \r
 340 #endif\r
 341 \r
 342 status_t DbgConsole_ReadOneCharacter(uint8_t *ch)\r
 343 {\r
 344 #if (defined(DEBUG_CONSOLE_RX_ENABLE) && (DEBUG_CONSOLE_RX_ENABLE > 0U))\r
 345 \r
 346 #if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING) && \\r
 347     (DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_BM) && defined(OSA_USED)\r
 348     return kStatus_Fail;\r
 349 #else\r
 350     status_t status = (status_t)kStatus_SerialManager_Error;\r
 351 \r
 352 /* recieve one char every time */\r
 353 #if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)\r
 354     status = (status_t)SerialManager_ReadNonBlocking(\r
 355         ((serial_read_handle_t)&s_debugConsoleState.serialReadHandleBuffer[0]), ch, 1);\r
 356 #else\r
 357     status = (status_t)SerialManager_ReadBlocking(\r
 358         ((serial_read_handle_t)&s_debugConsoleState.serialReadHandleBuffer[0]), ch, 1);\r
 359 #endif\r
 360     if ((status_t)kStatus_SerialManager_Success != status)\r
 361     {\r
 362         return (status_t)kStatus_Fail;\r
 363     }\r
 364     /* wait s_debugConsoleReadWaitSemaphore from RX callback */\r
 365     DEBUG_CONSOLE_TAKE_BINARY_SEMAPHORE_BLOCKING(s_debugConsoleReadWaitSemaphore);\r
 366 \r
 367     return (status_t)kStatus_Success;\r
 368 #endif\r
 369 \r
 370 #else\r
 371 \r
 372     return (status_t)kStatus_Fail;\r
 373 \r
 374 #endif\r
 375 }\r
 376 \r
 377 #if DEBUG_CONSOLE_ENABLE_ECHO_FUNCTION\r
 378 static status_t DbgConsole_EchoCharacter(uint8_t *ch, bool isGetChar, int *index)\r
 379 {\r
 380     /* Due to scanf take \n and \r as end of string,should not echo */\r
 381     if (((*ch != (uint8_t)'\r') && (*ch != (uint8_t)'\n')) || (isGetChar))\r
 382     {\r
 383         /* recieve one char every time */\r
 384         if (1 != DbgConsole_SendDataReliable(ch, 1U))\r
 385         {\r
 386             return (status_t)kStatus_Fail;\r
 387         }\r
 388     }\r
 389 \r
 390     if ((!isGetChar) && (index != NULL))\r
 391     {\r
 392         if (DEBUG_CONSOLE_BACKSPACE == *ch)\r
 393         {\r
 394             if ((*index >= 2))\r
 395             {\r
 396                 *index -= 2;\r
 397             }\r
 398             else\r
 399             {\r
 400                 *index = 0;\r
 401             }\r
 402         }\r
 403     }\r
 404 \r
 405     return (status_t)kStatus_Success;\r
 406 }\r
 407 #endif\r
 408 \r
 409 int DbgConsole_SendData(uint8_t *ch, size_t size)\r
 410 {\r
 411     status_t status = (status_t)kStatus_SerialManager_Error;\r
 412 #if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)\r
 413     uint32_t sendDataLength;\r
 414     int txBusy = 0;\r
 415 #endif\r
 416     assert(NULL != ch);\r
 417     assert(0 != size);\r
 418 \r
 419 #if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)\r
 420     uint32_t regPrimask = DisableGlobalIRQ();\r
 421     if (s_debugConsoleState.writeRingBuffer.ringHead != s_debugConsoleState.writeRingBuffer.ringTail)\r
 422     {\r
 423         txBusy = 1;\r
 424         sendDataLength =\r
 425             (s_debugConsoleState.writeRingBuffer.ringHead + s_debugConsoleState.writeRingBuffer.ringBufferSize -\r
 426              s_debugConsoleState.writeRingBuffer.ringTail) %\r
 427             s_debugConsoleState.writeRingBuffer.ringBufferSize;\r
 428     }\r
 429     else\r
 430     {\r
 431         sendDataLength = 0U;\r
 432     }\r
 433     sendDataLength = s_debugConsoleState.writeRingBuffer.ringBufferSize - sendDataLength - 1;\r
 434     if (sendDataLength < size)\r
 435     {\r
 436         EnableGlobalIRQ(regPrimask);\r
 437         return -1;\r
 438     }\r
 439     for (int i = 0; i < (int)size; i++)\r
 440     {\r
 441         s_debugConsoleState.writeRingBuffer.ringBuffer[s_debugConsoleState.writeRingBuffer.ringHead++] = ch[i];\r
 442         if (s_debugConsoleState.writeRingBuffer.ringHead >= s_debugConsoleState.writeRingBuffer.ringBufferSize)\r
 443         {\r
 444             s_debugConsoleState.writeRingBuffer.ringHead = 0U;\r
 445         }\r
 446     }\r
 447 \r
 448     status = (status_t)kStatus_SerialManager_Success;\r
 449 \r
 450     if (txBusy == 0)\r
 451     {\r
 452         if (s_debugConsoleState.writeRingBuffer.ringHead > s_debugConsoleState.writeRingBuffer.ringTail)\r
 453         {\r
 454             sendDataLength =\r
 455                 s_debugConsoleState.writeRingBuffer.ringHead - s_debugConsoleState.writeRingBuffer.ringTail;\r
 456         }\r
 457         else\r
 458         {\r
 459             sendDataLength =\r
 460                 s_debugConsoleState.writeRingBuffer.ringBufferSize - s_debugConsoleState.writeRingBuffer.ringTail;\r
 461         }\r
 462 \r
 463         status = (status_t)SerialManager_WriteNonBlocking(\r
 464             ((serial_write_handle_t)&s_debugConsoleState.serialWriteHandleBuffer[0]),\r
 465             &s_debugConsoleState.writeRingBuffer.ringBuffer[s_debugConsoleState.writeRingBuffer.ringTail],\r
 466             sendDataLength);\r
 467     }\r
 468     EnableGlobalIRQ(regPrimask);\r
 469 #else\r
 470     status = (status_t)SerialManager_WriteBlocking(\r
 471         ((serial_write_handle_t)&s_debugConsoleState.serialWriteHandleBuffer[0]), ch, size);\r
 472 #endif\r
 473     return (((status_t)kStatus_Success == status) ? (int)size : -1);\r
 474 }\r
 475 \r
 476 int DbgConsole_SendDataReliable(uint8_t *ch, size_t size)\r
 477 {\r
 478 #if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)\r
 479 #if (defined(DEBUG_CONSOLE_TX_RELIABLE_ENABLE) && (DEBUG_CONSOLE_TX_RELIABLE_ENABLE > 0U))\r
 480     status_t status = kStatus_SerialManager_Error;\r
 481     uint32_t sendDataLength;\r
 482     uint32_t totalLength = size;\r
 483     int sentLength;\r
 484 #endif /* DEBUG_CONSOLE_TX_RELIABLE_ENABLE */\r
 485 #else\r
 486     status_t status = kStatus_SerialManager_Error;\r
 487 #endif /* DEBUG_CONSOLE_TRANSFER_NON_BLOCKING */\r
 488 \r
 489     assert(NULL != ch);\r
 490     assert(0 != size);\r
 491 \r
 492     if (NULL == g_serialHandle)\r
 493     {\r
 494         return 0;\r
 495     }\r
 496 \r
 497 #if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)\r
 498 \r
 499 #if (defined(DEBUG_CONSOLE_TX_RELIABLE_ENABLE) && (DEBUG_CONSOLE_TX_RELIABLE_ENABLE > 0U))\r
 500     do\r
 501     {\r
 502         uint32_t regPrimask = DisableGlobalIRQ();\r
 503         if (s_debugConsoleState.writeRingBuffer.ringHead != s_debugConsoleState.writeRingBuffer.ringTail)\r
 504         {\r
 505             sendDataLength =\r
 506                 (s_debugConsoleState.writeRingBuffer.ringHead + s_debugConsoleState.writeRingBuffer.ringBufferSize -\r
 507                  s_debugConsoleState.writeRingBuffer.ringTail) %\r
 508                 s_debugConsoleState.writeRingBuffer.ringBufferSize;\r
 509         }\r
 510         else\r
 511         {\r
 512             sendDataLength = 0U;\r
 513         }\r
 514         sendDataLength = s_debugConsoleState.writeRingBuffer.ringBufferSize - sendDataLength - 1U;\r
 515 \r
 516         if (sendDataLength > 0U)\r
 517         {\r
 518             if (sendDataLength > totalLength)\r
 519             {\r
 520                 sendDataLength = totalLength;\r
 521             }\r
 522 \r
 523             sentLength = DbgConsole_SendData(&ch[size - totalLength], sendDataLength);\r
 524             if (sentLength > 0)\r
 525             {\r
 526                 totalLength = totalLength - (uint32_t)sentLength;\r
 527             }\r
 528         }\r
 529         EnableGlobalIRQ(regPrimask);\r
 530 \r
 531         if (totalLength != 0U)\r
 532         {\r
 533             status = DbgConsole_Flush();\r
 534             if ((status_t)kStatus_Success != status)\r
 535             {\r
 536                 break;\r
 537             }\r
 538         }\r
 539     } while (totalLength != 0U);\r
 540     return (status_t)(uint32_t)((uint32_t)size - totalLength);\r
 541 #else\r
 542     return DbgConsole_SendData(ch, size);\r
 543 #endif /* DEBUG_CONSOLE_TX_RELIABLE_ENABLE */\r
 544 \r
 545 #else\r
 546     status          = (status_t)SerialManager_WriteBlocking(\r
 547         ((serial_write_handle_t)&s_debugConsoleState.serialWriteHandleBuffer[0]), ch, size);\r
 548     return (((status_t)kStatus_Success == status) ? (int)size : -1);\r
 549 #endif /* DEBUG_CONSOLE_TRANSFER_NON_BLOCKING */\r
 550 }\r
 551 \r
 552 int DbgConsole_ReadLine(uint8_t *buf, size_t size)\r
 553 {\r
 554     int i = 0;\r
 555 \r
 556     assert(buf != NULL);\r
 557 \r
 558     if (NULL == g_serialHandle)\r
 559     {\r
 560         return -1;\r
 561     }\r
 562 \r
 563     /* take mutex lock function */\r
 564     DEBUG_CONSOLE_TAKE_MUTEX_SEMAPHORE_BLOCKING(s_debugConsoleReadSemaphore);\r
 565 \r
 566     do\r
 567     {\r
 568         /* recieve one char every time */\r
 569         if ((status_t)kStatus_Success != DbgConsole_ReadOneCharacter(&buf[i]))\r
 570         {\r
 571             /* release mutex lock function */\r
 572             DEBUG_CONSOLE_GIVE_MUTEX_SEMAPHORE(s_debugConsoleReadSemaphore);\r
 573             i = -1;\r
 574             break;\r
 575         }\r
 576 #if DEBUG_CONSOLE_ENABLE_ECHO_FUNCTION\r
 577         (void)DbgConsole_EchoCharacter(&buf[i], false, &i);\r
 578 #endif\r
 579         /* analysis data */\r
 580         if (((uint8_t)'\r' == buf[i]) || ((uint8_t)'\n' == buf[i]))\r
 581         {\r
 582             /* End of Line. */\r
 583             if (0 == i)\r
 584             {\r
 585                 buf[i] = (uint8_t)'\0';\r
 586                 continue;\r
 587             }\r
 588             else\r
 589             {\r
 590                 break;\r
 591             }\r
 592         }\r
 593         i++;\r
 594     } while (i < (int)size);\r
 595 \r
 596     /* get char should not add '\0'*/\r
 597     if (i == (int)size)\r
 598     {\r
 599         buf[i] = (uint8_t)'\0';\r
 600     }\r
 601     else\r
 602     {\r
 603         buf[i + 1] = (uint8_t)'\0';\r
 604     }\r
 605 \r
 606     /* release mutex lock function */\r
 607     DEBUG_CONSOLE_GIVE_MUTEX_SEMAPHORE(s_debugConsoleReadSemaphore);\r
 608 \r
 609     return i;\r
 610 }\r
 611 \r
 612 int DbgConsole_ReadCharacter(uint8_t *ch)\r
 613 {\r
 614     int ret;\r
 615 \r
 616     assert(ch);\r
 617 \r
 618     if (NULL == g_serialHandle)\r
 619     {\r
 620         return -1;\r
 621     }\r
 622 \r
 623     /* take mutex lock function */\r
 624     DEBUG_CONSOLE_TAKE_MUTEX_SEMAPHORE_BLOCKING(s_debugConsoleReadSemaphore);\r
 625     /* read one character */\r
 626     if ((status_t)kStatus_Success == DbgConsole_ReadOneCharacter(ch))\r
 627     {\r
 628         ret = 1;\r
 629 #if DEBUG_CONSOLE_ENABLE_ECHO_FUNCTION\r
 630         (void)DbgConsole_EchoCharacter(ch, true, NULL);\r
 631 #endif\r
 632     }\r
 633     else\r
 634     {\r
 635         ret = -1;\r
 636     }\r
 637 \r
 638     /* release mutex lock function */\r
 639     DEBUG_CONSOLE_GIVE_MUTEX_SEMAPHORE(s_debugConsoleReadSemaphore);\r
 640 \r
 641     return ret;\r
 642 }\r
 643 \r
 644 #if SDK_DEBUGCONSOLE\r
 645 static void DbgConsole_PrintCallback(char *buf, int32_t *indicator, char dbgVal, int len)\r
 646 {\r
 647     int i = 0;\r
 648 \r
 649     for (i = 0; i < len; i++)\r
 650     {\r
 651         if (((uint32_t)*indicator + 1UL) >= DEBUG_CONSOLE_PRINTF_MAX_LOG_LEN)\r
 652         {\r
 653             (void)DbgConsole_SendDataReliable((uint8_t *)buf, (uint32_t)(*indicator));\r
 654             *indicator = 0;\r
 655         }\r
 656 \r
 657         buf[*indicator] = dbgVal;\r
 658         (*indicator)++;\r
 659     }\r
 660 }\r
 661 #endif\r
 662 \r
 663 /*************Code for DbgConsole Init, Deinit, Printf, Scanf *******************************/\r
 664 \r
 665 #if ((SDK_DEBUGCONSOLE == DEBUGCONSOLE_REDIRECT_TO_SDK) || defined(SDK_DEBUGCONSOLE_UART))\r
 666 /* See fsl_debug_console.h for documentation of this function. */\r
 667 status_t DbgConsole_Init(uint8_t instance, uint32_t baudRate, serial_port_type_t device, uint32_t clkSrcFreq)\r
 668 {\r
 669     serial_manager_config_t serialConfig;\r
 670     status_t status = (status_t)kStatus_SerialManager_Error;\r
 671 \r
 672 #if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))\r
 673     serial_port_uart_config_t uartConfig = {\r
 674         .instance     = instance,\r
 675         .clockRate    = clkSrcFreq,\r
 676         .baudRate     = baudRate,\r
 677         .parityMode   = kSerialManager_UartParityDisabled,\r
 678         .stopBitCount = kSerialManager_UartOneStopBit,\r
 679         .enableRx     = 1,\r
 680         .enableTx     = 1,\r
 681     };\r
 682 #endif\r
 683 \r
 684 #if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))\r
 685     serial_port_usb_cdc_config_t usbCdcConfig = {\r
 686         .controllerIndex = (serial_port_usb_cdc_controller_index_t)instance,\r
 687     };\r
 688 #endif\r
 689 \r
 690 #if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))\r
 691     serial_port_swo_config_t swoConfig = {\r
 692         .clockRate = clkSrcFreq,\r
 693         .baudRate  = baudRate,\r
 694         .port      = instance,\r
 695         .protocol  = kSerialManager_SwoProtocolNrz,\r
 696     };\r
 697 #endif\r
 698 \r
 699 #if (defined(SERIAL_PORT_TYPE_USBCDC_VIRTUAL) && (SERIAL_PORT_TYPE_USBCDC_VIRTUAL > 0U))\r
 700     serial_port_usb_cdc_virtual_config_t usbCdcVirtualConfig = {\r
 701         .controllerIndex = (serial_port_usb_cdc_virtual_controller_index_t)instance,\r
 702     };\r
 703 #endif\r
 704     serialConfig.type = device;\r
 705 #if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)\r
 706     serialConfig.ringBuffer     = &s_debugConsoleState.readRingBuffer[0];\r
 707     serialConfig.ringBufferSize = DEBUG_CONSOLE_RECEIVE_BUFFER_LEN;\r
 708 #endif\r
 709 \r
 710     if (kSerialPort_Uart == device)\r
 711     {\r
 712 #if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))\r
 713         serialConfig.portConfig = &uartConfig;\r
 714 #else\r
 715         return status;\r
 716 #endif\r
 717     }\r
 718     else if (kSerialPort_UsbCdc == device)\r
 719     {\r
 720 #if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))\r
 721         serialConfig.portConfig = &usbCdcConfig;\r
 722 #else\r
 723         return status;\r
 724 #endif\r
 725     }\r
 726     else if (kSerialPort_Swo == device)\r
 727     {\r
 728 #if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))\r
 729         serialConfig.portConfig = &swoConfig;\r
 730 #else\r
 731         return status;\r
 732 #endif\r
 733     }\r
 734     else if (kSerialPort_UsbCdcVirtual == device)\r
 735     {\r
 736 #if (defined(SERIAL_PORT_TYPE_USBCDC_VIRTUAL) && (SERIAL_PORT_TYPE_USBCDC_VIRTUAL > 0U))\r
 737         serialConfig.portConfig = &usbCdcVirtualConfig;\r
 738 #else\r
 739         return status;\r
 740 #endif\r
 741     }\r
 742     else\r
 743     {\r
 744         return status;\r
 745     }\r
 746 \r
 747     (void)memset(&s_debugConsoleState, 0, sizeof(s_debugConsoleState));\r
 748 \r
 749 #if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)\r
 750     s_debugConsoleState.writeRingBuffer.ringBufferSize = DEBUG_CONSOLE_TRANSMIT_BUFFER_LEN;\r
 751 #endif\r
 752 \r
 753     s_debugConsoleState.serialHandle = (serial_handle_t)&s_debugConsoleState.serialHandleBuffer[0];\r
 754     status                           = (status_t)SerialManager_Init(s_debugConsoleState.serialHandle, &serialConfig);\r
 755 \r
 756     assert(kStatus_SerialManager_Success == status);\r
 757 \r
 758     DEBUG_CONSOLE_CREATE_MUTEX_SEMAPHORE(s_debugConsoleReadSemaphore);\r
 759 #if (defined(DEBUG_CONSOLE_RX_ENABLE) && (DEBUG_CONSOLE_RX_ENABLE > 0U))\r
 760     DEBUG_CONSOLE_CREATE_BINARY_SEMAPHORE(s_debugConsoleReadWaitSemaphore);\r
 761 #endif\r
 762 \r
 763     {\r
 764         status = (status_t)SerialManager_OpenWriteHandle(\r
 765             s_debugConsoleState.serialHandle, ((serial_write_handle_t)&s_debugConsoleState.serialWriteHandleBuffer[0]));\r
 766         assert(kStatus_SerialManager_Success == status);\r
 767 #if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)\r
 768         (void)SerialManager_InstallTxCallback(((serial_write_handle_t)&s_debugConsoleState.serialWriteHandleBuffer[0]),\r
 769                                               DbgConsole_SerialManagerTxCallback, &s_debugConsoleState);\r
 770 #endif\r
 771     }\r
 772 \r
 773 #if (defined(DEBUG_CONSOLE_RX_ENABLE) && (DEBUG_CONSOLE_RX_ENABLE > 0U))\r
 774     {\r
 775         status = (status_t)SerialManager_OpenReadHandle(\r
 776             s_debugConsoleState.serialHandle, ((serial_read_handle_t)&s_debugConsoleState.serialReadHandleBuffer[0]));\r
 777         assert(kStatus_SerialManager_Success == status);\r
 778 #if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)\r
 779         (void)SerialManager_InstallRxCallback(((serial_read_handle_t)&s_debugConsoleState.serialReadHandleBuffer[0]),\r
 780                                               DbgConsole_SerialManagerRxCallback, &s_debugConsoleState);\r
 781 #endif\r
 782     }\r
 783 #endif\r
 784 \r
 785     g_serialHandle = s_debugConsoleState.serialHandle;\r
 786 \r
 787     return kStatus_Success;\r
 788 }\r
 789 \r
 790 /* See fsl_debug_console.h for documentation of this function. */\r
 791 status_t DbgConsole_Deinit(void)\r
 792 {\r
 793     {\r
 794         if (s_debugConsoleState.serialHandle != NULL)\r
 795         {\r
 796             (void)SerialManager_CloseWriteHandle(\r
 797                 ((serial_write_handle_t)&s_debugConsoleState.serialWriteHandleBuffer[0]));\r
 798         }\r
 799     }\r
 800 #if (defined(DEBUG_CONSOLE_RX_ENABLE) && (DEBUG_CONSOLE_RX_ENABLE > 0U))\r
 801     {\r
 802         if (s_debugConsoleState.serialHandle != NULL)\r
 803         {\r
 804             (void)SerialManager_CloseReadHandle(((serial_read_handle_t)&s_debugConsoleState.serialReadHandleBuffer[0]));\r
 805         }\r
 806     }\r
 807 #endif\r
 808     if (s_debugConsoleState.serialHandle)\r
 809     {\r
 810         if (kStatus_SerialManager_Success == SerialManager_Deinit(s_debugConsoleState.serialHandle))\r
 811         {\r
 812             s_debugConsoleState.serialHandle = NULL;\r
 813             g_serialHandle                   = NULL;\r
 814         }\r
 815     }\r
 816 #if (defined(DEBUG_CONSOLE_RX_ENABLE) && (DEBUG_CONSOLE_RX_ENABLE > 0U))\r
 817     DEBUG_CONSOLE_DESTROY_BINARY_SEMAPHORE(s_debugConsoleReadWaitSemaphore);\r
 818 #endif\r
 819     DEBUG_CONSOLE_DESTROY_MUTEX_SEMAPHORE(s_debugConsoleReadSemaphore);\r
 820 \r
 821     return (status_t)kStatus_Success;\r
 822 }\r
 823 #endif /* ((SDK_DEBUGCONSOLE == DEBUGCONSOLE_REDIRECT_TO_SDK) || defined(SDK_DEBUGCONSOLE_UART)) */\r
 824 \r
 825 #if ((SDK_DEBUGCONSOLE > 0U) ||                                                   \\r
 826      ((SDK_DEBUGCONSOLE == 0U) && defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING) && \\r
 827       (defined(DEBUG_CONSOLE_TX_RELIABLE_ENABLE) && (DEBUG_CONSOLE_TX_RELIABLE_ENABLE > 0U))))\r
 828 DEBUG_CONSOLE_FUNCTION_PREFIX status_t DbgConsole_Flush(void)\r
 829 {\r
 830 #if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)\r
 831 \r
 832 #if (DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_BM) && defined(OSA_USED)\r
 833 \r
 834     if (s_debugConsoleState.writeRingBuffer.ringHead != s_debugConsoleState.writeRingBuffer.ringTail)\r
 835     {\r
 836         return (status_t)kStatus_Fail;\r
 837     }\r
 838 \r
 839 #else\r
 840 \r
 841     while (s_debugConsoleState.writeRingBuffer.ringHead != s_debugConsoleState.writeRingBuffer.ringTail)\r
 842     {\r
 843 #if (DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_FREERTOS)\r
 844         if (0U == IS_RUNNING_IN_ISR())\r
 845         {\r
 846             if (taskSCHEDULER_RUNNING == xTaskGetSchedulerState())\r
 847             {\r
 848                 vTaskDelay(1);\r
 849             }\r
 850         }\r
 851         else\r
 852         {\r
 853             return (status_t)kStatus_Fail;\r
 854         }\r
 855 #endif\r
 856     }\r
 857 \r
 858 #endif\r
 859 \r
 860 #endif\r
 861     return (status_t)kStatus_Success;\r
 862 }\r
 863 #endif\r
 864 \r
 865 #if SDK_DEBUGCONSOLE\r
 866 /* See fsl_debug_console.h for documentation of this function. */\r
 867 int DbgConsole_Printf(const char *formatString, ...)\r
 868 {\r
 869     va_list ap;\r
 870     int logLength = 0, dbgResult = 0;\r
 871     char printBuf[DEBUG_CONSOLE_PRINTF_MAX_LOG_LEN] = {'\0'};\r
 872 \r
 873     if (NULL == g_serialHandle)\r
 874     {\r
 875         return 0;\r
 876     }\r
 877 \r
 878     va_start(ap, formatString);\r
 879     /* format print log first */\r
 880     logLength = StrFormatPrintf(formatString, ap, printBuf, DbgConsole_PrintCallback);\r
 881     /* print log */\r
 882     dbgResult = DbgConsole_SendDataReliable((uint8_t *)printBuf, (size_t)logLength);\r
 883 \r
 884     va_end(ap);\r
 885 \r
 886     return dbgResult;\r
 887 }\r
 888 \r
 889 /* See fsl_debug_console.h for documentation of this function. */\r
 890 int DbgConsole_Putchar(int ch)\r
 891 {\r
 892     /* print char */\r
 893     return DbgConsole_SendDataReliable((uint8_t *)&ch, 1U);\r
 894 }\r
 895 \r
 896 /* See fsl_debug_console.h for documentation of this function. */\r
 897 int DbgConsole_Scanf(char *formatString, ...)\r
 898 {\r
 899     va_list ap;\r
 900     int formatResult;\r
 901     char scanfBuf[DEBUG_CONSOLE_SCANF_MAX_LOG_LEN + 1U] = {'\0'};\r
 902 \r
 903     /* scanf log */\r
 904     (void)DbgConsole_ReadLine((uint8_t *)scanfBuf, DEBUG_CONSOLE_SCANF_MAX_LOG_LEN);\r
 905     /* get va_list */\r
 906     va_start(ap, formatString);\r
 907     /* format scanf log */\r
 908     formatResult = StrFormatScanf(scanfBuf, formatString, ap);\r
 909 \r
 910     va_end(ap);\r
 911 \r
 912     return formatResult;\r
 913 }\r
 914 /* See fsl_debug_console.h for documentation of this function. */\r
 915 int DbgConsole_BlockingPrintf(const char *formatString, ...)\r
 916 {\r
 917     va_list ap;\r
 918     status_t status = (status_t)kStatus_SerialManager_Error;\r
 919     int logLength = 0, dbgResult = 0;\r
 920     char printBuf[DEBUG_CONSOLE_PRINTF_MAX_LOG_LEN] = {'\0'};\r
 921 \r
 922     if (NULL == g_serialHandle)\r
 923     {\r
 924         return 0;\r
 925     }\r
 926 \r
 927     va_start(ap, formatString);\r
 928     /* format print log first */\r
 929     logLength = StrFormatPrintf(formatString, ap, printBuf, DbgConsole_PrintCallback);\r
 930 \r
 931 #if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING)\r
 932     SerialManager_CancelWriting(((serial_write_handle_t)&s_debugConsoleState.serialWriteHandleBuffer[0]));\r
 933 #endif\r
 934     /* print log */\r
 935     status =\r
 936         (status_t)SerialManager_WriteBlocking(((serial_write_handle_t)&s_debugConsoleState.serialWriteHandleBuffer[0]),\r
 937                                               (uint8_t *)printBuf, (size_t)logLength);\r
 938     dbgResult = (((status_t)kStatus_Success == status) ? (int)logLength : -1);\r
 939     va_end(ap);\r
 940 \r
 941     return dbgResult;\r
 942 }\r
 943 \r
 944 #ifdef DEBUG_CONSOLE_TRANSFER_NON_BLOCKING\r
 945 status_t DbgConsole_TryGetchar(char *ch)\r
 946 {\r
 947 #if (defined(DEBUG_CONSOLE_RX_ENABLE) && (DEBUG_CONSOLE_RX_ENABLE > 0U))\r
 948     uint32_t length = 0;\r
 949     status_t status = (status_t)kStatus_Fail;\r
 950 \r
 951     assert(ch);\r
 952 \r
 953     if (NULL == g_serialHandle)\r
 954     {\r
 955         return kStatus_Fail;\r
 956     }\r
 957 \r
 958     /* take mutex lock function */\r
 959     DEBUG_CONSOLE_TAKE_MUTEX_SEMAPHORE_BLOCKING(s_debugConsoleReadSemaphore);\r
 960 \r
 961     if (kStatus_SerialManager_Success ==\r
 962         SerialManager_TryRead(((serial_read_handle_t)&s_debugConsoleState.serialReadHandleBuffer[0]), (uint8_t *)ch, 1,\r
 963                               &length))\r
 964     {\r
 965         if (length != 0U)\r
 966         {\r
 967 #if DEBUG_CONSOLE_ENABLE_ECHO_FUNCTION\r
 968             (void)DbgConsole_EchoCharacter((uint8_t *)ch, true, NULL);\r
 969 #endif\r
 970             status = (status_t)kStatus_Success;\r
 971         }\r
 972     }\r
 973     /* release mutex lock function */\r
 974     DEBUG_CONSOLE_GIVE_MUTEX_SEMAPHORE(s_debugConsoleReadSemaphore);\r
 975     return status;\r
 976 #else\r
 977     return (status_t)kStatus_Fail;\r
 978 #endif\r
 979 }\r
 980 #endif\r
 981 \r
 982 /* See fsl_debug_console.h for documentation of this function. */\r
 983 int DbgConsole_Getchar(void)\r
 984 {\r
 985     uint8_t ch = 0U;\r
 986 \r
 987     /* Get char */\r
 988     (void)DbgConsole_ReadCharacter(&ch);\r
 989 \r
 990     return (int)ch;\r
 991 }\r
 992 \r
 993 #endif /* SDK_DEBUGCONSOLE */\r
 994 \r
 995 /*************Code to support toolchain's printf, scanf *******************************/\r
 996 /* These function __write and __read is used to support IAR toolchain to printf and scanf*/\r
 997 #if (defined(__ICCARM__))\r
 998 #if defined(SDK_DEBUGCONSOLE_UART)\r
 999 #pragma weak __write\r
1000 size_t __write(int handle, const unsigned char *buffer, size_t size)\r
1001 {\r
1002     if (buffer == 0)\r
1003     {\r
1004         /*\r
1005          * This means that we should flush internal buffers.  Since we don't we just return.\r
1006          * (Remember, "handle" == -1 means that all handles should be flushed.)\r
1007          */\r
1008         return 0;\r
1009     }\r
1010 \r
1011     /* This function only writes to "standard out" and "standard err" for all other file handles it returns failure. */\r
1012     if ((handle != 1) && (handle != 2))\r
1013     {\r
1014         return ((size_t)-1);\r
1015     }\r
1016 \r
1017     /* Send data. */\r
1018     DbgConsole_SendDataReliable((uint8_t *)buffer, size);\r
1019 \r
1020     return size;\r
1021 }\r
1022 \r
1023 #pragma weak __read\r
1024 size_t __read(int handle, unsigned char *buffer, size_t size)\r
1025 {\r
1026     uint8_t ch     = 0U;\r
1027     int actualSize = 0U;\r
1028 \r
1029     /* This function only reads from "standard in", for all other file  handles it returns failure. */\r
1030     if (handle != 0)\r
1031     {\r
1032         return ((size_t)-1);\r
1033     }\r
1034 \r
1035     /* Receive data.*/\r
1036     for (; size > 0; size--)\r
1037     {\r
1038         DbgConsole_ReadCharacter(&ch);\r
1039         if (ch == 0)\r
1040         {\r
1041             break;\r
1042         }\r
1043 \r
1044         *buffer++ = ch;\r
1045         actualSize++;\r
1046     }\r
1047 \r
1048     return actualSize;\r
1049 }\r
1050 #endif /* SDK_DEBUGCONSOLE_UART */\r
1051 \r
1052 /* support LPC Xpresso with RedLib */\r
1053 #elif (defined(__REDLIB__))\r
1054 \r
1055 #if (defined(SDK_DEBUGCONSOLE_UART))\r
1056 int __attribute__((weak)) __sys_write(int handle, char *buffer, int size)\r
1057 {\r
1058     if (buffer == 0)\r
1059     {\r
1060         /* return -1 if error. */\r
1061         return -1;\r
1062     }\r
1063 \r
1064     /* This function only writes to "standard out" and "standard err" for all other file handles it returns failure. */\r
1065     if ((handle != 1) && (handle != 2))\r
1066     {\r
1067         return -1;\r
1068     }\r
1069 \r
1070     /* Send data. */\r
1071     DbgConsole_SendDataReliable((uint8_t *)buffer, size);\r
1072 \r
1073     return 0;\r
1074 }\r
1075 \r
1076 int __attribute__((weak)) __sys_readc(void)\r
1077 {\r
1078     char tmp;\r
1079 \r
1080     /* Receive data. */\r
1081     DbgConsole_ReadCharacter((uint8_t *)&tmp);\r
1082 \r
1083     return tmp;\r
1084 }\r
1085 #endif\r
1086 \r
1087 /* These function fputc and fgetc is used to support KEIL toolchain to printf and scanf*/\r
1088 #elif defined(__CC_ARM) || defined(__ARMCC_VERSION)\r
1089 #if defined(SDK_DEBUGCONSOLE_UART)\r
1090 #if defined(__CC_ARM)\r
1091 struct __FILE\r
1092 {\r
1093     int handle;\r
1094     /*\r
1095      * Whatever you require here. If the only file you are using is standard output using printf() for debugging,\r
1096      * no file handling is required.\r
1097      */\r
1098 };\r
1099 #endif\r
1100 \r
1101 /* FILE is typedef in stdio.h. */\r
1102 #pragma weak __stdout\r
1103 #pragma weak __stdin\r
1104 FILE __stdout;\r
1105 FILE __stdin;\r
1106 \r
1107 #pragma weak fputc\r
1108 int fputc(int ch, FILE *f)\r
1109 {\r
1110     /* Send data. */\r
1111     return DbgConsole_SendDataReliable((uint8_t *)(&ch), 1);\r
1112 }\r
1113 \r
1114 #pragma weak fgetc\r
1115 int fgetc(FILE *f)\r
1116 {\r
1117     char ch;\r
1118 \r
1119     /* Receive data. */\r
1120     DbgConsole_ReadCharacter((uint8_t *)&ch);\r
1121 \r
1122     return ch;\r
1123 }\r
1124 \r
1125 /*\r
1126  * Terminate the program, passing a return code back to the user.\r
1127  * This function may not return.\r
1128  */\r
1129 void _sys_exit(int returncode)\r
1130 {\r
1131     while (1)\r
1132     {\r
1133     }\r
1134 }\r
1135 \r
1136 /*\r
1137  * Writes a character to the output channel. This function is used\r
1138  * for last-resort error message output.\r
1139  */\r
1140 void _ttywrch(int ch)\r
1141 {\r
1142     char ench = ch;\r
1143     DbgConsole_SendDataReliable((uint8_t *)(&ench), 1);\r
1144 }\r
1145 \r
1146 char *_sys_command_string(char *cmd, int len)\r
1147 {\r
1148     return (cmd);\r
1149 }\r
1150 #endif /* SDK_DEBUGCONSOLE_UART */\r
1151 \r
1152 /* These function __write and __read is used to support ARM_GCC, KDS, Atollic toolchains to printf and scanf*/\r
1153 #elif (defined(__GNUC__))\r
1154 \r
1155 #if ((defined(__GNUC__) && (!defined(__MCUXPRESSO)) && (defined(SDK_DEBUGCONSOLE_UART))) || \\r
1156      (defined(__MCUXPRESSO) && (defined(SDK_DEBUGCONSOLE_UART))))\r
1157 int __attribute__((weak)) _write(int handle, char *buffer, int size);\r
1158 int __attribute__((weak)) _write(int handle, char *buffer, int size)\r
1159 {\r
1160     if (buffer == NULL)\r
1161     {\r
1162         /* return -1 if error. */\r
1163         return -1;\r
1164     }\r
1165 \r
1166     /* This function only writes to "standard out" and "standard err" for all other file handles it returns failure. */\r
1167     if ((handle != 1) && (handle != 2))\r
1168     {\r
1169         return -1;\r
1170     }\r
1171 \r
1172     /* Send data. */\r
1173     (void)DbgConsole_SendDataReliable((uint8_t *)buffer, (size_t)size);\r
1174 \r
1175     return size;\r
1176 }\r
1177 \r
1178 int __attribute__((weak)) _read(int handle, char *buffer, int size);\r
1179 int __attribute__((weak)) _read(int handle, char *buffer, int size)\r
1180 {\r
1181     uint8_t ch     = 0U;\r
1182     int actualSize = 0;\r
1183 \r
1184     /* This function only reads from "standard in", for all other file handles it returns failure. */\r
1185     if (handle != 0)\r
1186     {\r
1187         return -1;\r
1188     }\r
1189 \r
1190     /* Receive data. */\r
1191     for (; size > 0; size--)\r
1192     {\r
1193         if (DbgConsole_ReadCharacter(&ch) < 0)\r
1194         {\r
1195             break;\r
1196         }\r
1197 \r
1198         *buffer++ = (char)ch;\r
1199         actualSize++;\r
1200 \r
1201         if ((ch == 0U) || (ch == (uint8_t)'\n') || (ch == (uint8_t)'\r'))\r
1202         {\r
1203             break;\r
1204         }\r
1205     }\r
1206 \r
1207     return (actualSize > 0) ? actualSize : -1;\r
1208 }\r
1209 #endif\r
1210 \r
1211 #endif /* __ICCARM__ */\r