Merge tag 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mst/vhost
[cris-mirror.git] / drivers / media / v4l2-core / videobuf-dma-contig.c
blobe02353e340dd78d07d0750b05af0533ffad35dae
1 /*
2 * helper functions for physically contiguous capture buffers
4 * The functions support hardware lacking scatter gather support
5 * (i.e. the buffers must be linear in physical memory)
7 * Copyright (c) 2008 Magnus Damm
9 * Based on videobuf-vmalloc.c,
10 * (c) 2007 Mauro Carvalho Chehab, <mchehab@infradead.org>
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2
17 #include <linux/init.h>
18 #include <linux/module.h>
19 #include <linux/mm.h>
20 #include <linux/pagemap.h>
21 #include <linux/dma-mapping.h>
22 #include <linux/sched.h>
23 #include <linux/slab.h>
24 #include <media/videobuf-dma-contig.h>
26 struct videobuf_dma_contig_memory {
27 u32 magic;
28 void *vaddr;
29 dma_addr_t dma_handle;
30 unsigned long size;
33 #define MAGIC_DC_MEM 0x0733ac61
34 #define MAGIC_CHECK(is, should) \
35 if (unlikely((is) != (should))) { \
36 pr_err("magic mismatch: %x expected %x\n", (is), (should)); \
37 BUG(); \
40 static int __videobuf_dc_alloc(struct device *dev,
41 struct videobuf_dma_contig_memory *mem,
42 unsigned long size, gfp_t flags)
44 mem->size = size;
45 mem->vaddr = dma_alloc_coherent(dev, mem->size,
46 &mem->dma_handle, flags);
48 if (!mem->vaddr) {
49 dev_err(dev, "memory alloc size %ld failed\n", mem->size);
50 return -ENOMEM;
53 dev_dbg(dev, "dma mapped data is at %p (%ld)\n", mem->vaddr, mem->size);
55 return 0;
58 static void __videobuf_dc_free(struct device *dev,
59 struct videobuf_dma_contig_memory *mem)
61 dma_free_coherent(dev, mem->size, mem->vaddr, mem->dma_handle);
63 mem->vaddr = NULL;
66 static void videobuf_vm_open(struct vm_area_struct *vma)
68 struct videobuf_mapping *map = vma->vm_private_data;
70 dev_dbg(map->q->dev, "vm_open %p [count=%u,vma=%08lx-%08lx]\n",
71 map, map->count, vma->vm_start, vma->vm_end);
73 map->count++;
76 static void videobuf_vm_close(struct vm_area_struct *vma)
78 struct videobuf_mapping *map = vma->vm_private_data;
79 struct videobuf_queue *q = map->q;
80 int i;
82 dev_dbg(q->dev, "vm_close %p [count=%u,vma=%08lx-%08lx]\n",
83 map, map->count, vma->vm_start, vma->vm_end);
85 map->count--;
86 if (0 == map->count) {
87 struct videobuf_dma_contig_memory *mem;
89 dev_dbg(q->dev, "munmap %p q=%p\n", map, q);
90 videobuf_queue_lock(q);
92 /* We need first to cancel streams, before unmapping */
93 if (q->streaming)
94 videobuf_queue_cancel(q);
96 for (i = 0; i < VIDEO_MAX_FRAME; i++) {
97 if (NULL == q->bufs[i])
98 continue;
100 if (q->bufs[i]->map != map)
101 continue;
103 mem = q->bufs[i]->priv;
104 if (mem) {
105 /* This callback is called only if kernel has
106 allocated memory and this memory is mmapped.
107 In this case, memory should be freed,
108 in order to do memory unmap.
111 MAGIC_CHECK(mem->magic, MAGIC_DC_MEM);
113 /* vfree is not atomic - can't be
114 called with IRQ's disabled
116 dev_dbg(q->dev, "buf[%d] freeing %p\n",
117 i, mem->vaddr);
119 __videobuf_dc_free(q->dev, mem);
120 mem->vaddr = NULL;
123 q->bufs[i]->map = NULL;
124 q->bufs[i]->baddr = 0;
127 kfree(map);
129 videobuf_queue_unlock(q);
133 static const struct vm_operations_struct videobuf_vm_ops = {
134 .open = videobuf_vm_open,
135 .close = videobuf_vm_close,
139 * videobuf_dma_contig_user_put() - reset pointer to user space buffer
140 * @mem: per-buffer private videobuf-dma-contig data
142 * This function resets the user space pointer
144 static void videobuf_dma_contig_user_put(struct videobuf_dma_contig_memory *mem)
146 mem->dma_handle = 0;
147 mem->size = 0;
151 * videobuf_dma_contig_user_get() - setup user space memory pointer
152 * @mem: per-buffer private videobuf-dma-contig data
153 * @vb: video buffer to map
155 * This function validates and sets up a pointer to user space memory.
156 * Only physically contiguous pfn-mapped memory is accepted.
158 * Returns 0 if successful.
160 static int videobuf_dma_contig_user_get(struct videobuf_dma_contig_memory *mem,
161 struct videobuf_buffer *vb)
163 struct mm_struct *mm = current->mm;
164 struct vm_area_struct *vma;
165 unsigned long prev_pfn, this_pfn;
166 unsigned long pages_done, user_address;
167 unsigned int offset;
168 int ret;
170 offset = vb->baddr & ~PAGE_MASK;
171 mem->size = PAGE_ALIGN(vb->size + offset);
172 ret = -EINVAL;
174 down_read(&mm->mmap_sem);
176 vma = find_vma(mm, vb->baddr);
177 if (!vma)
178 goto out_up;
180 if ((vb->baddr + mem->size) > vma->vm_end)
181 goto out_up;
183 pages_done = 0;
184 prev_pfn = 0; /* kill warning */
185 user_address = vb->baddr;
187 while (pages_done < (mem->size >> PAGE_SHIFT)) {
188 ret = follow_pfn(vma, user_address, &this_pfn);
189 if (ret)
190 break;
192 if (pages_done == 0)
193 mem->dma_handle = (this_pfn << PAGE_SHIFT) + offset;
194 else if (this_pfn != (prev_pfn + 1))
195 ret = -EFAULT;
197 if (ret)
198 break;
200 prev_pfn = this_pfn;
201 user_address += PAGE_SIZE;
202 pages_done++;
205 out_up:
206 up_read(&current->mm->mmap_sem);
208 return ret;
211 static struct videobuf_buffer *__videobuf_alloc(size_t size)
213 struct videobuf_dma_contig_memory *mem;
214 struct videobuf_buffer *vb;
216 vb = kzalloc(size + sizeof(*mem), GFP_KERNEL);
217 if (vb) {
218 vb->priv = ((char *)vb) + size;
219 mem = vb->priv;
220 mem->magic = MAGIC_DC_MEM;
223 return vb;
226 static void *__videobuf_to_vaddr(struct videobuf_buffer *buf)
228 struct videobuf_dma_contig_memory *mem = buf->priv;
230 BUG_ON(!mem);
231 MAGIC_CHECK(mem->magic, MAGIC_DC_MEM);
233 return mem->vaddr;
236 static int __videobuf_iolock(struct videobuf_queue *q,
237 struct videobuf_buffer *vb,
238 struct v4l2_framebuffer *fbuf)
240 struct videobuf_dma_contig_memory *mem = vb->priv;
242 BUG_ON(!mem);
243 MAGIC_CHECK(mem->magic, MAGIC_DC_MEM);
245 switch (vb->memory) {
246 case V4L2_MEMORY_MMAP:
247 dev_dbg(q->dev, "%s memory method MMAP\n", __func__);
249 /* All handling should be done by __videobuf_mmap_mapper() */
250 if (!mem->vaddr) {
251 dev_err(q->dev, "memory is not alloced/mmapped.\n");
252 return -EINVAL;
254 break;
255 case V4L2_MEMORY_USERPTR:
256 dev_dbg(q->dev, "%s memory method USERPTR\n", __func__);
258 /* handle pointer from user space */
259 if (vb->baddr)
260 return videobuf_dma_contig_user_get(mem, vb);
262 /* allocate memory for the read() method */
263 if (__videobuf_dc_alloc(q->dev, mem, PAGE_ALIGN(vb->size),
264 GFP_KERNEL))
265 return -ENOMEM;
266 break;
267 case V4L2_MEMORY_OVERLAY:
268 default:
269 dev_dbg(q->dev, "%s memory method OVERLAY/unknown\n", __func__);
270 return -EINVAL;
273 return 0;
276 static int __videobuf_mmap_mapper(struct videobuf_queue *q,
277 struct videobuf_buffer *buf,
278 struct vm_area_struct *vma)
280 struct videobuf_dma_contig_memory *mem;
281 struct videobuf_mapping *map;
282 int retval;
283 unsigned long size;
285 dev_dbg(q->dev, "%s\n", __func__);
287 /* create mapping + update buffer list */
288 map = kzalloc(sizeof(struct videobuf_mapping), GFP_KERNEL);
289 if (!map)
290 return -ENOMEM;
292 buf->map = map;
293 map->q = q;
295 buf->baddr = vma->vm_start;
297 mem = buf->priv;
298 BUG_ON(!mem);
299 MAGIC_CHECK(mem->magic, MAGIC_DC_MEM);
301 if (__videobuf_dc_alloc(q->dev, mem, PAGE_ALIGN(buf->bsize),
302 GFP_KERNEL | __GFP_COMP))
303 goto error;
305 /* Try to remap memory */
306 size = vma->vm_end - vma->vm_start;
307 vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
309 /* the "vm_pgoff" is just used in v4l2 to find the
310 * corresponding buffer data structure which is allocated
311 * earlier and it does not mean the offset from the physical
312 * buffer start address as usual. So set it to 0 to pass
313 * the sanity check in vm_iomap_memory().
315 vma->vm_pgoff = 0;
317 retval = vm_iomap_memory(vma, mem->dma_handle, size);
318 if (retval) {
319 dev_err(q->dev, "mmap: remap failed with error %d. ",
320 retval);
321 dma_free_coherent(q->dev, mem->size,
322 mem->vaddr, mem->dma_handle);
323 goto error;
326 vma->vm_ops = &videobuf_vm_ops;
327 vma->vm_flags |= VM_DONTEXPAND;
328 vma->vm_private_data = map;
330 dev_dbg(q->dev, "mmap %p: q=%p %08lx-%08lx (%lx) pgoff %08lx buf %d\n",
331 map, q, vma->vm_start, vma->vm_end,
332 (long int)buf->bsize, vma->vm_pgoff, buf->i);
334 videobuf_vm_open(vma);
336 return 0;
338 error:
339 kfree(map);
340 return -ENOMEM;
343 static struct videobuf_qtype_ops qops = {
344 .magic = MAGIC_QTYPE_OPS,
345 .alloc_vb = __videobuf_alloc,
346 .iolock = __videobuf_iolock,
347 .mmap_mapper = __videobuf_mmap_mapper,
348 .vaddr = __videobuf_to_vaddr,
351 void videobuf_queue_dma_contig_init(struct videobuf_queue *q,
352 const struct videobuf_queue_ops *ops,
353 struct device *dev,
354 spinlock_t *irqlock,
355 enum v4l2_buf_type type,
356 enum v4l2_field field,
357 unsigned int msize,
358 void *priv,
359 struct mutex *ext_lock)
361 videobuf_queue_core_init(q, ops, dev, irqlock, type, field, msize,
362 priv, &qops, ext_lock);
364 EXPORT_SYMBOL_GPL(videobuf_queue_dma_contig_init);
366 dma_addr_t videobuf_to_dma_contig(struct videobuf_buffer *buf)
368 struct videobuf_dma_contig_memory *mem = buf->priv;
370 BUG_ON(!mem);
371 MAGIC_CHECK(mem->magic, MAGIC_DC_MEM);
373 return mem->dma_handle;
375 EXPORT_SYMBOL_GPL(videobuf_to_dma_contig);
377 void videobuf_dma_contig_free(struct videobuf_queue *q,
378 struct videobuf_buffer *buf)
380 struct videobuf_dma_contig_memory *mem = buf->priv;
382 /* mmapped memory can't be freed here, otherwise mmapped region
383 would be released, while still needed. In this case, the memory
384 release should happen inside videobuf_vm_close().
385 So, it should free memory only if the memory were allocated for
386 read() operation.
388 if (buf->memory != V4L2_MEMORY_USERPTR)
389 return;
391 if (!mem)
392 return;
394 MAGIC_CHECK(mem->magic, MAGIC_DC_MEM);
396 /* handle user space pointer case */
397 if (buf->baddr) {
398 videobuf_dma_contig_user_put(mem);
399 return;
402 /* read() method */
403 if (mem->vaddr) {
404 __videobuf_dc_free(q->dev, mem);
405 mem->vaddr = NULL;
408 EXPORT_SYMBOL_GPL(videobuf_dma_contig_free);
410 MODULE_DESCRIPTION("helper module to manage video4linux dma contig buffers");
411 MODULE_AUTHOR("Magnus Damm");
412 MODULE_LICENSE("GPL");