bsp: k230: add dma support to the i2c driver

1. add dma support to the I2C driver to improve efficiency.

Signed-off-by: Ze-Hou <yingkezhou@qq.com>

bsp/k230/.ci/attachconfig/ci.attachconfig.yml

@@ -13,6 +13,7 @@ devices.i2c:
       - CONFIG_RT_USING_I2C=y
       - CONFIG_BSP_USING_I2C=y
       - CONFIG_BSP_USING_I2C0=y
+      - CONFIG_BSP_USING_I2C_DMA=y
 devices.adc:
     <<: *scons
     kconfig:

bsp/k230/.config

@@ -941,7 +941,6 @@ CONFIG_RT_USING_VDSO=y
 # CONFIG_PKG_USING_R_RHEALSTONE is not set
 # CONFIG_PKG_USING_HEARTBEAT is not set
 # CONFIG_PKG_USING_MICRO_ROS_RTTHREAD_PACKAGE is not set
-# CONFIG_PKG_USING_CHERRYECAT is not set
 # end of system packages
 
 #
@@ -1099,12 +1098,6 @@ CONFIG_RT_USING_VDSO=y
 # CONFIG_PKG_USING_GD32_ARM_CMSIS_DRIVER is not set
 # CONFIG_PKG_USING_GD32_ARM_SERIES_DRIVER is not set
 # end of GD32 Drivers
-
-#
-# HPMicro SDK
-#
-# CONFIG_PKG_USING_HPM_SDK is not set
-# end of HPMicro SDK
 # end of HAL & SDK Drivers
 
 #

bsp/k230/board/Kconfig

@@ -32,6 +32,10 @@ menu "Drivers Configuration"
         default n
 
         if BSP_USING_I2C
+            config BSP_USING_I2C_DMA
+                bool "Enable I2C with DMA"
+                default n
+
             config BSP_USING_I2C0
                 bool "Enable I2C0"
                 default n

bsp/k230/drivers/interdrv/i2c/drv_i2c.c

@@ -33,9 +33,11 @@
 #include <rtdevice.h>
 #include <riscv_io.h>
 #include <ioremap.h>
+#include <mmu.h>
 #include "board.h"
 #include "drv_i2c.h"
 #include "sysctl_clk.h"
+#include "drv_pdma.h"
 
 #undef DBG_TAG
 #undef DBG_LVL
@@ -43,6 +45,42 @@
 #define DBG_LVL     DBG_INFO
 #include <rtdbg.h>
 
+/*
+ * Note:
+ * - When DMA is enabled, the PDMA driver requires both the address and
+ *   data to be 4-byte aligned.(Address alignment is handled internally
+ *   by this driver, so application developers do not need to worry about
+ *   address alignment.) Therefore, when using DMA for read/write operations,
+ *   if the data size is not 4-byte aligned, even with DMA enabled, the driver
+ *   will actually use CPU polling for read/write. Application code should be
+ *   aware of this and handle it accordingly. For example, if the data length
+ *   to be read or written is not 4-byte aligned, you can split the data into
+ *   an aligned part and an unaligned part, use DMA for the aligned part, and
+ *   use CPU polling for the unaligned part.
+ */
+
+#ifdef BSP_USING_I2C_DMA
+
+#define K230_I2C_PDMA_CH_INVALID        0xFF
+#define K230_I2C_PDMA_CACHE_LINE_SIZE   64
+
+struct _i2c_pdma_cfg
+{
+    rt_event_t event;
+    rt_uint8_t ch;
+    usr_pdma_cfg_t cfg;
+    device_sel_e tx_dev;
+    device_sel_e rx_dev;
+};
+
+typedef enum
+{
+    K230_I2C_PDMA_EVENT_NONE = 0x00,
+    K230_I2C_PDMA_EVENT_COMPLETE = 0x01,
+    K230_I2C_PDMA_EVENT_TIMEOUT = 0x02,
+} k230_i2c_pdma_event_t;
+#endif
+
 struct _i2c_speed_cfg
 {
     rt_uint16_t hcnt;
@@ -55,13 +93,22 @@ struct k230_i2c_dev
     struct rt_i2c_bus_device dev;
     const char *name;
     rt_ubase_t base;
+    rt_ubase_t base_pa;
     size_t size;
     int vector;
     rt_uint32_t clock;
     struct rt_i2c_msg *msg;
     struct _i2c_speed_cfg speed_cfg;
+#ifdef BSP_USING_I2C_DMA
+    struct _i2c_pdma_cfg pdma_cfg;
+#endif
 };
 
+#ifdef BSP_USING_I2C_DMA
+static rt_err_t k230_i2c_pdma_read(struct k230_i2c_dev *dev);
+static rt_err_t k230_i2c_pdma_write(struct k230_i2c_dev *dev);
+#endif
+
 static rt_size_t k230_i2c_get_timer(rt_size_t base)
 {
     return rt_tick_get() - base ;
@@ -76,7 +123,7 @@ static void k230_i2c_enable(struct k230_i2c_dev *dev, rt_bool_t enable)
     do
     {
         i2c->enable.enable = en_value;
-        if(i2c->enable_status.en == en_value)
+        if (i2c->enable_status.en == en_value)
         {
             return;
         }
@@ -87,7 +134,7 @@ static void k230_i2c_enable(struct k230_i2c_dev *dev, rt_bool_t enable)
          * 25us) as described in the DesignWare I2C databook.
          */
         rt_hw_us_delay(25);
-    }while(timeout--);
+    } while(timeout--);
 
     LOG_E("timeout in %s i2c\n", enable ? "enable" : "disable");
 }
@@ -120,15 +167,15 @@ static int k230_i2c_set_bus_speed(struct k230_i2c_dev *dev, rt_uint32_t speed)
     dev->speed_cfg.hcnt = period - dev->speed_cfg.lcnt;
     dev->speed_cfg.spklen = spklen;
 
-    if(speed <= I2C_STANDARD_SPEED_UP)
+    if (speed <= I2C_STANDARD_SPEED_UP)
     {
         i2c_spd = I2C_SPEED_MODE_STANDARD;
     }
-    else if(speed <= I2C_FAST_SPEED_UP)
+    else if (speed <= I2C_FAST_SPEED_UP)
     {
         i2c_spd = I2C_SPEED_MODE_FAST;
     }
-    else if(speed <= I2C_MAX_SPEED_UP)
+    else if (speed <= I2C_MAX_SPEED_UP)
     {
         i2c_spd = I2C_SPEED_MODE_MAX;
     }
@@ -140,7 +187,7 @@ static int k230_i2c_set_bus_speed(struct k230_i2c_dev *dev, rt_uint32_t speed)
     /* to set speed cltr must be disabled */
     k230_i2c_enable(dev, RT_FALSE);
 
-    switch(i2c_spd)
+    switch (i2c_spd)
     {
         case I2C_SPEED_MODE_STANDARD:
             i2c->ss_ufm_scl_hcnt.cnt = dev->speed_cfg.hcnt;
@@ -179,7 +226,7 @@ static void k230_i2c_set_addr(struct k230_i2c_dev *dev)
     /* Disable i2c */
     k230_i2c_enable(dev, RT_FALSE);
 
-    if(dev->msg->flags & RT_I2C_ADDR_10BIT || dev->dev.flags & RT_I2C_ADDR_10BIT)
+    if (dev->msg->flags & RT_I2C_ADDR_10BIT || dev->dev.flags & RT_I2C_ADDR_10BIT)
     {
         i2c->tar.master_10bit_addr = 1;
         i2c_addr &= 0x3FF;
@@ -200,7 +247,7 @@ static void k230_i2c_flush_rxfifo(struct k230_i2c_dev *dev)
 {
     volatile i2c_t *i2c = (i2c_t *)dev->base;
 
-    while(i2c->status.rfne)
+    while (i2c->status.rfne)
     {
         readl(&i2c->data_cmd);
     }
@@ -211,10 +258,10 @@ static int k230_i2c_wait_for_bus_busy(struct k230_i2c_dev *dev)
     rt_size_t start_time = k230_i2c_get_timer(0);
     volatile i2c_t *i2c = (i2c_t *)dev->base;
 
-    while((i2c->status.mst_activity) || !(i2c->status.tfe))
+    while ((i2c->status.mst_activity) || !(i2c->status.tfe))
     {
         /* Evaluate timeout */
-        if(k230_i2c_get_timer(start_time) > (rt_size_t)dev->dev.timeout * I2C_TX_FIFO_SIZE)
+        if (k230_i2c_get_timer(start_time) > (rt_size_t)dev->dev.timeout * I2C_TX_FIFO_SIZE)
         {
             return -RT_ETIMEOUT;
         }
@@ -226,9 +273,8 @@ static int k230_i2c_wait_for_bus_busy(struct k230_i2c_dev *dev)
 static int k230_i2c_xfer_init(struct k230_i2c_dev *dev)
 {
     volatile i2c_t *i2c = (i2c_t *)dev->base;
-    rt_uint8_t addr = 0;
 
-    if(k230_i2c_wait_for_bus_busy(dev) != RT_EOK)
+    if (k230_i2c_wait_for_bus_busy(dev) != RT_EOK)
     {
         return -RT_EBUSY;
     }
@@ -245,7 +291,7 @@ static int k230_i2c_xfer_finish(struct k230_i2c_dev *dev)
 
     while (1)
     {
-        if(i2c->raw_intr_stat.stop_det)
+        if (i2c->raw_intr_stat.stop_det)
         {
             readl(&i2c->clr_stop_det);
             break;
@@ -267,8 +313,15 @@ static int k230_i2c_xfer_finish(struct k230_i2c_dev *dev)
     return RT_EOK;
 }
 
-static int _k230_i2c_read(struct k230_i2c_dev *dev)
+static int k230_i2c_read(struct k230_i2c_dev *dev)
 {
+#ifdef BSP_USING_I2C_DMA
+    if (dev->msg->len % 4 == 0)
+    {
+        return k230_i2c_pdma_read(dev);
+    }
+#endif
+
     volatile i2c_t *i2c = (i2c_t *)dev->base;
     rt_size_t start_time_rx = 0;
     rt_uint32_t recv_len = dev->msg->len;
@@ -277,24 +330,24 @@ static int _k230_i2c_read(struct k230_i2c_dev *dev)
     rt_uint32_t cmd = 0;
 
     /* If no start condition is sent before reading, then send a repeated start. */
-    if(dev->msg->flags & RT_I2C_NO_START)
+    if (dev->msg->flags & RT_I2C_NO_START)
     {
         cmd |= I2C_DATA_CMD_RESTART;
     }
     else
     {
-        if(k230_i2c_xfer_init(dev) != RT_EOK)
+        if (k230_i2c_xfer_init(dev) != RT_EOK)
         {
             return -RT_EBUSY;
         }
     }
 
     start_time_rx = k230_i2c_get_timer(0);
-    while(recv_len || tran_len)
+    while (recv_len || tran_len)
     {
         if (tran_len)
         {
-            while(i2c->status.tfnf == 0);
+            while (i2c->status.tfnf == 0);
             /* Write stop when the last byte */
             cmd = tran_len == 1 ? cmd | I2C_DATA_CMD_STOP : cmd;
             /* Write to data cmd register to trigger i2c */
@@ -303,13 +356,13 @@ static int _k230_i2c_read(struct k230_i2c_dev *dev)
             tran_len--;
         }
 
-        if(i2c->status.rfne)
+        if (i2c->status.rfne)
         {
             *buffer++ = i2c->data_cmd.dat;
             recv_len--;
             start_time_rx = k230_i2c_get_timer(0);
         }
-        else if(k230_i2c_get_timer(start_time_rx) > dev->dev.timeout)
+        else if (k230_i2c_get_timer(start_time_rx) > dev->dev.timeout)
         {
             return -RT_ETIMEOUT;
         }
@@ -317,14 +370,20 @@ static int _k230_i2c_read(struct k230_i2c_dev *dev)
     return k230_i2c_xfer_finish(dev);
 }
 
-static int _k230_i2c_write(struct k230_i2c_dev *dev)
+static int k230_i2c_write(struct k230_i2c_dev *dev)
 {
+#ifdef BSP_USING_I2C_DMA
+    if (dev->msg->len % 4 == 0)
+    {
+        return k230_i2c_pdma_write(dev);
+    }
+#endif
+
     volatile i2c_t *i2c = (i2c_t *)dev->base;
     rt_size_t start_time_tx = 0;
     rt_uint32_t tran_len = dev->msg->len;
     rt_uint8_t *buffer = dev->msg->buf;
     rt_uint32_t cmd = 0;
-    rt_uint32_t cut = 0;
 
     if (k230_i2c_xfer_init(dev) != RT_EOK)
     {
@@ -332,12 +391,12 @@ static int _k230_i2c_write(struct k230_i2c_dev *dev)
     }
 
     start_time_tx = k230_i2c_get_timer(0);
-    while(tran_len)
+    while (tran_len)
     {
-        if(i2c->status.tfnf)
+        if (i2c->status.tfnf)
         {
             /* If there is no stop flag, the stop condition will not be sent at the last byte. */
-            if(tran_len == 1 && !(dev->msg->flags & RT_I2C_NO_STOP))
+            if (tran_len == 1 && !(dev->msg->flags & RT_I2C_NO_STOP))
             {
                 cmd |= I2C_DATA_CMD_STOP;
             }
@@ -351,7 +410,7 @@ static int _k230_i2c_write(struct k230_i2c_dev *dev)
             tran_len--;
             start_time_tx = k230_i2c_get_timer(0);
         }
-        else if(k230_i2c_get_timer(start_time_tx) > dev->dev.timeout)
+        else if (k230_i2c_get_timer(start_time_tx) > dev->dev.timeout)
         {
             return -RT_ETIMEOUT;
         }
@@ -381,14 +440,15 @@ static rt_ssize_t k230_i2c_xfer(struct rt_i2c_bus_device *bus, struct rt_i2c_msg
     {
         i2c_dev->msg = msgs;
 
-        if(msgs->flags & RT_I2C_RD)
+        if (msgs->flags & RT_I2C_RD)
         {
-            ret = _k230_i2c_read(i2c_dev);
+            ret = k230_i2c_read(i2c_dev);
         }
         else
         {
-            ret = _k230_i2c_write(i2c_dev);
+            ret = k230_i2c_write(i2c_dev);
         }
+
         if (ret != RT_EOK)
         {
             return -RT_EIO;
@@ -410,7 +470,7 @@ static rt_err_t k230_i2c_control(struct rt_i2c_bus_device *bus, int cmd, void *a
     {
         /* set 10-bit addr mode */
         case RT_I2C_DEV_CTRL_10BIT:
-            if(arg & RT_I2C_ADDR_10BIT)
+            if (arg & RT_I2C_ADDR_10BIT)
             {
                 i2c_dev->dev.flags |= RT_I2C_ADDR_10BIT;
             }
@@ -467,52 +527,372 @@ static struct k230_i2c_dev k230_i2c_devs[] =
 #ifdef BSP_USING_I2C0
     {
         .name = "i2c0",
-        .base = I2C0_BASE_ADDR,
+        .base_pa = I2C0_BASE_ADDR,
         .size = I2C0_IO_SIZE,
         .vector = K230_IRQ_I2C0,
+#ifdef BSP_USING_I2C_DMA
+        .pdma_cfg.tx_dev = I2C0_TX,
+        .pdma_cfg.rx_dev = I2C0_RX,
+#endif
     },
 #endif
 #ifdef BSP_USING_I2C1
     {
         .name = "i2c1",
-        .base = I2C1_BASE_ADDR,
+        .base_pa = I2C1_BASE_ADDR,
         .size = I2C1_IO_SIZE,
         .vector = K230_IRQ_I2C1,
+#ifdef BSP_USING_I2C_DMA
+        .pdma_cfg.tx_dev = I2C1_TX,
+        .pdma_cfg.rx_dev = I2C1_RX,
+#endif
     },
 #endif
 #ifdef BSP_USING_I2C2
     {
         .name = "i2c2",
-        .base = I2C2_BASE_ADDR,
+        .base_pa = I2C2_BASE_ADDR,
         .size = I2C2_IO_SIZE,
         .vector = K230_IRQ_I2C2,
+#ifdef BSP_USING_I2C_DMA
+        .pdma_cfg.tx_dev = I2C2_TX,
+        .pdma_cfg.rx_dev = I2C2_RX,
+#endif
     },
 #endif
 #ifdef BSP_USING_I2C3
     {
         .name = "i2c3",
-        .base = I2C3_BASE_ADDR,
+        .base_pa = I2C3_BASE_ADDR,
         .size = I2C3_IO_SIZE,
         .vector = K230_IRQ_I2C3,
+#ifdef BSP_USING_I2C_DMA
+        .pdma_cfg.tx_dev = I2C3_TX,
+        .pdma_cfg.rx_dev = I2C3_RX,
+#endif
     },
 #endif
 #ifdef BSP_USING_I2C4
     {
         .name = "i2c4",
-        .base = I2C4_BASE_ADDR,
+        .base_pa = I2C4_BASE_ADDR,
         .size = I2C4_IO_SIZE,
         .vector = K230_IRQ_I2C4,
+#ifdef BSP_USING_I2C_DMA
+        .pdma_cfg.tx_dev = I2C4_TX,
+        .pdma_cfg.rx_dev = I2C4_RX,
+#endif
     },
 #endif
 };
 
+#ifdef BSP_USING_I2C_DMA
+static void k230_i2c_pdma_call_back(rt_uint8_t ch, rt_bool_t is_done)
+{
+    k230_i2c_pdma_event_t event_type = is_done ? K230_I2C_PDMA_EVENT_COMPLETE : K230_I2C_PDMA_EVENT_TIMEOUT;
+    for (rt_uint8_t i = 0; i < sizeof(k230_i2c_devs)/sizeof(k230_i2c_devs[0]); i++)
+    {
+        struct k230_i2c_dev *dev = &k230_i2c_devs[i];
+        if (dev->pdma_cfg.event != RT_NULL && dev->pdma_cfg.ch == ch && dev->pdma_cfg.ch != K230_I2C_PDMA_CH_INVALID)
+        {
+            rt_event_send(dev->pdma_cfg.event, event_type);
+            return;
+        }
+    }
+}
+
+static void k230_i2c_pdma_cleanup(struct k230_i2c_dev *dev)
+{
+    rt_uint8_t ch = dev->pdma_cfg.ch;
+
+    if (ch == K230_I2C_PDMA_CH_INVALID)
+    {
+        return;
+    }
+
+    dev->pdma_cfg.ch = K230_I2C_PDMA_CH_INVALID;
+    k230_pdma_release_channel(ch);
+}
+
+static rt_err_t k230_i2c_pdma_read(struct k230_i2c_dev *dev)
+{
+    volatile i2c_t *i2c = (i2c_t *)dev->base;
+    rt_uint8_t *buffer = dev->msg->buf;
+    rt_uint8_t *buf;
+    void *buf_pa;
+    rt_err_t err;
+    rt_uint8_t ch;
+    rt_uint32_t recv_event, read_len;
+    rt_size_t start_time_tx = 0;
+    rt_uint32_t cmd = 0;
+
+    err = k230_pdma_request_channel(&ch);
+    if (err != RT_EOK)
+    {
+        LOG_E("i2c pdma request channel failed");
+        return err;
+    }
+    dev->pdma_cfg.ch = ch;
+
+    err = k230_pdma_set_callback(ch, k230_i2c_pdma_call_back);
+    if (err != RT_EOK)
+    {
+        LOG_E("i2c pdma set callback failed");
+        k230_i2c_pdma_cleanup(dev);
+        return err;
+    }
+
+    read_len = dev->msg->len;
+
+    buf = (rt_uint8_t *)rt_malloc_align(read_len, K230_I2C_PDMA_CACHE_LINE_SIZE);
+    if (buf == RT_NULL)
+    {
+        LOG_E("i2c pdma malloc buffer failed");
+        k230_i2c_pdma_cleanup(dev);
+        return -RT_ENOMEM;
+    }
+    buf_pa = rt_kmem_v2p(buf);
+    if (buf_pa == RT_NULL)
+    {
+        LOG_E("i2c pdma get phy addr failed");
+        k230_i2c_pdma_cleanup(dev);
+        rt_free_align(buf);
+        return -RT_ERROR;
+    }
+
+    rt_event_control(dev->pdma_cfg.event, RT_IPC_CMD_RESET, NULL);
+
+    dev->pdma_cfg.cfg.device = dev->pdma_cfg.rx_dev;
+    dev->pdma_cfg.cfg.src_addr = (rt_uint8_t *)(dev->base_pa + 0x10);
+    dev->pdma_cfg.cfg.dst_addr = (rt_uint8_t *)buf_pa;
+    dev->pdma_cfg.cfg.line_size = read_len;
+    dev->pdma_cfg.cfg.pdma_ch_cfg.ch_src_type = FIXED;
+    dev->pdma_cfg.cfg.pdma_ch_cfg.ch_dev_hsize = PSBYTE1;
+    dev->pdma_cfg.cfg.pdma_ch_cfg.ch_dat_endian = PDEFAULT;
+    dev->pdma_cfg.cfg.pdma_ch_cfg.ch_dev_blen = PBURST_LEN_4;
+    dev->pdma_cfg.cfg.pdma_ch_cfg.ch_priority = 7;
+    dev->pdma_cfg.cfg.pdma_ch_cfg.ch_dev_tout = 0xFFF;
+
+    err = k230_pdma_config(ch, &dev->pdma_cfg.cfg);
+    if (err != RT_EOK)
+    {
+        LOG_E("i2c pdma config failed");
+        k230_i2c_pdma_cleanup(dev);
+        rt_free_align(buf);
+        return err;
+    }
+
+    /* If no start condition is sent before reading, then send a repeated start. */
+    if (dev->msg->flags & RT_I2C_NO_START)
+    {
+        cmd |= I2C_DATA_CMD_RESTART;
+    }
+    else
+    {
+        if (k230_i2c_xfer_init(dev) != RT_EOK)
+        {
+            LOG_E("i2c pdma xfer init failed");
+            k230_i2c_pdma_cleanup(dev);
+            rt_free_align(buf);
+            return -RT_EBUSY;
+        }
+    }
+
+    start_time_tx = k230_i2c_get_timer(0);
+    err = k230_pdma_start(ch);
+    if (err != RT_EOK)
+    {
+        LOG_E("i2c pdma start failed");
+        k230_i2c_pdma_cleanup(dev);
+        rt_free_align(buf);
+        return err;
+    }
+
+    for (rt_uint32_t i = 0; i < read_len; i++)
+    {
+        while (i2c->status.tfnf == 0);
+        /* Write stop when the last byte */
+        cmd = i == (read_len - 1) ? I2C_DATA_CMD_STOP : 0;
+        /* Write to data cmd register to trigger i2c */
+        writel(cmd | I2C_DATA_CMD_READ, &i2c->data_cmd);
+        cmd = 0;
+    }
+
+    err = rt_event_recv(dev->pdma_cfg.event,
+                        K230_I2C_PDMA_EVENT_COMPLETE | K230_I2C_PDMA_EVENT_TIMEOUT,
+                        RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR,
+                        RT_WAITING_FOREVER,
+                        &recv_event);
+
+    if (err != RT_EOK || (recv_event & K230_I2C_PDMA_EVENT_TIMEOUT))
+    {
+        LOG_E("i2c pdma read timeout");
+        k230_pdma_stop(ch);
+        k230_i2c_pdma_cleanup(dev);
+        rt_free_align(buf);
+        return -RT_ETIMEOUT;
+    }
+
+    rt_memcpy(buffer, buf, read_len);
+
+    k230_pdma_stop(ch);
+    k230_i2c_pdma_cleanup(dev);
+    rt_free_align(buf);
+
+    if (k230_i2c_get_timer(start_time_tx) > dev->dev.timeout)
+    {
+        return -RT_ETIMEOUT;
+    }
+
+    return k230_i2c_xfer_finish(dev);
+}
+
+static inline rt_uint32_t k230_i2c_make_data_cmd(rt_uint8_t data, rt_uint32_t flags)
+{
+    return (rt_uint32_t)data | flags;
+}
+
+static rt_err_t k230_i2c_pdma_write(struct k230_i2c_dev *dev)
+{
+    volatile i2c_t *i2c = (i2c_t *)dev->base;
+    rt_uint8_t *buffer = dev->msg->buf;
+    rt_uint32_t *buf;
+    void *buf_pa;
+    rt_err_t err;
+    rt_uint8_t ch;
+    rt_uint32_t recv_event, tran_len, flags;
+    rt_size_t start_time_tx = 0;
+
+    err = k230_pdma_request_channel(&ch);
+    if (err != RT_EOK)
+    {
+        LOG_E("i2c pdma request channel failed");
+        return err;
+    }
+    dev->pdma_cfg.ch = ch;
+
+    err = k230_pdma_set_callback(ch, k230_i2c_pdma_call_back);
+    if (err != RT_EOK)
+    {
+        LOG_E("i2c pdma set callback failed");
+        k230_i2c_pdma_cleanup(dev);
+        return err;
+    }
+
+    tran_len = dev->msg->len;
+
+    buf = (rt_uint32_t *)rt_malloc_align(tran_len * sizeof(rt_uint32_t), K230_I2C_PDMA_CACHE_LINE_SIZE);
+    if (buf == RT_NULL)
+    {
+        LOG_E("i2c pdma malloc buffer failed");
+        k230_i2c_pdma_cleanup(dev);
+        return -RT_ENOMEM;
+    }
+    for (rt_uint32_t i = 0; i < tran_len; i++)
+    {
+        flags = 0;
+
+        if (i == (tran_len - 1) && !(dev->msg->flags & RT_I2C_NO_STOP))
+        {
+            flags |= I2C_DATA_CMD_STOP;
+        }
+
+        buf[i] = k230_i2c_make_data_cmd(buffer[i], flags);
+    }
+
+    buf_pa = rt_kmem_v2p(buf);
+    if (buf_pa == RT_NULL)
+    {
+        LOG_E("i2c pdma get phy addr failed");
+        k230_i2c_pdma_cleanup(dev);
+        rt_free_align(buf);
+        return -RT_ERROR;
+    }
+
+    rt_event_control(dev->pdma_cfg.event, RT_IPC_CMD_RESET, NULL);
+
+    dev->pdma_cfg.cfg.device = dev->pdma_cfg.tx_dev;
+    dev->pdma_cfg.cfg.src_addr = (rt_uint8_t *)buf_pa;
+    dev->pdma_cfg.cfg.dst_addr = (rt_uint8_t *)(dev->base_pa + 0x10);
+    dev->pdma_cfg.cfg.line_size = tran_len * sizeof(rt_uint32_t);
+    dev->pdma_cfg.cfg.pdma_ch_cfg.ch_src_type = CONTINUE;
+    dev->pdma_cfg.cfg.pdma_ch_cfg.ch_dev_hsize = PSBYTE4;
+    dev->pdma_cfg.cfg.pdma_ch_cfg.ch_dat_endian = PDEFAULT;
+    dev->pdma_cfg.cfg.pdma_ch_cfg.ch_dev_blen = PBURST_LEN_4;
+    dev->pdma_cfg.cfg.pdma_ch_cfg.ch_priority = 7;
+    dev->pdma_cfg.cfg.pdma_ch_cfg.ch_dev_tout = 0xFFF;
+
+    err = k230_pdma_config(ch, &dev->pdma_cfg.cfg);
+    if (err != RT_EOK)
+    {
+        LOG_E("i2c pdma config failed");
+        k230_i2c_pdma_cleanup(dev);
+        rt_free_align(buf);
+        return err;
+    }
+
+    if (k230_i2c_xfer_init(dev) != RT_EOK)
+    {
+        k230_i2c_pdma_cleanup(dev);
+        rt_free_align(buf);
+        return -RT_EBUSY;
+    }
+
+    start_time_tx = k230_i2c_get_timer(0);
+    err = k230_pdma_start(ch);
+    if (err != RT_EOK)
+    {
+        LOG_E("i2c pdma start failed");
+        k230_i2c_pdma_cleanup(dev);
+        rt_free_align(buf);
+        return err;
+    }
+
+    err = rt_event_recv(dev->pdma_cfg.event,
+                        K230_I2C_PDMA_EVENT_COMPLETE | K230_I2C_PDMA_EVENT_TIMEOUT,
+                        RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR,
+                        RT_WAITING_FOREVER,
+                        &recv_event);
+
+    if (err != RT_EOK || (recv_event & K230_I2C_PDMA_EVENT_TIMEOUT))
+    {
+        LOG_E("i2c pdma write timeout");
+        k230_pdma_stop(ch);
+        k230_i2c_pdma_cleanup(dev);
+        rt_free_align(buf);
+        return -RT_ETIMEOUT;
+    }
+
+    k230_pdma_stop(ch);
+    k230_i2c_pdma_cleanup(dev);
+    rt_free_align(buf);
+
+    if (k230_i2c_get_timer(start_time_tx) > dev->dev.timeout)
+    {
+        return -RT_ETIMEOUT;
+    }
+
+    return RT_EOK;
+}
+
+static void k230_i2c_pdma_init(struct k230_i2c_dev *dev)
+{
+    volatile i2c_t *i2c = (i2c_t *)dev->base;
+
+    i2c->dma_cr.tdmae = 1;
+    i2c->dma_cr.rdmae = 1;
+    i2c->dma_tdlr.dmatdl = 15;
+    i2c->dma_rdlr.dmardl = 3;
+}
+#endif
+
 int rt_hw_i2c_init(void)
 {
     int i;
 
     for (i = 0; i < sizeof(k230_i2c_devs) / sizeof(k230_i2c_devs[0]); i++)
     {
-        k230_i2c_devs[i].base = (rt_ubase_t)rt_ioremap((void *)k230_i2c_devs[i].base, k230_i2c_devs[i].size);
+        k230_i2c_devs[i].base = (rt_ubase_t)rt_ioremap((void *)k230_i2c_devs[i].base_pa, k230_i2c_devs[i].size);
         k230_i2c_devs[i].dev.ops = &k230_i2c_ops;
         k230_i2c_devs[i].clock = sysctl_clk_get_leaf_freq(SYSCTL_CLK_I2C0_CORE + i);
 
@@ -521,6 +901,21 @@ int rt_hw_i2c_init(void)
         k230_i2c_set_bus_speed(&k230_i2c_devs[i], I2C_DEFAULT_SPEED);
         rt_i2c_bus_device_register(&k230_i2c_devs[i].dev, k230_i2c_devs[i].name);
         LOG_I("i2c%d master mode, i2c%d clock=%dHz\n", i, i, k230_i2c_devs[i].clock);
+
+#ifdef BSP_USING_I2C_DMA
+        k230_i2c_pdma_init(&k230_i2c_devs[i]);
+        k230_i2c_devs[i].pdma_cfg.ch = K230_I2C_PDMA_CH_INVALID;
+        k230_i2c_devs[i].pdma_cfg.event = rt_event_create(k230_i2c_devs[i].name, RT_IPC_FLAG_FIFO);
+        if (k230_i2c_devs[i].pdma_cfg.event == RT_NULL)
+        {
+            LOG_E("i2c pdma event(%s) create failed", k230_i2c_devs[i].name);
+            for (int j = 0; j < i; j++)
+            {
+                rt_event_delete(k230_i2c_devs[j].pdma_cfg.event);
+            }
+            return -RT_ENOMEM;
+        }
+#endif
     }
 
     return RT_EOK;

bsp/k230/drivers/utest/test_i2c.c

@@ -48,7 +48,15 @@
  * 1. 测试I2C0主机模式
  *     主机模式下，主机向从机发送16字节数据（不包括写读地址），
  *     然后再读取回来进行校验，共执行两次，分别是400kHz和1MHz速率。
- *     注：使用的从机为AT24C08 EEPROM，设备地址为0x50。
+ *     第一次写数据时，带一字节地址，总共写16字节数据，读取15字节数据，
+ *     第二次写数据时，带一字节地址，总共写17字节数据，读取16字节数据。
+ *     在两次写数据的过程中，如果开启dma功能，第一次会调用dma进行写，
+ *     第二次会调用dma进行读。（前提是BSP_USING_I2C_DMA宏被定义，
+ *     因为pdma要求地址与数据都要4字节对齐（地址的对齐问题会在驱动
+ *     内部处理），若写/读数据大小非4字节对齐，即使启用了dma功能，
+ *     实际也是调用的cpu轮询读写，这一点需要应用程序注意并处理）
+ *     注：使用的从机为AT24C08 EEPROM，设备地址为0x50，
+ *     page size 为 16 字节。
  */
 
 #define I2C_NAME            "i2c0"
@@ -88,12 +96,12 @@ static int test_i2c_check_pin(void)
 {
     test_i2c0_deinit_pin();
 
-    if(kd_pin_read(I2C_SCL_PIN) != 1 || kd_pin_read(I2C_SDA_PIN) != 1)
+    if (kd_pin_read(I2C_SCL_PIN) != 1 || kd_pin_read(I2C_SDA_PIN) != 1)
     {
         LOG_W("i2c bus is not idle, try to recover it.");
         k230_pinctrl_set_oe(I2C_SCL_PIN, 1);
         kd_pin_mode(I2C_SCL_PIN, GPIO_DM_OUTPUT);
-        for(rt_uint8_t i = 0; i < 9; i++)
+        for (rt_uint8_t i = 0; i < 9; i++)
         {
             kd_pin_write(I2C_SCL_PIN, 0);
             rt_hw_us_delay(2);
@@ -104,7 +112,7 @@ static int test_i2c_check_pin(void)
         kd_pin_mode(I2C_SCL_PIN, GPIO_DM_INPUT);
     }
 
-    if(kd_pin_read(I2C_SCL_PIN) != 1 || kd_pin_read(I2C_SDA_PIN) != 1)
+    if (kd_pin_read(I2C_SCL_PIN) != 1 || kd_pin_read(I2C_SDA_PIN) != 1)
     {
         LOG_E("i2c bus recover failed");
         return -RT_ERROR;
@@ -131,7 +139,7 @@ static void _test_i2c0_master(rt_uint8_t *buffer_w, rt_uint8_t *buffer_r, rt_uin
     msgs[0].buf   = buffer_w;
     msgs[0].len   = size + 1;
 
-    if(rt_i2c_transfer(dev, msgs, 1) != 1)
+    if (rt_i2c_transfer(dev, msgs, 1) != 1)
     {
         LOG_E("i2c transfer failed");
         uassert_true(0);
@@ -149,17 +157,18 @@ static void _test_i2c0_master(rt_uint8_t *buffer_w, rt_uint8_t *buffer_r, rt_uin
     msgs[1].buf   = &buffer_r[1];
     msgs[1].len   = size;
 
-    if(rt_i2c_transfer(dev, msgs, 2) != 2)
+    if (rt_i2c_transfer(dev, msgs, 2) != 2)
     {
         LOG_E("i2c transfer failed");
         uassert_true(0);
     }
 
     LOG_I("Read data:\n");
-    for(rt_uint8_t i = 1; i < size + 1; i++)
+    for (rt_uint8_t i = 1; i < size + 1; i++)
     {
         LOG_I("0x%02X ", buffer_r[i]);
     }
+
     uassert_buf_equal(buffer_w + 1, buffer_r + 1, size);
 }
 
@@ -174,13 +183,15 @@ static void test_i2c0_master(void)
     buffer_w[0] = 0x00; // memory address
     memset(buffer_r, 0x00, TEST_BUFFER_SIZE + 1);
 
-    _test_i2c0_master(buffer_w, buffer_r, size, speed);
+    /* if BSP_USING_I2C_DMA is enabled, test i2c write with dma */
+    _test_i2c0_master(buffer_w, buffer_r, size - 1, speed);
 
     speed = 1000000; // 1MHz
     memset(buffer_w + 1, 0x55, TEST_BUFFER_SIZE);
     buffer_w[0] = 0x00; // memory address
     memset(buffer_r, 0x00, TEST_BUFFER_SIZE + 1);
 
+    /* if BSP_USING_I2C_DMA is enabled, test i2c read with dma */
     _test_i2c0_master(buffer_w, buffer_r, size, speed);
 }
 

bsp/k230/rtconfig.h

@@ -503,10 +503,6 @@
 /* GD32 Drivers */
 
 /* end of GD32 Drivers */
-
-/* HPMicro SDK */
-
-/* end of HPMicro SDK */
 /* end of HAL & SDK Drivers */
 
 /* sensors drivers */