[deliverable/linux.git] / drivers / media / video / videobuf-dma-contig.c

/*
 * helper functions for physically contiguous capture buffers
 *
 * The functions support hardware lacking scatter gather support
 * (i.e. the buffers must be linear in physical memory)
 *
 * Copyright (c) 2008 Magnus Damm
 *
 * Based on videobuf-vmalloc.c,
 * (c) 2007 Mauro Carvalho Chehab, <mchehab@infradead.org>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2
 */

#include <linux/init.h>
#include <linux/module.h>
#include <linux/dma-mapping.h>
#include <media/videobuf-dma-contig.h>

struct videobuf_dma_contig_memory {
	u32 magic;
	void *vaddr;
	dma_addr_t dma_handle;
	unsigned long size;
};

#define MAGIC_DC_MEM 0x0733ac61
#define MAGIC_CHECK(is, should)						\
	if (unlikely((is) != (should)))	{				\
		pr_err("magic mismatch: %x expected %x\n", is, should); \
		BUG();							\
	}

static void
videobuf_vm_open(struct vm_area_struct *vma)
{
	struct videobuf_mapping *map = vma->vm_private_data;

	dev_dbg(map->q->dev, "vm_open %p [count=%u,vma=%08lx-%08lx]\n",
		map, map->count, vma->vm_start, vma->vm_end);

	map->count++;
}

static void videobuf_vm_close(struct vm_area_struct *vma)
{
	struct videobuf_mapping *map = vma->vm_private_data;
	struct videobuf_queue *q = map->q;
	int i;

	dev_dbg(map->q->dev, "vm_close %p [count=%u,vma=%08lx-%08lx]\n",
		map, map->count, vma->vm_start, vma->vm_end);

	map->count--;
	if (0 == map->count) {
		struct videobuf_dma_contig_memory *mem;

		dev_dbg(map->q->dev, "munmap %p q=%p\n", map, q);
		mutex_lock(&q->vb_lock);

		/* We need first to cancel streams, before unmapping */
		if (q->streaming)
			videobuf_queue_cancel(q);

		for (i = 0; i < VIDEO_MAX_FRAME; i++) {
			if (NULL == q->bufs[i])
				continue;

			if (q->bufs[i]->map != map)
				continue;

			mem = q->bufs[i]->priv;
			if (mem) {
				/* This callback is called only if kernel has
				   allocated memory and this memory is mmapped.
				   In this case, memory should be freed,
				   in order to do memory unmap.
				 */

				MAGIC_CHECK(mem->magic, MAGIC_DC_MEM);

				/* vfree is not atomic - can't be
				   called with IRQ's disabled
				 */
				dev_dbg(map->q->dev, "buf[%d] freeing %p\n",
					i, mem->vaddr);

				dma_free_coherent(q->dev, mem->size,
						  mem->vaddr, mem->dma_handle);
				mem->vaddr = NULL;
			}

			q->bufs[i]->map   = NULL;
			q->bufs[i]->baddr = 0;
		}

		kfree(map);

		mutex_unlock(&q->vb_lock);
	}
}

static struct vm_operations_struct videobuf_vm_ops = {
	.open     = videobuf_vm_open,
	.close    = videobuf_vm_close,
};

static void *__videobuf_alloc(size_t size)
{
	struct videobuf_dma_contig_memory *mem;
	struct videobuf_buffer *vb;

	vb = kzalloc(size + sizeof(*mem), GFP_KERNEL);
	if (vb) {
		mem = vb->priv = ((char *)vb) + size;
		mem->magic = MAGIC_DC_MEM;
	}

	return vb;
}

static void *__videobuf_to_vmalloc(struct videobuf_buffer *buf)
{
	struct videobuf_dma_contig_memory *mem = buf->priv;

	BUG_ON(!mem);
	MAGIC_CHECK(mem->magic, MAGIC_DC_MEM);

	return mem->vaddr;
}

static int __videobuf_iolock(struct videobuf_queue *q,
			     struct videobuf_buffer *vb,
			     struct v4l2_framebuffer *fbuf)
{
	struct videobuf_dma_contig_memory *mem = vb->priv;

	BUG_ON(!mem);
	MAGIC_CHECK(mem->magic, MAGIC_DC_MEM);

	switch (vb->memory) {
	case V4L2_MEMORY_MMAP:
		dev_dbg(q->dev, "%s memory method MMAP\n", __func__);

		/* All handling should be done by __videobuf_mmap_mapper() */
		if (!mem->vaddr) {
			dev_err(q->dev, "memory is not alloced/mmapped.\n");
			return -EINVAL;
		}
		break;
	case V4L2_MEMORY_USERPTR:
		dev_dbg(q->dev, "%s memory method USERPTR\n", __func__);

		/* The only USERPTR currently supported is the one needed for
		   read() method.
		 */
		if (vb->baddr)
			return -EINVAL;

		mem->size = PAGE_ALIGN(vb->size);
		mem->vaddr = dma_alloc_coherent(q->dev, mem->size,
						&mem->dma_handle, GFP_KERNEL);
		if (!mem->vaddr) {
			dev_err(q->dev, "dma_alloc_coherent %ld failed\n",
					 mem->size);
			return -ENOMEM;
		}

		dev_dbg(q->dev, "dma_alloc_coherent data is at %p (%ld)\n",
			mem->vaddr, mem->size);
		break;
	case V4L2_MEMORY_OVERLAY:
	default:
		dev_dbg(q->dev, "%s memory method OVERLAY/unknown\n",
			__func__);
		return -EINVAL;
	}

	return 0;
}

static int __videobuf_sync(struct videobuf_queue *q,
			   struct videobuf_buffer *buf)
{
	struct videobuf_dma_contig_memory *mem = buf->priv;

	BUG_ON(!mem);
	MAGIC_CHECK(mem->magic, MAGIC_DC_MEM);

	dma_sync_single_for_cpu(q->dev, mem->dma_handle, mem->size,
				DMA_FROM_DEVICE);
	return 0;
}

static int __videobuf_mmap_free(struct videobuf_queue *q)
{
	unsigned int i;

	dev_dbg(q->dev, "%s\n", __func__);
	for (i = 0; i < VIDEO_MAX_FRAME; i++) {
		if (q->bufs[i] && q->bufs[i]->map)
			return -EBUSY;
	}

	return 0;
}

static int __videobuf_mmap_mapper(struct videobuf_queue *q,
				  struct vm_area_struct *vma)
{
	struct videobuf_dma_contig_memory *mem;
	struct videobuf_mapping *map;
	unsigned int first;
	int retval;
	unsigned long size, offset = vma->vm_pgoff << PAGE_SHIFT;

	dev_dbg(q->dev, "%s\n", __func__);
	if (!(vma->vm_flags & VM_WRITE) || !(vma->vm_flags & VM_SHARED))
		return -EINVAL;

	/* look for first buffer to map */
	for (first = 0; first < VIDEO_MAX_FRAME; first++) {
		if (!q->bufs[first])
			continue;

		if (V4L2_MEMORY_MMAP != q->bufs[first]->memory)
			continue;
		if (q->bufs[first]->boff == offset)
			break;
	}
	if (VIDEO_MAX_FRAME == first) {
		dev_dbg(q->dev, "invalid user space offset [offset=0x%lx]\n",
			offset);
		return -EINVAL;
	}

	/* create mapping + update buffer list */
	map = kzalloc(sizeof(struct videobuf_mapping), GFP_KERNEL);
	if (!map)
		return -ENOMEM;

	q->bufs[first]->map = map;
	map->start = vma->vm_start;
	map->end = vma->vm_end;
	map->q = q;

	q->bufs[first]->baddr = vma->vm_start;

	mem = q->bufs[first]->priv;
	BUG_ON(!mem);
	MAGIC_CHECK(mem->magic, MAGIC_DC_MEM);

	mem->size = PAGE_ALIGN(q->bufs[first]->bsize);
	mem->vaddr = dma_alloc_coherent(q->dev, mem->size,
					&mem->dma_handle, GFP_KERNEL);
	if (!mem->vaddr) {
		dev_err(q->dev, "dma_alloc_coherent size %ld failed\n",
			mem->size);
		goto error;
	}
	dev_dbg(q->dev, "dma_alloc_coherent data is at addr %p (size %ld)\n",
		mem->vaddr, mem->size);

	/* Try to remap memory */

	size = vma->vm_end - vma->vm_start;
	size = (size < mem->size) ? size : mem->size;

	vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
	retval = remap_pfn_range(vma, vma->vm_start,
				 mem->dma_handle >> PAGE_SHIFT,
				 size, vma->vm_page_prot);
	if (retval) {
		dev_err(q->dev, "mmap: remap failed with error %d. ", retval);
		dma_free_coherent(q->dev, mem->size,
				  mem->vaddr, mem->dma_handle);
		goto error;
	}

	vma->vm_ops          = &videobuf_vm_ops;
	vma->vm_flags       |= VM_DONTEXPAND;
	vma->vm_private_data = map;

	dev_dbg(q->dev, "mmap %p: q=%p %08lx-%08lx (%lx) pgoff %08lx buf %d\n",
		map, q, vma->vm_start, vma->vm_end,
		(long int) q->bufs[first]->bsize,
		vma->vm_pgoff, first);

	videobuf_vm_open(vma);

	return 0;

error:
	kfree(map);
	return -ENOMEM;
}

static int __videobuf_copy_to_user(struct videobuf_queue *q,
				   char __user *data, size_t count,
				   int nonblocking)
{
	struct videobuf_dma_contig_memory *mem = q->read_buf->priv;
	void *vaddr;

	BUG_ON(!mem);
	MAGIC_CHECK(mem->magic, MAGIC_DC_MEM);
	BUG_ON(!mem->vaddr);

	/* copy to userspace */
	if (count > q->read_buf->size - q->read_off)
		count = q->read_buf->size - q->read_off;

	vaddr = mem->vaddr;

	if (copy_to_user(data, vaddr + q->read_off, count))
		return -EFAULT;

	return count;
}

static int __videobuf_copy_stream(struct videobuf_queue *q,
				  char __user *data, size_t count, size_t pos,
				  int vbihack, int nonblocking)
{
	unsigned int  *fc;
	struct videobuf_dma_contig_memory *mem = q->read_buf->priv;

	BUG_ON(!mem);
	MAGIC_CHECK(mem->magic, MAGIC_DC_MEM);

	if (vbihack) {
		/* dirty, undocumented hack -- pass the frame counter
			* within the last four bytes of each vbi data block.
			* We need that one to maintain backward compatibility
			* to all vbi decoding software out there ... */
		fc = (unsigned int *)mem->vaddr;
		fc += (q->read_buf->size >> 2) - 1;
		*fc = q->read_buf->field_count >> 1;
		dev_dbg(q->dev, "vbihack: %d\n", *fc);
	}

	/* copy stuff using the common method */
	count = __videobuf_copy_to_user(q, data, count, nonblocking);

	if ((count == -EFAULT) && (pos == 0))
		return -EFAULT;

	return count;
}

static struct videobuf_qtype_ops qops = {
	.magic        = MAGIC_QTYPE_OPS,

	.alloc        = __videobuf_alloc,
	.iolock       = __videobuf_iolock,
	.sync         = __videobuf_sync,
	.mmap_free    = __videobuf_mmap_free,
	.mmap_mapper  = __videobuf_mmap_mapper,
	.video_copy_to_user = __videobuf_copy_to_user,
	.copy_stream  = __videobuf_copy_stream,
	.vmalloc      = __videobuf_to_vmalloc,
};

void videobuf_queue_dma_contig_init(struct videobuf_queue *q,
				    struct videobuf_queue_ops *ops,
				    struct device *dev,
				    spinlock_t *irqlock,
				    enum v4l2_buf_type type,
				    enum v4l2_field field,
				    unsigned int msize,
				    void *priv)
{
	videobuf_queue_core_init(q, ops, dev, irqlock, type, field, msize,
				 priv, &qops);
}
EXPORT_SYMBOL_GPL(videobuf_queue_dma_contig_init);

dma_addr_t videobuf_to_dma_contig(struct videobuf_buffer *buf)
{
	struct videobuf_dma_contig_memory *mem = buf->priv;

	BUG_ON(!mem);
	MAGIC_CHECK(mem->magic, MAGIC_DC_MEM);

	return mem->dma_handle;
}
EXPORT_SYMBOL_GPL(videobuf_to_dma_contig);

void videobuf_dma_contig_free(struct videobuf_queue *q,
			      struct videobuf_buffer *buf)
{
	struct videobuf_dma_contig_memory *mem = buf->priv;

	/* mmapped memory can't be freed here, otherwise mmapped region
	   would be released, while still needed. In this case, the memory
	   release should happen inside videobuf_vm_close().
	   So, it should free memory only if the memory were allocated for
	   read() operation.
	 */
	if ((buf->memory != V4L2_MEMORY_USERPTR) || !buf->baddr)
		return;

	if (!mem)
		return;

	MAGIC_CHECK(mem->magic, MAGIC_DC_MEM);

	dma_free_coherent(q->dev, mem->size, mem->vaddr, mem->dma_handle);
	mem->vaddr = NULL;
}
EXPORT_SYMBOL_GPL(videobuf_dma_contig_free);

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