1 /*
2  * videobuf2-dma-contig.c - DMA contig memory allocator for videobuf2
3  *
4  * Copyright (C) 2010 Samsung Electronics
5  *
6  * Author: Pawel Osciak <pawel@osciak.com>
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation.
11  */
12 
13 #include <linux/dma-buf.h>
14 #include <linux/module.h>
15 #include <linux/refcount.h>
16 #include <linux/scatterlist.h>
17 #include <linux/sched.h>
18 #include <linux/slab.h>
19 #include <linux/dma-mapping.h>
20 
21 #include <media/videobuf2-v4l2.h>
22 #include <media/videobuf2-dma-contig.h>
23 #include <media/videobuf2-memops.h>
24 
25 struct vb2_dc_buf {
26 	struct device			*dev;
27 	void				*vaddr;
28 	unsigned long			size;
29 	void				*cookie;
30 	dma_addr_t			dma_addr;
31 	unsigned long			attrs;
32 	enum dma_data_direction		dma_dir;
33 	struct sg_table			*dma_sgt;
34 	struct frame_vector		*vec;
35 
36 	/* MMAP related */
37 	struct vb2_vmarea_handler	handler;
38 	refcount_t			refcount;
39 	struct sg_table			*sgt_base;
40 
41 	/* DMABUF related */
42 	struct dma_buf_attachment	*db_attach;
43 };
44 
45 /*********************************************/
46 /*        scatterlist table functions        */
47 /*********************************************/
48 
49 static unsigned long vb2_dc_get_contiguous_size(struct sg_table *sgt)
50 {
51 	struct scatterlist *s;
52 	dma_addr_t expected = sg_dma_address(sgt->sgl);
53 	unsigned int i;
54 	unsigned long size = 0;
55 
56 	for_each_sgtable_dma_sg(sgt, s, i) {
57 		if (sg_dma_address(s) != expected)
58 			break;
59 		expected += sg_dma_len(s);
60 		size += sg_dma_len(s);
61 	}
62 	return size;
63 }
64 
65 /*********************************************/
66 /*         callbacks for all buffers         */
67 /*********************************************/
68 
69 static void *vb2_dc_cookie(void *buf_priv)
70 {
71 	struct vb2_dc_buf *buf = buf_priv;
72 
73 	return &buf->dma_addr;
74 }
75 
76 static void *vb2_dc_vaddr(void *buf_priv)
77 {
78 	struct vb2_dc_buf *buf = buf_priv;
79 	struct dma_buf_map map;
80 	int ret;
81 
82 	if (!buf->vaddr && buf->db_attach) {
83 		ret = dma_buf_vmap(buf->db_attach->dmabuf, &map);
84 		buf->vaddr = ret ? NULL : map.vaddr;
85 	}
86 
87 	return buf->vaddr;
88 }
89 
90 static unsigned int vb2_dc_num_users(void *buf_priv)
91 {
92 	struct vb2_dc_buf *buf = buf_priv;
93 
94 	return refcount_read(&buf->refcount);
95 }
96 
97 static void vb2_dc_prepare(void *buf_priv)
98 {
99 	struct vb2_dc_buf *buf = buf_priv;
100 	struct sg_table *sgt = buf->dma_sgt;
101 
102 	if (!sgt)
103 		return;
104 
105 	dma_sync_sgtable_for_device(buf->dev, sgt, buf->dma_dir);
106 }
107 
108 static void vb2_dc_finish(void *buf_priv)
109 {
110 	struct vb2_dc_buf *buf = buf_priv;
111 	struct sg_table *sgt = buf->dma_sgt;
112 
113 	if (!sgt)
114 		return;
115 
116 	dma_sync_sgtable_for_cpu(buf->dev, sgt, buf->dma_dir);
117 }
118 
119 /*********************************************/
120 /*        callbacks for MMAP buffers         */
121 /*********************************************/
122 
123 static void vb2_dc_put(void *buf_priv)
124 {
125 	struct vb2_dc_buf *buf = buf_priv;
126 
127 	if (!refcount_dec_and_test(&buf->refcount))
128 		return;
129 
130 	if (buf->sgt_base) {
131 		sg_free_table(buf->sgt_base);
132 		kfree(buf->sgt_base);
133 	}
134 	dma_free_attrs(buf->dev, buf->size, buf->cookie, buf->dma_addr,
135 		       buf->attrs);
136 	put_device(buf->dev);
137 	kfree(buf);
138 }
139 
140 static void *vb2_dc_alloc(struct device *dev, unsigned long attrs,
141 			  unsigned long size, enum dma_data_direction dma_dir,
142 			  gfp_t gfp_flags)
143 {
144 	struct vb2_dc_buf *buf;
145 
146 	if (WARN_ON(!dev))
147 		return ERR_PTR(-EINVAL);
148 
149 	buf = kzalloc(sizeof *buf, GFP_KERNEL);
150 	if (!buf)
151 		return ERR_PTR(-ENOMEM);
152 
153 	buf->attrs = attrs;
154 	buf->cookie = dma_alloc_attrs(dev, size, &buf->dma_addr,
155 					GFP_KERNEL | gfp_flags, buf->attrs);
156 	if (!buf->cookie) {
157 		dev_err(dev, "dma_alloc_coherent of size %ld failed\n", size);
158 		kfree(buf);
159 		return ERR_PTR(-ENOMEM);
160 	}
161 
162 	if ((buf->attrs & DMA_ATTR_NO_KERNEL_MAPPING) == 0)
163 		buf->vaddr = buf->cookie;
164 
165 	/* Prevent the device from being released while the buffer is used */
166 	buf->dev = get_device(dev);
167 	buf->size = size;
168 	buf->dma_dir = dma_dir;
169 
170 	buf->handler.refcount = &buf->refcount;
171 	buf->handler.put = vb2_dc_put;
172 	buf->handler.arg = buf;
173 
174 	refcount_set(&buf->refcount, 1);
175 
176 	return buf;
177 }
178 
179 static int vb2_dc_mmap(void *buf_priv, struct vm_area_struct *vma)
180 {
181 	struct vb2_dc_buf *buf = buf_priv;
182 	int ret;
183 
184 	if (!buf) {
185 		printk(KERN_ERR "No buffer to map\n");
186 		return -EINVAL;
187 	}
188 
189 	ret = dma_mmap_attrs(buf->dev, vma, buf->cookie,
190 		buf->dma_addr, buf->size, buf->attrs);
191 
192 	if (ret) {
193 		pr_err("Remapping memory failed, error: %d\n", ret);
194 		return ret;
195 	}
196 
197 	vma->vm_flags		|= VM_DONTEXPAND | VM_DONTDUMP;
198 	vma->vm_private_data	= &buf->handler;
199 	vma->vm_ops		= &vb2_common_vm_ops;
200 
201 	vma->vm_ops->open(vma);
202 
203 	pr_debug("%s: mapped dma addr 0x%08lx at 0x%08lx, size %ld\n",
204 		__func__, (unsigned long)buf->dma_addr, vma->vm_start,
205 		buf->size);
206 
207 	return 0;
208 }
209 
210 /*********************************************/
211 /*         DMABUF ops for exporters          */
212 /*********************************************/
213 
214 struct vb2_dc_attachment {
215 	struct sg_table sgt;
216 	enum dma_data_direction dma_dir;
217 };
218 
219 static int vb2_dc_dmabuf_ops_attach(struct dma_buf *dbuf,
220 	struct dma_buf_attachment *dbuf_attach)
221 {
222 	struct vb2_dc_attachment *attach;
223 	unsigned int i;
224 	struct scatterlist *rd, *wr;
225 	struct sg_table *sgt;
226 	struct vb2_dc_buf *buf = dbuf->priv;
227 	int ret;
228 
229 	attach = kzalloc(sizeof(*attach), GFP_KERNEL);
230 	if (!attach)
231 		return -ENOMEM;
232 
233 	sgt = &attach->sgt;
234 	/* Copy the buf->base_sgt scatter list to the attachment, as we can't
235 	 * map the same scatter list to multiple attachments at the same time.
236 	 */
237 	ret = sg_alloc_table(sgt, buf->sgt_base->orig_nents, GFP_KERNEL);
238 	if (ret) {
239 		kfree(attach);
240 		return -ENOMEM;
241 	}
242 
243 	rd = buf->sgt_base->sgl;
244 	wr = sgt->sgl;
245 	for (i = 0; i < sgt->orig_nents; ++i) {
246 		sg_set_page(wr, sg_page(rd), rd->length, rd->offset);
247 		rd = sg_next(rd);
248 		wr = sg_next(wr);
249 	}
250 
251 	attach->dma_dir = DMA_NONE;
252 	dbuf_attach->priv = attach;
253 
254 	return 0;
255 }
256 
257 static void vb2_dc_dmabuf_ops_detach(struct dma_buf *dbuf,
258 	struct dma_buf_attachment *db_attach)
259 {
260 	struct vb2_dc_attachment *attach = db_attach->priv;
261 	struct sg_table *sgt;
262 
263 	if (!attach)
264 		return;
265 
266 	sgt = &attach->sgt;
267 
268 	/* release the scatterlist cache */
269 	if (attach->dma_dir != DMA_NONE)
270 		/*
271 		 * Cache sync can be skipped here, as the vb2_dc memory is
272 		 * allocated from device coherent memory, which means the
273 		 * memory locations do not require any explicit cache
274 		 * maintenance prior or after being used by the device.
275 		 */
276 		dma_unmap_sgtable(db_attach->dev, sgt, attach->dma_dir,
277 				  DMA_ATTR_SKIP_CPU_SYNC);
278 	sg_free_table(sgt);
279 	kfree(attach);
280 	db_attach->priv = NULL;
281 }
282 
283 static struct sg_table *vb2_dc_dmabuf_ops_map(
284 	struct dma_buf_attachment *db_attach, enum dma_data_direction dma_dir)
285 {
286 	struct vb2_dc_attachment *attach = db_attach->priv;
287 	/* stealing dmabuf mutex to serialize map/unmap operations */
288 	struct mutex *lock = &db_attach->dmabuf->lock;
289 	struct sg_table *sgt;
290 
291 	mutex_lock(lock);
292 
293 	sgt = &attach->sgt;
294 	/* return previously mapped sg table */
295 	if (attach->dma_dir == dma_dir) {
296 		mutex_unlock(lock);
297 		return sgt;
298 	}
299 
300 	/* release any previous cache */
301 	if (attach->dma_dir != DMA_NONE) {
302 		dma_unmap_sgtable(db_attach->dev, sgt, attach->dma_dir,
303 				  DMA_ATTR_SKIP_CPU_SYNC);
304 		attach->dma_dir = DMA_NONE;
305 	}
306 
307 	/*
308 	 * mapping to the client with new direction, no cache sync
309 	 * required see comment in vb2_dc_dmabuf_ops_detach()
310 	 */
311 	if (dma_map_sgtable(db_attach->dev, sgt, dma_dir,
312 			    DMA_ATTR_SKIP_CPU_SYNC)) {
313 		pr_err("failed to map scatterlist\n");
314 		mutex_unlock(lock);
315 		return ERR_PTR(-EIO);
316 	}
317 
318 	attach->dma_dir = dma_dir;
319 
320 	mutex_unlock(lock);
321 
322 	return sgt;
323 }
324 
325 static void vb2_dc_dmabuf_ops_unmap(struct dma_buf_attachment *db_attach,
326 	struct sg_table *sgt, enum dma_data_direction dma_dir)
327 {
328 	/* nothing to be done here */
329 }
330 
331 static void vb2_dc_dmabuf_ops_release(struct dma_buf *dbuf)
332 {
333 	/* drop reference obtained in vb2_dc_get_dmabuf */
334 	vb2_dc_put(dbuf->priv);
335 }
336 
337 static int
338 vb2_dc_dmabuf_ops_begin_cpu_access(struct dma_buf *dbuf,
339 				   enum dma_data_direction direction)
340 {
341 	return 0;
342 }
343 
344 static int
345 vb2_dc_dmabuf_ops_end_cpu_access(struct dma_buf *dbuf,
346 				 enum dma_data_direction direction)
347 {
348 	return 0;
349 }
350 
351 static int vb2_dc_dmabuf_ops_vmap(struct dma_buf *dbuf, struct dma_buf_map *map)
352 {
353 	struct vb2_dc_buf *buf = dbuf->priv;
354 
355 	dma_buf_map_set_vaddr(map, buf->vaddr);
356 
357 	return 0;
358 }
359 
360 static int vb2_dc_dmabuf_ops_mmap(struct dma_buf *dbuf,
361 	struct vm_area_struct *vma)
362 {
363 	return vb2_dc_mmap(dbuf->priv, vma);
364 }
365 
366 static const struct dma_buf_ops vb2_dc_dmabuf_ops = {
367 	.attach = vb2_dc_dmabuf_ops_attach,
368 	.detach = vb2_dc_dmabuf_ops_detach,
369 	.map_dma_buf = vb2_dc_dmabuf_ops_map,
370 	.unmap_dma_buf = vb2_dc_dmabuf_ops_unmap,
371 	.begin_cpu_access = vb2_dc_dmabuf_ops_begin_cpu_access,
372 	.end_cpu_access = vb2_dc_dmabuf_ops_end_cpu_access,
373 	.vmap = vb2_dc_dmabuf_ops_vmap,
374 	.mmap = vb2_dc_dmabuf_ops_mmap,
375 	.release = vb2_dc_dmabuf_ops_release,
376 };
377 
378 static struct sg_table *vb2_dc_get_base_sgt(struct vb2_dc_buf *buf)
379 {
380 	int ret;
381 	struct sg_table *sgt;
382 
383 	sgt = kmalloc(sizeof(*sgt), GFP_KERNEL);
384 	if (!sgt) {
385 		dev_err(buf->dev, "failed to alloc sg table\n");
386 		return NULL;
387 	}
388 
389 	ret = dma_get_sgtable_attrs(buf->dev, sgt, buf->cookie, buf->dma_addr,
390 		buf->size, buf->attrs);
391 	if (ret < 0) {
392 		dev_err(buf->dev, "failed to get scatterlist from DMA API\n");
393 		kfree(sgt);
394 		return NULL;
395 	}
396 
397 	return sgt;
398 }
399 
400 static struct dma_buf *vb2_dc_get_dmabuf(void *buf_priv, unsigned long flags)
401 {
402 	struct vb2_dc_buf *buf = buf_priv;
403 	struct dma_buf *dbuf;
404 	DEFINE_DMA_BUF_EXPORT_INFO(exp_info);
405 
406 	exp_info.ops = &vb2_dc_dmabuf_ops;
407 	exp_info.size = buf->size;
408 	exp_info.flags = flags;
409 	exp_info.priv = buf;
410 
411 	if (!buf->sgt_base)
412 		buf->sgt_base = vb2_dc_get_base_sgt(buf);
413 
414 	if (WARN_ON(!buf->sgt_base))
415 		return NULL;
416 
417 	dbuf = dma_buf_export(&exp_info);
418 	if (IS_ERR(dbuf))
419 		return NULL;
420 
421 	/* dmabuf keeps reference to vb2 buffer */
422 	refcount_inc(&buf->refcount);
423 
424 	return dbuf;
425 }
426 
427 /*********************************************/
428 /*       callbacks for USERPTR buffers       */
429 /*********************************************/
430 
431 static void vb2_dc_put_userptr(void *buf_priv)
432 {
433 	struct vb2_dc_buf *buf = buf_priv;
434 	struct sg_table *sgt = buf->dma_sgt;
435 	int i;
436 	struct page **pages;
437 
438 	if (sgt) {
439 		/*
440 		 * No need to sync to CPU, it's already synced to the CPU
441 		 * since the finish() memop will have been called before this.
442 		 */
443 		dma_unmap_sgtable(buf->dev, sgt, buf->dma_dir,
444 				  DMA_ATTR_SKIP_CPU_SYNC);
445 		pages = frame_vector_pages(buf->vec);
446 		/* sgt should exist only if vector contains pages... */
447 		BUG_ON(IS_ERR(pages));
448 		if (buf->dma_dir == DMA_FROM_DEVICE ||
449 		    buf->dma_dir == DMA_BIDIRECTIONAL)
450 			for (i = 0; i < frame_vector_count(buf->vec); i++)
451 				set_page_dirty_lock(pages[i]);
452 		sg_free_table(sgt);
453 		kfree(sgt);
454 	} else {
455 		dma_unmap_resource(buf->dev, buf->dma_addr, buf->size,
456 				   buf->dma_dir, 0);
457 	}
458 	vb2_destroy_framevec(buf->vec);
459 	kfree(buf);
460 }
461 
462 static void *vb2_dc_get_userptr(struct device *dev, unsigned long vaddr,
463 	unsigned long size, enum dma_data_direction dma_dir)
464 {
465 	struct vb2_dc_buf *buf;
466 	struct frame_vector *vec;
467 	unsigned int offset;
468 	int n_pages, i;
469 	int ret = 0;
470 	struct sg_table *sgt;
471 	unsigned long contig_size;
472 	unsigned long dma_align = dma_get_cache_alignment();
473 
474 	/* Only cache aligned DMA transfers are reliable */
475 	if (!IS_ALIGNED(vaddr | size, dma_align)) {
476 		pr_debug("user data must be aligned to %lu bytes\n", dma_align);
477 		return ERR_PTR(-EINVAL);
478 	}
479 
480 	if (!size) {
481 		pr_debug("size is zero\n");
482 		return ERR_PTR(-EINVAL);
483 	}
484 
485 	if (WARN_ON(!dev))
486 		return ERR_PTR(-EINVAL);
487 
488 	buf = kzalloc(sizeof *buf, GFP_KERNEL);
489 	if (!buf)
490 		return ERR_PTR(-ENOMEM);
491 
492 	buf->dev = dev;
493 	buf->dma_dir = dma_dir;
494 
495 	offset = lower_32_bits(offset_in_page(vaddr));
496 	vec = vb2_create_framevec(vaddr, size);
497 	if (IS_ERR(vec)) {
498 		ret = PTR_ERR(vec);
499 		goto fail_buf;
500 	}
501 	buf->vec = vec;
502 	n_pages = frame_vector_count(vec);
503 	ret = frame_vector_to_pages(vec);
504 	if (ret < 0) {
505 		unsigned long *nums = frame_vector_pfns(vec);
506 
507 		/*
508 		 * Failed to convert to pages... Check the memory is physically
509 		 * contiguous and use direct mapping
510 		 */
511 		for (i = 1; i < n_pages; i++)
512 			if (nums[i-1] + 1 != nums[i])
513 				goto fail_pfnvec;
514 		buf->dma_addr = dma_map_resource(buf->dev,
515 				__pfn_to_phys(nums[0]), size, buf->dma_dir, 0);
516 		if (dma_mapping_error(buf->dev, buf->dma_addr)) {
517 			ret = -ENOMEM;
518 			goto fail_pfnvec;
519 		}
520 		goto out;
521 	}
522 
523 	sgt = kzalloc(sizeof(*sgt), GFP_KERNEL);
524 	if (!sgt) {
525 		pr_err("failed to allocate sg table\n");
526 		ret = -ENOMEM;
527 		goto fail_pfnvec;
528 	}
529 
530 	ret = sg_alloc_table_from_pages(sgt, frame_vector_pages(vec), n_pages,
531 		offset, size, GFP_KERNEL);
532 	if (ret) {
533 		pr_err("failed to initialize sg table\n");
534 		goto fail_sgt;
535 	}
536 
537 	/*
538 	 * No need to sync to the device, this will happen later when the
539 	 * prepare() memop is called.
540 	 */
541 	if (dma_map_sgtable(buf->dev, sgt, buf->dma_dir,
542 			    DMA_ATTR_SKIP_CPU_SYNC)) {
543 		pr_err("failed to map scatterlist\n");
544 		ret = -EIO;
545 		goto fail_sgt_init;
546 	}
547 
548 	contig_size = vb2_dc_get_contiguous_size(sgt);
549 	if (contig_size < size) {
550 		pr_err("contiguous mapping is too small %lu/%lu\n",
551 			contig_size, size);
552 		ret = -EFAULT;
553 		goto fail_map_sg;
554 	}
555 
556 	buf->dma_addr = sg_dma_address(sgt->sgl);
557 	buf->dma_sgt = sgt;
558 out:
559 	buf->size = size;
560 
561 	return buf;
562 
563 fail_map_sg:
564 	dma_unmap_sgtable(buf->dev, sgt, buf->dma_dir, DMA_ATTR_SKIP_CPU_SYNC);
565 
566 fail_sgt_init:
567 	sg_free_table(sgt);
568 
569 fail_sgt:
570 	kfree(sgt);
571 
572 fail_pfnvec:
573 	vb2_destroy_framevec(vec);
574 
575 fail_buf:
576 	kfree(buf);
577 
578 	return ERR_PTR(ret);
579 }
580 
581 /*********************************************/
582 /*       callbacks for DMABUF buffers        */
583 /*********************************************/
584 
585 static int vb2_dc_map_dmabuf(void *mem_priv)
586 {
587 	struct vb2_dc_buf *buf = mem_priv;
588 	struct sg_table *sgt;
589 	unsigned long contig_size;
590 
591 	if (WARN_ON(!buf->db_attach)) {
592 		pr_err("trying to pin a non attached buffer\n");
593 		return -EINVAL;
594 	}
595 
596 	if (WARN_ON(buf->dma_sgt)) {
597 		pr_err("dmabuf buffer is already pinned\n");
598 		return 0;
599 	}
600 
601 	/* get the associated scatterlist for this buffer */
602 	sgt = dma_buf_map_attachment(buf->db_attach, buf->dma_dir);
603 	if (IS_ERR(sgt)) {
604 		pr_err("Error getting dmabuf scatterlist\n");
605 		return -EINVAL;
606 	}
607 
608 	/* checking if dmabuf is big enough to store contiguous chunk */
609 	contig_size = vb2_dc_get_contiguous_size(sgt);
610 	if (contig_size < buf->size) {
611 		pr_err("contiguous chunk is too small %lu/%lu\n",
612 		       contig_size, buf->size);
613 		dma_buf_unmap_attachment(buf->db_attach, sgt, buf->dma_dir);
614 		return -EFAULT;
615 	}
616 
617 	buf->dma_addr = sg_dma_address(sgt->sgl);
618 	buf->dma_sgt = sgt;
619 	buf->vaddr = NULL;
620 
621 	return 0;
622 }
623 
624 static void vb2_dc_unmap_dmabuf(void *mem_priv)
625 {
626 	struct vb2_dc_buf *buf = mem_priv;
627 	struct sg_table *sgt = buf->dma_sgt;
628 	struct dma_buf_map map = DMA_BUF_MAP_INIT_VADDR(buf->vaddr);
629 
630 	if (WARN_ON(!buf->db_attach)) {
631 		pr_err("trying to unpin a not attached buffer\n");
632 		return;
633 	}
634 
635 	if (WARN_ON(!sgt)) {
636 		pr_err("dmabuf buffer is already unpinned\n");
637 		return;
638 	}
639 
640 	if (buf->vaddr) {
641 		dma_buf_vunmap(buf->db_attach->dmabuf, &map);
642 		buf->vaddr = NULL;
643 	}
644 	dma_buf_unmap_attachment(buf->db_attach, sgt, buf->dma_dir);
645 
646 	buf->dma_addr = 0;
647 	buf->dma_sgt = NULL;
648 }
649 
650 static void vb2_dc_detach_dmabuf(void *mem_priv)
651 {
652 	struct vb2_dc_buf *buf = mem_priv;
653 
654 	/* if vb2 works correctly you should never detach mapped buffer */
655 	if (WARN_ON(buf->dma_addr))
656 		vb2_dc_unmap_dmabuf(buf);
657 
658 	/* detach this attachment */
659 	dma_buf_detach(buf->db_attach->dmabuf, buf->db_attach);
660 	kfree(buf);
661 }
662 
663 static void *vb2_dc_attach_dmabuf(struct device *dev, struct dma_buf *dbuf,
664 	unsigned long size, enum dma_data_direction dma_dir)
665 {
666 	struct vb2_dc_buf *buf;
667 	struct dma_buf_attachment *dba;
668 
669 	if (dbuf->size < size)
670 		return ERR_PTR(-EFAULT);
671 
672 	if (WARN_ON(!dev))
673 		return ERR_PTR(-EINVAL);
674 
675 	buf = kzalloc(sizeof(*buf), GFP_KERNEL);
676 	if (!buf)
677 		return ERR_PTR(-ENOMEM);
678 
679 	buf->dev = dev;
680 	/* create attachment for the dmabuf with the user device */
681 	dba = dma_buf_attach(dbuf, buf->dev);
682 	if (IS_ERR(dba)) {
683 		pr_err("failed to attach dmabuf\n");
684 		kfree(buf);
685 		return dba;
686 	}
687 
688 	buf->dma_dir = dma_dir;
689 	buf->size = size;
690 	buf->db_attach = dba;
691 
692 	return buf;
693 }
694 
695 /*********************************************/
696 /*       DMA CONTIG exported functions       */
697 /*********************************************/
698 
699 const struct vb2_mem_ops vb2_dma_contig_memops = {
700 	.alloc		= vb2_dc_alloc,
701 	.put		= vb2_dc_put,
702 	.get_dmabuf	= vb2_dc_get_dmabuf,
703 	.cookie		= vb2_dc_cookie,
704 	.vaddr		= vb2_dc_vaddr,
705 	.mmap		= vb2_dc_mmap,
706 	.get_userptr	= vb2_dc_get_userptr,
707 	.put_userptr	= vb2_dc_put_userptr,
708 	.prepare	= vb2_dc_prepare,
709 	.finish		= vb2_dc_finish,
710 	.map_dmabuf	= vb2_dc_map_dmabuf,
711 	.unmap_dmabuf	= vb2_dc_unmap_dmabuf,
712 	.attach_dmabuf	= vb2_dc_attach_dmabuf,
713 	.detach_dmabuf	= vb2_dc_detach_dmabuf,
714 	.num_users	= vb2_dc_num_users,
715 };
716 EXPORT_SYMBOL_GPL(vb2_dma_contig_memops);
717 
718 /**
719  * vb2_dma_contig_set_max_seg_size() - configure DMA max segment size
720  * @dev:	device for configuring DMA parameters
721  * @size:	size of DMA max segment size to set
722  *
723  * To allow mapping the scatter-list into a single chunk in the DMA
724  * address space, the device is required to have the DMA max segment
725  * size parameter set to a value larger than the buffer size. Otherwise,
726  * the DMA-mapping subsystem will split the mapping into max segment
727  * size chunks. This function sets the DMA max segment size
728  * parameter to let DMA-mapping map a buffer as a single chunk in DMA
729  * address space.
730  * This code assumes that the DMA-mapping subsystem will merge all
731  * scatterlist segments if this is really possible (for example when
732  * an IOMMU is available and enabled).
733  * Ideally, this parameter should be set by the generic bus code, but it
734  * is left with the default 64KiB value due to historical litmiations in
735  * other subsystems (like limited USB host drivers) and there no good
736  * place to set it to the proper value.
737  * This function should be called from the drivers, which are known to
738  * operate on platforms with IOMMU and provide access to shared buffers
739  * (either USERPTR or DMABUF). This should be done before initializing
740  * videobuf2 queue.
741  */
742 int vb2_dma_contig_set_max_seg_size(struct device *dev, unsigned int size)
743 {
744 	if (!dev->dma_parms) {
745 		dev_err(dev, "Failed to set max_seg_size: dma_parms is NULL\n");
746 		return -ENODEV;
747 	}
748 	if (dma_get_max_seg_size(dev) < size)
749 		return dma_set_max_seg_size(dev, size);
750 
751 	return 0;
752 }
753 EXPORT_SYMBOL_GPL(vb2_dma_contig_set_max_seg_size);
754 
755 MODULE_DESCRIPTION("DMA-contig memory handling routines for videobuf2");
756 MODULE_AUTHOR("Pawel Osciak <pawel@osciak.com>");
757 MODULE_LICENSE("GPL");
758