关于finsh的一个问题

发布于 2012-03-11 03:21:12 浏览：3922 订阅该版

finsh使用自己写的驱口驱动就会“finsh=>”这几个字覆盖了show_version()信息的最后一行。 [s:170] 。
使用的是LPC21XX系列，用BSP里自带的串口驱动就不会有这个问题，下面是问题图片：
![QQ截图20120311031245.png](/uploads/3384_44896df8c38f40bf8869bd915d824338.png)。
把代码也贴上来吧，有时间帮忙看下 [s:183] ，找了好久找不出会是什么原因引起的，好像是漏了个"
"符一样 [s:182] 。
```

#include <rthw.h>
#include <rtio.h>
#include <rtthread.h>
#include <rtcirc.h>
#include "lpc213x.h"
#include "lpc213x_uart.h"
#include "board.h"

/*@{*/
#define UART_RX_BUF_SIZE		128
#define UART_TX_BUF_SIZE		128
#define UART_XMIT_SIZE          128

#define rd_regb(port, reg) 		(__raw_readb(portaddr(port, reg)))
#define rd_regl(port, reg) 		(__raw_readl(portaddr(port, reg)))
#define wr_regb(port, reg, val) (__raw_writeb(val, portaddr(port, reg)))
#define wr_regl(port, reg, val) (__raw_writel(val, portaddr(port, reg)))

#define portaddr(port, reg) 	((port)->hwbase + (reg))

#define uart_circ_empty(circ)		((circ)->head == (circ)->tail)
#define uart_circ_clear(circ)		((circ)->head = (circ)->tail = 0)
       
#define uart_circ_chars_pending(circ)	
	(CIRC_CNT((circ)->head, (circ)->tail, UART_XMIT_SIZE))

#define uart_circ_chars_free(circ)	
	(CIRC_SPACE((circ)->head, (circ)->tail, UART_XMIT_SIZE))

/* lpc213x uart device */
struct lpc_uart
{
	/* inherit from device */
	struct rt_device parent;
	
	/* port information */	
	rt_uint32_t 	 hwbase;
	rt_uint32_t 	 irqno;

/* port config */
	rt_uint32_t      baudrate;
	rt_uint8_t		 csize;
	rt_uint8_t       stopb;
	rt_uint8_t		 parity;
	rt_uint8_t		 fifosize;

/* interrupt hangler */
	rt_isr_handler_t isr;

/* reception field */
	struct circ_buf  tx_xmit;
	struct circ_buf  rx_xmit;
};

#ifdef RT_USING_UART1
struct lpc_uart lpc_uart1;
#endif
#ifdef RT_USING_UART2
struct lpc_uart lpc_uart2;
#endif

#define to_ourport(dev) (struct lpc_uart*)dev

static rt_err_t lpc_uart_init (rt_device_t uart)
{
	struct lpc_uart* port = to_ourport(uart);
	unsigned char lcr;
	
	/* disable UART interrupts */
	wr_regb(port, UART_IER, rd_regb(port, UART_IER) &(~(UART_IER_RDI | UART_IER_THRI | UART_IER_RLSI)));

if (port->baudrate == 0 || port->baudrate>115200)  	
		port->baudrate = 2400;

wr_regb(port, UART_LCR, UART_LCR_DLAB);		//DLAB=1
	wr_regb(port, UART_DLL, (PCLK /16 / port->baudrate) & 0xFF);
	wr_regb(port, UART_DLM, (PCLK /16 / port->baudrate) >>8);
	wr_regb(port, UART_LCR, rd_regb(port, UART_LCR) & (~UART_LCR_DLAB)); //DLAB=1
	
	lcr = port->csize - 5;
	lcr|=(port->stopb - 1) << 2;
	   
	wr_regb(port, UART_LCR, lcr);
	wr_regb(port, UART_FCR, UART_FCR_ENABLE_FIFO | UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT | UART_FCR_TRIGGER_8);	//使能FIFO深度为8字节
	
	if (uart->flag & (RT_DEVICE_FLAG_INT_RX | RT_DEVICE_FLAG_INT_TX))
	{
		rt_hw_interrupt_install(port->irqno, port->isr, RT_NULL);
	    rt_hw_interrupt_umask(port->irqno);
	}

if (uart->flag & RT_DEVICE_FLAG_INT_RX)
	{
		char* buf = rt_malloc(UART_RX_BUF_SIZE);
		if (buf == RT_NULL) 
			return RT_ENOMEM;

port->rx_xmit.buf = buf;
		uart_circ_clear(&port->rx_xmit);
	}

if (uart->flag & RT_DEVICE_FLAG_INT_TX)
	{
		char* buf = rt_malloc(UART_TX_BUF_SIZE);
		if (buf == RT_NULL) 
			return RT_ENOMEM;

port->tx_xmit.buf = buf;
		uart_circ_clear(&port->tx_xmit);
	}

return RT_EOK;	
}

static rt_err_t lpc_uart_open(rt_device_t uart, rt_uint16_t oflag)
{
	struct lpc_uart* port = to_ourport(uart);

RT_ASSERT(port != RT_NULL);

if (uart->flag & RT_DEVICE_FLAG_INT_RX)
	{
	    /* enable UART rx interrupt */
		wr_regb(port, UART_IER, rd_regb(port, UART_IER) | UART_IER_RDI );
	}

return RT_EOK;
}

/********************************************************************************************************
* 
*
********************************************************************************************************/
static rt_err_t lpc_uart_close(rt_device_t uart)
{
	struct lpc_uart* port = to_ourport(uart);

RT_ASSERT(port != RT_NULL);

if (uart->flag & (RT_DEVICE_FLAG_INT_RX | RT_DEVICE_FLAG_INT_TX))
	{
		/* disable UART rx interrupt */
		wr_regb(port, UART_IER, rd_regb(port, UART_IER) &(~(UART_IER_RDI | UART_IER_THRI)));
	}

return RT_EOK;
}

/********************************************************************************************************
* 
*
********************************************************************************************************/
static rt_err_t lpc_uart_control(rt_device_t uart, rt_uint8_t cmd, void *args)
{
	return RT_EOK;
}

static int __uart_get_char(struct lpc_uart* port, struct circ_buf *circ, unsigned char *c)
{
	rt_base_t level;

if (!circ->buf)
		return 0;
	
	level = rt_hw_interrupt_disable();
					
	if (uart_circ_chars_pending(circ)) 
	{
		*c = circ->buf[circ->tail];
		circ->tail = (circ->tail + 1) & (UART_XMIT_SIZE - 1);
		return 1;
	}

rt_hw_interrupt_enable(level);

return 0;
}

static int __uart_put_char(struct lpc_uart* port, struct circ_buf *circ, unsigned char c)
{
	rt_base_t level;

if (!circ->buf)
		return 0;
	
	level = rt_hw_interrupt_disable();
					
	if (uart_circ_chars_free(circ)) 
	{
		circ->buf[circ->head] = c;
		circ->head = (circ->head + 1) & (UART_XMIT_SIZE - 1);
		return 1;
	}

rt_hw_interrupt_enable(level);

return 0;
}

/********************************************************************************************************
* 
*
********************************************************************************************************/
static rt_size_t lpc_uart_read(rt_device_t uart, rt_off_t pos, void* buffer, rt_size_t size)
{
	struct lpc_uart* port = to_ourport(uart);
	rt_uint8_t* ptr;

RT_ASSERT(port != RT_NULL);

if (uart->flag & RT_DEVICE_FLAG_INT_RX)
	{
		while (size)
		{
			if (__uart_get_char(port, &port->tx_xmit, ptr) == 0)
				break;

ptr ++; size --;
		}
	}
	else if (uart->flag & RT_DEVICE_FLAG_DMA_RX)
	{
		/* not support */
		RT_ASSERT(0);
	}
	else
	{
		/* polling mode */
		while (size && (rd_regb(port ,UART_LSR) & UART_LSR_DR))
		{
			/* Read Character */
			*ptr = rd_regb(port, UART_RBR);
			
			ptr  ++; size --;
		}
	}
	
	return (rt_size_t)ptr - (rt_size_t)buffer;
}

/********************************************************************************************************
* 
*
********************************************************************************************************/
static rt_size_t lpc_uart_write(rt_device_t uart, rt_off_t pos, const void* buffer, rt_size_t size)
{
	struct lpc_uart* port = to_ourport(uart);
	char *ptr;

RT_ASSERT(port != RT_NULL);

/* point to buffer */
	ptr = (char *)buffer;

if (uart->flag & RT_DEVICE_FLAG_INT_TX)
	{
		while (size)
		{
			if (__uart_put_char(port, &port->tx_xmit, *ptr) == 0) 
				break;

ptr ++; size --;
		}

/* enable UART tx interrupts */
		wr_regb(port, UART_IER, rd_regb(port, UART_IER) | UART_IER_THRI);
	}
	else if (uart->flag & RT_DEVICE_FLAG_DMA_TX)
	{
		/* not support */
		RT_ASSERT(0);
	}
	else if (uart->flag & RT_DEVICE_FLAG_STREAM)
	{
		/* stream mode */
		while (size)
		{
			if (*ptr == '
')
			{	
				while (!(rd_regb(port, UART_LSR) & UART_LSR_THRE));
					wr_regb(port, UART_THR, '
');
			}
	
			while (!(rd_regb(port, UART_LSR) & UART_LSR_THRE));
				wr_regb(port, UART_THR, *ptr);
				
			ptr ++;
			size --;
		}
	}
	else
	{
		while (size)
		{
			while (!(rd_regb(port, UART_LSR) & UART_LSR_THRE));
				wr_regb(port, UART_THR, *ptr);
				
			ptr ++; size --;
		}
	}

return (rt_size_t) ptr - (rt_size_t) buffer;
}

static const struct rt_device_ops lpc_uart_ops = {
	lpc_uart_init, 		
	lpc_uart_open,
	lpc_uart_close,
	lpc_uart_read,
	lpc_uart_write,
	lpc_uart_control 		
};

rt_inline void __uart_tx_chars_thri(struct lpc_uart *port)
{
	int count = port->fifosize;
	struct circ_buf *xmit = &port->tx_xmit;
	
	/* try and drain the buffer... */
	while (!uart_circ_empty(xmit) && count-- > 0) 
	{
		wr_regb(port, UART_THR, xmit->buf[xmit->tail]);
		xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
	}

wr_regb(port, UART_IER, rd_regb(port, UART_IER) & (~UART_IER_THRI));
}

rt_inline void __uart_rx_lsr_err(struct lpc_uart *port)
{
	volatile unsigned char temp;
		
	while(rd_regb(port, UART_LSR) & UART_LSR_DR)
		temp = rd_regb(port, UART_RBR);
	wr_regb(port, UART_FCR, rd_regb(port, UART_FCR) | UART_FCR_CLEAR_RCVR);
}

rt_inline void __uart_rx_chars_rdi(struct lpc_uart *port)
{
	int count = port->fifosize;
	struct circ_buf *xmit = &port->tx_xmit;
	
	/* try and drain the buffer... */
	while ((rd_regb(port, UART_LSR) & UART_LSR_DR) && count-- > 0) 
	{
		xmit->buf[xmit->head] = rd_regb(port, UART_RBR);
		xmit->head = (xmit->head + 1) & (UART_XMIT_SIZE - 1);

////////////////////////////////////////////////
		if(uart_circ_chars_pending(xmit) >= 30)
		{
			if (port->parent.rx_indicate != RT_NULL)
				port->parent.rx_indicate(&port->parent, 0);
		}
		////////////////////////////////////////////////
	}
}

rt_inline void __uart_rx_chars_cti(struct lpc_uart *port)
{
	struct circ_buf *xmit = &port->tx_xmit;	
	
	while (rd_regb(port, UART_LSR) & UART_LSR_DR)
	{
		xmit->buf[xmit->head] = rd_regb(port, UART_RBR);
		xmit->head = (xmit->head + 1) & (UART_XMIT_SIZE - 1);
	}
	if (port->parent.rx_indicate != RT_NULL)
		port->parent.rx_indicate(&port->parent, 0);
}

rt_inline void __uart_rx_rlsi(struct lpc_uart *port)
{
	volatile unsigned char temp;

temp = rd_regb(port, UART_LSR);
}

void lpc_uart_isr_hangler(struct lpc_uart *port)
{
	volatile unsigned char iir;

RT_ASSERT(port != RT_NULL)

while(((iir = rd_regb(port, UART_IIR)) & UART_IIR_NO_INT) != UART_IIR_NO_INT)
	{
		switch(iir & UART_IIR_ID)
		{
		case UART_IIR_THRI:
			__uart_tx_chars_thri(port);
			break;
		case UART_IIR_RDI:
		case UART_IIR_CTI:
			if (rd_regb(port, UART_LSR) & UART_LSR_ERR_MASK)
			__uart_rx_lsr_err(port);	
			if ((iir & UART_IIR_ID) == UART_IIR_RDI) 
			__uart_rx_chars_rdi(port);		
			if ((iir & UART_IIR_ID) == UART_IIR_CTI) 
			__uart_rx_chars_cti(port);	
			break;
		case UART_IIR_RLSI:
		  	__uart_rx_rlsi(port);
			break;

default:
			break;
		}
	}
	
	/* acknowledge Interrupt */
	VICVectAddr = 0;
}

#ifdef RT_USING_UART1
void lpc_uart_isr_1(int irqno)
{
	/* get lpc serial device */
	lpc_uart_isr_hangler(&lpc_uart1);
}	
#endif

#ifdef RT_USING_UART2
void lpc_uart_isr_2(int irqno)
{
	/* get lpc serial device */
	lpc_uart_isr_hangler(&lpc_uart2);
}	
#endif

/**
 *						
 */

void rt_hw_uart_init(void)
{
#ifdef RT_USING_UART1
	/* Enable UART0 RxD and TxD pins */
  	PINSEL0 |= 0x05;

lpc_uart1.hwbase   = UART0_BASE;
	lpc_uart1.irqno    = UART0_INT;
	lpc_uart1.baudrate = 115200;
	lpc_uart1.csize    = 8;
	lpc_uart1.stopb    = 1;
	lpc_uart1.parity   = 0;
	lpc_uart1.fifosize = 8;
	lpc_uart1.isr      = lpc_uart_isr_1;

rt_device_register(&lpc_uart1.parent, "uart1", RT_Device_Class_Char, 
		RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX | RT_DEVICE_FLAG_INT_TX,
		&lpc_uart_ops, RT_NULL);
#endif

#ifdef RT_USING_UART2
	/* Enable UART1 RxD and TxD pins */
 	PINSEL0 |= 0x05 << 16;
	
	lpc_uart2.hwbase   = UART1_BASE;
	lpc_uart2.irqno    = UART1_INT;
	lpc_uart2.baudrate = 38400;
	lpc_uart2.csize    = 8;
	lpc_uart2.stopb    = 1;
	lpc_uart2.parity   = 0;
	lpc_uart2.fifosize = 8;
	lpc_uart2.isr      = lpc_uart_isr_2;

rt_device_register(&lpc_uart2.parent, "uart2", RT_Device_Class_Char,
		RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX | RT_DEVICE_FLAG_INT_TX,
		&lpc_uart_ops, RT_NULL);
#endif
}

/**
 * End of file
 */```