1
2
3
4
5
6
7
8
9
10
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
25struct 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
37 struct vb2_vmarea_handler handler;
38 refcount_t refcount;
39 struct sg_table *sgt_base;
40
41
42 struct dma_buf_attachment *db_attach;
43};
44
45
46
47
48
49static 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_sg(sgt->sgl, s, sgt->nents, i) {
57 if (sg_dma_address(s) != expected)
58 break;
59 expected = sg_dma_address(s) + sg_dma_len(s);
60 size += sg_dma_len(s);
61 }
62 return size;
63}
64
65
66
67
68
69static void *vb2_dc_cookie(void *buf_priv)
70{
71 struct vb2_dc_buf *buf = buf_priv;
72
73 return &buf->dma_addr;
74}
75
76static void *vb2_dc_vaddr(void *buf_priv)
77{
78 struct vb2_dc_buf *buf = buf_priv;
79
80 if (!buf->vaddr && buf->db_attach)
81 buf->vaddr = dma_buf_vmap(buf->db_attach->dmabuf);
82
83 return buf->vaddr;
84}
85
86static unsigned int vb2_dc_num_users(void *buf_priv)
87{
88 struct vb2_dc_buf *buf = buf_priv;
89
90 return refcount_read(&buf->refcount);
91}
92
93static void vb2_dc_prepare(void *buf_priv)
94{
95 struct vb2_dc_buf *buf = buf_priv;
96 struct sg_table *sgt = buf->dma_sgt;
97
98
99 if (!sgt || buf->db_attach)
100 return;
101
102 dma_sync_sg_for_device(buf->dev, sgt->sgl, sgt->orig_nents,
103 buf->dma_dir);
104}
105
106static void vb2_dc_finish(void *buf_priv)
107{
108 struct vb2_dc_buf *buf = buf_priv;
109 struct sg_table *sgt = buf->dma_sgt;
110
111
112 if (!sgt || buf->db_attach)
113 return;
114
115 dma_sync_sg_for_cpu(buf->dev, sgt->sgl, sgt->orig_nents, buf->dma_dir);
116}
117
118
119
120
121
122static void vb2_dc_put(void *buf_priv)
123{
124 struct vb2_dc_buf *buf = buf_priv;
125
126 if (!refcount_dec_and_test(&buf->refcount))
127 return;
128
129 if (buf->sgt_base) {
130 sg_free_table(buf->sgt_base);
131 kfree(buf->sgt_base);
132 }
133 dma_free_attrs(buf->dev, buf->size, buf->cookie, buf->dma_addr,
134 buf->attrs);
135 put_device(buf->dev);
136 kfree(buf);
137}
138
139static void *vb2_dc_alloc(struct device *dev, unsigned long attrs,
140 unsigned long size, enum dma_data_direction dma_dir,
141 gfp_t gfp_flags)
142{
143 struct vb2_dc_buf *buf;
144
145 if (WARN_ON(!dev))
146 return ERR_PTR(-EINVAL);
147
148 buf = kzalloc(sizeof *buf, GFP_KERNEL);
149 if (!buf)
150 return ERR_PTR(-ENOMEM);
151
152 if (attrs)
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
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
179static 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
190
191
192
193 vma->vm_pgoff = 0;
194
195 ret = dma_mmap_attrs(buf->dev, vma, buf->cookie,
196 buf->dma_addr, buf->size, buf->attrs);
197
198 if (ret) {
199 pr_err("Remapping memory failed, error: %d\n", ret);
200 return ret;
201 }
202
203 vma->vm_flags |= VM_DONTEXPAND | VM_DONTDUMP;
204 vma->vm_private_data = &buf->handler;
205 vma->vm_ops = &vb2_common_vm_ops;
206
207 vma->vm_ops->open(vma);
208
209 pr_debug("%s: mapped dma addr 0x%08lx at 0x%08lx, size %ld\n",
210 __func__, (unsigned long)buf->dma_addr, vma->vm_start,
211 buf->size);
212
213 return 0;
214}
215
216
217
218
219
220struct vb2_dc_attachment {
221 struct sg_table sgt;
222 enum dma_data_direction dma_dir;
223};
224
225static int vb2_dc_dmabuf_ops_attach(struct dma_buf *dbuf, struct device *dev,
226 struct dma_buf_attachment *dbuf_attach)
227{
228 struct vb2_dc_attachment *attach;
229 unsigned int i;
230 struct scatterlist *rd, *wr;
231 struct sg_table *sgt;
232 struct vb2_dc_buf *buf = dbuf->priv;
233 int ret;
234
235 attach = kzalloc(sizeof(*attach), GFP_KERNEL);
236 if (!attach)
237 return -ENOMEM;
238
239 sgt = &attach->sgt;
240
241
242
243 ret = sg_alloc_table(sgt, buf->sgt_base->orig_nents, GFP_KERNEL);
244 if (ret) {
245 kfree(attach);
246 return -ENOMEM;
247 }
248
249 rd = buf->sgt_base->sgl;
250 wr = sgt->sgl;
251 for (i = 0; i < sgt->orig_nents; ++i) {
252 sg_set_page(wr, sg_page(rd), rd->length, rd->offset);
253 rd = sg_next(rd);
254 wr = sg_next(wr);
255 }
256
257 attach->dma_dir = DMA_NONE;
258 dbuf_attach->priv = attach;
259
260 return 0;
261}
262
263static void vb2_dc_dmabuf_ops_detach(struct dma_buf *dbuf,
264 struct dma_buf_attachment *db_attach)
265{
266 struct vb2_dc_attachment *attach = db_attach->priv;
267 struct sg_table *sgt;
268
269 if (!attach)
270 return;
271
272 sgt = &attach->sgt;
273
274
275 if (attach->dma_dir != DMA_NONE)
276 dma_unmap_sg(db_attach->dev, sgt->sgl, sgt->orig_nents,
277 attach->dma_dir);
278 sg_free_table(sgt);
279 kfree(attach);
280 db_attach->priv = NULL;
281}
282
283static 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
288 struct mutex *lock = &db_attach->dmabuf->lock;
289 struct sg_table *sgt;
290
291 mutex_lock(lock);
292
293 sgt = &attach->sgt;
294
295 if (attach->dma_dir == dma_dir) {
296 mutex_unlock(lock);
297 return sgt;
298 }
299
300
301 if (attach->dma_dir != DMA_NONE) {
302 dma_unmap_sg(db_attach->dev, sgt->sgl, sgt->orig_nents,
303 attach->dma_dir);
304 attach->dma_dir = DMA_NONE;
305 }
306
307
308 sgt->nents = dma_map_sg(db_attach->dev, sgt->sgl, sgt->orig_nents,
309 dma_dir);
310 if (!sgt->nents) {
311 pr_err("failed to map scatterlist\n");
312 mutex_unlock(lock);
313 return ERR_PTR(-EIO);
314 }
315
316 attach->dma_dir = dma_dir;
317
318 mutex_unlock(lock);
319
320 return sgt;
321}
322
323static void vb2_dc_dmabuf_ops_unmap(struct dma_buf_attachment *db_attach,
324 struct sg_table *sgt, enum dma_data_direction dma_dir)
325{
326
327}
328
329static void vb2_dc_dmabuf_ops_release(struct dma_buf *dbuf)
330{
331
332 vb2_dc_put(dbuf->priv);
333}
334
335static void *vb2_dc_dmabuf_ops_kmap(struct dma_buf *dbuf, unsigned long pgnum)
336{
337 struct vb2_dc_buf *buf = dbuf->priv;
338
339 return buf->vaddr ? buf->vaddr + pgnum * PAGE_SIZE : NULL;
340}
341
342static void *vb2_dc_dmabuf_ops_vmap(struct dma_buf *dbuf)
343{
344 struct vb2_dc_buf *buf = dbuf->priv;
345
346 return buf->vaddr;
347}
348
349static int vb2_dc_dmabuf_ops_mmap(struct dma_buf *dbuf,
350 struct vm_area_struct *vma)
351{
352 return vb2_dc_mmap(dbuf->priv, vma);
353}
354
355static const struct dma_buf_ops vb2_dc_dmabuf_ops = {
356 .attach = vb2_dc_dmabuf_ops_attach,
357 .detach = vb2_dc_dmabuf_ops_detach,
358 .map_dma_buf = vb2_dc_dmabuf_ops_map,
359 .unmap_dma_buf = vb2_dc_dmabuf_ops_unmap,
360 .map = vb2_dc_dmabuf_ops_kmap,
361 .map_atomic = vb2_dc_dmabuf_ops_kmap,
362 .vmap = vb2_dc_dmabuf_ops_vmap,
363 .mmap = vb2_dc_dmabuf_ops_mmap,
364 .release = vb2_dc_dmabuf_ops_release,
365};
366
367static struct sg_table *vb2_dc_get_base_sgt(struct vb2_dc_buf *buf)
368{
369 int ret;
370 struct sg_table *sgt;
371
372 sgt = kmalloc(sizeof(*sgt), GFP_KERNEL);
373 if (!sgt) {
374 dev_err(buf->dev, "failed to alloc sg table\n");
375 return NULL;
376 }
377
378 ret = dma_get_sgtable_attrs(buf->dev, sgt, buf->cookie, buf->dma_addr,
379 buf->size, buf->attrs);
380 if (ret < 0) {
381 dev_err(buf->dev, "failed to get scatterlist from DMA API\n");
382 kfree(sgt);
383 return NULL;
384 }
385
386 return sgt;
387}
388
389static struct dma_buf *vb2_dc_get_dmabuf(void *buf_priv, unsigned long flags)
390{
391 struct vb2_dc_buf *buf = buf_priv;
392 struct dma_buf *dbuf;
393 DEFINE_DMA_BUF_EXPORT_INFO(exp_info);
394
395 exp_info.ops = &vb2_dc_dmabuf_ops;
396 exp_info.size = buf->size;
397 exp_info.flags = flags;
398 exp_info.priv = buf;
399
400 if (!buf->sgt_base)
401 buf->sgt_base = vb2_dc_get_base_sgt(buf);
402
403 if (WARN_ON(!buf->sgt_base))
404 return NULL;
405
406 dbuf = dma_buf_export(&exp_info);
407 if (IS_ERR(dbuf))
408 return NULL;
409
410
411 refcount_inc(&buf->refcount);
412
413 return dbuf;
414}
415
416
417
418
419
420static void vb2_dc_put_userptr(void *buf_priv)
421{
422 struct vb2_dc_buf *buf = buf_priv;
423 struct sg_table *sgt = buf->dma_sgt;
424 int i;
425 struct page **pages;
426
427 if (sgt) {
428
429
430
431
432 dma_unmap_sg_attrs(buf->dev, sgt->sgl, sgt->orig_nents,
433 buf->dma_dir, DMA_ATTR_SKIP_CPU_SYNC);
434 pages = frame_vector_pages(buf->vec);
435
436 BUG_ON(IS_ERR(pages));
437 for (i = 0; i < frame_vector_count(buf->vec); i++)
438 set_page_dirty_lock(pages[i]);
439 sg_free_table(sgt);
440 kfree(sgt);
441 }
442 vb2_destroy_framevec(buf->vec);
443 kfree(buf);
444}
445
446
447
448
449
450
451
452
453
454#ifdef __arch_pfn_to_dma
455static inline dma_addr_t vb2_dc_pfn_to_dma(struct device *dev, unsigned long pfn)
456{
457 return (dma_addr_t)__arch_pfn_to_dma(dev, pfn);
458}
459#elif defined(__pfn_to_bus)
460static inline dma_addr_t vb2_dc_pfn_to_dma(struct device *dev, unsigned long pfn)
461{
462 return (dma_addr_t)__pfn_to_bus(pfn);
463}
464#elif defined(__pfn_to_phys)
465static inline dma_addr_t vb2_dc_pfn_to_dma(struct device *dev, unsigned long pfn)
466{
467 return (dma_addr_t)__pfn_to_phys(pfn);
468}
469#else
470static inline dma_addr_t vb2_dc_pfn_to_dma(struct device *dev, unsigned long pfn)
471{
472
473 return (dma_addr_t)(pfn) << PAGE_SHIFT;
474}
475#endif
476
477static void *vb2_dc_get_userptr(struct device *dev, unsigned long vaddr,
478 unsigned long size, enum dma_data_direction dma_dir)
479{
480 struct vb2_dc_buf *buf;
481 struct frame_vector *vec;
482 unsigned long offset;
483 int n_pages, i;
484 int ret = 0;
485 struct sg_table *sgt;
486 unsigned long contig_size;
487 unsigned long dma_align = dma_get_cache_alignment();
488
489
490 if (!IS_ALIGNED(vaddr | size, dma_align)) {
491 pr_debug("user data must be aligned to %lu bytes\n", dma_align);
492 return ERR_PTR(-EINVAL);
493 }
494
495 if (!size) {
496 pr_debug("size is zero\n");
497 return ERR_PTR(-EINVAL);
498 }
499
500 if (WARN_ON(!dev))
501 return ERR_PTR(-EINVAL);
502
503 buf = kzalloc(sizeof *buf, GFP_KERNEL);
504 if (!buf)
505 return ERR_PTR(-ENOMEM);
506
507 buf->dev = dev;
508 buf->dma_dir = dma_dir;
509
510 offset = vaddr & ~PAGE_MASK;
511 vec = vb2_create_framevec(vaddr, size, dma_dir == DMA_FROM_DEVICE ||
512 dma_dir == DMA_BIDIRECTIONAL);
513 if (IS_ERR(vec)) {
514 ret = PTR_ERR(vec);
515 goto fail_buf;
516 }
517 buf->vec = vec;
518 n_pages = frame_vector_count(vec);
519 ret = frame_vector_to_pages(vec);
520 if (ret < 0) {
521 unsigned long *nums = frame_vector_pfns(vec);
522
523
524
525
526
527 for (i = 1; i < n_pages; i++)
528 if (nums[i-1] + 1 != nums[i])
529 goto fail_pfnvec;
530 buf->dma_addr = vb2_dc_pfn_to_dma(buf->dev, nums[0]);
531 goto out;
532 }
533
534 sgt = kzalloc(sizeof(*sgt), GFP_KERNEL);
535 if (!sgt) {
536 pr_err("failed to allocate sg table\n");
537 ret = -ENOMEM;
538 goto fail_pfnvec;
539 }
540
541 ret = sg_alloc_table_from_pages(sgt, frame_vector_pages(vec), n_pages,
542 offset, size, GFP_KERNEL);
543 if (ret) {
544 pr_err("failed to initialize sg table\n");
545 goto fail_sgt;
546 }
547
548
549
550
551
552 sgt->nents = dma_map_sg_attrs(buf->dev, sgt->sgl, sgt->orig_nents,
553 buf->dma_dir, DMA_ATTR_SKIP_CPU_SYNC);
554 if (sgt->nents <= 0) {
555 pr_err("failed to map scatterlist\n");
556 ret = -EIO;
557 goto fail_sgt_init;
558 }
559
560 contig_size = vb2_dc_get_contiguous_size(sgt);
561 if (contig_size < size) {
562 pr_err("contiguous mapping is too small %lu/%lu\n",
563 contig_size, size);
564 ret = -EFAULT;
565 goto fail_map_sg;
566 }
567
568 buf->dma_addr = sg_dma_address(sgt->sgl);
569 buf->dma_sgt = sgt;
570out:
571 buf->size = size;
572
573 return buf;
574
575fail_map_sg:
576 dma_unmap_sg_attrs(buf->dev, sgt->sgl, sgt->orig_nents,
577 buf->dma_dir, DMA_ATTR_SKIP_CPU_SYNC);
578
579fail_sgt_init:
580 sg_free_table(sgt);
581
582fail_sgt:
583 kfree(sgt);
584
585fail_pfnvec:
586 vb2_destroy_framevec(vec);
587
588fail_buf:
589 kfree(buf);
590
591 return ERR_PTR(ret);
592}
593
594
595
596
597
598static int vb2_dc_map_dmabuf(void *mem_priv)
599{
600 struct vb2_dc_buf *buf = mem_priv;
601 struct sg_table *sgt;
602 unsigned long contig_size;
603
604 if (WARN_ON(!buf->db_attach)) {
605 pr_err("trying to pin a non attached buffer\n");
606 return -EINVAL;
607 }
608
609 if (WARN_ON(buf->dma_sgt)) {
610 pr_err("dmabuf buffer is already pinned\n");
611 return 0;
612 }
613
614
615 sgt = dma_buf_map_attachment(buf->db_attach, buf->dma_dir);
616 if (IS_ERR(sgt)) {
617 pr_err("Error getting dmabuf scatterlist\n");
618 return -EINVAL;
619 }
620
621
622 contig_size = vb2_dc_get_contiguous_size(sgt);
623 if (contig_size < buf->size) {
624 pr_err("contiguous chunk is too small %lu/%lu b\n",
625 contig_size, buf->size);
626 dma_buf_unmap_attachment(buf->db_attach, sgt, buf->dma_dir);
627 return -EFAULT;
628 }
629
630 buf->dma_addr = sg_dma_address(sgt->sgl);
631 buf->dma_sgt = sgt;
632 buf->vaddr = NULL;
633
634 return 0;
635}
636
637static void vb2_dc_unmap_dmabuf(void *mem_priv)
638{
639 struct vb2_dc_buf *buf = mem_priv;
640 struct sg_table *sgt = buf->dma_sgt;
641
642 if (WARN_ON(!buf->db_attach)) {
643 pr_err("trying to unpin a not attached buffer\n");
644 return;
645 }
646
647 if (WARN_ON(!sgt)) {
648 pr_err("dmabuf buffer is already unpinned\n");
649 return;
650 }
651
652 if (buf->vaddr) {
653 dma_buf_vunmap(buf->db_attach->dmabuf, buf->vaddr);
654 buf->vaddr = NULL;
655 }
656 dma_buf_unmap_attachment(buf->db_attach, sgt, buf->dma_dir);
657
658 buf->dma_addr = 0;
659 buf->dma_sgt = NULL;
660}
661
662static void vb2_dc_detach_dmabuf(void *mem_priv)
663{
664 struct vb2_dc_buf *buf = mem_priv;
665
666
667 if (WARN_ON(buf->dma_addr))
668 vb2_dc_unmap_dmabuf(buf);
669
670
671 dma_buf_detach(buf->db_attach->dmabuf, buf->db_attach);
672 kfree(buf);
673}
674
675static void *vb2_dc_attach_dmabuf(struct device *dev, struct dma_buf *dbuf,
676 unsigned long size, enum dma_data_direction dma_dir)
677{
678 struct vb2_dc_buf *buf;
679 struct dma_buf_attachment *dba;
680
681 if (dbuf->size < size)
682 return ERR_PTR(-EFAULT);
683
684 if (WARN_ON(!dev))
685 return ERR_PTR(-EINVAL);
686
687 buf = kzalloc(sizeof(*buf), GFP_KERNEL);
688 if (!buf)
689 return ERR_PTR(-ENOMEM);
690
691 buf->dev = dev;
692
693 dba = dma_buf_attach(dbuf, buf->dev);
694 if (IS_ERR(dba)) {
695 pr_err("failed to attach dmabuf\n");
696 kfree(buf);
697 return dba;
698 }
699
700 buf->dma_dir = dma_dir;
701 buf->size = size;
702 buf->db_attach = dba;
703
704 return buf;
705}
706
707
708
709
710
711const struct vb2_mem_ops vb2_dma_contig_memops = {
712 .alloc = vb2_dc_alloc,
713 .put = vb2_dc_put,
714 .get_dmabuf = vb2_dc_get_dmabuf,
715 .cookie = vb2_dc_cookie,
716 .vaddr = vb2_dc_vaddr,
717 .mmap = vb2_dc_mmap,
718 .get_userptr = vb2_dc_get_userptr,
719 .put_userptr = vb2_dc_put_userptr,
720 .prepare = vb2_dc_prepare,
721 .finish = vb2_dc_finish,
722 .map_dmabuf = vb2_dc_map_dmabuf,
723 .unmap_dmabuf = vb2_dc_unmap_dmabuf,
724 .attach_dmabuf = vb2_dc_attach_dmabuf,
725 .detach_dmabuf = vb2_dc_detach_dmabuf,
726 .num_users = vb2_dc_num_users,
727};
728EXPORT_SYMBOL_GPL(vb2_dma_contig_memops);
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754int vb2_dma_contig_set_max_seg_size(struct device *dev, unsigned int size)
755{
756 if (!dev->dma_parms) {
757 dev->dma_parms = kzalloc(sizeof(*dev->dma_parms), GFP_KERNEL);
758 if (!dev->dma_parms)
759 return -ENOMEM;
760 }
761 if (dma_get_max_seg_size(dev) < size)
762 return dma_set_max_seg_size(dev, size);
763
764 return 0;
765}
766EXPORT_SYMBOL_GPL(vb2_dma_contig_set_max_seg_size);
767
768
769
770
771
772
773
774
775
776void vb2_dma_contig_clear_max_seg_size(struct device *dev)
777{
778 kfree(dev->dma_parms);
779 dev->dma_parms = NULL;
780}
781EXPORT_SYMBOL_GPL(vb2_dma_contig_clear_max_seg_size);
782
783MODULE_DESCRIPTION("DMA-contig memory handling routines for videobuf2");
784MODULE_AUTHOR("Pawel Osciak <pawel@osciak.com>");
785MODULE_LICENSE("GPL");
786