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