rt-thread-official/libcpu/xilinx/microblaze/serial.c

/*
 * 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_UARTLITE_1_DEVICE_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;
                if (*ptr & 1)
                    rt_hw_board_led_on(2);
                else
                    rt_hw_board_led_off(2);
                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;
                if (*ptr & 1)
                    rt_hw_board_led_on(2);
                else
                    rt_hw_board_led_off(2);
                ptr ++; size --;
            }
        }
    }

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

static rt_err_t rt_serial_control (rt_device_t dev, int 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_UARTLITE_1_DEVICE_ID;
    serial1.baudrate        = 115200;

    /* 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;
}