• 流式DMA映射实践3：dmaengine与memcpy

    前言


            本次是第三篇。

            第一篇，写一个通用框架，做到拿来就能用。

            第二篇，实现mmap功能，内核中的read_buf和write_buf都映射到用户空间，然后呢。写read_buf和write_buf的最后一个字节为‘R’和'W'，然后再release函数中打印这两个字节。更加复杂的验证，根据需要自行添加，写的太复杂，意义不大。

            第三篇，通过测试app，控制复制src_buf到dst_buf，复制方式可以使用DMA引擎和memcpy，并计算复制过程中消耗的微秒数，并在测试app中验证复制是否准确，尽最大努力保证整个流程的准确无误。

    一 dmaengine标准API

            Linux内核目前推荐使用dmaengine的驱动架构来编写DMA控制器的驱动，同时外设的驱动使用标准的dmaengine API进行DMA的准备、发起和完成时的回调工作。和中断一样，在使用DMA之前，设备驱动程序需首先向dmaengine系统申请DMA通道，申请DMA通道的函数如下：

    1. struct dma_chan *dma_request_slave_channel(struct device *dev, const char *name);
    2. struct dma_chan *__dma_request_channel(const dma_cap_mask_t *mask,
    3.                                          dma_filter_fn fn, void *fn_param);

    使用完DMA通道后，应该利用如下函数释放该通道：

    void dma_release_channel(struct dma_chan *chan);

            之后，一般通过如代码清单11.15的方法初始化并发起一次DMA操作。它通过dmaengine_prep_slave_single（）准备好一些DMA描述符，并填充其完成回调为xxx_dma_fini_callback（），之后通过dmaengine_submit（）把这个描述符插入队列，再通过dma_async_issue_pending（）发起这次DMA动作。DMA完成后，xxx_dma_fini_callback（）函数会被dmaengine驱动自动调用。

    1.   static void xxx_dma_fini_callback(void *data)
    2.   {
    3.          struct completion *dma_complete = data;
    4.  
    5.          complete(dma_complete);
    6.   }
    7.  
    8.   issue_xxx_dma(...)
    9.   {
    10.       rx_desc = dmaengine_prep_slave_single(xxx->rx_chan,
    11.               xxx->dst_start, t->len, DMA_DEV_TO_MEM,
    12.               DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
    13.       rx_desc->callback = xxx_dma_fini_callback;
    14.       rx_desc->callback_param = &xxx->rx_done;
    15.  
    16.       dmaengine_submit(rx_desc);
    17.       dma_async_issue_pending(xxx->rx_chan);
    18.  }

    这点知识不够用啊(⊙o⊙)…。

    二 开始写代码

    头文件Dmaengine.h (include\linux) 

    dmaengine_prep_slave_single的函数原型

    1. static inline struct dma_async_tx_descriptor *dmaengine_prep_slave_single(
    2. 	struct dma_chan *chan, dma_addr_t buf, size_t len,
    3. 	enum dma_transfer_direction dir, unsigned long flags)
    4. {
    5. 	struct scatterlist sg;
    6. 	sg_init_table(&sg, 1);
    7. 	sg_dma_address(&sg) = buf;
    8. 	sg_dma_len(&sg) = len;
    9.  
    10. 	return chan->device->device_prep_slave_sg(chan, &sg, 1,
    11. 						  dir, flags, NULL);
    12. }

    为了让这个函数工作起来，我们要定义如下几个变量

    1. struct dma_async_tx_descriptor *rx_desc;
    2. struct dma_chan rx_chan;
    3. dma_addr_t dst_start;
    4. size_t len = CSS_DMA_IMAGE_SIZE;
    5. enum dma_transfer_direction dir = DMA_MEM_TO_MEM;

    大概写完的伪代码就是这样的

    1. static void css_dma_fini_callback(void *data)
    2. {
    3. 	struct _css_dev_ *css_dev = (struct _css_dev_ *)data;
    4. 	//struct completion *dma_complete = data;
    5. 	DEBUG_CSS("css_dev->name",css_dev->name);
    6. 	//complete(dma_complete);
    7. }
    8. static int css_dma_init(struct _css_dev_ *css_dev)
    9. {
    10. 	struct dma_async_tx_descriptor *rx_desc;
    11. 	struct dma_chan rx_chan;
    12. 	dma_addr_t dst_start;
    13. 	size_t len = CSS_DMA_IMAGE_SIZE;
    14. 	enum dma_transfer_direction dir = DMA_DEV_TO_MEM;
    15. 	
    16. 	rx_desc = dmaengine_prep_slave_single(&rx_chan,
    17.               dst_start, len, dir,
    18.               DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
    19.       rx_desc->callback = xxx_dma_fini_callback;
    20.       rx_desc->callback_param = css_dev;
    21.  
    22.       dmaengine_submit(rx_desc);
    23.       dma_async_issue_pending(css_dev);
    24. }

    三 测试代码

    应用代码：csi_single_mmap.c

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9.  
    10. #define DEBUG_INFO(format,...)	printf("%s:%d"format"\n",\
    11. 	__func__,__LINE__,##__VA_ARGS__);
    12.  
    13. #define _CSS_DMA_DEV_NAME	"/dev/css_dma"
    14.  
    15. #define CSS_DMA_IMAGE_SIZE		(1280*800)
    16.  
    17. #define CSI_DMA_SET_CUR_MAP_BUF_TYPE_IOCTL 0x1001
    18. #define CSI_DMA_FILL_CHAR_AND_RUN_DMAENGIEN_IOCTL	0x1002
    19. #define CSI_DMA_FILL_CHAR_RUN_MEMCPY_IOCTL	0x1003
    20.  
    21. enum _css_dev_buf_type{
    22.    _CSS_DEV_READ_BUF = 0,
    23.    _CSS_DEV_WRITE_BUF,
    24.    _CSS_DEV_UNKNOWN_BUF_TYPE,
    25.    _CSS_DEV_MAX_BUF_TYPE,
    26. };
    27.  
    28. struct __css_dev_ {
    29. 	char *read_buf;
    30. 	char *write_buf;
    31. }_css_dev_;
    32.  
    33.  
    34.  
    35. static int cycle_dmaengine_test(struct __css_dev_ *css_dev,int fd,int count){
    36. 	int i = 0,j = 0;
    37. 	char c = 'a' - 1;
    38. 	for(i = 0;i < count;i++){
    39. 		c = c + 1;
    40. 		
    41. 		if(ioctl(fd,
    42. 				CSI_DMA_FILL_CHAR_AND_RUN_DMAENGIEN_IOCTL,
    43. 				&c) < 0)
    44. 		{
    45. 			perror("ioctl");
    46. 			DEBUG_INFO("ioctl CSI_DMA_FILL_CHAR_IOCTL fail");
    47. 			return -1;
    48. 		}
    49. 		
    50. 		for(j = 0;j < CSS_DMA_IMAGE_SIZE;j++){
    51. 			if(css_dev->read_buf[j] != c || css_dev->write_buf[j] != c){
    52. 				DEBUG_INFO("error:css_dev->read_buf[%d] = %c,css_dev->write_buf[%d] = %c",
    53. 					j,css_dev->read_buf[j],
    54. 					j,css_dev->write_buf[j]);
    55. 				return -1;
    56. 			}
    57. 		}
    58. 		DEBUG_INFO("set c = %c ok",c);
    59. 		if(c == 'z'){
    60. 			c = 'a' - 1;
    61. 		}
    62. 	}
    63. }
    64.  
    65. static int cycle_memcpy_test(struct __css_dev_ *css_dev,int fd,int count){
    66. 	int i = 0,j = 0;
    67. 	char c = 'a' - 1;
    68. 	for(i = 0;i < count;i++){
    69. 		c = c + 1;
    70. 		
    71. 		if(ioctl(fd,
    72. 				CSI_DMA_FILL_CHAR_RUN_MEMCPY_IOCTL,
    73. 				&c) < 0)
    74. 		{
    75. 			perror("ioctl");
    76. 			DEBUG_INFO("ioctl CSI_DMA_FILL_CHAR_IOCTL fail");
    77. 			return -1;
    78. 		}
    79. 		
    80. 		for(j = 0;j < CSS_DMA_IMAGE_SIZE;j++){
    81. 			if(css_dev->read_buf[j] != c || css_dev->write_buf[j] != c){
    82. 				DEBUG_INFO("error:css_dev->read_buf[%d] = %c,css_dev->write_buf[%d] = %c",
    83. 					j,css_dev->read_buf[j],
    84. 					j,css_dev->write_buf[j]);
    85. 				return -1;
    86. 			}
    87. 		}
    88. 		DEBUG_INFO("set c = %c ok",c);
    89. 		if(c == 'z'){
    90. 			c = 'a' - 1;
    91. 		}
    92. 	}
    93. }
    94.  
    95. int main(int argc,char *argv[])
    96. {
    97. 	struct __css_dev_ *css_dev = &_css_dev_;
    98. 	char *name = _CSS_DMA_DEV_NAME;
    99. 	int fd = open(name,O_RDWR);
    100. 	if(fd < 0){
    101. 		DEBUG_INFO("open %s",name);
    102. 		return -1;
    103. 	}
    104. 	DEBUG_INFO("open %s ok",name);
    105. 	if(ioctl(fd,
    106. 			CSI_DMA_SET_CUR_MAP_BUF_TYPE_IOCTL,
    107. 			_CSS_DEV_READ_BUF) < 0)
    108. 	{
    109. 		perror("ioctl");
    110. 		DEBUG_INFO("ioctl fail");
    111. 		goto fail;
    112. 	}
    113. 	css_dev->read_buf = (char*)mmap(NULL,
    114. 		CSS_DMA_IMAGE_SIZE,
    115. 		PROT_READ|PROT_WRITE,
    116. 		MAP_SHARED,fd,0);
    117. 	if(css_dev->read_buf == NULL){
    118. 		perror("mmap");
    119. 		DEBUG_INFO("mmap fail");
    120. 		goto fail;
    121. 	}
    122. 	DEBUG_INFO("css_dev->read_buf = %p",css_dev->read_buf);
    123. 	if(ioctl(fd,
    124. 			CSI_DMA_SET_CUR_MAP_BUF_TYPE_IOCTL,
    125. 			_CSS_DEV_WRITE_BUF) < 0)
    126. 	{
    127. 		perror("ioctl");
    128. 		DEBUG_INFO("ioctl fail");
    129. 		goto fail;
    130. 	}
    131. 	css_dev->write_buf = (char*)mmap(NULL,
    132. 		CSS_DMA_IMAGE_SIZE,
    133. 		PROT_READ|PROT_WRITE,
    134. 		MAP_SHARED,fd,0);
    135. 	if(css_dev->write_buf == NULL){
    136. 		perror("mmap");
    137. 		DEBUG_INFO("mmap fail");
    138. 		goto fail;
    139. 	}
    140. 	
    141. 	DEBUG_INFO("css_dev->write_buf = %p",css_dev->write_buf);
    142. 	cycle_dmaengine_test(css_dev,fd,10);
    143. 	cycle_memcpy_test(css_dev,fd,10);
    144. 	
    145. fail:
    146. 	close(fd);
    147. 	return 0;
    148. }

    驱动代码：csi_single.c

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12. #include 
    13. #include 
    14. #include 
    15. #include 
    16. #include 
    17. #include 
    18.  
    19.  
    20. #define DEBUG_CSS(format,...)\
    21. 		printk(KERN_INFO"info:%s:%s:%d: "format"\n",\
    22. 		__FILE__,__func__,__LINE__,\
    23. 		##__VA_ARGS__)
    24. #define DEBUG_CSS_ERR(format,...)\
    25. 		printk("\001" "1""error:%s:%s:%d: "format"\n",\
    26. 		__FILE__,__func__,__LINE__,\
    27. 		##__VA_ARGS__)
    28.  
    29. #define CSS_DMA_IMAGE_SIZE		(1280*800)
    30.  
    31. #define CSI_DMA_SET_CUR_MAP_BUF_TYPE_IOCTL 0x1001
    32. #define CSI_DMA_FILL_CHAR_AND_RUN_DMAENGIEN_IOCTL	0x1002
    33. #define CSI_DMA_FILL_CHAR_RUN_MEMCPY_IOCTL	0x1003
    34.  
    35.  
    36. enum _css_dev_buf_type{
    37.    _CSS_DEV_READ_BUF = 0,
    38.    _CSS_DEV_WRITE_BUF,
    39.    _CSS_DEV_UNKNOWN_BUF_TYPE,
    40.    _CSS_DEV_MAX_BUF_TYPE,
    41. };
    42. struct _css_dev_{
    43. 	struct file_operations _css_fops;
    44. 	struct miscdevice misc;
    45. 	int buf_size;
    46. 	int buf_size_order;
    47. 	char *src_buf;
    48. 	char *dst_buf;
    49. 	char *user_src_buf_vaddr;
    50. 	char *user_dst_buf_vaddr;
    51. 	dma_addr_t src_addr;
    52. 	dma_addr_t dst_addr;	
    53. 	struct spinlock slock;
    54. 	struct mutex open_lock;
    55. 	char name[10];
    56. 	enum _css_dev_buf_type buf_type; 
    57. 	struct device *dev;
    58. 	struct dma_chan * dma_m2m_chan;
    59. 	struct completion dma_m2m_ok;
    60. 	struct imx_dma_data m2m_dma_data;
    61. 	struct timeval tv_start,tv_end;
    62. 	struct device *chan_dev;
    63. 	struct dma_device *dma_dev;
    64. 	struct dma_async_tx_descriptor *dma_m2m_desc;
    65. };
    66.  
    67. #define _to_css_dev_(file)	(struct _css_dev_ *)container_of(file->f_op,struct _css_dev_,_css_fops)
    68. static int _css_open(struct inode *inode, struct file *file)
    69. {
    70. 	struct _css_dev_ *css_dev = _to_css_dev_(file);
    71. 	DEBUG_CSS("css_dev->name = %s",css_dev->name);
    72. 	return 0;
    73. }
    74. static ssize_t _css_read(struct file *file, char __user *ubuf, size_t size, loff_t *ppos)
    75. {
    76. 	struct _css_dev_ *css_dev = _to_css_dev_(file);
    77. 	DEBUG_CSS("css_dev->name = %s",css_dev->name);
    78. 	return 0;
    79. }
    80. static int _css_mmap (struct file *file, struct vm_area_struct *vma)
    81. {
    82. 	struct _css_dev_ *css_dev = _to_css_dev_(file);
    83. 	char *p = NULL;
    84. 	char **user_addr;
    85.  
    86. 	switch(css_dev->buf_type){
    87. 		case _CSS_DEV_READ_BUF:
    88. 			p = css_dev->src_buf;
    89. 			user_addr = (char**)&css_dev->user_src_buf_vaddr;
    90. 			break;
    91. 		case _CSS_DEV_WRITE_BUF:
    92. 			p = css_dev->dst_buf;
    93. 			user_addr = (char**)&css_dev->user_dst_buf_vaddr;
    94. 			break;
    95. 		default:
    96. 			p = NULL;
    97. 			return -EINVAL;
    98. 			break;			
    99. 	}
    100. 	if (remap_pfn_range(vma, vma->vm_start, virt_to_phys(p) >> PAGE_SHIFT,
    101. 	        vma->vm_end-vma->vm_start, vma->vm_page_prot)) {
    102. 	        DEBUG_CSS_ERR( "remap_pfn_range error\n"); 
    103. 	        return -EAGAIN;
    104. 	}
    105. 	css_dev->buf_type = _CSS_DEV_UNKNOWN_BUF_TYPE;
    106. 	*user_addr = (void*)vma->vm_start;	
    107. 	DEBUG_CSS("mmap ok user_addr = %p kernel addr = %p",*user_addr,p);
    108. 	return 0;
    109. }
    110. static ssize_t _css_write(struct file *file, const char __user *ubuf, size_t size, loff_t *ppos)
    111. {
    112. 	struct _css_dev_ *css_dev = _to_css_dev_(file);
    113. 	DEBUG_CSS("css_dev->name = %s",css_dev->name);
    114. 	return size;
    115. }
    116.  
    117. static int _css_release (struct inode *inode, struct file *file)
    118. {
    119. 	struct _css_dev_ *css_dev = _to_css_dev_(file);
    120. 	DEBUG_CSS("css_dev->name = %s",css_dev->name);
    121. 	DEBUG_CSS("css_dev->src_buf[%d] = %c",css_dev->buf_size - 1,
    122. 		((char*)css_dev->src_buf)[css_dev->buf_size - 1]);
    123. 	DEBUG_CSS("css_dev->dst_buf[%d] = %c",css_dev->buf_size - 1,
    124. 		((char*)css_dev->dst_buf)[css_dev->buf_size - 1]);
    125. 	return 0;
    126. }
    127.  
    128. static int _css_set_buf_type(struct file *file, enum _css_dev_buf_type buf_type)
    129. {
    130. 	unsigned long flags;
    131. 	struct _css_dev_ *css_dev = _to_css_dev_(file);
    132. 	DEBUG_CSS("buf_type=%d",buf_type);
    133. 	if(buf_type >= _CSS_DEV_MAX_BUF_TYPE){
    134. 		DEBUG_CSS_ERR("invalid buf type");
    135. 		return -EINVAL;
    136. 	}
    137. 	spin_lock_irqsave(&css_dev->slock,flags);
    138. 	css_dev->buf_type = buf_type;	
    139. 	spin_unlock_irqrestore(&css_dev->slock,flags);
    140. 	return 0;
    141. }
    142. static void css_dma_async_tx_callback(void *dma_async_param)
    143. {
    144. 	struct _css_dev_ *css_dev = (struct _css_dev_ *)dma_async_param;
    145. 	complete(&css_dev->dma_m2m_ok);
    146. }
    147. static int css_dmaengine_cpy(struct _css_dev_ *css_dev)
    148. {	
    149. 	dma_cookie_t cookie;
    150. 	enum dma_status dma_status;
    151.  
    152. 	do_gettimeofday(&css_dev->tv_start);
    153. 	
    154. 	css_dev->src_addr = dma_map_single(css_dev->chan_dev, css_dev->src_buf, css_dev->buf_size, DMA_TO_DEVICE);	
    155.  
    156. 	css_dev->dst_addr = dma_map_single(css_dev->chan_dev, css_dev->dst_buf, css_dev->buf_size, DMA_FROM_DEVICE);	
    157. 	//DEBUG_CSS("32bit:css_dev->src_addr = %x,css_dev->dst_addr = %x",css_dev->src_addr,css_dev->dst_addr);
    158.  
    159. 	css_dev->dma_m2m_desc = css_dev->dma_dev->device_prep_dma_memcpy(css_dev->dma_m2m_chan,
    160. 													css_dev->dst_addr,
    161. 													css_dev->src_addr,
    162. 													css_dev->buf_size,0);
    163. 	css_dev->dma_m2m_desc->callback = css_dma_async_tx_callback;
    164. 	css_dev->dma_m2m_desc->callback_param = css_dev;
    165. 	init_completion(&css_dev->dma_m2m_ok);
    166. 	cookie = dmaengine_submit(css_dev->dma_m2m_desc);
    167. 	if(dma_submit_error(cookie)){
    168. 		DEBUG_CSS("dmaengine_submit error");
    169. 		return -EINVAL;
    170. 	}
    171. 	dma_async_issue_pending(css_dev->dma_m2m_chan);
    172. 	wait_for_completion(&css_dev->dma_m2m_ok);
    173. 	
    174. 	dma_status = dma_async_is_tx_complete(css_dev->dma_m2m_chan,cookie,NULL,NULL);
    175. 	if(DMA_COMPLETE != dma_status){
    176. 		DEBUG_CSS("error:dma_status = %d",dma_status);
    177. 	}
    178. 	dma_unmap_single(css_dev->chan_dev,css_dev->src_addr,css_dev->buf_size,DMA_TO_DEVICE);
    179. 	dma_unmap_single(css_dev->chan_dev,css_dev->dst_addr,css_dev->buf_size,DMA_FROM_DEVICE);
    180. 	
    181. 	do_gettimeofday(&css_dev->tv_end);
    182. 	DEBUG_CSS("dma used time = %ld us",
    183. 	(css_dev->tv_end.tv_sec - css_dev->tv_start.tv_sec)*1000000 
    184. 	+ (css_dev->tv_end.tv_usec - css_dev->tv_start.tv_usec));
    185. 	return 0;
    186. }
    187.  
    188. static long _css_unlocked_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
    189. {
    190. 	int ret = 0;
    191. 	struct _css_dev_ *css_dev = _to_css_dev_(file);
    192. 	char *p;
    193. 	switch(cmd){
    194. 		case CSI_DMA_SET_CUR_MAP_BUF_TYPE_IOCTL:
    195. 		ret = _css_set_buf_type(file,(enum _css_dev_buf_type)arg);
    196. 		break;
    197. 		case CSI_DMA_FILL_CHAR_AND_RUN_DMAENGIEN_IOCTL:
    198. 		p = (char*)arg;
    199. 		memset(css_dev->src_buf,*p,css_dev->buf_size);		
    200. 		css_dmaengine_cpy(css_dev);
    201. 		break;
    202. 		case CSI_DMA_FILL_CHAR_RUN_MEMCPY_IOCTL:
    203. 		p = (char*)arg;
    204. 		do_gettimeofday(&css_dev->tv_start);
    205. 		memset(css_dev->src_buf,*p,css_dev->buf_size);	
    206. 		do_gettimeofday(&css_dev->tv_end);
    207. 	DEBUG_CSS("memset used time = %ld us",
    208. 	(css_dev->tv_end.tv_sec - css_dev->tv_start.tv_sec)*1000000 
    209. 	+ (css_dev->tv_end.tv_usec - css_dev->tv_start.tv_usec));
    210.  
    211. 		do_gettimeofday(&css_dev->tv_start);
    212. 		memcpy(css_dev->dst_buf,css_dev->src_buf,css_dev->buf_size);
    213. 		do_gettimeofday(&css_dev->tv_end);
    214. 	DEBUG_CSS("memcpy used time = %ld us",
    215. 	(css_dev->tv_end.tv_sec - css_dev->tv_start.tv_sec)*1000000 
    216. 	+ (css_dev->tv_end.tv_usec - css_dev->tv_start.tv_usec));
    217. 		break;
    218. 		default:
    219. 			DEBUG_CSS_ERR("unknown cmd = %x",cmd);
    220. 			ret = -EINVAL;
    221. 			break;
    222. 	}
    223. 	
    224. 	return ret;
    225. }
    226.  
    227. static struct _css_dev_ _global_css_dev = {
    228. 	.name = "lkmao",
    229. 	._css_fops = {
    230. 		.owner = THIS_MODULE,
    231. 		.mmap = _css_mmap,
    232. 		.open = _css_open,
    233. 		.release = _css_release,
    234. 		.read = _css_read,
    235. 		.write = _css_write,
    236. 		.unlocked_ioctl = _css_unlocked_ioctl,
    237. 	},
    238. 	.misc = {
    239. 		.minor = MISC_DYNAMIC_MINOR,
    240. 		.name = "css_dma",
    241. 	},
    242. 	.buf_type = _CSS_DEV_UNKNOWN_BUF_TYPE,
    243. 	.user_src_buf_vaddr = NULL,
    244. 	.user_dst_buf_vaddr = NULL,
    245. 	.m2m_dma_data = {
    246. 		.peripheral_type = IMX_DMATYPE_MEMORY,
    247. 		.priority = DMA_PRIO_HIGH,
    248. 	},
    249. };
    250.  
    251.  
    252. static int css_dev_get_dma_addr(struct _css_dev_ *css_dev,char **vaddr,dma_addr_t *phys, int direction)
    253. {
    254. 	char *p;
    255. 	dma_addr_t dma_addr;
    256.  
    257. 	p = (char*)__get_free_pages(GFP_KERNEL|GFP_DMA,css_dev->buf_size_order);
    258. 	if(p == NULL || IS_ERR(p)){
    259. 		DEBUG_CSS("devm_kmalloc error");
    260. 		return -ENOMEM;
    261. 	}
    262. 	dma_addr = dma_map_single(css_dev->dev, p, css_dev->buf_size, direction);	
    263.  
    264. 	*vaddr = p;
    265. 	*phys = dma_addr;
    266.  
    267. 	DEBUG_CSS("32bit:p = %p,dma_addr = %x",p,dma_addr);
    268. 	return 0;
    269. }
    270.  
    271. static bool css_dma_filter_fn(struct dma_chan *chan, void *filter_param)
    272. {
    273. 	if(!imx_dma_is_general_purpose(chan)){
    274. 		DEBUG_CSS("css_dma_filter_fn error");
    275. 		return false;
    276. 	}
    277. 	chan->private = filter_param;
    278. 	return true;
    279. }
    280.  
    281. static int css_dmaengine_init(struct _css_dev_ *css_dev)
    282. {
    283. 	dma_cap_mask_t dma_m2m_mask;
    284. 	struct dma_slave_config dma_m2m_config = {0};
    285. 	css_dev->m2m_dma_data.peripheral_type = IMX_DMATYPE_MEMORY;
    286. 	css_dev->m2m_dma_data.priority = DMA_PRIO_HIGH;
    287. 	
    288. 	dma_cap_zero(dma_m2m_mask);
    289. 	dma_cap_set(DMA_MEMCPY,dma_m2m_mask);
    290.  
    291. 	
    292.  
    293. 	css_dev->dma_m2m_chan = dma_request_channel(dma_m2m_mask,css_dma_filter_fn,&css_dev->m2m_dma_data);
    294. 	if(!css_dev->dma_m2m_chan){
    295. 		DEBUG_CSS("dma_request_channel error");
    296. 		return -EINVAL;
    297. 	}
    298. 	dma_m2m_config.direction = DMA_MEM_TO_MEM;
    299. 	dma_m2m_config.dst_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
    300. 	dmaengine_slave_config(css_dev->dma_m2m_chan,&dma_m2m_config);
    301.  
    302. 	css_dev->dma_dev = css_dev->dma_m2m_chan->device;
    303. 	css_dev->chan_dev = css_dev->dma_m2m_chan->device->dev;
    304.  
    305. 	
    306. 	
    307. 	return 0;
    308. }
    309.  
    310. static int css_dev_init(struct platform_device *pdev,struct _css_dev_ *css_dev)
    311. {
    312. 	css_dev->misc.fops = &css_dev->_css_fops;
    313.  
    314. 	pr_debug("css_init init ok");
    315. 	mutex_init(&css_dev->open_lock);
    316. 	spin_lock_init(&css_dev->slock);
    317. 	printk("KERN_ALERT = %s",KERN_ALERT);
    318. 	
    319.  
    320. 	css_dev->dev = &pdev->dev;
    321. 	css_dev->buf_size = CSS_DMA_IMAGE_SIZE;
    322. 	css_dev->buf_size_order = get_order(css_dev->buf_size);
    323. 	
    324. 	if(css_dev_get_dma_addr(css_dev,&css_dev->src_buf,&css_dev->src_addr,DMA_TO_DEVICE)){
    325. 		return -ENOMEM;
    326. 	}
    327. 	css_dev->src_buf = (char*)__get_free_pages(GFP_KERNEL|GFP_DMA,css_dev->buf_size_order);
    328. 	if(css_dev->src_buf == NULL || IS_ERR(css_dev->src_buf)){
    329. 		DEBUG_CSS("devm_kmalloc error");
    330. 		return -ENOMEM;
    331. 	}
    332. 	css_dev->dst_buf = (char*)__get_free_pages(GFP_KERNEL|GFP_DMA,css_dev->buf_size_order);
    333. 	if(css_dev->dst_buf == NULL || IS_ERR(css_dev->dst_buf)){
    334. 		DEBUG_CSS("devm_kmalloc error");
    335. 		return -ENOMEM;
    336. 	}
    337. 	DEBUG_CSS("32bit:css_dev->src_buf = %p,css_dev->dst_buf = %p",css_dev->src_buf,css_dev->dst_buf);
    338.  
    339. 	if(misc_register(&css_dev->misc) != 0){
    340. 		DEBUG_CSS("misc_register error");
    341. 		return -EINVAL;
    342. 	}
    343. 	platform_set_drvdata(pdev,css_dev);
    344. 	css_dmaengine_init(css_dev);
    345. 	return 0;
    346. }
    347.  
    348.  
    349. static int css_probe(struct platform_device *pdev)
    350. {
    351. 	struct _css_dev_ *css_dev = (struct _css_dev_ *)&_global_css_dev;
    352. 	if(css_dev_init(pdev,css_dev)){
    353. 		return -EINVAL;
    354. 	}	
    355. 	DEBUG_CSS("init ok");
    356. 	return 0;
    357. }
    358.  
    359. static int css_remove(struct platform_device *pdev)
    360. {
    361. 	struct _css_dev_ *css_dev = &_global_css_dev;
    362.  
    363. 	//dma_unmap_single(css_dev->dev,css_dev->src_addr,css_dev->buf_size,DMA_FROM_DEVICE);
    364. 	//dma_unmap_single(css_dev->dev,css_dev->dst_addr,css_dev->buf_size,DMA_FROM_DEVICE);
    365.  
    366. 	free_page((unsigned long )css_dev->dst_buf);
    367. 	free_page((unsigned long )css_dev->src_buf);
    368.  
    369. 	misc_deregister(&css_dev->misc);
    370. 	dma_release_channel(css_dev->dma_m2m_chan);
    371. 	DEBUG_CSS("exit ok");
    372. 	return 0;
    373. }
    374.  
    375. static const struct of_device_id css_of_ids[] = {
    376. 	{.compatible = "css_dma"},
    377. 	{},
    378. };
    379. MODULE_DEVICE_TABLE(of,css_of_ids);
    380. static struct platform_driver css_platform_driver = {
    381. 	.probe =  css_probe,
    382. 	.remove = css_remove,
    383. 	.driver = {
    384. 		.name = "css_dma",
    385. 		.of_match_table = css_of_ids,
    386. 		.owner = THIS_MODULE,
    387. 	},
    388. };
    389.  
    390. static int __init css_init(void)
    391. {
    392. 	int ret_val;
    393. 	ret_val = platform_driver_register(&css_platform_driver);
    394. 	if(ret_val != 0){
    395. 		DEBUG_CSS("platform_driver_register error");
    396. 		return ret_val;
    397. 	}
    398. 	DEBUG_CSS("platform_driver_register ok");
    399. 	return 0;
    400. }
    401.  
    402. static void __exit css_exit(void)
    403. {
    404. 	platform_driver_unregister(&css_platform_driver);
    405. }
    406.  
    407. module_init(css_init);
    408. module_exit(css_exit);
    409. MODULE_LICENSE("GPL");
    410.

    Makefile：

    1. export ARCH=arm
    2. export CROSS_COMPILE=arm-linux-gnueabihf-
    3. KERN_DIR = /home/lkmao/imx/linux/linux-imx
    4.  
    5. FILE_NAME=csi_single
    6. obj-m += $(FILE_NAME).o
    7. APP_NAME=csi_single_mmap
    8.  
    9. all:
    10.         make -C $(KERN_DIR) M=$(shell pwd) modules
    11.         sudo cp $(FILE_NAME).ko /big/nfsroot/jiaocheng_rootfs/home/root/
    12.         sudo scp $(FILE_NAME).ko root@192.168.0.3:/home/root/
    13.         arm-linux-gnueabihf-gcc -o $(APP_NAME) $(APP_NAME).c
    14.         sudo cp $(APP_NAME) /big/nfsroot/jiaocheng_rootfs/home/root/
    15.         sudo scp $(APP_NAME) root@192.168.0.3:/home/root/
    16.  
    17. .PHONY:clean
    18. clean:
    19.         make -C $(KERN_DIR) M=$(shell pwd) clean
    20.         rm $(APP_NAME) -rf

    设备树配置

    1.     sdma_m2m{
    2. 		compatible = "css_dma";
    3. 	};

    测试过程和结果：

    1 make编译Makefile

    2 进入开发板加载模块：insmod csi_single.ko

    1. root@ATK-IMX6U:~# insmod csi_single.ko
    2. [   41.430795] KERN_ALERT = 1
    3. [   41.433620] info:/big/csi_driver/css_dma/csi_single.c:css_dev_get_dma_addr:267: 32bit:p = 94c00000,dma_addr = 94c00000
    4. [   41.447390] info:/big/csi_driver/css_dma/csi_single.c:css_dev_init:337: 32bit:css_dev->src_buf = 94d00000,css_dev->dst_buf = 94e00000
    5. [   41.463653] info:/big/csi_driver/css_dma/csi_single.c:css_probe:355: init ok
    6. [   41.474842] info:/big/csi_driver/css_dma/csi_single.c:css_init:398: platform_driver_register ok
    7. root@ATK-IMX6U:~#

    3 运行测试应用：./csi_single_mmap

    执行结果如下图所示：

    测试分两个部分，一个是dma引擎复制数据的部分，第二个是memcpy复制数据的部分

    驱动中的调试信息

     应用输出的调试信息：

     小结

            我对这个测试结果是表示怀疑的，DMA引擎20多毫秒，memcpy1.7毫秒，memset 0.7毫秒。我一度怀疑是代码出了问题。还得想办法做更多的测试才行。

  • 相关阅读:
    【Linux C】Linux如何执行一个程序（程序存储空间、系统调用、内核调用）
    DB307S-ASEMI整流桥DB307S
    【路径规划】基于模糊逻辑系统实现车辆的自主导航附matlab代码
    攻防演练-安全监测岗都做哪些工作
    C++ explicit关键字的用法
    MySQL XA事务文档翻译
    AWR1843+DCA1000+mmwave_studio 采集原始数据
    月薪2w+的大数据就业岗位有哪些？
    把 vs Code 添加到右键菜单 ( 其他程序一样 )
    【IEEE出版顺利申请中】2024年第四届电子信息工程与计算机科学国际会议(EIECS 2024)
  • 原文地址：https://blog.csdn.net/yueni_zhao/article/details/127678694