本文的部分内容可能来源于网络，该内容归原作者所有，如果侵犯到您的权益，请及时通知我，我将立即删除，原创内容copyleft归tingkman@163.com所有，使用GPL发布，可以*拷贝，转载。但转载请保持文档的完整性，注明原作者及原链接，严禁用于任何商业用途。欢迎加入zynq-arm-linux提高交流群：788265722
文档错误可能很多，大家多包涵，主要理解文件的目的就好。可留言
Zynq-axidma是大家常用的功能，所以，很多同学都用到，但是有很大一部分同学比较熟悉裸跑下axidma使用，网络上也有很多这方面的教程，像米联客AXI_DMA_LOOP 环路测试，但是linux下使用axidma的使用方法却很少，所以才有了今天这个博文，
阅读这篇博文之前，大家可以参考以下博客内容，为理解linux下axi dma使用做铺垫。
Axidma 裸跑例子（更多的可以百度）
AXI_DMA_LOOP 环路测
https://www.cnblogs.com/milinker/p/6484011.html
https://blog.csdn.net/long_fly/article/details/79702222
AXI_DMA_LOOP，在viviado图里有两部分，一个是axidma模块，一个是数据回环模块，首先，用户通过写dma下发一个数据，比方1234，然后用户通过读dma读取数据读到1234，表示测试完成，这里面其实有两个dma通道一个写一个读做了两次dma操作，读写都是由用户发起的，搬运都是dma控制器执行的如下图：
在linux下驱动主要牵涉的文件有3个，一个是设备文件描述dtb，一个是axidma控制器驱动xilinx_dma.c，一个是axidmatest.c，我们今天的主角就是axidmatest.c
Xilinx官网给的axidma驱动说明在这里大家可以看看
https://xilinx-wiki.atlassian.net/wiki/spaces/A/pages/18842337/Linux+Soft+DMA+Driver
各个文件的位置如下：
内核目录
https://github.com/Xilinx/linux-xlnx/blob/master/arch/arm/boot/dts/zynq-zc706.c，这个是官网评估板的dtb描述，原版的dtb里面没有dma的描述，要把dma的描述加进来
https://github.com/Xilinx/linux-xlnx/blob/master/drivers/dma/xilinx/xilinx_dma.c
https://github.com/Xilinx/linux-xlnx/blob/master/drivers/dma/xilinx/axidmatest.c
在设备树里表示dma读写通道，用以下表示
dma-channel@40400000 axi-dma-mm2s-channel 写通道，是ddr网datafifo写
dma-channel@40400030 axi-dma-s2mm-channel 读通道 是datafifo往ddr搬
这个描述对应的是控制器驱动xilinx_dma.c，有这个
描述xilinx_dma.c这个驱动才会加载。
|
axi_dma_1: dma@40400000 { #dma-cells = <1>; clock-names = "s_axi_lite_aclk", "m_axi_sg_aclk", "m_axi_mm2s_aclk", "m_axi_s2mm_aclk"; clocks = <&clkc 15>, <&clkc 15>, <&clkc 15>, <&clkc 15>; compatible = "xlnx,axi-dma-1.00.a"; interrupt-parent = <&intc>; interrupts = <0 29 4 0 30 4>; reg = <0x40400000 0x10000>; xlnx,addrwidth = <0x20>; xlnx,include-sg ; dma-channel@40400000 { compatible = "xlnx,axi-dma-mm2s-channel"; dma-channels = <0x1>; interrupts = <0 29 4>; xlnx,datawidth = <0x20>; xlnx,device-id = <0x0>; xlnx,include-dre ; }; dma-channel@40400030 { compatible = "xlnx,axi-dma-s2mm-channel"; dma-channels = <0x1>; interrupts = <0 30 4>; xlnx,datawidth = <0x20>; xlnx,device-id = <0x0>; xlnx,include-dre ; }; }; |
在linux里驱动是分层的，一般像spi i2c dma这类的驱动都是分控制器驱动，和下面的设备驱动，控制器是单独的驱动，下面挂的设备是设备的驱动，设备的驱动都是去想控制器去申请的。
那么今天的主题设备驱动axidmatest.c也在设备树里面有自己的描述，我们看到它用了两个dma通道，就是dma控制器的两个读写通道。
axidmatest_1: axidmatest@1 {
compatible ="xlnx,axi-dma-test-1.00.a";
dmas = <&axi_dma_1 0
&axi_dma_1 1>;
dma-names = "axidma0", "axidma1";
} ;
这里设备树和驱动是怎么对应的那，linux采用的是compatible里面的描述
控制器 compatible = "xlnx,axi-dma-1.00.a";
测试程序驱动compatible ="xlnx,axi-dma-test-1.00.a";
驱动程序表示如下:
这样写好，还要把内核配置也配置好，这些驱动才都能加载
在写dma驱动我们不用关注xilinx_dma.c驱动的实现，只需要理解axidmatest.c的实现，下面就分析一下：axidmatest.c这个驱动。
那么从哪里开始分析那，我们知道一般程序都有个入口，比方说main函数，那在linux下axidmatest.c入口就是以下函数。
late_initcall这个意思大概意思就是后面初始化，实际上dma控制器xilinx_dma.c实在测试驱动axidmatest.c之前运行的，因为测试驱动要去向控制器申请通道，所以控制器要先初始化好，才能给测试驱动提供通道。
|
static int __init axidma_init(void) { return platform_driver_register(&xilinx_axidmatest_driver); } late_initcall(axidma_init);
|
|
static const struct of_device_id xilinx_axidmatest_of_ids[] = { { .compatible = "xlnx,axi-dma-test-1.00.a",}, {} }; static struct platform_driver xilinx_axidmatest_driver = { .driver = { .name = "xilinx_axidmatest", .owner = THIS_MODULE, .of_match_table = xilinx_axidmatest_of_ids, }, .probe = xilinx_axidmatest_probe, .remove = xilinx_axidmatest_remove, }; |
axidma_init其实使用platform_driver_register，加载平台设备驱动xilinx_axidmatest_driver，
平台设备驱动有几个描述driver和probe，remove函数，remove函数是在驱动程序卸载才会执行，这里一般内核启动后不会卸载。当xilinx_axidmatest_of_ids里面的compatible和设备树描述文件dtb里面的对应后probe就会运行
axidmatest_1: axidmatest@1 {
compatible ="xlnx,axi-dma-test-1.00.a";
dmas = <&axi_dma_1 0
&axi_dma_1 1>;
dma-names = "axidma0", "axidma1";
} ;
当probe函数xilinx_axidmatest_probe才开始测试驱动的初始化。
dma_request_slave_channel是linux驱动编写的标准函数，dma测试程序申请dma通道要用这个函数，具体实现我们可以不管，只需要用这个申请就可以了，当然了，控制器驱动已经准备好了，才能申请成功。
|
static int xilinx_axidmatest_probe(struct platform_device *pdev) { struct dma_chan *chan, *rx_chan; int err; chan = dma_request_slave_channel(&pdev->dev, "axidma0"); //---------------------向控制器申请dma发送通道 if (IS_ERR(chan)) { pr_err("xilinx_dmatest: No Tx channel\n"); return PTR_ERR(chan); } rx_chan = dma_request_slave_channel(&pdev->dev, "axidma1"); //---------------------向控制器申请dma接收通道
if (IS_ERR(rx_chan)) { err = PTR_ERR(rx_chan); pr_err("xilinx_dmatest: No Rx channel\n"); goto free_tx; } err = dmatest_add_slave_channels(chan, rx_chan); if (err) { pr_err("xilinx_dmatest: Unable to add channels\n"); goto free_rx; } return 0; free_rx: dma_release_channel(rx_chan); free_tx: dma_release_channel(chan); return err; } |
dmatest_add_slave_channels(chan, rx_chan)函数进一步初始化。
定义两个dmatest_chan类型的数据结构tx_dtc，rx_dtc用来保存之前申请的两个通道，后面就用这两个数据接口来访问通道。
|
static int dmatest_add_slave_channels(struct dma_chan *tx_chan, struct dma_chan *rx_chan) { struct dmatest_chan *tx_dtc; struct dmatest_chan *rx_dtc; unsigned int thread_count = 0;
tx_dtc = kmalloc(sizeof(struct dmatest_chan), GFP_KERNEL); if (!tx_dtc) { pr_warn("dmatest: No memory for tx %s\n", dma_chan_name(tx_chan)); return -ENOMEM; } rx_dtc = kmalloc(sizeof(struct dmatest_chan), GFP_KERNEL); if (!rx_dtc) { pr_warn("dmatest: No memory for rx %s\n", dma_chan_name(rx_chan)); return -ENOMEM; } tx_dtc->chan = tx_chan; rx_dtc->chan = rx_chan; INIT_LIST_HEAD(&tx_dtc->threads); INIT_LIST_HEAD(&rx_dtc->threads);
dmatest_add_slave_threads(tx_dtc, rx_dtc); thread_count += 1;
pr_info("dmatest: Started %u threads using %s %s\n", thread_count, dma_chan_name(tx_chan), dma_chan_name(rx_chan));
list_add_tail(&tx_dtc->node, &dmatest_channels); list_add_tail(&rx_dtc->node, &dmatest_channels); nr_channels += 2;
if (iterations) wait_event(thread_wait, !is_threaded_test_run(tx_dtc, rx_dtc));
return 0; } |
dmatest_add_slave_threads实际上是创建了一个内核任务，这个任务才是发起dma操作的，
在linux-dma测试程序中发起dma请求，都是由标准的函数，我们写的时候也要用到这些函数
这里要了解一些linuxdma的相关知识，这里找几篇博客参考
http://www.wowotech.net/linux_kenrel/dma_engine_overview.html
http://www.wowotech.net/linux_kenrel/dma_engine_api.html
https://www.cnblogs.com/xiaojiang1025/archive/2017/02/11/6389194.html
Dma驱动一般分两种，一种是一致性dma一种是流式dma，本文用的dma是流式的。
相关函数如下：
dma_map_single
sg_init_table(tx_sg, bd_cnt);
sg_dma_address
sg_dma_len
device_prep_slave_sg
rxd->tx_submit
dmatest_slave_func函数基本流程我先概况一下：
先通过准备数据通过写通道dma发送给datafifo，然后在通过读通道dma从datafifo读出来，对比发送的数据是否和接收的数据一致，一致则认为测试通过，循环做几次测试
|
static int dmatest_slave_func(void *data)函数分析
|
|
static int dmatest_slave_func(void *data) { struct dmatest_slave_thread *thread = data; struct dma_chan *tx_chan; struct dma_chan *rx_chan; const char *thread_name; unsigned int src_off, dst_off, len; unsigned int error_count; unsigned int failed_tests = 0; unsigned int total_tests = 0; dma_cookie_t tx_cookie; dma_cookie_t rx_cookie; enum dma_status status; enum dma_ctrl_flags flags; int ret; int src_cnt; int dst_cnt; int bd_cnt = 11; int i;
ktime_t ktime, start, diff; ktime_t filltime = 0; ktime_t comparetime = 0; s64 runtime = 0; unsigned long long total_len = 0; thread_name = current->comm; ret = -ENOMEM;
/* Ensure that all previous reads are complete */ smp_rmb(); tx_chan = thread->tx_chan; rx_chan = thread->rx_chan; dst_cnt = bd_cnt; //这里为11，实际上是创建11个sg，sg支持多个分块dma传输，这里可以改成1，就一块 src_cnt = bd_cnt; //申请发送缓冲区数据结构，
thread->srcs = kcalloc(src_cnt + 1, sizeof(u8 *), GFP_KERNEL); if (!thread->srcs) goto err_srcs; //申请发送缓冲区，这里面放发送的数据，往datafifo发送的数据
for (i = 0; i < src_cnt; i++) { thread->srcs[i] = kmalloc(test_buf_size, GFP_KERNEL); if (!thread->srcs[i]) goto err_srcbuf; } thread->srcs[i] = NULL; //申请接收缓冲区数据结构， thread->dsts = kcalloc(dst_cnt + 1, sizeof(u8 *), GFP_KERNEL); if (!thread->dsts) goto err_dsts;
//申请接收缓冲区，这里是dma从datafifo搬运的数据放到这里，
for (i = 0; i < dst_cnt; i++) { thread->dsts[i] = kmalloc(test_buf_size, GFP_KERNEL); if (!thread->dsts[i]) goto err_dstbuf; } thread->dsts[i] = NULL;
set_user_nice(current, 10);
flags = DMA_CTRL_ACK | DMA_PREP_INTERRUPT;
ktime = ktime_get(); while (!kthread_should_stop() && !(iterations && total_tests >= iterations)) { struct dma_device *tx_dev = tx_chan->device; struct dma_device *rx_dev = rx_chan->device; struct dma_async_tx_descriptor *txd = NULL; struct dma_async_tx_descriptor *rxd = NULL; dma_addr_t dma_srcs[src_cnt]; dma_addr_t dma_dsts[dst_cnt]; struct completion rx_cmp; struct completion tx_cmp; unsigned long rx_tmo = msecs_to_jiffies(300000); /* RX takes longer */ unsigned long tx_tmo = msecs_to_jiffies(30000); u8 align = 0; struct scatterlist tx_sg[bd_cnt]; //定义发送dma数据结构， struct scatterlist rx_sg[bd_cnt]; //定义接收dma数据结构，
total_tests++; //----------------字节对齐，dma传输要求字节对齐 /* honor larger alignment restrictions */ align = tx_dev->copy_align; if (rx_dev->copy_align > align) align = rx_dev->copy_align;
if (1 << align > test_buf_size) { pr_err("%u-byte buffer too small for %d-byte alignment\n", test_buf_size, 1 << align); break; }
len = dmatest_random() % test_buf_size + 1; len = (len >> align) << align; if (!len) len = 1 << align; total_len += len; src_off = dmatest_random() % (test_buf_size - len + 1); dst_off = dmatest_random() % (test_buf_size - len + 1);
src_off = (src_off >> align) << align; dst_off = (dst_off >> align) << align;
start = ktime_get(); dmatest_init_srcs(thread->srcs, src_off, len); dmatest_init_dsts(thread->dsts, dst_off, len); //----------------字节对齐，dma传输要求字节对齐
diff = ktime_sub(ktime_get(), start); filltime = ktime_add(filltime, diff);
for (i = 0; i < src_cnt; i++) { u8 *buf = thread->srcs[i] + src_off; //dma映射后获取的物理地址，实际上dma初始化用的是物理地址，thread->srcs[i] 这个是虚拟地址，是程序可以直接使用的，但是dma用的是物理地址 dma_srcs[i] = dma_map_single(tx_dev->dev, buf, len, DMA_MEM_TO_DEV); }
for (i = 0; i < dst_cnt; i++) { //dma映射后获取的物理地址，实际上dma初始化用的是物理地址，thread->srcs[i] 这个是虚拟地址，是程序可以直接使用的，但是dma用的是物理地址
dma_dsts[i] = dma_map_single(rx_dev->dev, thread->dsts[i], test_buf_size, DMA_BIDIRECTIONAL); } //初始化发送接收数据结构---------------------- sg_init_table(tx_sg, bd_cnt); sg_init_table(rx_sg, bd_cnt);
for (i = 0; i < bd_cnt; i++) { sg_dma_address(&tx_sg[i]) = dma_srcs[i]; //物理地址 sg_dma_address(&rx_sg[i]) = dma_dsts[i] + dst_off;
sg_dma_len(&tx_sg[i]) = len; //dma一次传输的长度 sg_dma_len(&rx_sg[i]) = len; } //准备发送 接收sg rxd = rx_dev->device_prep_slave_sg(rx_chan, rx_sg, bd_cnt, DMA_DEV_TO_MEM, flags, NULL);
txd = tx_dev->device_prep_slave_sg(tx_chan, tx_sg, bd_cnt, DMA_MEM_TO_DEV, flags, NULL);
if (!rxd || !txd) { for (i = 0; i < src_cnt; i++) dma_unmap_single(tx_dev->dev, dma_srcs[i], len, DMA_MEM_TO_DEV); for (i = 0; i < dst_cnt; i++) dma_unmap_single(rx_dev->dev, dma_dsts[i], test_buf_size, DMA_BIDIRECTIONAL); pr_warn("%s: #%u: prep error with src_off=0x%x ", thread_name, total_tests - 1, src_off); pr_warn("dst_off=0x%x len=0x%x\n", dst_off, len); msleep(100); failed_tests++; continue; } //接收的dma，先准备接收的 init_completion(&rx_cmp); rxd->callback = dmatest_slave_rx_callback;//dma搬运完这个函数会运行 rxd->callback_param = &rx_cmp; rx_cookie = rxd->tx_submit(rxd);
//发送的dma， init_completion(&tx_cmp); txd->callback = dmatest_slave_tx_callback;//dma搬运完这个函数会运行 txd->callback_param = &tx_cmp; tx_cookie = txd->tx_submit(txd);
if (dma_submit_error(rx_cookie) || dma_submit_error(tx_cookie)) { pr_warn("%s: #%u: submit error %d/%d with src_off=0x%x ", thread_name, total_tests - 1, rx_cookie, tx_cookie, src_off); pr_warn("dst_off=0x%x len=0x%x\n", dst_off, len); msleep(100); failed_tests++; continue; } dma_async_issue_pending(rx_chan); dma_async_issue_pending(tx_chan); //--dma_async_issue_pending这个执行后就相当于给dma控制器发命令了，dma控制器就会根据我们提供的参数来自己搬运数据了
tx_tmo = wait_for_completion_timeout(&tx_cmp, tx_tmo); //等待发送dma传输完 等completion status = dma_async_is_tx_complete(tx_chan, tx_cookie, NULL, NULL);
if (tx_tmo == 0) { pr_warn("%s: #%u: tx test timed out\n", thread_name, total_tests - 1); failed_tests++; continue; } else if (status != DMA_COMPLETE) { pr_warn("%s: #%u: tx got completion callback, ", thread_name, total_tests - 1); pr_warn("but status is \'%s\'\n", status == DMA_ERROR ? "error" : "in progress"); failed_tests++; continue; }
rx_tmo = wait_for_completion_timeout(&rx_cmp, rx_tmo); //等待接收传输完 status = dma_async_is_tx_complete(rx_chan, rx_cookie, NULL, NULL);
if (rx_tmo == 0) { pr_warn("%s: #%u: rx test timed out\n", thread_name, total_tests - 1); failed_tests++; continue; } else if (status != DMA_COMPLETE) { pr_warn("%s: #%u: rx got completion callback, ", thread_name, total_tests - 1); pr_warn("but status is \'%s\'\n", status == DMA_ERROR ? "error" : "in progress"); failed_tests++; continue; } //前面是先映射，这里是解除映射，这样缓冲区的数据才是正确的，不执行这个操作，缓冲区数据不对。 /* Unmap by myself */ for (i = 0; i < dst_cnt; i++) dma_unmap_single(rx_dev->dev, dma_dsts[i], test_buf_size, DMA_BIDIRECTIONAL);
error_count = 0; start = ktime_get(); pr_debug("%s: verifying source buffer...\n", thread_name); error_count += dmatest_verify(thread->srcs, 0, src_off, 0, PATTERN_SRC, true); error_count += dmatest_verify(thread->srcs, src_off, src_off + len, src_off, PATTERN_SRC | PATTERN_COPY, true); error_count += dmatest_verify(thread->srcs, src_off + len, test_buf_size, src_off + len, PATTERN_SRC, true);
pr_debug("%s: verifying dest buffer...\n", thread->task->comm); //--校验接收的数据和发送的数据， error_count += dmatest_verify(thread->dsts, 0, dst_off, 0, PATTERN_DST, false); error_count += dmatest_verify(thread->dsts, dst_off, dst_off + len, src_off, PATTERN_SRC | PATTERN_COPY, false); error_count += dmatest_verify(thread->dsts, dst_off + len, test_buf_size, dst_off + len, PATTERN_DST, false); diff = ktime_sub(ktime_get(), start); comparetime = ktime_add(comparetime, diff);
if (error_count) { pr_warn("%s: #%u: %u errors with ", thread_name, total_tests - 1, error_count); pr_warn("src_off=0x%x dst_off=0x%x len=0x%x\n", src_off, dst_off, len); failed_tests++; } else { pr_debug("%s: #%u: No errors with ", thread_name, total_tests - 1); pr_debug("src_off=0x%x dst_off=0x%x len=0x%x\n", src_off, dst_off, len); } }
ktime = ktime_sub(ktime_get(), ktime); ktime = ktime_sub(ktime, comparetime); ktime = ktime_sub(ktime, filltime); runtime = ktime_to_us(ktime);
ret = 0; for (i = 0; thread->dsts[i]; i++) kfree(thread->dsts[i]); err_dstbuf: kfree(thread->dsts); err_dsts: for (i = 0; thread->srcs[i]; i++) kfree(thread->srcs[i]); err_srcbuf: kfree(thread->srcs); err_srcs: pr_notice("%s: terminating after %u tests, %u failures %llu iops %llu KB/s (status %d)\n", thread_name, total_tests, failed_tests, dmatest_persec(runtime, total_tests), dmatest_KBs(runtime, total_len), ret);
thread->done = true; wake_up(&thread_wait);
return ret; } |
|
|
至此，axidmatest.c主要部分就是这个任务，所以，把这个搞明白就行，还有一点数据准备这块有个字节对齐，有点麻烦，容易搞不清楚，可以使用__get_free_pages申请缓冲区，这种函数本身就是对齐的，还有，这种流式的dma要先dma_map_single传输完后还要dma_unmap_single后才能去读传输的数据，这种函数我测试数据量小的话好用，如果很大的话，就比较花时间，一致性dma就不用这样。后面有时间吧这个改造一下，做一致性的dma，写的尽量简单能用，能理解大概就行。