5 bsp中stm32串口dma接收

发布于 2021-07-13 09:47:08 浏览：1350 订阅该版

rtt关于stm32的bsp，不支持dma接收吗？
分析过程如下：
```c
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;

rx_dma = (struct rt_serial_rx_dma*)serial->serial_rx;
        RT_ASSERT(rx_dma != RT_NULL);

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;
        rt_hw_interrupt_enable(level);

if (result == RT_EOK) return length;

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 < (int)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;
    }
}
```
上述代码，当bufsz==0，则dma直接将数据拷贝到用户buf，如果bufsz != 0,则从接收fifo拷贝数据。但是：

问题1：bufsz!=0时候，第一次dma传输的发起是从哪里发起的呢？

另外，当bufsz==0时候，调用了
`serial->ops->dma_transmit(serial, data, length, RT_SERIAL_DMA_RX);`
提供的驱动如下:
```c
static rt_size_t stm32_dma_transmit(struct rt_serial_device *serial, rt_uint8_t *buf, rt_size_t size, int direction)
{
    struct stm32_uart *uart;
    RT_ASSERT(serial != RT_NULL);
    RT_ASSERT(buf != RT_NULL);
    uart = rt_container_of(serial, struct stm32_uart, serial);

if (size == 0)
    {
        return 0;
    }

if (RT_SERIAL_DMA_TX == direction)
    {
        if (HAL_UART_Transmit_DMA(&uart->handle, buf, size) == HAL_OK)
        {
            return size;
        }
        else
        {
            return 0;
        }
    }
    return 0;
}
```
并没有关于RT_SERIAL_DMA_RX这种情况的处理，所以

问题2：这个stm32 bsp的串口驱动程序是不是还没有完全支持dma接收呢？

123 认证专家 2021-07-13

这家伙很懒，什么也没写！

先说结论，是支持的。

_serial_dma_rx 里面调用了serial->ops->dma_transmit(serial, data, length, RT_SERIAL_DMA_RX);
其实这个只是一个标志，真正对接到底层驱动时候，由于DMA接收是在中断中完成的，不是主动接收的，所以这个接口`stm32_dma_transmit` 并没有用到`RT_SERIAL_DMA_RX`这个标志。真正接收的地方是这三个中断里：
```c
1. IDLE中断
uart_isr()
{
#ifdef RT_SERIAL_USING_DMA
    else if ((uart->uart_dma_flag) && (__HAL_UART_GET_FLAG(&(uart->handle), UART_FLAG_IDLE) != RESET)
             && (__HAL_UART_GET_IT_SOURCE(&(uart->handle), UART_IT_IDLE) != RESET))
    {
        level = rt_hw_interrupt_disable();
        recv_total_index = serial->config.bufsz - __HAL_DMA_GET_COUNTER(&(uart->dma_rx.handle));
        recv_len = recv_total_index - uart->dma_rx.last_index;
        uart->dma_rx.last_index = recv_total_index;
        rt_hw_interrupt_enable(level);

if (recv_len)
        {
            rt_hw_serial_isr(serial, RT_SERIAL_EVENT_RX_DMADONE | (recv_len << 8));
        }
        __HAL_UART_CLEAR_IDLEFLAG(&uart->handle);
    }
}

2. 接收完成回调
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)；

3. 接收半完成回调
void HAL_UART_RxHalfCpltCallback(UART_HandleTypeDef *huart)；
```

最后的数据处理是在 `rt_hw_serial_isr` 的 `RT_SERIAL_EVENT_RX_DMADONE` 里面进行的。

arminker 2021-07-13

这家伙很懒，什么也没写！

我个人认为你的回答，只是针对bufsz ！= 0 的情形，我刚刚也发现了，这种情况下，`rt_serial_open`的时候判断`oflag`为`RT_DEVICE_FLAG_DMA_RX`，然后判断`bufsz！=0`，则分配fifo，然后通过`serial->ops->control`发起了dma传输，dma传输完成或者半完成，则将数据拷贝到fifo，调用接收完成函数给应用线程发消息处理数据。代码如下：
```c
// ----------------rt_serial_open函数中：------------------------------
        else 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));
                RT_ASSERT(rx_dma != RT_NULL);
                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;
                rx_fifo->is_full = RT_FALSE;
                serial->serial_rx = rx_fifo;
                /* configure fifo address and length to low level device */
                
                // -----------------这一句发起了dma传输-------------------
                serial->ops->control(serial, RT_DEVICE_CTRL_CONFIG, (void *) RT_DEVICE_FLAG_DMA_RX);
            }
```
关于 serial->ops->control，在drv_usart中如下：
```c
// --------------------stm32_control中有如下代码-----------------------
    case RT_DEVICE_CTRL_CONFIG:
        stm32_dma_config(serial, ctrl_arg);
        break;
```
在stm32_dma_config中的确发起了dma传输，代码如下：
```
    if (flag == RT_DEVICE_FLAG_DMA_RX)
    {
        rx_fifo = (struct rt_serial_rx_fifo *)serial->serial_rx;
        /* Start DMA transfer */
        // ------------------启动dma传输------------------
        if (HAL_UART_Receive_DMA(&(uart->handle), rx_fifo->buffer, serial->config.bufsz) != HAL_OK)
        {
            /* Transfer error in reception process */
            RT_ASSERT(0);
        }
        CLEAR_BIT(uart->handle.Instance->CR3, USART_CR3_EIE);
        __HAL_UART_ENABLE_IT(&(uart->handle), UART_IT_IDLE);
    }
```

---

好了，回到`bufsz=0`的情况，发起传输的语句为：
`rt_serial_read`中的这句话，如下所示：
```c
#ifdef RT_SERIAL_USING_DMA
    else if (dev->open_flag & RT_DEVICE_FLAG_DMA_RX)
    {
        return _serial_dma_rx(serial, (rt_uint8_t *)buffer, size);
    }
```
在_serial_dma_rx中发起传输
```c
    if (serial->config.bufsz == 0)
    {
        int result = RT_EOK;
        struct rt_serial_rx_dma *rx_dma;

rx_dma = (struct rt_serial_rx_dma*)serial->serial_rx;
        RT_ASSERT(rx_dma != RT_NULL);

if (rx_dma->activated != RT_TRUE)
        {
            rx_dma->activated = RT_TRUE;
            RT_ASSERT(serial->ops->dma_transmit != RT_NULL);
            //----------------发起传输----------------------------
            //----------------但是dma_transmit的具体实现，没有对RT_SERIAL_DMA_RX标记的处理
            serial->ops->dma_transmit(serial, data, length, RT_SERIAL_DMA_RX);
        }
        else result = -RT_EBUSY;
        rt_hw_interrupt_enable(level);

if (result == RT_EOK) return length;

rt_set_errno(result);
        return 0;
    }
```

123 2021-07-13

这家伙很懒，什么也没写！

@RongLiu  楼主很细心哈，也分析的是有道理的，不过目前用dma的时候都要使用bufsz的。当 bufsz = 0 时候，也就是代表串口框架里面没有接收缓冲区，那么DMA_RX的模式下，是肯定需要接收缓冲区的 (DMA接收嘛，是外设到缓冲区传输，肯定需要定义缓冲区)，**所以这个缓冲区就得让用户去实现了**，（这个有些类似 DMA发送无缓冲区配置时 的情况），你也可以再结合这个 `rt_hw_serial_isr`代码去分析bufsz=0时候的处理逻辑，
```c
rt_hw_serial_isr()
{
case RT_SERIAL_EVENT_RX_DMADONE:
{
    int length;
    rt_base_t level;

/* 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;
        RT_ASSERT(rx_dma != RT_NULL);

RT_ASSERT(serial->parent.rx_indicate != RT_NULL);
        serial->parent.rx_indicate(&(serial->parent), length);
        rx_dma->activated = RT_FALSE;
    }
}
```
这段代码很简单，就是dma接收到数据后，把数据长度传给串口接收回调`rx_indicate`就结束了。所以数据缓冲区都是用户定义即可，这样的话，会发现其实当bufsz=0的时候，用dma接收不太方便，因此后边都是使用带buffsz的场景。（也可以换句话说，更果断一点的解释：使用dma接收时，为什么没有缓冲区呢，这个肯定是要有的）
另外你也可以看一下，RTT官方有[串口V2版本的串口框架](https://www.rt-thread.org/document/site/#/rt-thread-version/rt-thread-standard/programming-manual/device/uart/uart_v2/uart)，里面的DMA接收传输时，一定一定要有串口缓冲区，串口框架是给用户提供通用型的上层应用的便利的，而不是为用户去节省那些无法省去的内存占用, 更何况这个资源占用也就几十字节而已。