libs/rt-thread-official
libs
/
rt-thread-official
mirror of https://github.com/RT-Thread/rt-thread.git
4
0
Fork 0
Code Issues Releases Wiki Activity

Merge pull request #335 from heyuanjie87/ForPullRequest 

[Serial] BUG Fix: data be send twice in mode that other than polling
This commit is contained in:
Bernard Xiong 2014-09-02 16:55:52 +08:00
parent 7bd85ac547 8a44c7dbfb
commit be9aa36abf
1 changed files with 365 additions and 363 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

690
components/drivers/serial/serial.c
View File

@ -37,48 +37,48 @@
*/ */
rt_inline int _serial_poll_rx(struct rt_serial_device *serial, rt_uint8_t *data, int length) rt_inline int _serial_poll_rx(struct rt_serial_device *serial, rt_uint8_t *data, int length)
{ {
int ch; int ch;
int size; int size;
RT_ASSERT(serial != RT_NULL); RT_ASSERT(serial != RT_NULL);
size = length; size = length;
while (length) while (length)
{ {
ch = serial->ops->getc(serial); ch = serial->ops->getc(serial);
*data = ch; *data = ch;
data ++; length --; data ++; length --;
if (ch == '\n') break; if (ch == '\n') break;
} }
return size - length; return size - length;
} }
rt_inline int _serial_poll_tx(struct rt_serial_device *serial, const rt_uint8_t *data, int length) rt_inline int _serial_poll_tx(struct rt_serial_device *serial, const rt_uint8_t *data, int length)
{ {
int size; int size;
RT_ASSERT(serial != RT_NULL); RT_ASSERT(serial != RT_NULL);
size = length; size = length;
while (length) while (length)
{ {
/* /*
* to be polite with serial console add a line feed * to be polite with serial console add a line feed
* to the carriage return character * to the carriage return character
*/ */
if (*data == '\n' && (serial->parent.flag & RT_DEVICE_FLAG_STREAM)) if (*data == '\n' && (serial->parent.flag & RT_DEVICE_FLAG_STREAM))
{ {
serial->ops->putc(serial, '\r'); serial->ops->putc(serial, '\r');
} }
serial->ops->putc(serial, *data); serial->ops->putc(serial, *data);
++ data; ++ data;
-- length; -- length;
} }
return size - length; return size - length;
} }
/* /*
@ -86,69 +86,69 @@ rt_inline int _serial_poll_tx(struct rt_serial_device *serial, const rt_uint8_t
*/ */
rt_inline int _serial_int_rx(struct rt_serial_device *serial, rt_uint8_t *data, int length) rt_inline int _serial_int_rx(struct rt_serial_device *serial, rt_uint8_t *data, int length)
{ {
int size; int size;
struct rt_serial_rx_fifo* rx_fifo; struct rt_serial_rx_fifo* rx_fifo;
RT_ASSERT(serial != RT_NULL); RT_ASSERT(serial != RT_NULL);
size = length; size = length;
rx_fifo = (struct rt_serial_rx_fifo*) serial->serial_rx; rx_fifo = (struct rt_serial_rx_fifo*) serial->serial_rx;
RT_ASSERT(rx_fifo != RT_NULL); RT_ASSERT(rx_fifo != RT_NULL);
/* read from software FIFO */ /* read from software FIFO */
while (length) while (length)
{ {
int ch; int ch;
rt_base_t level; rt_base_t level;
/* disable interrupt */ /* disable interrupt */
level = rt_hw_interrupt_disable(); level = rt_hw_interrupt_disable();
if (rx_fifo->get_index != rx_fifo->put_index) if (rx_fifo->get_index != rx_fifo->put_index)
{ {
ch = rx_fifo->buffer[rx_fifo->get_index]; ch = rx_fifo->buffer[rx_fifo->get_index];
rx_fifo->get_index += 1; rx_fifo->get_index += 1;
if (rx_fifo->get_index >= serial->config.bufsz) rx_fifo->get_index = 0; if (rx_fifo->get_index >= serial->config.bufsz) rx_fifo->get_index = 0;
} }
else else
{ {
/* no data, enable interrupt and break out */ /* no data, enable interrupt and break out */
rt_hw_interrupt_enable(level); rt_hw_interrupt_enable(level);
break; break;
} }
/* enable interrupt */ /* enable interrupt */
rt_hw_interrupt_enable(level); rt_hw_interrupt_enable(level);
*data = ch & 0xff; *data = ch & 0xff;
data ++; length --; data ++; length --;
} }
return size - length; return size - length;
} }
rt_inline int _serial_int_tx(struct rt_serial_device *serial, const rt_uint8_t *data, int length) rt_inline int _serial_int_tx(struct rt_serial_device *serial, const rt_uint8_t *data, int length)
{ {
int size; int size;
struct rt_serial_tx_fifo *tx; struct rt_serial_tx_fifo *tx;
RT_ASSERT(serial != RT_NULL); RT_ASSERT(serial != RT_NULL);
size = length; size = length;
tx = (struct rt_serial_tx_fifo*) serial->serial_tx; tx = (struct rt_serial_tx_fifo*) serial->serial_tx;
RT_ASSERT(tx != RT_NULL); RT_ASSERT(tx != RT_NULL);
while (length) while (length)
{ {
if (serial->ops->putc(serial, *(char*)data) == -1) if (serial->ops->putc(serial, *(char*)data) == -1)
{ {
rt_completion_wait(&(tx->completion), RT_WAITING_FOREVER); rt_completion_wait(&(tx->completion), RT_WAITING_FOREVER);
continue; continue;
} }
data ++; length --; data ++; length --;
} }
return size - length; return size - length;
} }
/* /*
@ -156,61 +156,61 @@ rt_inline int _serial_int_tx(struct rt_serial_device *serial, const rt_uint8_t *
*/ */
rt_inline int _serial_dma_rx(struct rt_serial_device *serial, rt_uint8_t *data, int length) rt_inline int _serial_dma_rx(struct rt_serial_device *serial, rt_uint8_t *data, int length)
{ {
rt_base_t level; rt_base_t level;
int result = RT_EOK; int result = RT_EOK;
struct rt_serial_rx_dma *rx_dma; struct rt_serial_rx_dma *rx_dma;
RT_ASSERT((serial != RT_NULL) && (data != RT_NULL)); RT_ASSERT((serial != RT_NULL) && (data != RT_NULL));
rx_dma = (struct rt_serial_rx_dma*)serial->serial_rx; rx_dma = (struct rt_serial_rx_dma*)serial->serial_rx;
RT_ASSERT(rx_dma != RT_NULL); RT_ASSERT(rx_dma != RT_NULL);
level = rt_hw_interrupt_disable(); level = rt_hw_interrupt_disable();
if (rx_dma->activated != RT_TRUE) if (rx_dma->activated != RT_TRUE)
{ {
rx_dma->activated = RT_TRUE; rx_dma->activated = RT_TRUE;
serial->ops->dma_transmit(serial, data, length, RT_SERIAL_DMA_RX); serial->ops->dma_transmit(serial, data, length, RT_SERIAL_DMA_RX);
} }
else result = -RT_EBUSY; else result = -RT_EBUSY;
rt_hw_interrupt_enable(level); rt_hw_interrupt_enable(level);
if (result == RT_EOK) return length; if (result == RT_EOK) return length;
rt_set_errno(result); rt_set_errno(result);
return 0; return 0;
} }
rt_inline int _serial_dma_tx(struct rt_serial_device *serial, const rt_uint8_t *data, int length) rt_inline int _serial_dma_tx(struct rt_serial_device *serial, const rt_uint8_t *data, int length)
{ {
rt_base_t level; rt_base_t level;
rt_err_t result; rt_err_t result;
struct rt_serial_tx_dma *tx_dma; struct rt_serial_tx_dma *tx_dma;
tx_dma = (struct rt_serial_tx_dma*)(serial->serial_tx); tx_dma = (struct rt_serial_tx_dma*)(serial->serial_tx);
result = rt_data_queue_push(&(tx_dma->data_queue), data, length, RT_WAITING_FOREVER); result = rt_data_queue_push(&(tx_dma->data_queue), data, length, RT_WAITING_FOREVER);
if (result == RT_EOK) if (result == RT_EOK)
{ {
level = rt_hw_interrupt_disable(); level = rt_hw_interrupt_disable();
if (tx_dma->activated != RT_TRUE) if (tx_dma->activated != RT_TRUE)
{ {
tx_dma->activated = RT_TRUE; tx_dma->activated = RT_TRUE;
rt_hw_interrupt_enable(level); rt_hw_interrupt_enable(level);
/* make a DMA transfer */ /* make a DMA transfer */
serial->ops->dma_transmit(serial, data, length, RT_SERIAL_DMA_TX); serial->ops->dma_transmit(serial, data, length, RT_SERIAL_DMA_TX);
} }
else else
{ {
rt_hw_interrupt_enable(level); rt_hw_interrupt_enable(level);
} }
return length; return length;
} }
else else
{ {
rt_set_errno(result); rt_set_errno(result);
return 0; return 0;
} }
} }
/* RT-Thread Device Interface */ /* RT-Thread Device Interface */
@ -225,15 +225,15 @@ static rt_err_t rt_serial_init(struct rt_device *dev)
RT_ASSERT(dev != RT_NULL); RT_ASSERT(dev != RT_NULL);
serial = (struct rt_serial_device *)dev; serial = (struct rt_serial_device *)dev;
/* initialize rx/tx */ /* initialize rx/tx */
serial->serial_rx = RT_NULL; serial->serial_rx = RT_NULL;
serial->serial_tx = RT_NULL; serial->serial_tx = RT_NULL;
/* apply configuration */ /* apply configuration */
if (serial->ops->configure) if (serial->ops->configure)
result = serial->ops->configure(serial, &serial->config); result = serial->ops->configure(serial, &serial->config);
return result; return result;
} }
static rt_err_t rt_serial_open(struct rt_device *dev, rt_uint16_t oflag) static rt_err_t rt_serial_open(struct rt_device *dev, rt_uint16_t oflag)
@ -243,89 +243,89 @@ static rt_err_t rt_serial_open(struct rt_device *dev, rt_uint16_t oflag)
RT_ASSERT(dev != RT_NULL); RT_ASSERT(dev != RT_NULL);
serial = (struct rt_serial_device *)dev; serial = (struct rt_serial_device *)dev;
/* check device flag with the open flag */ /* check device flag with the open flag */
if ((oflag & RT_DEVICE_FLAG_DMA_RX) && !(dev->flag & RT_DEVICE_FLAG_DMA_RX)) if ((oflag & RT_DEVICE_FLAG_DMA_RX) && !(dev->flag & RT_DEVICE_FLAG_DMA_RX))
return -RT_EIO; return -RT_EIO;
if ((oflag & RT_DEVICE_FLAG_DMA_TX) && !(dev->flag & RT_DEVICE_FLAG_DMA_TX)) if ((oflag & RT_DEVICE_FLAG_DMA_TX) && !(dev->flag & RT_DEVICE_FLAG_DMA_TX))
return -RT_EIO; return -RT_EIO;
if ((oflag & RT_DEVICE_FLAG_INT_RX) && !(dev->flag & RT_DEVICE_FLAG_INT_RX)) if ((oflag & RT_DEVICE_FLAG_INT_RX) && !(dev->flag & RT_DEVICE_FLAG_INT_RX))
return -RT_EIO; return -RT_EIO;
if ((oflag & RT_DEVICE_FLAG_INT_TX) && !(dev->flag & RT_DEVICE_FLAG_INT_TX)) if ((oflag & RT_DEVICE_FLAG_INT_TX) && !(dev->flag & RT_DEVICE_FLAG_INT_TX))
return -RT_EIO; return -RT_EIO;
/* get open flags */ /* get open flags */
dev->open_flag = oflag & 0xff; dev->open_flag = oflag & 0xff;
/* initialize the Rx/Tx structure according to open flag */ /* initialize the Rx/Tx structure according to open flag */
if (serial->serial_rx == RT_NULL) if (serial->serial_rx == RT_NULL)
{ {
if (oflag & RT_DEVICE_FLAG_DMA_RX) if (oflag & RT_DEVICE_FLAG_DMA_RX)
{ {
struct rt_serial_rx_dma* rx_dma; struct rt_serial_rx_dma* rx_dma;
rx_dma = (struct rt_serial_rx_dma*) rt_malloc (sizeof(struct rt_serial_rx_dma)); rx_dma = (struct rt_serial_rx_dma*) rt_malloc (sizeof(struct rt_serial_rx_dma));
RT_ASSERT(rx_dma != RT_NULL); RT_ASSERT(rx_dma != RT_NULL);
rx_dma->activated = RT_FALSE; rx_dma->activated = RT_FALSE;
serial->serial_rx = rx_dma; serial->serial_rx = rx_dma;
dev->open_flag |= RT_DEVICE_FLAG_DMA_RX; dev->open_flag |= RT_DEVICE_FLAG_DMA_RX;
} }
else if (oflag & RT_DEVICE_FLAG_INT_RX) else if (oflag & RT_DEVICE_FLAG_INT_RX)
{ {
struct rt_serial_rx_fifo* rx_fifo; struct rt_serial_rx_fifo* rx_fifo;
rx_fifo = (struct rt_serial_rx_fifo*) rt_malloc (sizeof(struct rt_serial_rx_fifo) + rx_fifo = (struct rt_serial_rx_fifo*) rt_malloc (sizeof(struct rt_serial_rx_fifo) +
serial->config.bufsz); serial->config.bufsz);
RT_ASSERT(rx_fifo != RT_NULL); RT_ASSERT(rx_fifo != RT_NULL);
rx_fifo->buffer = (rt_uint8_t*) (rx_fifo + 1); rx_fifo->buffer = (rt_uint8_t*) (rx_fifo + 1);
rt_memset(rx_fifo->buffer, 0, RT_SERIAL_RB_BUFSZ); rt_memset(rx_fifo->buffer, 0, RT_SERIAL_RB_BUFSZ);
rx_fifo->put_index = 0; rx_fifo->put_index = 0;
rx_fifo->get_index = 0; rx_fifo->get_index = 0;
serial->serial_rx = rx_fifo; serial->serial_rx = rx_fifo;
dev->open_flag |= RT_DEVICE_FLAG_INT_RX; dev->open_flag |= RT_DEVICE_FLAG_INT_RX;
/* configure low level device */ /* configure low level device */
serial->ops->control(serial, RT_DEVICE_CTRL_SET_INT, (void *)RT_DEVICE_FLAG_INT_RX); serial->ops->control(serial, RT_DEVICE_CTRL_SET_INT, (void *)RT_DEVICE_FLAG_INT_RX);
} }
else else
{ {
serial->serial_rx = RT_NULL; serial->serial_rx = RT_NULL;
} }
} }
if (serial->serial_tx == RT_NULL) if (serial->serial_tx == RT_NULL)
{ {
if (oflag & RT_DEVICE_FLAG_DMA_TX) if (oflag & RT_DEVICE_FLAG_DMA_TX)
{ {
struct rt_serial_tx_dma* tx_dma; struct rt_serial_tx_dma* tx_dma;
tx_dma = (struct rt_serial_tx_dma*) rt_malloc (sizeof(struct rt_serial_tx_dma)); tx_dma = (struct rt_serial_tx_dma*) rt_malloc (sizeof(struct rt_serial_tx_dma));
RT_ASSERT(tx_dma != RT_NULL); RT_ASSERT(tx_dma != RT_NULL);
rt_data_queue_init(&(tx_dma->data_queue), 8, 4, RT_NULL); rt_data_queue_init(&(tx_dma->data_queue), 8, 4, RT_NULL);
serial->serial_tx = tx_dma; serial->serial_tx = tx_dma;
dev->open_flag |= RT_DEVICE_FLAG_DMA_TX; dev->open_flag |= RT_DEVICE_FLAG_DMA_TX;
} }
else if (oflag & RT_DEVICE_FLAG_INT_TX) else if (oflag & RT_DEVICE_FLAG_INT_TX)
{ {
struct rt_serial_tx_fifo *tx_fifo; struct rt_serial_tx_fifo *tx_fifo;
tx_fifo = (struct rt_serial_tx_fifo*) rt_malloc(sizeof(struct rt_serial_tx_fifo)); tx_fifo = (struct rt_serial_tx_fifo*) rt_malloc(sizeof(struct rt_serial_tx_fifo));
RT_ASSERT(tx_fifo != RT_NULL); RT_ASSERT(tx_fifo != RT_NULL);
rt_completion_init(&(tx_fifo->completion)); rt_completion_init(&(tx_fifo->completion));
serial->serial_tx = tx_fifo; serial->serial_tx = tx_fifo;
dev->open_flag |= RT_DEVICE_FLAG_INT_TX; dev->open_flag |= RT_DEVICE_FLAG_INT_TX;
/* configure low level device */ /* configure low level device */
serial->ops->control(serial, RT_DEVICE_CTRL_SET_INT, (void *)RT_DEVICE_FLAG_INT_TX); serial->ops->control(serial, RT_DEVICE_CTRL_SET_INT, (void *)RT_DEVICE_FLAG_INT_TX);
} }
else else
{ {
serial->serial_tx = RT_NULL; serial->serial_tx = RT_NULL;
} }
} }
return RT_EOK; return RT_EOK;
} }
@ -337,58 +337,58 @@ static rt_err_t rt_serial_close(struct rt_device *dev)
RT_ASSERT(dev != RT_NULL); RT_ASSERT(dev != RT_NULL);
serial = (struct rt_serial_device *)dev; serial = (struct rt_serial_device *)dev;
/* this device has more reference count */ /* this device has more reference count */
if (dev->ref_count > 1) return RT_EOK; if (dev->ref_count > 1) return RT_EOK;
if (dev->open_flag & RT_DEVICE_FLAG_INT_RX) if (dev->open_flag & RT_DEVICE_FLAG_INT_RX)
{ {
struct rt_serial_rx_fifo* rx_fifo; struct rt_serial_rx_fifo* rx_fifo;
rx_fifo = (struct rt_serial_rx_fifo*)serial->serial_rx; rx_fifo = (struct rt_serial_rx_fifo*)serial->serial_rx;
RT_ASSERT(rx_fifo != RT_NULL); RT_ASSERT(rx_fifo != RT_NULL);
rt_free(rx_fifo); rt_free(rx_fifo);
serial->serial_rx = RT_NULL; serial->serial_rx = RT_NULL;
dev->open_flag &= ~RT_DEVICE_FLAG_INT_RX; dev->open_flag &= ~RT_DEVICE_FLAG_INT_RX;
/* configure low level device */ /* configure low level device */
serial->ops->control(serial, RT_DEVICE_CTRL_CLR_INT, (void*)RT_DEVICE_FLAG_INT_TX); serial->ops->control(serial, RT_DEVICE_CTRL_CLR_INT, (void*)RT_DEVICE_FLAG_INT_TX);
} }
else if (dev->open_flag & RT_DEVICE_FLAG_DMA_RX) else if (dev->open_flag & RT_DEVICE_FLAG_DMA_RX)
{ {
struct rt_serial_rx_dma* rx_dma; struct rt_serial_rx_dma* rx_dma;
rx_dma = (struct rt_serial_rx_dma*)serial->serial_tx; rx_dma = (struct rt_serial_rx_dma*)serial->serial_tx;
RT_ASSERT(rx_dma != RT_NULL); RT_ASSERT(rx_dma != RT_NULL);
rt_free(rx_dma); rt_free(rx_dma);
serial->serial_rx = RT_NULL; serial->serial_rx = RT_NULL;
dev->open_flag &= ~RT_DEVICE_FLAG_DMA_RX; dev->open_flag &= ~RT_DEVICE_FLAG_DMA_RX;
} }
if (dev->open_flag & RT_DEVICE_FLAG_INT_TX) if (dev->open_flag & RT_DEVICE_FLAG_INT_TX)
{ {
struct rt_serial_tx_fifo* tx_fifo; struct rt_serial_tx_fifo* tx_fifo;
tx_fifo = (struct rt_serial_tx_fifo*)serial->serial_rx; tx_fifo = (struct rt_serial_tx_fifo*)serial->serial_rx;
RT_ASSERT(tx_fifo != RT_NULL); RT_ASSERT(tx_fifo != RT_NULL);
rt_free(tx_fifo); rt_free(tx_fifo);
serial->serial_tx = RT_NULL; serial->serial_tx = RT_NULL;
dev->open_flag &= ~RT_DEVICE_FLAG_INT_TX; dev->open_flag &= ~RT_DEVICE_FLAG_INT_TX;
/* configure low level device */ /* configure low level device */
serial->ops->control(serial, RT_DEVICE_CTRL_CLR_INT, (void*)RT_DEVICE_FLAG_INT_TX); serial->ops->control(serial, RT_DEVICE_CTRL_CLR_INT, (void*)RT_DEVICE_FLAG_INT_TX);
} }
else if (dev->open_flag & RT_DEVICE_FLAG_DMA_TX) else if (dev->open_flag & RT_DEVICE_FLAG_DMA_TX)
{ {
struct rt_serial_tx_dma* tx_dma; struct rt_serial_tx_dma* tx_dma;
tx_dma = (struct rt_serial_tx_dma*)serial->serial_tx; tx_dma = (struct rt_serial_tx_dma*)serial->serial_tx;
RT_ASSERT(tx_dma != RT_NULL); RT_ASSERT(tx_dma != RT_NULL);
rt_free(tx_dma); rt_free(tx_dma);
serial->serial_tx = RT_NULL; serial->serial_tx = RT_NULL;
dev->open_flag &= ~RT_DEVICE_FLAG_DMA_TX; dev->open_flag &= ~RT_DEVICE_FLAG_DMA_TX;
} }
return RT_EOK; return RT_EOK;
} }
@ -405,16 +405,16 @@ static rt_size_t rt_serial_read(struct rt_device *dev,
serial = (struct rt_serial_device *)dev; serial = (struct rt_serial_device *)dev;
if (dev->open_flag & RT_DEVICE_FLAG_INT_RX) if (dev->open_flag & RT_DEVICE_FLAG_INT_RX)
{ {
return _serial_int_rx(serial, buffer, size); return _serial_int_rx(serial, buffer, size);
} }
else if (dev->open_flag & RT_DEVICE_FLAG_DMA_RX) else if (dev->open_flag & RT_DEVICE_FLAG_DMA_RX)
{ {
return _serial_dma_rx(serial, buffer, size); return _serial_dma_rx(serial, buffer, size);
} }
return _serial_poll_rx(serial, buffer, size); return _serial_poll_rx(serial, buffer, size);
} }
static rt_size_t rt_serial_write(struct rt_device *dev, static rt_size_t rt_serial_write(struct rt_device *dev,
@ -429,16 +429,18 @@ static rt_size_t rt_serial_write(struct rt_device *dev,
serial = (struct rt_serial_device *)dev; serial = (struct rt_serial_device *)dev;
if (dev->open_flag & RT_DEVICE_FLAG_INT_TX) if (dev->open_flag & RT_DEVICE_FLAG_INT_TX)
{ {
_serial_int_tx(serial, buffer, size); return _serial_int_tx(serial, buffer, size);
} }
else if (dev->open_flag & RT_DEVICE_FLAG_DMA_TX) else if (dev->open_flag & RT_DEVICE_FLAG_DMA_TX)
{ {
_serial_dma_tx(serial, buffer, size); return _serial_dma_tx(serial, buffer, size);
} }
else
return _serial_poll_tx(serial, buffer, size); {
return _serial_poll_tx(serial, buffer, size);
}
} }
static rt_err_t rt_serial_control(struct rt_device *dev, static rt_err_t rt_serial_control(struct rt_device *dev,
@ -508,106 +510,106 @@ rt_err_t rt_hw_serial_register(struct rt_serial_device *serial,
/* ISR for serial interrupt */ /* ISR for serial interrupt */
void rt_hw_serial_isr(struct rt_serial_device *serial, int event) void rt_hw_serial_isr(struct rt_serial_device *serial, int event)
{ {
switch (event & 0xff) switch (event & 0xff)
{ {
case RT_SERIAL_EVENT_RX_IND: case RT_SERIAL_EVENT_RX_IND:
{ {
int ch = -1; int ch = -1;
rt_base_t level; rt_base_t level;
struct rt_serial_rx_fifo* rx_fifo; struct rt_serial_rx_fifo* rx_fifo;
rx_fifo = (struct rt_serial_rx_fifo*)serial->serial_rx; rx_fifo = (struct rt_serial_rx_fifo*)serial->serial_rx;
RT_ASSERT(rx_fifo != RT_NULL); RT_ASSERT(rx_fifo != RT_NULL);
/* interrupt mode receive */ /* interrupt mode receive */
RT_ASSERT(serial->parent.open_flag & RT_DEVICE_FLAG_INT_RX); RT_ASSERT(serial->parent.open_flag & RT_DEVICE_FLAG_INT_RX);
while (1) while (1)
{ {
ch = serial->ops->getc(serial); ch = serial->ops->getc(serial);
if (ch == -1) break; if (ch == -1) break;
/* disable interrupt */ /* disable interrupt */
level = rt_hw_interrupt_disable(); level = rt_hw_interrupt_disable();
rx_fifo->buffer[rx_fifo->put_index] = ch; rx_fifo->buffer[rx_fifo->put_index] = ch;
rx_fifo->put_index += 1; rx_fifo->put_index += 1;
if (rx_fifo->put_index >= serial->config.bufsz) rx_fifo->put_index = 0; if (rx_fifo->put_index >= serial->config.bufsz) rx_fifo->put_index = 0;
/* if the next position is read index, discard this 'read char' */ /* if the next position is read index, discard this 'read char' */
if (rx_fifo->put_index == rx_fifo->get_index) if (rx_fifo->put_index == rx_fifo->get_index)
{ {
rx_fifo->get_index += 1; rx_fifo->get_index += 1;
if (rx_fifo->get_index >= serial->config.bufsz) rx_fifo->get_index = 0; if (rx_fifo->get_index >= serial->config.bufsz) rx_fifo->get_index = 0;
} }
/* enable interrupt */ /* enable interrupt */
rt_hw_interrupt_enable(level); rt_hw_interrupt_enable(level);
} }
/* invoke callback */ /* invoke callback */
if (serial->parent.rx_indicate != RT_NULL) if (serial->parent.rx_indicate != RT_NULL)
{ {
rt_size_t rx_length; rt_size_t rx_length;
/* get rx length */ /* get rx length */
level = rt_hw_interrupt_disable(); level = rt_hw_interrupt_disable();
rx_length = (rx_fifo->put_index >= rx_fifo->get_index)? (rx_fifo->put_index - rx_fifo->get_index): rx_length = (rx_fifo->put_index >= rx_fifo->get_index)? (rx_fifo->put_index - rx_fifo->get_index):
(serial->config.bufsz - (rx_fifo->get_index - rx_fifo->put_index)); (serial->config.bufsz - (rx_fifo->get_index - rx_fifo->put_index));
rt_hw_interrupt_enable(level); rt_hw_interrupt_enable(level);
serial->parent.rx_indicate(&serial->parent, rx_length); serial->parent.rx_indicate(&serial->parent, rx_length);
} }
break; break;
} }
case RT_SERIAL_EVENT_TX_DONE: case RT_SERIAL_EVENT_TX_DONE:
{ {
struct rt_serial_tx_fifo* tx_fifo; struct rt_serial_tx_fifo* tx_fifo;
tx_fifo = (struct rt_serial_tx_fifo*)serial->serial_tx; tx_fifo = (struct rt_serial_tx_fifo*)serial->serial_tx;
rt_completion_done(&(tx_fifo->completion)); rt_completion_done(&(tx_fifo->completion));
break; break;
} }
case RT_SERIAL_EVENT_TX_DMADONE: case RT_SERIAL_EVENT_TX_DMADONE:
{ {
const void *data_ptr; const void *data_ptr;
rt_size_t data_size; rt_size_t data_size;
const void *last_data_ptr; const void *last_data_ptr;
struct rt_serial_tx_dma* tx_dma; struct rt_serial_tx_dma* tx_dma;
tx_dma = (struct rt_serial_tx_dma*) serial->serial_tx; tx_dma = (struct rt_serial_tx_dma*) serial->serial_tx;
rt_data_queue_pop(&(tx_dma->data_queue), &last_data_ptr, &data_size, 0); rt_data_queue_pop(&(tx_dma->data_queue), &last_data_ptr, &data_size, 0);
if (rt_data_queue_peak(&(tx_dma->data_queue), &data_ptr, &data_size) == RT_EOK) if (rt_data_queue_peak(&(tx_dma->data_queue), &data_ptr, &data_size) == RT_EOK)
{ {
/* transmit next data node */ /* transmit next data node */
tx_dma->activated = RT_TRUE; tx_dma->activated = RT_TRUE;
serial->ops->dma_transmit(serial, data_ptr, data_size, RT_SERIAL_DMA_TX); serial->ops->dma_transmit(serial, data_ptr, data_size, RT_SERIAL_DMA_TX);
} }
else else
{ {
tx_dma->activated = RT_FALSE; tx_dma->activated = RT_FALSE;
} }
/* invoke callback */ /* invoke callback */
if (serial->parent.tx_complete != RT_NULL) if (serial->parent.tx_complete != RT_NULL)
{ {
serial->parent.tx_complete(&serial->parent, (void*)last_data_ptr); serial->parent.tx_complete(&serial->parent, (void*)last_data_ptr);
} }
break; break;
} }
case RT_SERIAL_EVENT_RX_DMADONE: case RT_SERIAL_EVENT_RX_DMADONE:
{ {
int length; int length;
struct rt_serial_rx_dma* rx_dma; struct rt_serial_rx_dma* rx_dma;
rx_dma = (struct rt_serial_rx_dma*)serial->serial_rx; rx_dma = (struct rt_serial_rx_dma*)serial->serial_rx;
/* get DMA rx length */ /* get DMA rx length */
length = (event & (~0xff)) >> 8; length = (event & (~0xff)) >> 8;
serial->parent.rx_indicate(&(serial->parent), length); serial->parent.rx_indicate(&(serial->parent), length);
rx_dma->activated = RT_FALSE; rx_dma->activated = RT_FALSE;
break; break;
} }
} }
} }