309 lines
7.8 KiB
C
Executable File
309 lines
7.8 KiB
C
Executable File
/*
|
|
* File : serial.c
|
|
* This file is part of RT-Thread RTOS
|
|
* COPYRIGHT (C) 2006, RT-Thread Development Team
|
|
*
|
|
* The license and distribution terms for this file may be
|
|
* found in the file LICENSE in this distribution or at
|
|
* http://openlab.rt-thread.com/license/LICENSE
|
|
*
|
|
* Change Logs:
|
|
* Date Author Notes
|
|
* 2006-08-23 Bernard first version
|
|
* 2009-05-14 Bernard add RT-THread device interface
|
|
*
|
|
* 2011-12-17 nl1031 MicroBlaze
|
|
*/
|
|
|
|
#include <rthw.h>
|
|
#include <rtthread.h>
|
|
#include "serial.h"
|
|
|
|
typedef volatile rt_uint32_t REG32;
|
|
struct rt_mb_uart_lite_hw
|
|
{
|
|
REG32 Rx_FIFO; // Receiver Holding Register
|
|
REG32 Tx_FIFO; // Transmitter Holding Register
|
|
REG32 STAT_REG; // Channel Status Register
|
|
REG32 CTRL_REG; // Control Register
|
|
};
|
|
|
|
struct rt_mb_uart_lite
|
|
{
|
|
struct rt_device parent;
|
|
|
|
struct rt_mb_uart_lite_hw* hw_base;
|
|
rt_uint16_t peripheral_id;
|
|
rt_uint32_t baudrate;
|
|
|
|
/* reception field */
|
|
rt_uint16_t save_index, read_index;
|
|
rt_uint8_t rx_buffer[RT_UART_RX_BUFFER_SIZE];
|
|
};
|
|
#ifdef RT_USING_UART1
|
|
struct rt_mb_uart_lite serial1;
|
|
#endif
|
|
|
|
static void rt_hw_serial_isr(void)
|
|
{
|
|
unsigned int status;
|
|
rt_base_t level;
|
|
struct rt_device* device;
|
|
struct rt_mb_uart_lite* serial = RT_NULL;
|
|
|
|
#ifdef RT_USING_UART1
|
|
/* serial 1 */
|
|
serial = &serial1;
|
|
#endif
|
|
RT_ASSERT(serial != RT_NULL);
|
|
|
|
/* get generic device object */
|
|
device = (rt_device_t) serial;
|
|
|
|
/* disable interrupt */
|
|
level = rt_hw_interrupt_disable();
|
|
|
|
/* get uart status register */
|
|
status = serial->hw_base->STAT_REG;
|
|
while (status & XUL_SR_RX_FIFO_VALID_DATA)
|
|
{
|
|
/* get received character */
|
|
serial->rx_buffer[serial->save_index] = serial->hw_base->Rx_FIFO;
|
|
|
|
/* move to next position */
|
|
serial->save_index++;
|
|
if (serial->save_index >= RT_UART_RX_BUFFER_SIZE)
|
|
serial->save_index = 0;
|
|
|
|
/* if the next position is read index, discard this 'read char' */
|
|
if (serial->save_index == serial->read_index)
|
|
{
|
|
serial->read_index++;
|
|
if (serial->read_index >= RT_UART_RX_BUFFER_SIZE)
|
|
serial->read_index = 0;
|
|
}
|
|
status = serial->hw_base->STAT_REG;
|
|
}
|
|
/* enable interrupt */
|
|
rt_hw_interrupt_enable(level);
|
|
|
|
/* indicate to upper layer application */
|
|
if (device->rx_indicate != RT_NULL)
|
|
device->rx_indicate(device, 1);
|
|
|
|
}
|
|
|
|
static rt_err_t rt_serial_init(rt_device_t dev)
|
|
{
|
|
struct rt_mb_uart_lite* serial = (struct rt_mb_uart_lite*) dev;
|
|
|
|
RT_ASSERT(serial != RT_NULL);
|
|
|
|
RT_ASSERT(serial->peripheral_id != XPAR_INTC_0_UARTLITE_1_VEC_ID);
|
|
|
|
/* reset rx index */
|
|
serial->save_index = 0;
|
|
serial->read_index = 0;
|
|
|
|
/* reset rx buffer */
|
|
rt_memset(serial->rx_buffer, 0, RT_UART_RX_BUFFER_SIZE);
|
|
|
|
return RT_EOK;
|
|
}
|
|
|
|
static rt_err_t rt_serial_open(rt_device_t dev, rt_uint16_t oflag)
|
|
{
|
|
struct rt_mb_uart_lite *serial = (struct rt_mb_uart_lite*) dev;
|
|
RT_ASSERT(serial != RT_NULL);
|
|
|
|
if (dev->flag & RT_DEVICE_FLAG_INT_RX)
|
|
{
|
|
/* enable UART rx interrupt */
|
|
serial->hw_base->CTRL_REG = XUL_CR_ENABLE_INTR; /* enable interrupt */
|
|
|
|
/* install UART handler */
|
|
rt_hw_interrupt_install(serial->peripheral_id, (rt_isr_handler_t) rt_hw_serial_isr, RT_NULL);
|
|
rt_hw_interrupt_umask(serial->peripheral_id);
|
|
}
|
|
|
|
return RT_EOK;
|
|
}
|
|
|
|
static rt_err_t rt_serial_close(rt_device_t dev)
|
|
{
|
|
struct rt_mb_uart_lite *serial = (struct rt_mb_uart_lite*) dev;
|
|
RT_ASSERT(serial != RT_NULL);
|
|
|
|
if (dev->flag & RT_DEVICE_FLAG_INT_RX)
|
|
{
|
|
/* disable interrupt */
|
|
serial->hw_base->CTRL_REG = 0; /* RxReady interrupt */
|
|
}
|
|
|
|
return RT_EOK;
|
|
}
|
|
|
|
static rt_size_t rt_serial_read(rt_device_t dev, rt_off_t pos, void* buffer, rt_size_t size)
|
|
{
|
|
rt_uint8_t* ptr;
|
|
struct rt_mb_uart_lite *serial = (struct rt_mb_uart_lite*) dev;
|
|
RT_ASSERT(serial != RT_NULL);
|
|
|
|
/* point to buffer */
|
|
ptr = (rt_uint8_t*) buffer;
|
|
|
|
if (dev->flag & RT_DEVICE_FLAG_INT_RX)
|
|
{
|
|
while (size)
|
|
{
|
|
/* interrupt receive */
|
|
rt_base_t level;
|
|
|
|
/* disable interrupt */
|
|
level = rt_hw_interrupt_disable();
|
|
if (serial->read_index != serial->save_index)
|
|
{
|
|
*ptr = serial->rx_buffer[serial->read_index];
|
|
|
|
serial->read_index++;
|
|
if (serial->read_index >= RT_UART_RX_BUFFER_SIZE)
|
|
serial->read_index = 0;
|
|
} else
|
|
{
|
|
/* no data in rx buffer */
|
|
|
|
/* enable interrupt */
|
|
rt_hw_interrupt_enable(level);
|
|
break;
|
|
}
|
|
|
|
/* enable interrupt */
|
|
rt_hw_interrupt_enable(level);
|
|
|
|
ptr++;
|
|
size--;
|
|
}
|
|
|
|
return (rt_uint32_t) ptr - (rt_uint32_t) buffer;
|
|
} else if (dev->flag & RT_DEVICE_FLAG_DMA_RX)
|
|
{
|
|
/* not support right now */
|
|
RT_ASSERT(0);
|
|
} else
|
|
{
|
|
/* poll mode */
|
|
while (size)
|
|
{
|
|
/* Wait for Full Rx Buffer */
|
|
while (!(serial->hw_base->STAT_REG & XUL_SR_RX_FIFO_VALID_DATA))
|
|
;
|
|
|
|
/* Read Character */
|
|
*ptr = serial->hw_base->Rx_FIFO;
|
|
ptr++;
|
|
size--;
|
|
}
|
|
|
|
return (rt_size_t) ptr - (rt_size_t) buffer;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static rt_size_t rt_serial_write(rt_device_t dev, rt_off_t pos, const void* buffer, rt_size_t size)
|
|
{
|
|
rt_uint8_t* ptr;
|
|
struct rt_mb_uart_lite *serial = (struct rt_mb_uart_lite*) dev;
|
|
RT_ASSERT(serial != RT_NULL);
|
|
|
|
ptr = (rt_uint8_t*) buffer;
|
|
if (dev->open_flag & RT_DEVICE_OFLAG_WRONLY)
|
|
{
|
|
if (dev->flag & RT_DEVICE_FLAG_STREAM)
|
|
{
|
|
/* it's a stream mode device */
|
|
while (size)
|
|
{
|
|
/* stream mode */
|
|
if (*ptr == '\n')
|
|
{
|
|
while (!(serial->hw_base->STAT_REG & XUL_SR_TX_FIFO_EMPTY))
|
|
;
|
|
serial->hw_base->Tx_FIFO = '\r';
|
|
}
|
|
|
|
/* Wait for Empty Tx Buffer */
|
|
while (!(serial->hw_base->STAT_REG & XUL_SR_TX_FIFO_EMPTY)) ;
|
|
|
|
/* Transmit Character */
|
|
serial->hw_base->Tx_FIFO = *ptr;
|
|
ptr++;
|
|
size--;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
while (size)
|
|
{
|
|
/* Wait for Empty Tx Buffer */
|
|
while (!(serial->hw_base->STAT_REG & XUL_SR_TX_FIFO_EMPTY))
|
|
;
|
|
|
|
/* Transmit Character */
|
|
serial->hw_base->Tx_FIFO = *ptr;
|
|
ptr++;
|
|
size--;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (rt_size_t) ptr - (rt_size_t) buffer;
|
|
}
|
|
|
|
static rt_err_t rt_serial_control(rt_device_t dev, rt_uint8_t cmd, void *args)
|
|
{
|
|
return RT_EOK;
|
|
}
|
|
|
|
rt_err_t rt_hw_serial_init()
|
|
{
|
|
rt_device_t device;
|
|
|
|
#ifndef RT_USING_CONSOLE
|
|
int Status;
|
|
|
|
/*
|
|
* Initialize the UartLite driver so that it is ready to use.
|
|
*/
|
|
Status = XUartLite_Initialize(&uart_lite, RS232_DEVICE_ID);
|
|
if (Status != XST_SUCCESS)
|
|
{
|
|
return;
|
|
}
|
|
|
|
#endif
|
|
|
|
#ifdef RT_USING_UART1
|
|
device = (rt_device_t) &serial1;
|
|
|
|
/* init serial device private data */
|
|
serial1.hw_base = (struct rt_mb_uart_lite_hw*) XPAR_USB_UART_BASEADDR;
|
|
serial1.peripheral_id = XPAR_INTC_0_UARTLITE_1_VEC_ID;
|
|
serial1.baudrate = 9600;
|
|
|
|
/* set device virtual interface */
|
|
device->init = rt_serial_init;
|
|
device->open = rt_serial_open;
|
|
device->close = rt_serial_close;
|
|
device->read = rt_serial_read;
|
|
device->write = rt_serial_write;
|
|
device->control = rt_serial_control;
|
|
|
|
/* register uart1 on device subsystem */
|
|
rt_device_register(device, "uart1", RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX);
|
|
#endif
|
|
|
|
return RT_EOK;
|
|
}
|
|
|