Merge branch 'timers-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git...
[linux-2.6.git] / drivers / media / video / videobuf-dma-contig.c
1 /*
2  * helper functions for physically contiguous capture buffers
3  *
4  * The functions support hardware lacking scatter gather support
5  * (i.e. the buffers must be linear in physical memory)
6  *
7  * Copyright (c) 2008 Magnus Damm
8  *
9  * Based on videobuf-vmalloc.c,
10  * (c) 2007 Mauro Carvalho Chehab, <mchehab@infradead.org>
11  *
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
15  */
16
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 <media/videobuf-dma-contig.h>
23
24 struct videobuf_dma_contig_memory {
25         u32 magic;
26         void *vaddr;
27         dma_addr_t dma_handle;
28         unsigned long size;
29         int is_userptr;
30 };
31
32 #define MAGIC_DC_MEM 0x0733ac61
33 #define MAGIC_CHECK(is, should)                                             \
34         if (unlikely((is) != (should))) {                                   \
35                 pr_err("magic mismatch: %x expected %x\n", (is), (should)); \
36                 BUG();                                                      \
37         }
38
39 static void
40 videobuf_vm_open(struct vm_area_struct *vma)
41 {
42         struct videobuf_mapping *map = vma->vm_private_data;
43
44         dev_dbg(map->q->dev, "vm_open %p [count=%u,vma=%08lx-%08lx]\n",
45                 map, map->count, vma->vm_start, vma->vm_end);
46
47         map->count++;
48 }
49
50 static void videobuf_vm_close(struct vm_area_struct *vma)
51 {
52         struct videobuf_mapping *map = vma->vm_private_data;
53         struct videobuf_queue *q = map->q;
54         int i;
55
56         dev_dbg(map->q->dev, "vm_close %p [count=%u,vma=%08lx-%08lx]\n",
57                 map, map->count, vma->vm_start, vma->vm_end);
58
59         map->count--;
60         if (0 == map->count) {
61                 struct videobuf_dma_contig_memory *mem;
62
63                 dev_dbg(map->q->dev, "munmap %p q=%p\n", map, q);
64                 mutex_lock(&q->vb_lock);
65
66                 /* We need first to cancel streams, before unmapping */
67                 if (q->streaming)
68                         videobuf_queue_cancel(q);
69
70                 for (i = 0; i < VIDEO_MAX_FRAME; i++) {
71                         if (NULL == q->bufs[i])
72                                 continue;
73
74                         if (q->bufs[i]->map != map)
75                                 continue;
76
77                         mem = q->bufs[i]->priv;
78                         if (mem) {
79                                 /* This callback is called only if kernel has
80                                    allocated memory and this memory is mmapped.
81                                    In this case, memory should be freed,
82                                    in order to do memory unmap.
83                                  */
84
85                                 MAGIC_CHECK(mem->magic, MAGIC_DC_MEM);
86
87                                 /* vfree is not atomic - can't be
88                                    called with IRQ's disabled
89                                  */
90                                 dev_dbg(map->q->dev, "buf[%d] freeing %p\n",
91                                         i, mem->vaddr);
92
93                                 dma_free_coherent(q->dev, mem->size,
94                                                   mem->vaddr, mem->dma_handle);
95                                 mem->vaddr = NULL;
96                         }
97
98                         q->bufs[i]->map   = NULL;
99                         q->bufs[i]->baddr = 0;
100                 }
101
102                 kfree(map);
103
104                 mutex_unlock(&q->vb_lock);
105         }
106 }
107
108 static struct vm_operations_struct videobuf_vm_ops = {
109         .open     = videobuf_vm_open,
110         .close    = videobuf_vm_close,
111 };
112
113 /**
114  * videobuf_dma_contig_user_put() - reset pointer to user space buffer
115  * @mem: per-buffer private videobuf-dma-contig data
116  *
117  * This function resets the user space pointer
118  */
119 static void videobuf_dma_contig_user_put(struct videobuf_dma_contig_memory *mem)
120 {
121         mem->is_userptr = 0;
122         mem->dma_handle = 0;
123         mem->size = 0;
124 }
125
126 /**
127  * videobuf_dma_contig_user_get() - setup user space memory pointer
128  * @mem: per-buffer private videobuf-dma-contig data
129  * @vb: video buffer to map
130  *
131  * This function validates and sets up a pointer to user space memory.
132  * Only physically contiguous pfn-mapped memory is accepted.
133  *
134  * Returns 0 if successful.
135  */
136 static int videobuf_dma_contig_user_get(struct videobuf_dma_contig_memory *mem,
137                                         struct videobuf_buffer *vb)
138 {
139         struct mm_struct *mm = current->mm;
140         struct vm_area_struct *vma;
141         unsigned long prev_pfn, this_pfn;
142         unsigned long pages_done, user_address;
143         int ret;
144
145         mem->size = PAGE_ALIGN(vb->size);
146         mem->is_userptr = 0;
147         ret = -EINVAL;
148
149         down_read(&mm->mmap_sem);
150
151         vma = find_vma(mm, vb->baddr);
152         if (!vma)
153                 goto out_up;
154
155         if ((vb->baddr + mem->size) > vma->vm_end)
156                 goto out_up;
157
158         pages_done = 0;
159         prev_pfn = 0; /* kill warning */
160         user_address = vb->baddr;
161
162         while (pages_done < (mem->size >> PAGE_SHIFT)) {
163                 ret = follow_pfn(vma, user_address, &this_pfn);
164                 if (ret)
165                         break;
166
167                 if (pages_done == 0)
168                         mem->dma_handle = this_pfn << PAGE_SHIFT;
169                 else if (this_pfn != (prev_pfn + 1))
170                         ret = -EFAULT;
171
172                 if (ret)
173                         break;
174
175                 prev_pfn = this_pfn;
176                 user_address += PAGE_SIZE;
177                 pages_done++;
178         }
179
180         if (!ret)
181                 mem->is_userptr = 1;
182
183  out_up:
184         up_read(&current->mm->mmap_sem);
185
186         return ret;
187 }
188
189 static void *__videobuf_alloc(size_t size)
190 {
191         struct videobuf_dma_contig_memory *mem;
192         struct videobuf_buffer *vb;
193
194         vb = kzalloc(size + sizeof(*mem), GFP_KERNEL);
195         if (vb) {
196                 mem = vb->priv = ((char *)vb) + size;
197                 mem->magic = MAGIC_DC_MEM;
198         }
199
200         return vb;
201 }
202
203 static void *__videobuf_to_vmalloc(struct videobuf_buffer *buf)
204 {
205         struct videobuf_dma_contig_memory *mem = buf->priv;
206
207         BUG_ON(!mem);
208         MAGIC_CHECK(mem->magic, MAGIC_DC_MEM);
209
210         return mem->vaddr;
211 }
212
213 static int __videobuf_iolock(struct videobuf_queue *q,
214                              struct videobuf_buffer *vb,
215                              struct v4l2_framebuffer *fbuf)
216 {
217         struct videobuf_dma_contig_memory *mem = vb->priv;
218
219         BUG_ON(!mem);
220         MAGIC_CHECK(mem->magic, MAGIC_DC_MEM);
221
222         switch (vb->memory) {
223         case V4L2_MEMORY_MMAP:
224                 dev_dbg(q->dev, "%s memory method MMAP\n", __func__);
225
226                 /* All handling should be done by __videobuf_mmap_mapper() */
227                 if (!mem->vaddr) {
228                         dev_err(q->dev, "memory is not alloced/mmapped.\n");
229                         return -EINVAL;
230                 }
231                 break;
232         case V4L2_MEMORY_USERPTR:
233                 dev_dbg(q->dev, "%s memory method USERPTR\n", __func__);
234
235                 /* handle pointer from user space */
236                 if (vb->baddr)
237                         return videobuf_dma_contig_user_get(mem, vb);
238
239                 /* allocate memory for the read() method */
240                 mem->size = PAGE_ALIGN(vb->size);
241                 mem->vaddr = dma_alloc_coherent(q->dev, mem->size,
242                                                 &mem->dma_handle, GFP_KERNEL);
243                 if (!mem->vaddr) {
244                         dev_err(q->dev, "dma_alloc_coherent %ld failed\n",
245                                          mem->size);
246                         return -ENOMEM;
247                 }
248
249                 dev_dbg(q->dev, "dma_alloc_coherent data is at %p (%ld)\n",
250                         mem->vaddr, mem->size);
251                 break;
252         case V4L2_MEMORY_OVERLAY:
253         default:
254                 dev_dbg(q->dev, "%s memory method OVERLAY/unknown\n",
255                         __func__);
256                 return -EINVAL;
257         }
258
259         return 0;
260 }
261
262 static int __videobuf_mmap_free(struct videobuf_queue *q)
263 {
264         unsigned int i;
265
266         dev_dbg(q->dev, "%s\n", __func__);
267         for (i = 0; i < VIDEO_MAX_FRAME; i++) {
268                 if (q->bufs[i] && q->bufs[i]->map)
269                         return -EBUSY;
270         }
271
272         return 0;
273 }
274
275 static int __videobuf_mmap_mapper(struct videobuf_queue *q,
276                                   struct vm_area_struct *vma)
277 {
278         struct videobuf_dma_contig_memory *mem;
279         struct videobuf_mapping *map;
280         unsigned int first;
281         int retval;
282         unsigned long size, offset = vma->vm_pgoff << PAGE_SHIFT;
283
284         dev_dbg(q->dev, "%s\n", __func__);
285         if (!(vma->vm_flags & VM_WRITE) || !(vma->vm_flags & VM_SHARED))
286                 return -EINVAL;
287
288         /* look for first buffer to map */
289         for (first = 0; first < VIDEO_MAX_FRAME; first++) {
290                 if (!q->bufs[first])
291                         continue;
292
293                 if (V4L2_MEMORY_MMAP != q->bufs[first]->memory)
294                         continue;
295                 if (q->bufs[first]->boff == offset)
296                         break;
297         }
298         if (VIDEO_MAX_FRAME == first) {
299                 dev_dbg(q->dev, "invalid user space offset [offset=0x%lx]\n",
300                         offset);
301                 return -EINVAL;
302         }
303
304         /* create mapping + update buffer list */
305         map = kzalloc(sizeof(struct videobuf_mapping), GFP_KERNEL);
306         if (!map)
307                 return -ENOMEM;
308
309         q->bufs[first]->map = map;
310         map->start = vma->vm_start;
311         map->end = vma->vm_end;
312         map->q = q;
313
314         q->bufs[first]->baddr = vma->vm_start;
315
316         mem = q->bufs[first]->priv;
317         BUG_ON(!mem);
318         MAGIC_CHECK(mem->magic, MAGIC_DC_MEM);
319
320         mem->size = PAGE_ALIGN(q->bufs[first]->bsize);
321         mem->vaddr = dma_alloc_coherent(q->dev, mem->size,
322                                         &mem->dma_handle, GFP_KERNEL);
323         if (!mem->vaddr) {
324                 dev_err(q->dev, "dma_alloc_coherent size %ld failed\n",
325                         mem->size);
326                 goto error;
327         }
328         dev_dbg(q->dev, "dma_alloc_coherent data is at addr %p (size %ld)\n",
329                 mem->vaddr, mem->size);
330
331         /* Try to remap memory */
332
333         size = vma->vm_end - vma->vm_start;
334         size = (size < mem->size) ? size : mem->size;
335
336         vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
337         retval = remap_pfn_range(vma, vma->vm_start,
338                                  mem->dma_handle >> PAGE_SHIFT,
339                                  size, vma->vm_page_prot);
340         if (retval) {
341                 dev_err(q->dev, "mmap: remap failed with error %d. ", retval);
342                 dma_free_coherent(q->dev, mem->size,
343                                   mem->vaddr, mem->dma_handle);
344                 goto error;
345         }
346
347         vma->vm_ops          = &videobuf_vm_ops;
348         vma->vm_flags       |= VM_DONTEXPAND;
349         vma->vm_private_data = map;
350
351         dev_dbg(q->dev, "mmap %p: q=%p %08lx-%08lx (%lx) pgoff %08lx buf %d\n",
352                 map, q, vma->vm_start, vma->vm_end,
353                 (long int) q->bufs[first]->bsize,
354                 vma->vm_pgoff, first);
355
356         videobuf_vm_open(vma);
357
358         return 0;
359
360 error:
361         kfree(map);
362         return -ENOMEM;
363 }
364
365 static int __videobuf_copy_to_user(struct videobuf_queue *q,
366                                    char __user *data, size_t count,
367                                    int nonblocking)
368 {
369         struct videobuf_dma_contig_memory *mem = q->read_buf->priv;
370         void *vaddr;
371
372         BUG_ON(!mem);
373         MAGIC_CHECK(mem->magic, MAGIC_DC_MEM);
374         BUG_ON(!mem->vaddr);
375
376         /* copy to userspace */
377         if (count > q->read_buf->size - q->read_off)
378                 count = q->read_buf->size - q->read_off;
379
380         vaddr = mem->vaddr;
381
382         if (copy_to_user(data, vaddr + q->read_off, count))
383                 return -EFAULT;
384
385         return count;
386 }
387
388 static int __videobuf_copy_stream(struct videobuf_queue *q,
389                                   char __user *data, size_t count, size_t pos,
390                                   int vbihack, int nonblocking)
391 {
392         unsigned int  *fc;
393         struct videobuf_dma_contig_memory *mem = q->read_buf->priv;
394
395         BUG_ON(!mem);
396         MAGIC_CHECK(mem->magic, MAGIC_DC_MEM);
397
398         if (vbihack) {
399                 /* dirty, undocumented hack -- pass the frame counter
400                         * within the last four bytes of each vbi data block.
401                         * We need that one to maintain backward compatibility
402                         * to all vbi decoding software out there ... */
403                 fc = (unsigned int *)mem->vaddr;
404                 fc += (q->read_buf->size >> 2) - 1;
405                 *fc = q->read_buf->field_count >> 1;
406                 dev_dbg(q->dev, "vbihack: %d\n", *fc);
407         }
408
409         /* copy stuff using the common method */
410         count = __videobuf_copy_to_user(q, data, count, nonblocking);
411
412         if ((count == -EFAULT) && (pos == 0))
413                 return -EFAULT;
414
415         return count;
416 }
417
418 static struct videobuf_qtype_ops qops = {
419         .magic        = MAGIC_QTYPE_OPS,
420
421         .alloc        = __videobuf_alloc,
422         .iolock       = __videobuf_iolock,
423         .mmap_free    = __videobuf_mmap_free,
424         .mmap_mapper  = __videobuf_mmap_mapper,
425         .video_copy_to_user = __videobuf_copy_to_user,
426         .copy_stream  = __videobuf_copy_stream,
427         .vmalloc      = __videobuf_to_vmalloc,
428 };
429
430 void videobuf_queue_dma_contig_init(struct videobuf_queue *q,
431                                     struct videobuf_queue_ops *ops,
432                                     struct device *dev,
433                                     spinlock_t *irqlock,
434                                     enum v4l2_buf_type type,
435                                     enum v4l2_field field,
436                                     unsigned int msize,
437                                     void *priv)
438 {
439         videobuf_queue_core_init(q, ops, dev, irqlock, type, field, msize,
440                                  priv, &qops);
441 }
442 EXPORT_SYMBOL_GPL(videobuf_queue_dma_contig_init);
443
444 dma_addr_t videobuf_to_dma_contig(struct videobuf_buffer *buf)
445 {
446         struct videobuf_dma_contig_memory *mem = buf->priv;
447
448         BUG_ON(!mem);
449         MAGIC_CHECK(mem->magic, MAGIC_DC_MEM);
450
451         return mem->dma_handle;
452 }
453 EXPORT_SYMBOL_GPL(videobuf_to_dma_contig);
454
455 void videobuf_dma_contig_free(struct videobuf_queue *q,
456                               struct videobuf_buffer *buf)
457 {
458         struct videobuf_dma_contig_memory *mem = buf->priv;
459
460         /* mmapped memory can't be freed here, otherwise mmapped region
461            would be released, while still needed. In this case, the memory
462            release should happen inside videobuf_vm_close().
463            So, it should free memory only if the memory were allocated for
464            read() operation.
465          */
466         if (buf->memory != V4L2_MEMORY_USERPTR)
467                 return;
468
469         if (!mem)
470                 return;
471
472         MAGIC_CHECK(mem->magic, MAGIC_DC_MEM);
473
474         /* handle user space pointer case */
475         if (buf->baddr) {
476                 videobuf_dma_contig_user_put(mem);
477                 return;
478         }
479
480         /* read() method */
481         dma_free_coherent(q->dev, mem->size, mem->vaddr, mem->dma_handle);
482         mem->vaddr = NULL;
483 }
484 EXPORT_SYMBOL_GPL(videobuf_dma_contig_free);
485
486 MODULE_DESCRIPTION("helper module to manage video4linux dma contig buffers");
487 MODULE_AUTHOR("Magnus Damm");
488 MODULE_LICENSE("GPL");