[DeviceDrivers] Add fifo mode to serial DMA rx when serial->config.bufsz != 0.

components/drivers/serial/serial.c

@@ -30,6 +30,7 @@
  * 2015-05-19     Quintin      fix DMA tx mod tx_dma->activated flag !=RT_FALSE BUG
  *                             in open function.
  * 2015-11-10     bernard      fix the poll rx issue when there is no data.
+ * 2016-05-10     armink       add fifo mode to DMA rx when serial->config.bufsz != 0.
  */
 
 #include <rthw.h>
@@ -157,23 +158,103 @@ rt_inline int _serial_int_tx(struct rt_serial_device *serial, const rt_uint8_t *
     return size - length;
 }
 
+/**
+ * Calculate DMA received data length.
+ *
+ * @param serial serial device
+ *
+ * @return length
+ */
+static rt_size_t rt_dma_calc_recved_len(struct rt_serial_device *serial) {
+    static rt_size_t rx_length;
+    struct rt_serial_rx_fifo *rx_fifo = (struct rt_serial_rx_fifo *)serial->serial_rx;
+
+    RT_ASSERT(rx_fifo != RT_NULL);
+
+    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));
+    return rx_length;
+}
+
+/**
+ * Read data finish by DMA mode then update the gut index for receive fifo.
+ *
+ * @param serial serial device
+ * @param len get data length for this operate
+ */
+static void rt_dma_recv_update_get_index(struct rt_serial_device *serial, rt_size_t len) {
+    struct rt_serial_rx_fifo *rx_fifo = (struct rt_serial_rx_fifo *)serial->serial_rx;
+
+    RT_ASSERT(rx_fifo != RT_NULL);
+    RT_ASSERT(len <= rt_dma_calc_recved_len(serial));
+
+    rx_fifo->get_index += len;
+    if (rx_fifo->get_index > serial->config.bufsz ) {
+        rx_fifo->get_index -= serial->config.bufsz;
+    }
+}
+
+/**
+ * DMA received finish then update put index for receive fifo.
+ *
+ * @param serial serial device
+ * @param len received length for this transmit
+ */
+static void rt_dma_recv_update_put_index(struct rt_serial_device *serial, rt_size_t len) {
+    struct rt_serial_rx_fifo *rx_fifo = (struct rt_serial_rx_fifo *)serial->serial_rx;
+    rt_size_t i;
+
+    RT_ASSERT(rx_fifo != RT_NULL);
+
+    if (rx_fifo->get_index <= rx_fifo->put_index) {
+        rx_fifo->put_index += len;
+        /* beyond the fifo end */
+        if (rx_fifo->put_index >= serial->config.bufsz) {
+            for (i = 0; i <= len / serial->config.bufsz; i++) {
+                rx_fifo->put_index -= serial->config.bufsz;
+            }
+            /* force overwrite get index */
+            if (rx_fifo->put_index >= rx_fifo->get_index) {
+                rx_fifo->get_index = rx_fifo->put_index + 1;
+            }
+        }
+    } else {
+        rx_fifo->put_index += len;
+        if(rx_fifo->put_index >= rx_fifo->get_index) {
+            /* beyond the fifo end */
+            if(rx_fifo->put_index >= serial->config.bufsz) {
+                for (i = 0; i <= len / serial->config.bufsz; i++) {
+                    rx_fifo->put_index -= serial->config.bufsz;
+                }
+            }
+            /* force overwrite get index */
+            rx_fifo->get_index = rx_fifo->put_index + 1;
+        }
+    }
+}
+
 /*
  * Serial DMA routines
  */
 rt_inline int _serial_dma_rx(struct rt_serial_device *serial, rt_uint8_t *data, int length)
 {
     rt_base_t level;
+
+    RT_ASSERT((serial != RT_NULL) && (data != RT_NULL));
+
+    level = rt_hw_interrupt_disable();
+
+    if (serial->config.bufsz == 0) {
         int result = RT_EOK;
         struct rt_serial_rx_dma *rx_dma;
 
-    RT_ASSERT((serial != RT_NULL) && (data != RT_NULL));
         rx_dma = (struct rt_serial_rx_dma*)serial->serial_rx;
         RT_ASSERT(rx_dma != RT_NULL);
 
-    level = rt_hw_interrupt_disable();
         if (rx_dma->activated != RT_TRUE)
         {
             rx_dma->activated = RT_TRUE;
+            RT_ASSERT(serial->ops->dma_transmit != RT_NULL);
             serial->ops->dma_transmit(serial, data, length, RT_SERIAL_DMA_RX);
         }
         else result = -RT_EBUSY;
@@ -183,6 +264,30 @@ rt_inline int _serial_dma_rx(struct rt_serial_device *serial, rt_uint8_t *data,
 
         rt_set_errno(result);
         return 0;
+    } else {
+        struct rt_serial_rx_fifo *rx_fifo = (struct rt_serial_rx_fifo *) serial->serial_rx;
+        rt_size_t recv_len = 0, fifo_recved_len = rt_dma_calc_recved_len(serial);
+
+        RT_ASSERT(rx_fifo != RT_NULL);
+
+        if (length < fifo_recved_len) {
+            recv_len = length;
+        } else {
+            recv_len = fifo_recved_len;
+        }
+
+        if (rx_fifo->get_index + recv_len < serial->config.bufsz) {
+            rt_memcpy(data, rx_fifo->buffer + rx_fifo->get_index, recv_len);
+        } else {
+            rt_memcpy(data, rx_fifo->buffer + rx_fifo->get_index,
+                    serial->config.bufsz - rx_fifo->get_index);
+            rt_memcpy(data + serial->config.bufsz - rx_fifo->get_index, rx_fifo->buffer,
+                    recv_len + rx_fifo->get_index - serial->config.bufsz);
+        }
+        rt_dma_recv_update_get_index(serial, recv_len);
+        rt_hw_interrupt_enable(level);
+        return recv_len;
+    }
 }
 
 rt_inline int _serial_dma_tx(struct rt_serial_device *serial, const rt_uint8_t *data, int length)
@@ -203,7 +308,7 @@ rt_inline int _serial_dma_tx(struct rt_serial_device *serial, const rt_uint8_t *
             rt_hw_interrupt_enable(level);
 
             /* make a DMA transfer */
-            serial->ops->dma_transmit(serial, data, length, RT_SERIAL_DMA_TX);
+            serial->ops->dma_transmit(serial, (rt_uint8_t *)data, length, RT_SERIAL_DMA_TX);
         }
         else
         {
@@ -267,6 +372,7 @@ static rt_err_t rt_serial_open(struct rt_device *dev, rt_uint16_t oflag)
     {
         if (oflag & RT_DEVICE_FLAG_DMA_RX)
         {
+            if (serial->config.bufsz == 0) {
                 struct rt_serial_rx_dma* rx_dma;
 
                 rx_dma = (struct rt_serial_rx_dma*) rt_malloc (sizeof(struct rt_serial_rx_dma));
@@ -274,6 +380,20 @@ static rt_err_t rt_serial_open(struct rt_device *dev, rt_uint16_t oflag)
                 rx_dma->activated = RT_FALSE;
 
                 serial->serial_rx = rx_dma;
+            } else {
+                struct rt_serial_rx_fifo* rx_fifo;
+
+                rx_fifo = (struct rt_serial_rx_fifo*) rt_malloc (sizeof(struct rt_serial_rx_fifo) +
+                    serial->config.bufsz);
+                RT_ASSERT(rx_fifo != RT_NULL);
+                rx_fifo->buffer = (rt_uint8_t*) (rx_fifo + 1);
+                rt_memset(rx_fifo->buffer, 0, serial->config.bufsz);
+                rx_fifo->put_index = 0;
+                rx_fifo->get_index = 0;
+                serial->serial_rx = rx_fifo;
+                /* configure fifo address and length to low level device */
+                serial->ops->control(serial, RT_DEVICE_CTRL_CONFIG, (void *) RT_DEVICE_FLAG_DMA_RX);
+            }
             dev->open_flag |= RT_DEVICE_FLAG_DMA_RX;
         }
         else if (oflag & RT_DEVICE_FLAG_INT_RX)
@@ -362,12 +482,23 @@ static rt_err_t rt_serial_close(struct rt_device *dev)
     }
     else if (dev->open_flag & RT_DEVICE_FLAG_DMA_RX)
     {
+        if (serial->config.bufsz == 0) {
             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_rx;
             RT_ASSERT(rx_dma != RT_NULL);
 
             rt_free(rx_dma);
+        } else {
+            struct rt_serial_rx_fifo* rx_fifo;
+
+            rx_fifo = (struct rt_serial_rx_fifo*)serial->serial_rx;
+            RT_ASSERT(rx_fifo != RT_NULL);
+
+            rt_free(rx_fifo);
+        }
+        /* configure low level device */
+        serial->ops->control(serial, RT_DEVICE_CTRL_CLR_INT, (void *) RT_DEVICE_FLAG_DMA_RX);
         serial->serial_rx = RT_NULL;
         dev->open_flag &= ~RT_DEVICE_FLAG_DMA_RX;
     }
@@ -376,7 +507,7 @@ static rt_err_t rt_serial_close(struct rt_device *dev)
     {
         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_tx;
         RT_ASSERT(tx_fifo != RT_NULL);
 
         rt_free(tx_fifo);
@@ -590,7 +721,7 @@ void rt_hw_serial_isr(struct rt_serial_device *serial, int event)
             {
                 /* transmit next data node */
                 tx_dma->activated = RT_TRUE;
-                serial->ops->dma_transmit(serial, data_ptr, data_size, RT_SERIAL_DMA_TX);
+                serial->ops->dma_transmit(serial, (rt_uint8_t *)data_ptr, data_size, RT_SERIAL_DMA_TX);
             }
             else
             {
@@ -607,13 +738,27 @@ void rt_hw_serial_isr(struct rt_serial_device *serial, int event)
         case RT_SERIAL_EVENT_RX_DMADONE:
         {
             int length;
+
+            /* get DMA rx length */
+            length = (event & (~0xff)) >> 8;
+
+            if (serial->config.bufsz == 0) {
                 struct rt_serial_rx_dma* rx_dma;
 
                 rx_dma = (struct rt_serial_rx_dma*)serial->serial_rx;
-            /* get DMA rx length */
+                RT_ASSERT(rx_dma != RT_NULL);
-            length = (event & (~0xff)) >> 8;
+
+                RT_ASSERT(serial->parent.rx_indicate != RT_NULL);
                 serial->parent.rx_indicate(&(serial->parent), length);
                 rx_dma->activated = RT_FALSE;
+            } else {
+                /* update fifo put index */
+                rt_dma_recv_update_put_index(serial, length);
+                /* invoke callback */
+                if (serial->parent.rx_indicate != RT_NULL) {
+                    serial->parent.rx_indicate(&(serial->parent), rt_dma_calc_recved_len(serial));
+                }
+            }
             break;
         }
     }