init

code/Makefile

+#已经编译过的内核源码路径
+KERNEL_DIR = /home/uisrc/uisrc-lab-xlnx/sources/kernel
+
+export ARCH=arm64
+export CROSS_COMPILE=aarch64-linux-gnu-
+
+#当前路径
+CURRENT_DIR = $(shell pwd)
+APP = dma_app
+all : 
+#进入并调用内核源码目录中Makefile的规则, 将当前的目录中的源码编译成模块
+	make -C $(KERNEL_DIR) M=$(CURRENT_DIR) modules 
+ifneq ($(APP), )
+	$(CROSS_COMPILE)gcc $(APP).c -o $(APP)
+endif
+
+clean : 
+	make -C $(KERNEL_DIR) M=$(CURRENT_DIR) clean
+
+#指定编译哪个文件
+obj-m += dma_drv.o
\ No newline at end of file

code/dma_app.c

+#include <stdio.h>
+#include <sys/time.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <fcntl.h>
+#include <string.h>
+#include <linux/fb.h>
+#include <sys/mman.h>
+#include <sys/ioctl.h>
+#include <arpa/inet.h>
+#include <sys/time.h>
+#include <poll.h>
+#include "client_arm.c"
+
+extern int send_data(char *buf, int len);
+extern int net_init(char *ip);
+extern void net_close(void);
+
+#define ADC_IOCTL_MAGIC 'M'
+#define CMD_GET_DMADATA _IO(ADC_IOCTL_MAGIC, 0)
+#define CMD_SET_START _IO(ADC_IOCTL_MAGIC, 1)
+
+#define ADC_SIZE 1024 * 1024
+
+int main(int argc, char **argv)
+{
+	int fd;
+	int ret = 0;
+	char data[ADC_SIZE];
+	uint16_t data_tmp[1024][8];
+	char *save = NULL;
+	int mem_switch = 0;
+	int num_buf;
+	int start;
+	int i, j;
+	int n = 0;
+
+	struct pollfd poll_fd[2];
+	struct timeval tv;
+	struct timeval tv_end;
+
+	if (argc < 2)
+	{
+		printf("input server ip\n");
+		return -1;
+	}
+
+	fd = open("/dev/adcdma_fun", O_RDWR);
+	if (fd < 0)
+	{
+		printf("can't open file fdma_fun\n");
+		return (-1);
+	}
+
+	memset(data, 0, sizeof(data));
+
+	poll_fd[0].events = POLLIN;
+	poll_fd[0].fd = 0;
+	poll_fd[1].events = POLLIN;
+	poll_fd[1].fd = fd;
+
+	net_init(argv[1]);
+	start = 1;
+	ioctl(fd, CMD_SET_START, &start);
+
+	while (1)
+	{
+		ret = poll(poll_fd, 2, -1);
+		if (ret < 0)
+		{
+			printf("error\n");
+			break;
+		}
+		if (poll_fd[0].revents & POLLIN)
+		{
+			printf("input\n");
+			break;
+		}
+		ret = ioctl(fd, CMD_GET_DMADATA, data);
+		if (ret < 0)
+		{
+			perror("get data err\n");
+			continue;
+		}
+		ret = send_data(data, ADC_SIZE);
+		if (ret < 0)
+		{
+			printf("send err\n");
+			break;
+		}
+	}
+
+	start = 0;
+	ioctl(fd, CMD_SET_START, &start);
+
+	printf("break while\n");
+	net_close();
+merr:
+	close(fd);
+	return ret;
+}
\ No newline at end of file

code/dma_app_修改.c

+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <fcntl.h>
+#include <string.h>
+#include <sys/ioctl.h>
+
+#define ADC_IOCTL_MAGIC 'M'
+#define CMD_GET_DMADATA _IO(ADC_IOCTL_MAGIC, 0)
+#define CMD_SET_START _IO(ADC_IOCTL_MAGIC, 1)
+
+#define ADC_SIZE (1024 * 1024)
+
+int main()
+{
+    int fd;             // 文件描述符
+    int ret = 0;        // 返回值
+    char data[ADC_SIZE];    // 用于存储 DMA 数据的缓冲区
+    uint16_t *data_tmp; // 临时指针，用于按照 16 位读取数据
+    int start = 1;      // 控制 DMA 数据传输的标志
+    int i, j;
+
+    // 打开 DMA 设备文件
+    fd = open("/dev/adcdma_fun", O_RDWR);
+    if (fd < 0)
+    {
+        printf("Can't open file fdma_fun\n");
+        return -1;
+    }
+
+    // 启动 DMA 数据传输
+    ioctl(fd, CMD_SET_START, &start);
+
+    while (1)
+    {
+        // 从 DMA 设备中读取数据
+        ret = ioctl(fd, CMD_GET_DMADATA, data);
+        if (ret < 0)
+        {
+            perror("Get data error\n");
+            break;
+        }
+
+        // 将数据按照 16 位进行打印
+        data_tmp = (uint16_t *)data;
+        for (i = 0; i < ADC_SIZE / sizeof(uint16_t); i += 8)
+        {
+            for (j = 0; j < 8; j++)
+            {
+                printf("%04X ", data_tmp[i + j]);
+            }
+            printf("\n");
+        }
+    }
+
+    // 停止 DMA 数据传输
+    start = 0;
+    ioctl(fd, CMD_SET_START, &start);
+
+    // 关闭 DMA 设备文件
+    close(fd);
+
+    return ret;
+}
\ No newline at end of file

code/dma_drv.c

+#include <linux/wait.h>
+#include <linux/poll.h>
+#include <linux/cdev.h>
+#include <linux/slab.h>
+#include <linux/errno.h>
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/device.h>
+#include <linux/interrupt.h>
+#include <linux/gpio.h>
+#include <linux/of.h>
+#include <linux/of_platform.h>
+#include <linux/of_gpio.h>
+#include <linux/of_address.h>
+#include <linux/sched.h>
+#include <linux/delay.h>
+#include <linux/workqueue.h>
+#include <linux/mm.h>
+#include <linux/exportfs.h>
+#include <linux/clk.h>
+#include <linux/init.h>
+#include <linux/platform_device.h>
+#include <linux/regmap.h>
+#include <linux/of_dma.h>
+#include <linux/dma-mapping.h>
+#include <linux/dmaengine.h>
+#include <linux/dma/xilinx_dma.h>
+
+#define ADC_DMAINIT_S 1
+
+#define ADCDATA_SIZE (1024 * 1024)
+
+/*
+ *buf_con:缓存数,不大于32
+ *adc_phys:dma物理内存地址
+ *adc_virt:dma物理内存对应的映射地址
+ *mem_switch:当前dma使用的内存
+ *mem_flag:缓存标识，被dma写之后对应位置1，读取之后对应位置0
+ *read_mem:当前读取的内存块
+ *
+ */
+
+struct adcdma_para
+{
+	struct dma_chan *dma;
+	int buf_con;
+	int mem_switch;
+	int mem_flag;
+	int read_mem;
+	phys_addr_t adc_phys[32];
+	void __iomem *adc_virt[32];
+	struct scatterlist sglis[32];
+};
+
+struct adcdma_fun
+{
+	struct class *adcdma_class;
+	struct device *adcdma_dev;
+	wait_queue_head_t read_queue;
+	int irq_reprot;
+	int trans_en;
+	dev_t t_dev;
+	struct gpio_desc *reset_gpio;
+	struct gpio_desc *enable_gpio;
+	struct adcdma_para *dmad;
+	int used;
+};
+struct adcdma_fun *adcdma_data;
+
+extern int cam_5640_init(int flag);
+static int adcdma_setup(struct adcdma_para *dmap, int nfb);
+
+#define ADC_IOCTL_MAGIC 'M'
+
+#define CMD_GET_DMADATA _IO(ADC_IOCTL_MAGIC, 0)
+#define CMD_SET_START _IO(ADC_IOCTL_MAGIC, 1)
+
+static void irq_change_mem(struct adcdma_para *dmap, int num)
+{
+	struct adcdma_para *dmad_tmp = dmap;
+	int next;
+
+	dmad_tmp->mem_flag |= (1 << dmad_tmp->mem_switch);
+	next = (dmad_tmp->mem_switch + 1) % dmad_tmp->buf_con;
+	if ((dmad_tmp->mem_flag & (1 << next)) == 0)
+	{
+		dmad_tmp->mem_switch = next;
+		adcdma_setup(dmap, next);
+		dma_async_issue_pending(dmap->dma);
+	}
+	else
+	{
+		printk("mem change err %d\n", next);
+	}
+}
+
+static void adcdma_irq_handler(void *data)
+{
+	int num = (int)data;
+
+	//	printk("irq %d\n", num);
+	adcdma_data->irq_reprot = 1;
+
+	if (adcdma_data->trans_en)
+	{
+		wake_up_interruptible(&adcdma_data->read_queue);
+		irq_change_mem(adcdma_data->dmad, num);
+	}
+}
+
+static int adcdma_setup(struct adcdma_para *dmap, int nfb)
+{
+	struct dma_async_tx_descriptor *desc;
+	struct scatterlist *rx_sg = &dmap->sglis[nfb];
+	struct dma_device *rx_dev = dmap->dma->device;
+	enum dma_ctrl_flags flags;
+	int ret = 0;
+
+	flags = DMA_PREP_INTERRUPT;
+
+#if ADC_DMAINIT_S
+	desc = dmaengine_prep_slave_single(dmap->dma, dmap->adc_phys[nfb],
+									   ADCDATA_SIZE, DMA_DEV_TO_MEM, flags);
+	if (!desc)
+	{
+		pr_err("Failed to prepare DMA descriptor\n");
+		return -ENOMEM;
+	}
+	else
+	{
+		ret = dmaengine_submit(desc);
+		if (ret < 0)
+			printk("submit err\n");
+		desc->callback = adcdma_irq_handler;
+		desc->callback_param = (void *)nfb;
+	}
+#else
+	dmap->adc_virt[nfb] = kmalloc(ADCDATA_SIZE, GFP_KERNEL);
+	dma_addr_t adc_dma_rx;
+	dma_cookie_t rx_cookie;
+
+	memset(dmap->adc_virt[nfb], 0, ADCDATA_SIZE);
+
+	adc_dma_rx = dma_map_single(rx_dev->dev, dmap->adc_virt[nfb],
+								ADCDATA_SIZE, DMA_MEM_TO_DEV);
+
+	dma_unmap_single(rx_dev->dev, adc_dma_rx,
+					 ADCDATA_SIZE,
+					 DMA_MEM_TO_DEV);
+
+	adc_dma_rx = dma_map_single(rx_dev->dev, dmap->adc_virt[nfb],
+								ADCDATA_SIZE, DMA_DEV_TO_MEM);
+
+	sg_init_table(rx_sg, 1);
+	sg_dma_address(rx_sg) = adc_dma_rx;
+	sg_dma_len(rx_sg) = ADCDATA_SIZE;
+
+	desc = rx_dev->device_prep_slave_sg(dmap->dma, rx_sg, 1,
+										DMA_DEV_TO_MEM, flags, NULL);
+
+	rx_cookie = desc->tx_submit(desc);
+	desc->callback = adcdma_irq_handler;
+	desc->callback_param = (void *)nfb;
+#endif
+
+	return 0;
+}
+
+static int data_to_user(struct adcdma_para *dmap, void __user *user_buf)
+{
+	int size;
+	int ret = 0;
+
+	size = ADCDATA_SIZE;
+	ret = copy_to_user(user_buf, dmap->adc_virt[dmap->read_mem], size) ? -EFAULT : 0;
+	// if (adcdma_data->trans_en == 1)
+	// adcdma_setup(dmap,dmap->read_mem);
+	//	dma_async_issue_pending(dmap->dma);
+	dmap->mem_flag &= ~(1 << dmap->read_mem);
+	//	printk("ioctl free mem %d\n", dmap->read_mem);
+	dmap->read_mem = (dmap->read_mem + 1) % dmap->buf_con;
+	return ret;
+}
+
+static long adcdma_func_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
+{
+	int ret = 0;
+	void __user *user_arg = (void __user *)arg;
+	int flag;
+	int n;
+
+	switch (cmd)
+	{
+	case CMD_GET_DMADATA:
+		ret = data_to_user(adcdma_data->dmad, user_arg);
+		break;
+
+	case CMD_SET_START:
+		copy_from_user(&flag, user_arg, sizeof(flag));
+		printk("flag = %d\n", flag);
+
+		adcdma_data->dmad->mem_switch = 0;
+		adcdma_data->dmad->mem_flag = 0;
+		adcdma_data->dmad->read_mem = 0;
+
+		if (flag == 0)
+		{
+			adcdma_data->trans_en = 0;
+			dmaengine_terminate_all(adcdma_data->dmad->dma);
+		}
+		else
+		{
+			adcdma_data->trans_en = 1;
+
+			ret = adcdma_setup(adcdma_data->dmad, 0);
+			dma_async_issue_pending(adcdma_data->dmad->dma);
+		}
+		gpiod_set_value_cansleep(adcdma_data->enable_gpio, flag);
+
+		break;
+
+	default:
+		ret = -EFAULT;
+		break;
+	}
+	return ret;
+}
+
+static unsigned int adcdma_func_poll(struct file *file, struct poll_table_struct *wait)
+{
+	int mask = 0;
+
+	poll_wait(file, &(adcdma_data->read_queue), wait);
+	if (adcdma_data->irq_reprot == 1)
+	{
+		adcdma_data->irq_reprot = 0;
+		mask |= (POLLIN | POLLRDNORM);
+	}
+
+	return mask;
+}
+
+void adcdma_reset(void)
+{
+	gpiod_set_value_cansleep(adcdma_data->reset_gpio, 0);
+	gpiod_set_value_cansleep(adcdma_data->enable_gpio, 0);
+	gpiod_set_value_cansleep(adcdma_data->reset_gpio, 1);
+}
+
+int adcdma_func_open(struct inode *inode, struct file *file)
+{
+	int ret = 0;
+
+	if (adcdma_data->used >= 1)
+	{
+		printk("%s driver busy\n", file->f_path.dentry->d_iname);
+		return -EBUSY;
+	}
+	adcdma_data->used = 1;
+
+	adcdma_data->trans_en = 1;
+
+	// dmaengine_terminate_all(adcdma_data->dmad[i]->dma);
+	adcdma_data->dmad->mem_switch = 0;
+	adcdma_data->dmad->mem_flag = 0;
+	adcdma_data->dmad->read_mem = 0;
+	// adcdma_reset();
+
+	return ret;
+}
+
+int adcdma_func_release(struct inode *inode, struct file *file)
+
+{
+	int j = 0;
+
+	dmaengine_terminate_all(adcdma_data->dmad->dma);
+	adcdma_data->trans_en = 0;
+	adcdma_data->used = 0;
+
+#if !ADC_DMAINIT_S
+
+	for (j = 0; j < adcdma_data->dmad->buf_con; j++)
+		kfree(adcdma_data->dmad->adc_virt[j]);
+#endif
+	return 0;
+}
+
+const struct file_operations adcdma_fops =
+	{
+		.owner = THIS_MODULE,
+		.open = adcdma_func_open,
+		.release = adcdma_func_release,
+		.unlocked_ioctl = adcdma_func_ioctl,
+		.poll = adcdma_func_poll,
+};
+
+int adcdma_cdev_init(struct adcdma_fun *pdata)
+{
+	int rc;
+	struct cdev *c_dev;
+
+	rc = alloc_chrdev_region(&pdata->t_dev, 0, 1, "adcdma_fun");
+
+	if (rc)
+		goto out_err;
+
+	c_dev = cdev_alloc();
+	if (!c_dev)
+		goto out_err;
+
+	cdev_init(c_dev, &adcdma_fops);
+	rc = cdev_add(c_dev, pdata->t_dev, 1);
+	if (rc)
+		goto out_unreg;
+
+	pdata->adcdma_class = class_create(THIS_MODULE, "adcdma");
+	if (IS_ERR(pdata->adcdma_class))
+	{
+		printk("[err]class_create error\n");
+		rc = -1;
+		goto out_devdel;
+	}
+
+	pdata->adcdma_dev = device_create(pdata->adcdma_class, NULL, pdata->t_dev, NULL, "adcdma_fun");
+	if (!pdata->adcdma_dev)
+	{
+		rc = -1;
+		goto class_err;
+	}
+
+	return 0;
+
+class_err:
+	class_destroy(pdata->adcdma_class);
+
+out_devdel:
+	cdev_del(c_dev);
+
+out_unreg:
+	unregister_chrdev_region(pdata->t_dev, 1);
+
+out_err:
+
+	return rc;
+}
+
+int of_adcdma_data(struct adcdma_fun *pdata, struct platform_device *pdev)
+{
+	int cnt = 0;
+	int ret = 0;
+	int i = 0;
+	int hsize = 0;
+
+	pdata->reset_gpio = devm_gpiod_get_optional(&pdev->dev, "reset",
+												GPIOD_OUT_LOW);
+	if (IS_ERR(pdata->reset_gpio))
+	{
+
+		printk("[zgq]get reset gpio err\n");
+		return PTR_ERR(pdata->reset_gpio);
+	}
+
+	pdata->enable_gpio = devm_gpiod_get_optional(&pdev->dev, "enable",
+												 GPIOD_OUT_LOW);
+	if (IS_ERR(pdata->enable_gpio))
+	{
+		printk("[zgq]get enable gpio err\n");
+		return PTR_ERR(pdata->enable_gpio);
+	}
+	adcdma_reset();
+
+	pdata->dmad = devm_kmalloc(&pdev->dev, sizeof(struct adcdma_para), GFP_KERNEL);
+	if (pdata->dmad == NULL)
+	{
+		printk("kmalloc err\n");
+		return -1;
+	}
+	memset(pdata->dmad, 0, sizeof(struct adcdma_para));
+	pdata->dmad->dma = dma_request_chan(&pdev->dev, "adc");
+	if (IS_ERR_OR_NULL(pdata->dmad->dma))
+	{
+		printk("get dma0 err\n");
+		return PTR_ERR(pdata->dmad->dma);
+	}
+
+	ret = of_property_read_u32(pdev->dev.of_node,
+							   "num-buf", &cnt);
+	if (ret < 0)
+	{
+		pr_err("adcdmatest: missing num-frm property\n");
+		return ret;
+	}
+	cnt = cnt > 32 ? 32 : cnt;
+	pdata->dmad->buf_con = cnt;
+
+	hsize = ADCDATA_SIZE;
+
+#if ADC_DMAINIT_S
+	for (i = 0; i < cnt; i++)
+	{
+		pdata->dmad->adc_virt[i] = dma_alloc_coherent(&pdev->dev, PAGE_ALIGN(hsize),
+													  &pdata->dmad->adc_phys[i], GFP_KERNEL);
+		if (pdata->dmad->adc_virt[i] == NULL)
+		{
+			printk("can't alloc mem\n");
+		}
+		memset(pdata->dmad->adc_virt[i], 0, hsize);
+	}
+#endif
+	init_waitqueue_head(&pdata->read_queue);
+	return 0;
+}
+
+static int adcdma_fun_probe(struct platform_device *pdev)
+{
+	struct device *dev = &pdev->dev;
+	struct adcdma_fun *pdata = dev_get_platdata(dev);
+	int ret = 0;
+
+	if (!pdata)
+	{
+		pdata = devm_kzalloc(dev, sizeof(struct adcdma_fun), GFP_KERNEL);
+		if (!pdata)
+			return -ENOMEM;
+
+		platform_set_drvdata(pdev, pdata);
+	}
+	adcdma_data = pdata;
+	ret = of_adcdma_data(pdata, pdev);
+	if (ret < 0)
+		goto out;
+
+	ret = adcdma_cdev_init(pdata);
+	if (ret < 0)
+		goto out;
+
+out:
+	return ret;
+}
+
+static void clean_dma(struct platform_device *pdev, struct adcdma_para *dmap)
+{
+	int size;
+	int i = 0;
+
+	size = ADCDATA_SIZE;
+
+#if ADC_DMAINIT_S
+
+	for (i = 0; i < dmap->buf_con; i++)
+	{
+		dma_free_coherent(&pdev->dev, PAGE_ALIGN(size),
+						  dmap->adc_virt[i], dmap->adc_phys[i]);
+	}
+#endif
+}
+
+static int adcdma_fun_remove(struct platform_device *pdev)
+{
+
+	dma_release_channel(adcdma_data->dmad->dma);
+	clean_dma(pdev, adcdma_data->dmad);
+
+	device_unregister(adcdma_data->adcdma_dev);
+	unregister_chrdev_region(adcdma_data->t_dev, 1);
+	class_destroy(adcdma_data->adcdma_class);
+	return 0;
+}
+
+static struct of_device_id adcdma_fun_of_match[] = {
+	{
+		.compatible = "adcdma_demo",
+	},
+	{},
+};
+
+static struct platform_driver adcdma_fun_device_driver = {
+	.probe = adcdma_fun_probe,
+	.remove = adcdma_fun_remove,
+	.driver = {
+		.name = "adcdma_demo",
+		.owner = THIS_MODULE,
+		.of_match_table = of_match_ptr(adcdma_fun_of_match),
+	}
+};
+
+static int __init adcdma_fun_init(void)
+{
+	return platform_driver_register(&adcdma_fun_device_driver);
+}
+
+static void __exit adcdma_fun_exit(void)
+{
+	platform_driver_unregister(&adcdma_fun_device_driver);
+}
+
+late_initcall(adcdma_fun_init);
+module_exit(adcdma_fun_exit);
+
+// module_platform_driver(adcdma_fun_device_driver);
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("uisrc");

code/dma_drv_详细注释.c

+#define ADC_DMAINIT_S 1
+
+#define ADCDATA_SIZE (1024 * 1024)
+/*
+struct dma_chan *dma;：DMA 通道指针，用于管理 DMA 操作。
+int buf_con;：缓存数，表示 DMA 中缓存的数量，不大于 32。
+int mem_switch;：当前 DMA 使用的内存块索引，表示当前写入的内存块。
+int mem_flag;：缓存标识，被 DMA 写入后对应位置 1，读取后对应位置 0。
+int read_mem;：当前读取的内存块索引。
+phys_addr_t adc_phys[32];：DMA 物理内存地址数组，用于存储 32 个内存块的物理地址。
+void __iomem *adc_virt[32];：DMA 物理内存对应的映射地址数组，用于存储 32 个内存块的虚拟地址。
+struct scatterlist sglis[32];：散射列表，用于描述 DMA 操作中的内存分布情况，包括物理地址和大小等信息。
+*/
+struct adcdma_para
+{
+	struct dma_chan *dma;
+	int buf_con;
+	int mem_switch;
+	int mem_flag;
+	int read_mem;
+	phys_addr_t adc_phys[32];
+	void __iomem *adc_virt[32];
+	struct scatterlist sglis[32];
+};
+/*
+struct class *adcdma_class;：指向设备类的指针，用于创建设备文件。
+struct device *adcdma_dev;：指向设备的指针，用于表示设备。
+wait_queue_head_t read_queue;：用于实现阻塞等待的等待队列头部。
+int irq_reprot;：IRQ 报告标志，用于标识是否接收到中断。
+int trans_en;：传输使能标志，用于标识 DMA 是否启用。
+dev_t t_dev;：设备号，用于标识设备。
+struct gpio_desc *reset_gpio;：复位 GPIO 描述符，用于控制设备复位。
+struct gpio_desc *enable_gpio;：使能 GPIO 描述符，用于控制设备使能。
+struct adcdma_para *dmad;：指向 adcdma_para 结构体的指针，用于管理 DMA 参数。
+int used;：设备使用标志，用于标识设备是否被使用。
+*/
+struct adcdma_fun
+{
+	struct class *adcdma_class;
+	struct device *adcdma_dev;
+	wait_queue_head_t read_queue;
+	int irq_reprot;
+	int trans_en;
+	dev_t t_dev;
+	struct gpio_desc *reset_gpio;
+	struct gpio_desc *enable_gpio;
+	struct adcdma_para *dmad;
+	int used;
+};
+
+/*
+CMD_GET_DMADATA：用于从设备中获取 ADC 数据的命令，对应的宏 _IO(ADC_IOCTL_MAGIC, 0) 表示没有参数的 IOCTL 命令。
+CMD_SET_START：用于启动 ADC 传输的命令，对应的宏 _IO(ADC_IOCTL_MAGIC, 1) 表示没有参数的 IOCTL 命令。
+*/
+#define ADC_IOCTL_MAGIC 'M'
+
+#define CMD_GET_DMADATA _IO(ADC_IOCTL_MAGIC, 0)
+#define CMD_SET_START _IO(ADC_IOCTL_MAGIC, 1)
+
+/*
+定义了一个名为 irq_change_mem 的静态函数，用于处理中断并切换 DMA 内存块。下面是对函数的注释和解析：
+*/
+static void irq_change_mem(struct adcdma_para *dmap, int num)
+{
+	struct adcdma_para *dmad_tmp = dmap; //创建一个临时指针 dmad_tmp，指向传入的 adcdma_para 结构体。
+	int next;
+
+	dmad_tmp->mem_flag |= (1 << dmad_tmp->mem_switch); //将当前内存块的标志位置为已使用，即将对应位置 1
+	next = (dmad_tmp->mem_switch + 1) % dmad_tmp->buf_con; //计算下一个要使用的内存块的索引
+	if ((dmad_tmp->mem_flag & (1 << next)) == 0) //检查下一个内存块是否已被使用
+	{
+        //如果未被使用，则切换到下一个内存块并调用 adcdma_setup 函数进行设置，并通过 dma_async_issue_pending 函数发出 DMA 异步操作请求。
+		dmad_tmp->mem_switch = next; 
+		adcdma_setup(dmap, next);
+		dma_async_issue_pending(dmap->dma);
+	}
+	else
+	{
+        //如果已被使用，则打印错误信息
+		printk("mem change err %d\n", next);
+	}
+}
+/*
+定义了一个名为 adcdma_irq_handler 的静态函数，用于处理 ADC DMA 的中断事件。下面是对函数的注释和解析
+*/
+static void adcdma_irq_handler(void *data)
+{
+	int num = (int)data; //将 data 转换为整数类型，表示中断号
+
+	//	printk("irq %d\n", num);
+	adcdma_data->irq_reprot = 1; //将 IRQ 报告标志位置为 1，表示接收到中断
+
+	if (adcdma_data->trans_en) //检查传输使能标志是否为真
+	{
+        //如果为真，则唤醒等待队列中的进程，并调用 irq_change_mem 函数切换 DMA 内存块
+		wake_up_interruptible(&adcdma_data->read_queue);
+		irq_change_mem(adcdma_data->dmad, num);
+	}
+}
+/*
+定义了一个名为 adcdma_setup 的函数，用于设置 ADC DMA 的参数并提交 DMA 传输请求。根据 ADC_DMAINIT_S 宏的定义，函数会选择不同的初始化方式
+*/
+static int adcdma_setup(struct adcdma_para *dmap, int nfb)
+{
+	struct dma_async_tx_descriptor *desc; //DMA 异步传输描述符，用于描述 DMA 传输的参数和状态
+	struct scatterlist *rx_sg = &dmap->sglis[nfb]; //散射-聚集列表（scatter-gather list，SG），用于描述 DMA 操作中的内存分布情况
+	struct dma_device *rx_dev = dmap->dma->device; //DMA 设备指针，用于表示 DMA 控制器的设备
+	enum dma_ctrl_flags flags; //DMA 控制标志，用于设置 DMA 控制参数
+	int ret = 0;
+
+	flags = DMA_PREP_INTERRUPT;
+
+//如果 ADC_DMAINIT_S 宏为真，表示使用 dmaengine_prep_slave_single 函数进行初始化：
+#if ADC_DMAINIT_S
+	desc = dmaengine_prep_slave_single(dmap->dma, dmap->adc_phys[nfb],
+									   ADCDATA_SIZE, DMA_DEV_TO_MEM, flags);  //用于准备一个单一的 DMA 传输，将数据从设备传输到内存。
+	if (!desc)
+	{
+		pr_err("Failed to prepare DMA descriptor\n");
+		return -ENOMEM;
+	}
+	else
+	{
+        //如果成功准备了 DMA 描述符，则将其提交给 DMA 引擎进行传输，并设置回调函数 adcdma_irq_handler 处理传输完成的中断
+		ret = dmaengine_submit(desc);
+		if (ret < 0)
+			printk("submit err\n");
+		desc->callback = adcdma_irq_handler;
+		desc->callback_param = (void *)nfb;
+	}
+//如果 ADC_DMAINIT_S 宏为假，表示使用手动分配和映射内存的方式进行初始化：
+#else
+	dmap->adc_virt[nfb] = kmalloc(ADCDATA_SIZE, GFP_KERNEL);
+	dma_addr_t adc_dma_rx;
+	dma_cookie_t rx_cookie;
+
+	memset(dmap->adc_virt[nfb], 0, ADCDATA_SIZE);
+
+	adc_dma_rx = dma_map_single(rx_dev->dev, dmap->adc_virt[nfb],
+								ADCDATA_SIZE, DMA_MEM_TO_DEV);
+
+	dma_unmap_single(rx_dev->dev, adc_dma_rx,
+					 ADCDATA_SIZE,
+					 DMA_MEM_TO_DEV);
+
+	adc_dma_rx = dma_map_single(rx_dev->dev, dmap->adc_virt[nfb],
+								ADCDATA_SIZE, DMA_DEV_TO_MEM);
+
+	sg_init_table(rx_sg, 1);
+	sg_dma_address(rx_sg) = adc_dma_rx;
+	sg_dma_len(rx_sg) = ADCDATA_SIZE;
+
+	desc = rx_dev->device_prep_slave_sg(dmap->dma, rx_sg, 1,
+										DMA_DEV_TO_MEM, flags, NULL);
+
+	rx_cookie = desc->tx_submit(desc);
+	desc->callback = adcdma_irq_handler;
+	desc->callback_param = (void *)nfb;
+#endif
+
+	return 0;
+}
+
+static int data_to_user(struct adcdma_para *dmap, void __user *user_buf)
+{
+	int size;
+	int ret = 0;
+
+	size = ADCDATA_SIZE;
+	ret = copy_to_user(user_buf, dmap->adc_virt[dmap->read_mem], size) ? -EFAULT : 0;
+	// if (adcdma_data->trans_en == 1)
+	// adcdma_setup(dmap,dmap->read_mem);
+	//	dma_async_issue_pending(dmap->dma);
+	dmap->mem_flag &= ~(1 << dmap->read_mem);
+	//	printk("ioctl free mem %d\n", dmap->read_mem);
+	dmap->read_mem = (dmap->read_mem + 1) % dmap->buf_con;
+	return ret;
+}
+
+/*
+实现了设备驱动程序的 ioctl 函数，用于处理用户空间程序发起的设备控制命令
+*/
+static long adcdma_func_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
+{
+	int ret = 0;
+	void __user *user_arg = (void __user *)arg; //将 arg 转换为用户空间指针，用于访问用户空间的数据
+	int flag;
+	int n;
+
+	switch (cmd)
+	{
+	//从设备获取 AD 数据
+	case CMD_GET_DMADATA:
+		ret = data_to_user(adcdma_data->dmad, user_arg);
+		break;
+	//启动 DMA 传输
+	case CMD_SET_START:
+		copy_from_user(&flag, user_arg, sizeof(flag));
+		printk("flag = %d\n", flag);
+
+		adcdma_data->dmad->mem_switch = 0;
+		adcdma_data->dmad->mem_flag = 0;
+		adcdma_data->dmad->read_mem = 0;
+		//根据 flag 设置传输使能标志，并根据需要进行 DMA 设置和传输发起
+		if (flag == 0) 
+		{
+			adcdma_data->trans_en = 0;
+			dmaengine_terminate_all(adcdma_data->dmad->dma); //函数终止当前 DMA 通道上的所有传输，确保传输完全停止
+		}
+		else
+		{
+			adcdma_data->trans_en = 1;
+
+			ret = adcdma_setup(adcdma_data->dmad, 0);
+			dma_async_issue_pending(adcdma_data->dmad->dma); //发出 DMA 异步操作请求，开始数据传输
+		}
+		gpiod_set_value_cansleep(adcdma_data->enable_gpio, flag);
+
+		break;
+
+	default:
+		ret = -EFAULT;
+		break;
+	}
+	return ret;
+}
+/*
+处理用户空间程序对设备文件的轮询操作
+*/
+static unsigned int adcdma_func_poll(struct file *file, struct poll_table_struct *wait)
+{
+	int mask = 0; //初始化轮询事件掩码为 0
+
+	poll_wait(file, &(adcdma_data->read_queue), wait); //将当前进程添加到设备等待队列中，以便在设备事件发生时唤醒进程
+	if (adcdma_data->irq_reprot == 1) //如果 IRQ 报告标志为 1，则清除 IRQ 报告标志并设置轮询事件掩码为可读事件（POLLIN | POLLRDNORM）
+	{
+		adcdma_data->irq_reprot = 0;
+		mask |= (POLLIN | POLLRDNORM);
+	}
+
+	return mask;
+}
+/*
+重置 ADC DMA 设备
+*/
+void adcdma_reset(void)
+{
+	gpiod_set_value_cansleep(adcdma_data->reset_gpio, 0);
+	gpiod_set_value_cansleep(adcdma_data->enable_gpio, 0);
+	gpiod_set_value_cansleep(adcdma_data->reset_gpio, 1);
+}
+/*
+打开设备文件
+*/
+int adcdma_func_open(struct inode *inode, struct file *file)
+{
+	int ret = 0;
+
+	if (adcdma_data->used >= 1) //如果设备已被打开（used >= 1），则打印驱动程序忙的消息并返回 -EBUSY 错误码
+	{
+		printk("%s driver busy\n", file->f_path.dentry->d_iname);
+		return -EBUSY;
+	}
+	adcdma_data->used = 1;
+
+	adcdma_data->trans_en = 1;
+
+	// dmaengine_terminate_all(adcdma_data->dmad[i]->dma);
+
+	//将 DMA 参数重置，包括内存块切换、内存块标志和读取的内存块索引
+	adcdma_data->dmad->mem_switch = 0;
+	adcdma_data->dmad->mem_flag = 0;
+	adcdma_data->dmad->read_mem = 0;
+	// adcdma_reset();
+
+	return ret;
+}
+/*
+关闭设备文件
+*/
+int adcdma_func_release(struct inode *inode, struct file *file)
+
+{
+	int j = 0;
+
+	dmaengine_terminate_all(adcdma_data->dmad->dma); //终止当前 DMA 通道上的所有传输
+	adcdma_data->trans_en = 0;
+	adcdma_data->used = 0;
+
+#if !ADC_DMAINIT_S
+
+	for (j = 0; j < adcdma_data->dmad->buf_con; j++)
+		kfree(adcdma_data->dmad->adc_virt[j]);
+#endif
+	return 0;
+}
+
+const struct file_operations adcdma_fops =
+	{
+		.owner = THIS_MODULE,
+		.open = adcdma_func_open,
+		.release = adcdma_func_release,
+		.unlocked_ioctl = adcdma_func_ioctl,
+		.poll = adcdma_func_poll,
+};
+/*
+初始化 ADC DMA 的字符设备
+*/
+int adcdma_cdev_init(struct adcdma_fun *pdata)
+{
+	int rc;
+	struct cdev *c_dev;
+
+	rc = alloc_chrdev_region(&pdata->t_dev, 0, 1, "adcdma_fun"); //分配字符设备的主次设备号
+	if (rc)
+		goto out_err;
+
+	c_dev = cdev_alloc(); //分配一个字符设备结构体
+	if (!c_dev)
+		goto out_err;
+
+	cdev_init(c_dev, &adcdma_fops); //初始化字符设备结构体
+	rc = cdev_add(c_dev, pdata->t_dev, 1); //将字符设备添加到系统
+	if (rc)
+		goto out_unreg;
+
+	pdata->adcdma_class = class_create(THIS_MODULE, "adcdma"); //创建设备类
+	if (IS_ERR(pdata->adcdma_class))
+	{
+		printk("[err]class_create error\n");
+		rc = -1;
+		goto out_devdel;
+	}
+
+	pdata->adcdma_dev = device_create(pdata->adcdma_class, NULL, pdata->t_dev, NULL, "adcdma_fun"); //创建设备
+	if (!pdata->adcdma_dev)
+	{
+		rc = -1;
+		goto class_err;
+	}
+
+	return 0;
+
+class_err:
+	class_destroy(pdata->adcdma_class);
+
+out_devdel:
+	cdev_del(c_dev);
+
+out_unreg:
+	unregister_chrdev_region(pdata->t_dev, 1);
+
+out_err:
+
+	return rc;
+}
+/*
+从设备树中读取 ADC DMA 的配置信息并初始化相关数据结构
+*/
+int of_adcdma_data(struct adcdma_fun *pdata, struct platform_device *pdev)
+{
+	int cnt = 0;
+	int ret = 0;
+	int i = 0;
+	int hsize = 0;
+
+	pdata->reset_gpio = devm_gpiod_get_optional(&pdev->dev, "reset", //获取复位 GPIO，如果未找到则返回错误
+												GPIOD_OUT_LOW);
+	if (IS_ERR(pdata->reset_gpio))
+	{
+
+		printk("[zgq]get reset gpio err\n");
+		return PTR_ERR(pdata->reset_gpio);
+	}
+
+	pdata->enable_gpio = devm_gpiod_get_optional(&pdev->dev, "enable", //获取使能 GPIO，如果未找到则返回错误
+												 GPIOD_OUT_LOW);
+	if (IS_ERR(pdata->enable_gpio))
+	{
+		printk("[zgq]get enable gpio err\n");
+		return PTR_ERR(pdata->enable_gpio);
+	}
+	adcdma_reset();
+
+	pdata->dmad = devm_kmalloc(&pdev->dev, sizeof(struct adcdma_para), GFP_KERNEL); //分配 DMA 参数结构体的内存
+	if (pdata->dmad == NULL)
+	{
+		printk("kmalloc err\n");
+		return -1;
+	}
+	memset(pdata->dmad, 0, sizeof(struct adcdma_para)); //将 DMA 参数结构体清零
+	pdata->dmad->dma = dma_request_chan(&pdev->dev, "adc"); //请求 DMA 通道
+	if (IS_ERR_OR_NULL(pdata->dmad->dma))
+	{
+		printk("get dma0 err\n");
+		return PTR_ERR(pdata->dmad->dma);
+	}
+
+	ret = of_property_read_u32(pdev->dev.of_node, //从设备树中读取缓存数量
+							   "num-buf", &cnt);
+	if (ret < 0)
+	{
+		pr_err("adcdmatest: missing num-frm property\n");
+		return ret;
+	}
+	cnt = cnt > 32 ? 32 : cnt;
+	pdata->dmad->buf_con = cnt; //设置 DMA 参数结构体中的缓存数量
+
+	hsize = ADCDATA_SIZE;
+
+#if ADC_DMAINIT_S
+	for (i = 0; i < cnt; i++)
+	{
+		/*
+		分配一段连续的内存，用于 DMA 传输，并返回虚拟地址和物理地址
+
+		&pdev->dev：设备结构体指针，用于指定分配内存的设备上下文。
+		PAGE_ALIGN(hsize)：将 hsize 向上对齐到页大小的倍数，以保证分配的内存大小是页大小的整数倍。
+		&pdata->dmad->adc_phys[i]：用于存储分配到的物理地址的指针。
+		GFP_KERNEL：内存分配标志，表示在内核堆中分配内存，可能会阻塞进程。
+		*/
+		pdata->dmad->adc_virt[i] = dma_alloc_coherent(&pdev->dev, PAGE_ALIGN(hsize), 
+													  &pdata->dmad->adc_phys[i], GFP_KERNEL);
+		if (pdata->dmad->adc_virt[i] == NULL)
+		{
+			printk("can't alloc mem\n");
+		}
+		memset(pdata->dmad->adc_virt[i], 0, hsize);
+	}
+#endif
+	init_waitqueue_head(&pdata->read_queue);
+	return 0;
+}
+/*
+在设备被检测到时执行初始化操作
+*/
+static int adcdma_fun_probe(struct platform_device *pdev)
+{
+	struct device *dev = &pdev->dev;
+	struct adcdma_fun *pdata = dev_get_platdata(dev); //获取设备的平台数据指针
+	int ret = 0;
+
+	if (!pdata) //如果平台数据指针为空，则说明设备没有平台数据，需要进行初始化
+	{
+		pdata = devm_kzalloc(dev, sizeof(struct adcdma_fun), GFP_KERNEL);
+		if (!pdata)
+			return -ENOMEM;
+
+		platform_set_drvdata(pdev, pdata); //将平台数据指针保存在设备结构体中，以便后续使用
+	} 
+	adcdma_data = pdata;
+	ret = of_adcdma_data(pdata, pdev); //从设备树中读取配置信息并初始化设备
+	if (ret < 0)
+		goto out;
+
+	ret = adcdma_cdev_init(pdata); //初始化字符设备
+	if (ret < 0)
+		goto out;
+
+out:
+	return ret;
+}
+/*
+释放 DMA 缓存所占用的内存
+*/
+static void clean_dma(struct platform_device *pdev, struct adcdma_para *dmap)
+{
+	int size;
+	int i = 0;
+
+	size = ADCDATA_SIZE;
+
+#if ADC_DMAINIT_S
+
+	for (i = 0; i < dmap->buf_con; i++)
+	{
+		dma_free_coherent(&pdev->dev, PAGE_ALIGN(size),
+						  dmap->adc_virt[i], dmap->adc_phys[i]);
+	}
+#endif
+}
+/*
+在设备被移除时执行清理操作
+*/
+static int adcdma_fun_remove(struct platform_device *pdev)
+{
+
+	dma_release_channel(adcdma_data->dmad->dma);
+	clean_dma(pdev, adcdma_data->dmad);
+
+	device_unregister(adcdma_data->adcdma_dev);
+	unregister_chrdev_region(adcdma_data->t_dev, 1);
+	class_destroy(adcdma_data->adcdma_class);
+	return 0;
+}
+/*
+定义了一个名为 adcdma_fun_of_match 的设备树匹配表，用于匹配设备树中的设备节点
+*/
+static struct of_device_id adcdma_fun_of_match[] = {
+	{
+		.compatible = "adcdma_demo",
+	},
+	{},
+};
+/*
+定义了一个名为 adcdma_fun_device_driver 的平台驱动程序，用于管理设备的探测和移除
+*/
+static struct platform_driver adcdma_fun_device_driver = {
+	.probe = adcdma_fun_probe,
+	.remove = adcdma_fun_remove,
+	.driver = {
+		.name = "adcdma_demo",
+		.owner = THIS_MODULE,
+		.of_match_table = of_match_ptr(adcdma_fun_of_match),
+	}
+};
+
+static int __init adcdma_fun_init(void)
+{
+	return platform_driver_register(&adcdma_fun_device_driver); //注册平台驱动程序
+}
+
+static void __exit adcdma_fun_exit(void)
+{
+	platform_driver_unregister(&adcdma_fun_device_driver); //注销平台驱动程序
+}
+
+late_initcall(adcdma_fun_init);
+module_exit(adcdma_fun_exit);
+
+// module_platform_driver(adcdma_fun_device_driver);
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("uisrc");

drivers/dma_adc.c

+#include <linux/wait.h>
+#include <linux/poll.h>
+#include <linux/cdev.h>
+#include <linux/slab.h>
+#include <linux/errno.h>
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/device.h>
+#include <linux/interrupt.h>
+#include <linux/gpio.h>
+#include <linux/of.h>
+#include <linux/of_platform.h>
+#include <linux/of_gpio.h>
+#include <linux/of_address.h>
+#include <linux/sched.h>
+#include <linux/delay.h>
+#include <linux/workqueue.h>
+#include <linux/mm.h>
+#include <linux/exportfs.h>
+#include <linux/clk.h>
+#include <linux/init.h>
+#include <linux/platform_device.h>
+#include <linux/regmap.h>
+#include <linux/of_dma.h>
+#include <linux/dma-mapping.h>
+#include <linux/dmaengine.h>
+#include <linux/dma/xilinx_dma.h>
+
+#define ADC_DMAINIT_S 1
+
+#define ADCDATA_SIZE (1024 * 1024)
+
+/*
+ *buf_con:缓存数,不大于32
+ *adc_phys:dma物理内存地址
+ *adc_virt:dma物理内存对应的映射地址
+ *mem_switch:当前dma使用的内存
+ *mem_flag:缓存标识，被dma写之后对应位置1，读取之后对应位置0
+ *read_mem:当前读取的内存块
+ *
+ */
+
+struct adcdma_para
+{
+	struct dma_chan *dma;
+	int buf_con;
+	int mem_switch;
+	int mem_flag;
+	int read_mem;
+	phys_addr_t adc_phys[32];
+	void __iomem *adc_virt[32];
+	struct scatterlist sglis[32];
+};
+
+struct adcdma_fun
+{
+	struct class *adcdma_class;
+	struct device *adcdma_dev;
+	wait_queue_head_t read_queue;
+	int irq_reprot;
+	int trans_en;
+	dev_t t_dev;
+	struct gpio_desc *reset_gpio;
+	struct gpio_desc *enable_gpio;
+	struct adcdma_para *dmad;
+	int used;
+};
+struct adcdma_fun *adcdma_data;
+
+extern int cam_5640_init(int flag);
+static int adcdma_setup(struct adcdma_para *dmap, int nfb);
+
+#define ADC_IOCTL_MAGIC 'M'
+
+#define CMD_GET_DMADATA _IO(ADC_IOCTL_MAGIC, 0)
+#define CMD_SET_START _IO(ADC_IOCTL_MAGIC, 1)
+
+static void irq_change_mem(struct adcdma_para *dmap, int num)
+{
+	struct adcdma_para *dmad_tmp = dmap;
+	int next;
+
+	dmad_tmp->mem_flag |= (1 << dmad_tmp->mem_switch);
+	next = (dmad_tmp->mem_switch + 1) % dmad_tmp->buf_con;
+	if ((dmad_tmp->mem_flag & (1 << next)) == 0)
+	{
+		dmad_tmp->mem_switch = next;
+		adcdma_setup(dmap, next);
+		dma_async_issue_pending(dmap->dma);
+	}
+	else
+	{
+		printk("mem change err %d\n", next);
+	}
+}
+
+static void adcdma_irq_handler(void *data)
+{
+	int num = (int)data;
+
+	//	printk("irq %d\n", num);
+	adcdma_data->irq_reprot = 1;
+
+	if (adcdma_data->trans_en)
+	{
+		wake_up_interruptible(&adcdma_data->read_queue);
+		irq_change_mem(adcdma_data->dmad, num);
+	}
+}
+
+static int adcdma_setup(struct adcdma_para *dmap, int nfb)
+{
+	struct dma_async_tx_descriptor *desc;
+	struct scatterlist *rx_sg = &dmap->sglis[nfb];
+	struct dma_device *rx_dev = dmap->dma->device;
+	enum dma_ctrl_flags flags;
+	int ret = 0;
+
+	flags = DMA_PREP_INTERRUPT;
+
+#if ADC_DMAINIT_S
+	desc = dmaengine_prep_slave_single(dmap->dma, dmap->adc_phys[nfb],
+									   ADCDATA_SIZE, DMA_DEV_TO_MEM, flags);
+	if (!desc)
+	{
+		pr_err("Failed to prepare DMA descriptor\n");
+		return -ENOMEM;
+	}
+	else
+	{
+		ret = dmaengine_submit(desc);
+		if (ret < 0)
+			printk("submit err\n");
+		desc->callback = adcdma_irq_handler;
+		desc->callback_param = (void *)nfb;
+	}
+#else
+	dmap->adc_virt[nfb] = kmalloc(ADCDATA_SIZE, GFP_KERNEL);
+	dma_addr_t adc_dma_rx;
+	dma_cookie_t rx_cookie;
+
+	memset(dmap->adc_virt[nfb], 0, ADCDATA_SIZE);
+
+	adc_dma_rx = dma_map_single(rx_dev->dev, dmap->adc_virt[nfb],
+								ADCDATA_SIZE, DMA_MEM_TO_DEV);
+
+	dma_unmap_single(rx_dev->dev, adc_dma_rx,
+					 ADCDATA_SIZE,
+					 DMA_MEM_TO_DEV);
+
+	adc_dma_rx = dma_map_single(rx_dev->dev, dmap->adc_virt[nfb],
+								ADCDATA_SIZE, DMA_DEV_TO_MEM);
+
+	sg_init_table(rx_sg, 1);
+	sg_dma_address(rx_sg) = adc_dma_rx;
+	sg_dma_len(rx_sg) = ADCDATA_SIZE;
+
+	desc = rx_dev->device_prep_slave_sg(dmap->dma, rx_sg, 1,
+										DMA_DEV_TO_MEM, flags, NULL);
+
+	rx_cookie = desc->tx_submit(desc);
+	desc->callback = adcdma_irq_handler;
+	desc->callback_param = (void *)nfb;
+#endif
+
+	return 0;
+}
+
+static int data_to_user(struct adcdma_para *dmap, void __user *user_buf)
+{
+	int size;
+	int ret = 0;
+
+	size = ADCDATA_SIZE;
+	ret = copy_to_user(user_buf, dmap->adc_virt[dmap->read_mem], size) ? -EFAULT : 0;
+	// if (adcdma_data->trans_en == 1)
+	// adcdma_setup(dmap,dmap->read_mem);
+	//	dma_async_issue_pending(dmap->dma);
+	dmap->mem_flag &= ~(1 << dmap->read_mem);
+	//	printk("ioctl free mem %d\n", dmap->read_mem);
+	dmap->read_mem = (dmap->read_mem + 1) % dmap->buf_con;
+	return ret;
+}
+
+static long adcdma_func_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
+{
+	int ret = 0;
+	void __user *user_arg = (void __user *)arg;
+	int flag;
+	int n;
+
+	switch (cmd)
+	{
+	case CMD_GET_DMADATA:
+		ret = data_to_user(adcdma_data->dmad, user_arg);
+		break;
+
+	case CMD_SET_START:
+		copy_from_user(&flag, user_arg, sizeof(flag));
+		printk("flag = %d\n", flag);
+
+		adcdma_data->dmad->mem_switch = 0;
+		adcdma_data->dmad->mem_flag = 0;
+		adcdma_data->dmad->read_mem = 0;
+
+		if (flag == 0)
+		{
+			adcdma_data->trans_en = 0;
+			dmaengine_terminate_all(adcdma_data->dmad->dma);
+		}
+		else
+		{
+			adcdma_data->trans_en = 1;
+
+			ret = adcdma_setup(adcdma_data->dmad, 0);
+			dma_async_issue_pending(adcdma_data->dmad->dma);
+		}
+		gpiod_set_value_cansleep(adcdma_data->enable_gpio, flag);
+
+		break;
+
+	default:
+		ret = -EFAULT;
+		break;
+	}
+	return ret;
+}
+
+static unsigned int adcdma_func_poll(struct file *file, struct poll_table_struct *wait)
+{
+	int mask = 0;
+
+	poll_wait(file, &(adcdma_data->read_queue), wait);
+	if (adcdma_data->irq_reprot == 1)
+	{
+		adcdma_data->irq_reprot = 0;
+		mask |= (POLLIN | POLLRDNORM);
+	}
+
+	return mask;
+}
+
+void adcdma_reset(void)
+{
+	gpiod_set_value_cansleep(adcdma_data->reset_gpio, 0);
+	gpiod_set_value_cansleep(adcdma_data->enable_gpio, 0);
+	gpiod_set_value_cansleep(adcdma_data->reset_gpio, 1);
+}
+
+int adcdma_func_open(struct inode *inode, struct file *file)
+{
+	int ret = 0;
+
+	if (adcdma_data->used >= 1)
+	{
+		printk("%s driver busy\n", file->f_path.dentry->d_iname);
+		return -EBUSY;
+	}
+	adcdma_data->used = 1;
+
+	adcdma_data->trans_en = 1;
+
+	// dmaengine_terminate_all(adcdma_data->dmad[i]->dma);
+	adcdma_data->dmad->mem_switch = 0;
+	adcdma_data->dmad->mem_flag = 0;
+	adcdma_data->dmad->read_mem = 0;
+	// adcdma_reset();
+
+	return ret;
+}
+
+int adcdma_func_release(struct inode *inode, struct file *file)
+
+{
+	int j = 0;
+
+	dmaengine_terminate_all(adcdma_data->dmad->dma);
+	adcdma_data->trans_en = 0;
+	adcdma_data->used = 0;
+
+#if !ADC_DMAINIT_S
+
+	for (j = 0; j < adcdma_data->dmad->buf_con; j++)
+		kfree(adcdma_data->dmad->adc_virt[j]);
+#endif
+	return 0;
+}
+
+const struct file_operations adcdma_fops =
+	{
+		.owner = THIS_MODULE,
+		.open = adcdma_func_open,
+		.release = adcdma_func_release,
+		.unlocked_ioctl = adcdma_func_ioctl,
+		.poll = adcdma_func_poll,
+};
+
+int adcdma_cdev_init(struct adcdma_fun *pdata)
+{
+	int rc;
+	struct cdev *c_dev;
+
+	rc = alloc_chrdev_region(&pdata->t_dev, 0, 1, "adcdma_fun");
+
+	if (rc)
+		goto out_err;
+
+	c_dev = cdev_alloc();
+	if (!c_dev)
+		goto out_err;
+
+	cdev_init(c_dev, &adcdma_fops);
+	rc = cdev_add(c_dev, pdata->t_dev, 1);
+	if (rc)
+		goto out_unreg;
+
+	pdata->adcdma_class = class_create(THIS_MODULE, "adcdma");
+	if (IS_ERR(pdata->adcdma_class))
+	{
+		printk("[err]class_create error\n");
+		rc = -1;
+		goto out_devdel;
+	}
+
+	pdata->adcdma_dev = device_create(pdata->adcdma_class, NULL, pdata->t_dev, NULL, "adcdma_fun");
+	if (!pdata->adcdma_dev)
+	{
+		rc = -1;
+		goto class_err;
+	}
+
+	return 0;
+
+class_err:
+	class_destroy(pdata->adcdma_class);
+
+out_devdel:
+	cdev_del(c_dev);
+
+out_unreg:
+	unregister_chrdev_region(pdata->t_dev, 1);
+
+out_err:
+
+	return rc;
+}
+
+int of_adcdma_data(struct adcdma_fun *pdata, struct platform_device *pdev)
+{
+	int cnt = 0;
+	int ret = 0;
+	int i = 0;
+	int hsize = 0;
+
+	pdata->reset_gpio = devm_gpiod_get_optional(&pdev->dev, "reset",
+												GPIOD_OUT_LOW);
+	if (IS_ERR(pdata->reset_gpio))
+	{
+
+		printk("[zgq]get reset gpio err\n");
+		return PTR_ERR(pdata->reset_gpio);
+	}
+
+	pdata->enable_gpio = devm_gpiod_get_optional(&pdev->dev, "enable",
+												 GPIOD_OUT_LOW);
+	if (IS_ERR(pdata->enable_gpio))
+	{
+		printk("[zgq]get enable gpio err\n");
+		return PTR_ERR(pdata->enable_gpio);
+	}
+	adcdma_reset();
+
+	pdata->dmad = devm_kmalloc(&pdev->dev, sizeof(struct adcdma_para), GFP_KERNEL);
+	if (pdata->dmad == NULL)
+	{
+		printk("kmalloc err\n");
+		return -1;
+	}
+	memset(pdata->dmad, 0, sizeof(struct adcdma_para));
+	pdata->dmad->dma = dma_request_chan(&pdev->dev, "adc");
+	if (IS_ERR_OR_NULL(pdata->dmad->dma))
+	{
+		printk("get dma0 err\n");
+		return PTR_ERR(pdata->dmad->dma);
+	}
+
+	ret = of_property_read_u32(pdev->dev.of_node,
+							   "num-buf", &cnt);
+	if (ret < 0)
+	{
+		pr_err("adcdmatest: missing num-frm property\n");
+		return ret;
+	}
+	cnt = cnt > 32 ? 32 : cnt;
+	pdata->dmad->buf_con = cnt;
+
+	hsize = ADCDATA_SIZE;
+
+#if ADC_DMAINIT_S
+	for (i = 0; i < cnt; i++)
+	{
+		pdata->dmad->adc_virt[i] = dma_alloc_coherent(&pdev->dev, PAGE_ALIGN(hsize),
+													  &pdata->dmad->adc_phys[i], GFP_KERNEL);
+		if (pdata->dmad->adc_virt[i] == NULL)
+		{
+			printk("can't alloc mem\n");
+		}
+		memset(pdata->dmad->adc_virt[i], 0, hsize);
+	}
+#endif
+	init_waitqueue_head(&pdata->read_queue);
+	return 0;
+}
+
+static int adcdma_fun_probe(struct platform_device *pdev)
+{
+	struct device *dev = &pdev->dev;
+	struct adcdma_fun *pdata = dev_get_platdata(dev);
+	int ret = 0;
+
+	if (!pdata)
+	{
+		pdata = devm_kzalloc(dev, sizeof(struct adcdma_fun), GFP_KERNEL);
+		if (!pdata)
+			return -ENOMEM;
+
+		platform_set_drvdata(pdev, pdata);
+	}
+	adcdma_data = pdata;
+	ret = of_adcdma_data(pdata, pdev);
+	if (ret < 0)
+		goto out;
+
+	ret = adcdma_cdev_init(pdata);
+	if (ret < 0)
+		goto out;
+
+out:
+	return ret;
+}
+
+static void clean_dma(struct platform_device *pdev, struct adcdma_para *dmap)
+{
+	int size;
+	int i = 0;
+
+	size = ADCDATA_SIZE;
+
+#if ADC_DMAINIT_S
+
+	for (i = 0; i < dmap->buf_con; i++)
+	{
+		dma_free_coherent(&pdev->dev, PAGE_ALIGN(size),
+						  dmap->adc_virt[i], dmap->adc_phys[i]);
+	}
+#endif
+}
+
+static int adcdma_fun_remove(struct platform_device *pdev)
+{
+
+	dma_release_channel(adcdma_data->dmad->dma);
+	clean_dma(pdev, adcdma_data->dmad);
+
+	device_unregister(adcdma_data->adcdma_dev);
+	unregister_chrdev_region(adcdma_data->t_dev, 1);
+	class_destroy(adcdma_data->adcdma_class);
+	return 0;
+}
+
+static struct of_device_id adcdma_fun_of_match[] = {
+	{
+		.compatible = "adcdma_demo",
+	},
+	{},
+};
+
+static struct platform_driver adcdma_fun_device_driver = {
+	.probe = adcdma_fun_probe,
+	.remove = adcdma_fun_remove,
+	.driver = {
+		.name = "adcdma_demo",
+		.owner = THIS_MODULE,
+		.of_match_table = of_match_ptr(adcdma_fun_of_match),
+	}};
+
+static int __init adcdma_fun_init(void)
+{
+	return platform_driver_register(&adcdma_fun_device_driver);
+}
+
+static void __exit adcdma_fun_exit(void)
+{
+	platform_driver_unregister(&adcdma_fun_device_driver);
+}
+
+late_initcall(adcdma_fun_init);
+module_exit(adcdma_fun_exit);
+
+// module_platform_driver(adcdma_fun_device_driver);
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("uisrc");

dts/zynqmp-mzux.dts

+/dts-v1/;
+
+#include "zynqmp.dtsi"
+#include "zynqmp-clk-ccf.dtsi"
+#include <dt-bindings/input/input.h>
+#include <dt-bindings/interrupt-controller/irq.h>
+#include <dt-bindings/gpio/gpio.h>
+#include <dt-bindings/pinctrl/pinctrl-zynqmp.h>
+#include <dt-bindings/phy/phy.h>
+
+/ {
+	model = "UISRC.COM MZU07A-7EV";
+	compatible = "uisrc,mzu07a",
+				"xlnx,zynqmp-zcu100-revC",
+				"xlnx,zynqmp-zcu100",
+				"xlnx,zynqmp";
+
+	aliases {
+		ethernet0 = &gem3;
+		rtc0 = &rtc;
+		i2c0 = &i2c0;
+		serial0 = &uart0;
+		spi0 = &qspi;
+		usb0 = &usb0;
+	};
+	chosen {
+		bootargs = "earlycon clk_ignore_unused";
+		stdout-path = "serial0:115200n8";
+	};
+	memory@0 {
+		device_type = "memory";
+		reg = <0x0 0x0 0x0 0x7ff00000>, <0x00000008 0x00000000 0x0 0x80000000>;
+	};
+};
+
+/ {
+	amba_pl: amba_pl@0 {
+		#address-cells = <2>;
+		#size-cells = <2>;
+		compatible = "simple-bus";
+		ranges ;
+		axi_dma_0: dma@80000000 {
+			#dma-cells = <1>;
+			clock-names = "m_axi_s2mm_aclk", "s_axi_lite_aclk";
+			clocks = <&zynqmp_clk 71>, <&zynqmp_clk 71>;
+			compatible = "xlnx,axi-dma-7.1", "xlnx,axi-dma-1.00.a";
+			interrupt-names = "s2mm_introut";
+			interrupt-parent = <&gic>;
+			interrupts = <0 89 4>;
+			reg = <0x0 0x80000000 0x0 0x10000>;
+			xlnx,addrwidth = <0x20>;
+			xlnx,sg-length-width = <0x17>;
+			dma-channel@80000030 {
+				compatible = "xlnx,axi-dma-s2mm-channel";
+				dma-channels = <0x1>;
+				interrupts = <0 89 4>;
+				xlnx,datawidth = <0x80>;
+				xlnx,device-id = <0x0>;
+			};
+		};
+		gpio_user_rstn: gpio@80010000 {
+			#gpio-cells = <3>;
+			clock-names = "s_axi_aclk";
+			clocks = <&zynqmp_clk 71>;
+			compatible = "xlnx,axi-gpio-2.0", "xlnx,xps-gpio-1.00.a";
+			gpio-controller ;
+			reg = <0x0 0x80010000 0x0 0x10000>;
+			xlnx,all-inputs = <0x0>;
+			xlnx,all-inputs-2 = <0x0>;
+			xlnx,all-outputs = <0x0>;
+			xlnx,all-outputs-2 = <0x0>;
+			xlnx,dout-default = <0x00000000>;
+			xlnx,dout-default-2 = <0x00000000>;
+			xlnx,gpio-width = <0x1>;
+			xlnx,gpio2-width = <0x20>;
+			xlnx,interrupt-present = <0x0>;
+			xlnx,is-dual = <0x0>;
+			xlnx,tri-default = <0xFFFFFFFF>;
+			xlnx,tri-default-2 = <0xFFFFFFFF>;
+		};
+		gpio_user_start: gpio@80020000 {
+			#gpio-cells = <3>;
+			clock-names = "s_axi_aclk";
+			clocks = <&zynqmp_clk 71>;
+			compatible = "xlnx,axi-gpio-2.0", "xlnx,xps-gpio-1.00.a";
+			gpio-controller ;
+			reg = <0x0 0x80020000 0x0 0x10000>;
+			xlnx,all-inputs = <0x0>;
+			xlnx,all-inputs-2 = <0x0>;
+			xlnx,all-outputs = <0x0>;
+			xlnx,all-outputs-2 = <0x0>;
+			xlnx,dout-default = <0x00000000>;
+			xlnx,dout-default-2 = <0x00000000>;
+			xlnx,gpio-width = <0x1>;
+			xlnx,gpio2-width = <0x20>;
+			xlnx,interrupt-present = <0x0>;
+			xlnx,is-dual = <0x0>;
+			xlnx,tri-default = <0xFFFFFFFF>;
+			xlnx,tri-default-2 = <0xFFFFFFFF>;
+		};
+		adcdma_fun_0: adcdma_fun0@0 {
+			compatible = "adcdma_demo";
+			dmas = <&axi_dma_0 0>; 
+			dma-names = "adc";
+			num-buf = <3>;
+			reset-gpios = <&gpio_user_rstn 0 0 GPIO_ACTIVE_HIGH>;
+			enable-gpios = <&gpio_user_start 0 0 GPIO_ACTIVE_HIGH>;
+		};
+	};
+};
+
+
+&fclk0 {
+	status = "okay";
+};
+&gic {
+	num_cpus = <2>;
+	num_interrupts = <96>;
+};
+&lpd_dma_chan1 {
+	status = "okay";
+};
+&lpd_dma_chan2 {
+	status = "okay";
+};
+&lpd_dma_chan3 {
+	status = "okay";
+};
+&lpd_dma_chan4 {
+	status = "okay";
+};
+&lpd_dma_chan5 {
+	status = "okay";
+};
+&lpd_dma_chan6 {
+	status = "okay";
+};
+&lpd_dma_chan7 {
+	status = "okay";
+};
+&lpd_dma_chan8 {
+	status = "okay";
+};
+&xilinx_ams {
+	status = "okay";
+};
+&can1 {
+	status = "okay";
+};
+&cci {
+	status = "okay";
+};
+&zynqmp_dpsub {
+	phy-names = "dp-phy0","dp-phy1";
+	phys = <&lane1 6 0 1 27000000>, <&lane0 6 1 1 27000000>;
+	status = "okay";
+	xlnx,max-lanes = <2>;
+};
+&xlnx_dpdma {
+	status = "okay";
+};
+&gem3 {
+	status = "okay";
+	phy-mode = "rgmii-id";
+	xlnx,ptp-enet-clock = <0x0>;
+	phy-handle = <&ethernet_phy>;
+	ethernet_phy: ethernet-phy@5 {
+		reg = <5>;
+	};
+};
+&fpd_dma_chan1 {
+	status = "okay";
+};
+&fpd_dma_chan2 {
+	status = "okay";
+};
+&fpd_dma_chan3 {
+	status = "okay";
+};
+&fpd_dma_chan4 {
+	status = "okay";
+};
+&fpd_dma_chan5 {
+	status = "okay";
+};
+&fpd_dma_chan6 {
+	status = "okay";
+};
+&fpd_dma_chan7 {
+	status = "okay";
+};
+&fpd_dma_chan8 {
+	status = "okay";
+};
+&gpio {
+	emio-gpio-width = <32>;
+	gpio-mask-high = <0x0>;
+	gpio-mask-low = <0x5600>;
+	status = "okay";
+};
+&gpu {
+	status = "okay";
+	xlnx,tz-nonsecure = <0x1>;
+};
+&i2c0 {
+	status = "okay";
+	clock-frequency = <400000>;
+	scl-gpios = <&gpio 18 GPIO_ACTIVE_HIGH>;
+	sda-gpios = <&gpio 19 GPIO_ACTIVE_HIGH>;
+
+	rtc@68 {
+		compatible = "dallas,ds1337";
+		reg = <0x68>;
+	};
+	eeprom@50 {
+		compatible = "atmel,24c02";
+		//compatible = "at24,24c02";
+		reg = <0x50>;
+	};
+};
+&qspi {
+	status = "okay";
+	is-dual = <1>;
+	num-cs = <1>;
+
+	flash@0 {
+		compatible = "m25p80", "jedec,spi-nor"; /* 32MB */
+		#address-cells = <1>;
+		#size-cells = <1>;
+		reg = <0x0>;
+		spi-rx-bus-width = <4>;
+		spi-tx-bus-width = <4>;
+		spi-max-frequency = <108000000>;
+	};
+};
+&rtc {
+	status = "okay";
+};
+&sata {
+	ceva,p0-burst-params = /bits/ 8 <0x13 0x08 0x4A 0x06>;
+	ceva,p0-cominit-params = /bits/ 8 <0x18 0x40 0x18 0x28>;
+	ceva,p0-comwake-params = /bits/ 8 <0x06 0x14 0x08 0x0E>;
+	ceva,p0-retry-params = /bits/ 16 <0x96A4 0x3FFC>;
+	ceva,p1-burst-params = /bits/ 8 <0x13 0x08 0x4A 0x06>;
+	ceva,p1-cominit-params = /bits/ 8 <0x18 0x40 0x18 0x28>;
+	ceva,p1-comwake-params = /bits/ 8 <0x06 0x14 0x08 0x0E>;
+	ceva,p1-retry-params = /bits/ 16 <0x96A4 0x3FFC>;
+	status = "okay";
+	xlnx,tz-nonsecure-sata0 = <0x0>;
+	xlnx,tz-nonsecure-sata1 = <0x0>;
+};
+&sdhci0 {
+	clock-frequency = <50000000>;
+	status = "okay";
+	xlnx,mio_bank = <0x0>;
+	no-1-8-v;
+	disable-wp;
+};
+&sdhci1 {
+	clock-frequency = <187500000>;
+	status = "okay";
+	xlnx,mio_bank = <0x1>;
+	bus-width = <8>;
+	non-removable;
+	disable-wp;
+};
+&serdes {
+	status = "okay";
+};
+&uart0 {
+	cts-override ;
+	device_type = "serial";
+	port-number = <0>;
+	status = "okay";
+	u-boot,dm-pre-reloc ;
+};
+&usb0 {
+	status = "okay";
+	xlnx,tz-nonsecure = <0x1>;
+	xlnx,usb-polarity = <0x0>;
+	xlnx,usb-reset-mode = <0x0>;
+};
+&dwc3_0 {
+	status = "okay";
+	dr_mode = "host";
+};
+&lpd_watchdog {
+	status = "okay";
+};
+&watchdog0 {
+	status = "okay";
+};
+&pss_ref_clk {
+	clock-frequency = <33333333>;
+};
+&ams_ps {
+	status = "okay";
+};
+&ams_pl {
+	status = "okay";
+};
+&zynqmp_dp_snd_pcm0 {
+	status = "okay";
+};
+&zynqmp_dp_snd_pcm1 {
+	status = "okay";
+};
+&zynqmp_dp_snd_card0 {
+	status = "okay";
+};
+&zynqmp_dp_snd_codec0 {
+	status = "okay";
+};
\ No newline at end of file