demos/amlogic/driver/uart/uart.c - yocto/firmware/aocpu - Git Browser for ODROID

 /*
  * Copyright (C) 2014-2018 Amlogic, Inc. All rights reserved.
  *
  * All information contained herein is Amlogic confidential.
  *
  * This software is provided to you pursuant to Software License Agreement
  * (SLA) with Amlogic Inc ("Amlogic"). This software may be used
  * only in accordance with the terms of this agreement.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification is strictly prohibited without prior written permission from
  * Amlogic.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */

 /*
  * UART driver
  */

 #include "FreeRTOS.h"
 #include "timers.h"
 #include "common.h"
 #include "FreeRTOSConfig.h"
 #include "uart.h"
 #include "register.h"
 #include "soc.h"
 #include "string.h"
 #include "timer_source.h"

 //#define UART_PORT_CONS UART_B_WFIFO

 #define UART_STP_BIT UART_MODE_MASK_STP_1BIT
 #define UART_PRTY_BIT 0
 #define UART_CHAR_LEN   UART_MODE_MASK_CHAR_8BIT
 #define UART_MODE_RESET_MASK	\
 			(UART_MODE_MASK_RST_TX \
 			| UART_MODE_MASK_RST_RX \
 			| UART_MODE_MASK_CLR_ERR)

 #define UART_WFIFO      (0<<2)
 #define UART_RFIFO	(1<<2)
 #define UART_MODE	(2<<2)
 #define UART_STATUS     (3<<2)
 #define UART_IRQCTL	(4<<2)
 #define UART_CTRL	(5<<2)
 #define UART_MODE_MASK_STP_1BIT                 (0<<16)
 #define UART_MODE_MASK_CHAR_8BIT                (0<<20)
 #define UART_MODE_MASK_TX_EN                    (1<<12)
 #define UART_MODE_MASK_RX_EN                    (1<<13)
 #define UART_MODE_MASK_RST_TX                   (1<<22)
 #define UART_MODE_MASK_RST_RX                   (1<<23)
 #define UART_MODE_MASK_CLR_ERR                  (1<<24)
 #define UART_CTRL_USE_XTAL_CLK			(1<<24)
 #define UART_CTRL_USE_NEW_BAUD_RATE		(1<<23)

 #define UART_STAT_MASK_RFIFO_FULL		(1<<19)
 #define UART_STAT_MASK_RFIFO_EMPTY		(1<<20)
 #define UART_STAT_MASK_TFIFO_FULL		(1<<21)
 #define UART_STAT_MASK_TFIFO_EMPTY		(1<<22)

 #define P_UART(uart_base, reg)		(uart_base+reg)
 #define P_UART_WFIFO(uart_base)		P_UART(uart_base, UART_WFIFO)
 #define P_UART_MODE(uart_base)		P_UART(uart_base, UART_MODE)
 #define P_UART_CTRL(uart_base)		P_UART(uart_base, UART_CTRL)
 #define P_UART_STATUS(uart_base)	P_UART(uart_base, UART_STATUS)

 #define UART_TX_BUF_SIZE        (512)
 #define POLL_TX_FIFO_PRD        (portTICK_PERIOD_MS)
 #define POLL_TX_BUF_PRD         (portTICK_PERIOD_MS * 10)
 #define UART_TXBUF_TASK_PRI     (3)
 #define UART_TX_FIFO_FULL_WAIT  (5000) //us

 struct xUartTxBuf_t {
 	char *pcTxBuf;
 	uint32_t ulRdPtr;
 	uint32_t ulWrPtr;
 	uint32_t ulBufCnt;
 	uint32_t ulTimerPeriod;
 	TimerHandle_t xTimer;
 	uint8_t ucWarnMsgPrtEn;
 	uint8_t ucBufReady;
 };

 static const char cWarnMsg[] = "\r\nWarning: AOCPU log is lost due to TX FIFO full!\n";
 static struct xUartTxBuf_t xUartTxBuf;

 #ifdef ACS_DIS_PRINT_FLAG
 static uint8_t bl30_print_en;
 void enable_bl30_print(uint8_t enable)
 {
 	/* Applied to output important logs */
 	bl30_print_en = enable;
 }

 #if configSUPPORT_STICK_MEM
 #include "stick_mem.h"
 #include "mailbox-api.h"
 /* Applied to enable or disable bl30 start logs before first
  * suspend or shutdown when compile with '--noverbose'.
  */
 static void *xMboxBL30PrintEn(void *msg)
 {
 	stick_mem_write(STICK_BL30_PRINT_EN, *(uint32_t *)msg);

 	return NULL;
 }

 void vBL30PrintControlInit(void)
 {
 	xInstallRemoteMessageCallbackFeedBack(AOREE_CHANNEL,
 		MBX_CMD_SET_BL30_PRINT, xMboxBL30PrintEn, 0);
 }
 #endif
 #endif /* ACS_DIS_PRINT_FLAG */

 static int prvUartTxIsFull(void)
 {
 	return REG32(P_UART_STATUS(UART_PORT_CONS)) & UART_STAT_MASK_TFIFO_FULL;
 }

 void vUartTxFlush(void)
 {
 	while (!
 	       (REG32(P_UART_STATUS(UART_PORT_CONS)) &
 		UART_STAT_MASK_TFIFO_EMPTY));
 }

 static int prvFillTxBuf(char c)
 {
 	char *pcBuf;

 	taskENTER_CRITICAL();
 	if (xUartTxBuf.ulBufCnt >= UART_TX_BUF_SIZE) {
 		xUartTxBuf.ucWarnMsgPrtEn = 1;
 		taskEXIT_CRITICAL();
 		return 1;
 	}

 	pcBuf = xUartTxBuf.pcTxBuf;
 	pcBuf[xUartTxBuf.ulWrPtr] = c;
 	xUartTxBuf.ulWrPtr++;
 	xUartTxBuf.ulBufCnt++;
 	if (xUartTxBuf.ulWrPtr >= UART_TX_BUF_SIZE)
 		xUartTxBuf.ulWrPtr = 0;
 	taskEXIT_CRITICAL();
 	return 0;
 }

 static int prvFillTxBufStr(const char *s)
 {
 	const char *pcChar = s;
 	int iCnt = 0;

 	while (*pcChar) {
 		if ('\n' == *pcChar) {
 			prvFillTxBuf('\r');
 			iCnt++;
 		}
 		prvFillTxBuf(*s);
 		iCnt++;
 		pcChar++;
 	}

 	return iCnt;
 }

 static uint8_t prvChkTxFifoBusy(void)
 {
 	uint8_t ucIsTxBusy = 0;
 	uint32_t time_start;
 	uint32_t time_end;
 	uint32_t time_elapse;

 	/* Check if UART TX FIFO is busy */
 	time_start = timere_read_us();
 	while (prvUartTxIsFull()) {
 		time_end = timere_read_us();
 		time_elapse = time_end - time_start;
 		if (time_elapse > UART_TX_FIFO_FULL_WAIT) {
 			ucIsTxBusy = 1;
 			break;
 		}
 	}

 	return ucIsTxBusy;
 }

 void vUartPutc(const char c)
 {
 #ifdef ACS_DIS_PRINT_FLAG
 #if configSUPPORT_STICK_MEM
 	unsigned int stick_mem_bl30_print_en;

 	stick_mem_read(STICK_BL30_PRINT_EN, &stick_mem_bl30_print_en);
 #endif

 	if ((REG32(ACS_DIS_PRINT_REG) & ACS_DIS_PRINT_FLAG) && !bl30_print_en
 #if configSUPPORT_STICK_MEM
 		&& (stick_mem_bl30_print_en != STICK_MEM_EN_BL30_PRINT_FLAG)
 #endif
 	)
 		return;
 #endif /* ACS_DIS_PRINT_FLAG */

 	if (c == '\n')
 		vUartPutc('\r');

 	while (prvUartTxIsFull());
 	REG32(P_UART_WFIFO(UART_PORT_CONS)) = (char)c;
 }

 void vUartPuts(const char *s)
 {
 	uint8_t ucIsTxBusy;

 	while (*s) {
 		ucIsTxBusy = prvChkTxFifoBusy();
 		/* If Uart TX FIFO is busy, send string to TX Buffer */
 		if (ucIsTxBusy && xUartTxBuf.ucBufReady) {
 			prvFillTxBufStr(s);
 			break;
 		}

 		if (!ucIsTxBusy || !xUartTxBuf.ucBufReady) {
 			vUartPutc(*s);
 			s++;
 		}
 	}
 }

 void vUartTxStart(void)
 {
 	/* Do not allow deep sleep while transmit in progress */
 #ifdef CONFIG_LOW_POWER_IDLE
 	disable_sleep(SLEEP_MASK_UART);
 #endif

 	//uart_flush_output();
 }

 void vUartTxStop(void)
 {

 }

 long lUartTxReady(void)
 {
 	return !(REG32(P_UART_STATUS(UART_PORT_CONS)) &
 		 UART_STAT_MASK_TFIFO_FULL);
 }
 #if 0
 void vUartWriteChar(char c)
 {
 	vUartPutc(c);
 }

 int uart_tx_char(int c)
 {
 	vUartPutc(c);

 	return c;
 }
 /*print BCD*/
 void print_u32_dec(unsigned int num) {
 	char buf[16];
 	char *s = buf + (sizeof(buf) / sizeof(buf[0])) - 1;
 	char *e = s;

 	do {
 		*--s = '0' + num % 10;
 	} while (num /= 10);

 	while (s < e)
 		uart_tx_char(*s++);
 }

 void serial_put_hex(unsigned long data, unsigned int bitlen)
 {
 	int i;
 	unsigned char s;

 	for (i = bitlen - 4; i >= 0; i -= 4)
 	{
 		s = (data >> i) & 0xf;
 		if (s < 10)
 			vUartPutc(0x30 + s);
 		else if (s < 16)
 			vUartPutc(0x61 + s - 10);
 	}
 }
 #endif
 #if 0
 /* Interrupt handler for console UART */
 void uart_interrupt(void)
 {
 	/* Fill output FIFO */
 	uart_process_output();
 }

 DECLARE_IRQ(IRQ_AO_UART_NUM, uart_interrupt, 1);
 #endif

 static void prvUartTxBufHandle(TimerHandle_t xTimer)
 {
 	char cTxChar;
 	uint32_t ulIsTxFifoEmpty;

 	(void)xTimer;
 	taskENTER_CRITICAL();
 	if (xUartTxBuf.ulBufCnt == 0) {
 		if (xUartTxBuf.ulTimerPeriod != POLL_TX_BUF_PRD) {
 			xUartTxBuf.ulTimerPeriod = POLL_TX_BUF_PRD;
 			xTimerChangePeriod(xUartTxBuf.xTimer, xUartTxBuf.ulTimerPeriod, 0);
 		}
 		ulIsTxFifoEmpty = (REG32(P_UART_STATUS(UART_PORT_CONS)) &
 				UART_STAT_MASK_TFIFO_EMPTY);
 		if (ulIsTxFifoEmpty && xUartTxBuf.ucWarnMsgPrtEn) {
 			xUartTxBuf.ucWarnMsgPrtEn = 0;
 			vUartPuts(cWarnMsg);
 		}
 	} else {
 		if (xUartTxBuf.ulTimerPeriod != POLL_TX_FIFO_PRD) {
 			xUartTxBuf.ulTimerPeriod = POLL_TX_FIFO_PRD;
 			xTimerChangePeriod(xUartTxBuf.xTimer, xUartTxBuf.ulTimerPeriod, 0);
 		}
 		while (xUartTxBuf.ulBufCnt) {
 			cTxChar = xUartTxBuf.pcTxBuf[xUartTxBuf.ulRdPtr];
 			vUartPutc(cTxChar);
 			xUartTxBuf.ulRdPtr++;
 			xUartTxBuf.ulBufCnt--;
 			if (xUartTxBuf.ulRdPtr >= UART_TX_BUF_SIZE)
 				xUartTxBuf.ulRdPtr = 0;
 		}
 	}
 	taskEXIT_CRITICAL();
 }

 /*
  *	Set UART to 115200-8-N-1
  *
  *	Using 24M XTAL as UART reference clock, *NOT* clk81
  *	So the clk81 can be dynamically changed and not
  *	disturb UART transfers.
  */
 void vUartInit(void)
 {
 	TimerHandle_t xUartTimer = NULL;

 	xUartTxBuf.pcTxBuf = pvPortMalloc(UART_TX_BUF_SIZE);
 	if (xUartTxBuf.pcTxBuf) {
 		memset(xUartTxBuf.pcTxBuf, 0, UART_TX_BUF_SIZE);
 		xUartTimer = xTimerCreate("UartTimer", pdMS_TO_TICKS(POLL_TX_BUF_PRD),
 				pdTRUE, NULL, prvUartTxBufHandle);
 		if (xUartTimer) {
 			xUartTxBuf.ulRdPtr = 0;
 			xUartTxBuf.ulWrPtr = 0;
 			xUartTxBuf.ulBufCnt = 0;
 			xUartTxBuf.ucWarnMsgPrtEn = 0;
 			xUartTxBuf.ucBufReady = 1;
 			xUartTxBuf.xTimer = xUartTimer;
 			xUartTxBuf.ulTimerPeriod = POLL_TX_BUF_PRD;
 			xTimerStart(xUartTxBuf.xTimer, 0);
 		} else {
 			vPortFree(xUartTxBuf.pcTxBuf);
 			vUartPuts("Warning: xUartTimer create fail\n");
 		}
 	}
 }
	/*
	* Copyright (C) 2014-2018 Amlogic, Inc. All rights reserved.
	*
	* All information contained herein is Amlogic confidential.
	*
	* This software is provided to you pursuant to Software License Agreement
	* (SLA) with Amlogic Inc ("Amlogic"). This software may be used
	* only in accordance with the terms of this agreement.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification is strictly prohibited without prior written permission from
	* Amlogic.
	*
	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
	* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	*/

	/*
	* UART driver
	*/

	#include "FreeRTOS.h"
	#include "timers.h"
	#include "common.h"
	#include "FreeRTOSConfig.h"
	#include "uart.h"
	#include "register.h"
	#include "soc.h"
	#include "string.h"
	#include "timer_source.h"

	//#define UART_PORT_CONS UART_B_WFIFO

	#define UART_STP_BIT UART_MODE_MASK_STP_1BIT
	#define UART_PRTY_BIT 0
	#define UART_CHAR_LEN UART_MODE_MASK_CHAR_8BIT
	#define UART_MODE_RESET_MASK \
	(UART_MODE_MASK_RST_TX \
	\| UART_MODE_MASK_RST_RX \
	\| UART_MODE_MASK_CLR_ERR)

	#define UART_WFIFO (0<<2)
	#define UART_RFIFO (1<<2)
	#define UART_MODE (2<<2)
	#define UART_STATUS (3<<2)
	#define UART_IRQCTL (4<<2)
	#define UART_CTRL (5<<2)
	#define UART_MODE_MASK_STP_1BIT (0<<16)
	#define UART_MODE_MASK_CHAR_8BIT (0<<20)
	#define UART_MODE_MASK_TX_EN (1<<12)
	#define UART_MODE_MASK_RX_EN (1<<13)
	#define UART_MODE_MASK_RST_TX (1<<22)
	#define UART_MODE_MASK_RST_RX (1<<23)
	#define UART_MODE_MASK_CLR_ERR (1<<24)
	#define UART_CTRL_USE_XTAL_CLK (1<<24)
	#define UART_CTRL_USE_NEW_BAUD_RATE (1<<23)

	#define UART_STAT_MASK_RFIFO_FULL (1<<19)
	#define UART_STAT_MASK_RFIFO_EMPTY (1<<20)
	#define UART_STAT_MASK_TFIFO_FULL (1<<21)
	#define UART_STAT_MASK_TFIFO_EMPTY (1<<22)

	#define P_UART(uart_base, reg) (uart_base+reg)
	#define P_UART_WFIFO(uart_base) P_UART(uart_base, UART_WFIFO)
	#define P_UART_MODE(uart_base) P_UART(uart_base, UART_MODE)
	#define P_UART_CTRL(uart_base) P_UART(uart_base, UART_CTRL)
	#define P_UART_STATUS(uart_base) P_UART(uart_base, UART_STATUS)

	#define UART_TX_BUF_SIZE (512)
	#define POLL_TX_FIFO_PRD (portTICK_PERIOD_MS)
	#define POLL_TX_BUF_PRD (portTICK_PERIOD_MS * 10)
	#define UART_TXBUF_TASK_PRI (3)
	#define UART_TX_FIFO_FULL_WAIT (5000) //us

	struct xUartTxBuf_t {
	char *pcTxBuf;
	uint32_t ulRdPtr;
	uint32_t ulWrPtr;
	uint32_t ulBufCnt;
	uint32_t ulTimerPeriod;
	TimerHandle_t xTimer;
	uint8_t ucWarnMsgPrtEn;
	uint8_t ucBufReady;
	};

	static const char cWarnMsg[] = "\r\nWarning: AOCPU log is lost due to TX FIFO full!\n";
	static struct xUartTxBuf_t xUartTxBuf;

	#ifdef ACS_DIS_PRINT_FLAG
	static uint8_t bl30_print_en;
	void enable_bl30_print(uint8_t enable)
	{
	/* Applied to output important logs */
	bl30_print_en = enable;
	}

	#if configSUPPORT_STICK_MEM
	#include "stick_mem.h"
	#include "mailbox-api.h"
	/* Applied to enable or disable bl30 start logs before first
	* suspend or shutdown when compile with '--noverbose'.
	*/
	static void xMboxBL30PrintEn(void msg)
	{
	stick_mem_write(STICK_BL30_PRINT_EN, (uint32_t )msg);

	return NULL;
	}

	void vBL30PrintControlInit(void)
	{
	xInstallRemoteMessageCallbackFeedBack(AOREE_CHANNEL,
	MBX_CMD_SET_BL30_PRINT, xMboxBL30PrintEn, 0);
	}
	#endif
	#endif /* ACS_DIS_PRINT_FLAG */

	static int prvUartTxIsFull(void)
	{
	return REG32(P_UART_STATUS(UART_PORT_CONS)) & UART_STAT_MASK_TFIFO_FULL;
	}

	void vUartTxFlush(void)
	{
	while (!
	(REG32(P_UART_STATUS(UART_PORT_CONS)) &
	UART_STAT_MASK_TFIFO_EMPTY));
	}

	static int prvFillTxBuf(char c)
	{
	char *pcBuf;

	taskENTER_CRITICAL();
	if (xUartTxBuf.ulBufCnt >= UART_TX_BUF_SIZE) {
	xUartTxBuf.ucWarnMsgPrtEn = 1;
	taskEXIT_CRITICAL();
	return 1;
	}

	pcBuf = xUartTxBuf.pcTxBuf;
	pcBuf[xUartTxBuf.ulWrPtr] = c;
	xUartTxBuf.ulWrPtr++;
	xUartTxBuf.ulBufCnt++;
	if (xUartTxBuf.ulWrPtr >= UART_TX_BUF_SIZE)
	xUartTxBuf.ulWrPtr = 0;
	taskEXIT_CRITICAL();
	return 0;
	}

	static int prvFillTxBufStr(const char *s)
	{
	const char *pcChar = s;
	int iCnt = 0;

	while (*pcChar) {
	if ('\n' == *pcChar) {
	prvFillTxBuf('\r');
	iCnt++;
	}
	prvFillTxBuf(*s);
	iCnt++;
	pcChar++;
	}

	return iCnt;
	}

	static uint8_t prvChkTxFifoBusy(void)
	{
	uint8_t ucIsTxBusy = 0;
	uint32_t time_start;
	uint32_t time_end;
	uint32_t time_elapse;

	/* Check if UART TX FIFO is busy */
	time_start = timere_read_us();
	while (prvUartTxIsFull()) {
	time_end = timere_read_us();
	time_elapse = time_end - time_start;
	if (time_elapse > UART_TX_FIFO_FULL_WAIT) {
	ucIsTxBusy = 1;
	break;
	}
	}

	return ucIsTxBusy;
	}

	void vUartPutc(const char c)
	{
	#ifdef ACS_DIS_PRINT_FLAG
	#if configSUPPORT_STICK_MEM
	unsigned int stick_mem_bl30_print_en;

	stick_mem_read(STICK_BL30_PRINT_EN, &stick_mem_bl30_print_en);
	#endif

	if ((REG32(ACS_DIS_PRINT_REG) & ACS_DIS_PRINT_FLAG) && !bl30_print_en
	#if configSUPPORT_STICK_MEM
	&& (stick_mem_bl30_print_en != STICK_MEM_EN_BL30_PRINT_FLAG)
	#endif
	)
	return;
	#endif /* ACS_DIS_PRINT_FLAG */

	if (c == '\n')
	vUartPutc('\r');

	while (prvUartTxIsFull());
	REG32(P_UART_WFIFO(UART_PORT_CONS)) = (char)c;
	}

	void vUartPuts(const char *s)
	{
	uint8_t ucIsTxBusy;

	while (*s) {
	ucIsTxBusy = prvChkTxFifoBusy();
	/* If Uart TX FIFO is busy, send string to TX Buffer */
	if (ucIsTxBusy && xUartTxBuf.ucBufReady) {
	prvFillTxBufStr(s);
	break;
	}

	if (!ucIsTxBusy \|\| !xUartTxBuf.ucBufReady) {
	vUartPutc(*s);
	s++;
	}
	}
	}

	void vUartTxStart(void)
	{
	/* Do not allow deep sleep while transmit in progress */
	#ifdef CONFIG_LOW_POWER_IDLE
	disable_sleep(SLEEP_MASK_UART);
	#endif

	//uart_flush_output();
	}

	void vUartTxStop(void)
	{

	}

	long lUartTxReady(void)
	{
	return !(REG32(P_UART_STATUS(UART_PORT_CONS)) &
	UART_STAT_MASK_TFIFO_FULL);
	}
	#if 0
	void vUartWriteChar(char c)
	{
	vUartPutc(c);
	}

	int uart_tx_char(int c)
	{
	vUartPutc(c);

	return c;
	}
	/print BCD/
	void print_u32_dec(unsigned int num) {
	char buf[16];
	char *s = buf + (sizeof(buf) / sizeof(buf[0])) - 1;
	char *e = s;

	do {
	*--s = '0' + num % 10;
	} while (num /= 10);

	while (s < e)
	uart_tx_char(*s++);
	}

	void serial_put_hex(unsigned long data, unsigned int bitlen)
	{
	int i;
	unsigned char s;

	for (i = bitlen - 4; i >= 0; i -= 4)
	{
	s = (data >> i) & 0xf;
	if (s < 10)
	vUartPutc(0x30 + s);
	else if (s < 16)
	vUartPutc(0x61 + s - 10);
	}
	}
	#endif
	#if 0
	/* Interrupt handler for console UART */
	void uart_interrupt(void)
	{
	/* Fill output FIFO */
	uart_process_output();
	}

	DECLARE_IRQ(IRQ_AO_UART_NUM, uart_interrupt, 1);
	#endif

	static void prvUartTxBufHandle(TimerHandle_t xTimer)
	{
	char cTxChar;
	uint32_t ulIsTxFifoEmpty;

	(void)xTimer;
	taskENTER_CRITICAL();
	if (xUartTxBuf.ulBufCnt == 0) {
	if (xUartTxBuf.ulTimerPeriod != POLL_TX_BUF_PRD) {
	xUartTxBuf.ulTimerPeriod = POLL_TX_BUF_PRD;
	xTimerChangePeriod(xUartTxBuf.xTimer, xUartTxBuf.ulTimerPeriod, 0);
	}
	ulIsTxFifoEmpty = (REG32(P_UART_STATUS(UART_PORT_CONS)) &
	UART_STAT_MASK_TFIFO_EMPTY);
	if (ulIsTxFifoEmpty && xUartTxBuf.ucWarnMsgPrtEn) {
	xUartTxBuf.ucWarnMsgPrtEn = 0;
	vUartPuts(cWarnMsg);
	}
	} else {
	if (xUartTxBuf.ulTimerPeriod != POLL_TX_FIFO_PRD) {
	xUartTxBuf.ulTimerPeriod = POLL_TX_FIFO_PRD;
	xTimerChangePeriod(xUartTxBuf.xTimer, xUartTxBuf.ulTimerPeriod, 0);
	}
	while (xUartTxBuf.ulBufCnt) {
	cTxChar = xUartTxBuf.pcTxBuf[xUartTxBuf.ulRdPtr];
	vUartPutc(cTxChar);
	xUartTxBuf.ulRdPtr++;
	xUartTxBuf.ulBufCnt--;
	if (xUartTxBuf.ulRdPtr >= UART_TX_BUF_SIZE)
	xUartTxBuf.ulRdPtr = 0;
	}
	}
	taskEXIT_CRITICAL();
	}

	/*
	* Set UART to 115200-8-N-1
	*
	* Using 24M XTAL as UART reference clock, NOT clk81
	* So the clk81 can be dynamically changed and not
	* disturb UART transfers.
	*/
	void vUartInit(void)
	{
	TimerHandle_t xUartTimer = NULL;

	xUartTxBuf.pcTxBuf = pvPortMalloc(UART_TX_BUF_SIZE);
	if (xUartTxBuf.pcTxBuf) {
	memset(xUartTxBuf.pcTxBuf, 0, UART_TX_BUF_SIZE);
	xUartTimer = xTimerCreate("UartTimer", pdMS_TO_TICKS(POLL_TX_BUF_PRD),
	pdTRUE, NULL, prvUartTxBufHandle);
	if (xUartTimer) {
	xUartTxBuf.ulRdPtr = 0;
	xUartTxBuf.ulWrPtr = 0;
	xUartTxBuf.ulBufCnt = 0;
	xUartTxBuf.ucWarnMsgPrtEn = 0;
	xUartTxBuf.ucBufReady = 1;
	xUartTxBuf.xTimer = xUartTimer;
	xUartTxBuf.ulTimerPeriod = POLL_TX_BUF_PRD;
	xTimerStart(xUartTxBuf.xTimer, 0);
	} else {
	vPortFree(xUartTxBuf.pcTxBuf);
	vUartPuts("Warning: xUartTimer create fail\n");
	}
	}
	}