[linux-2.6-block.git] / drivers / media / v4l2-core / videobuf-vmalloc.c

/*
 * helper functions for vmalloc video4linux capture buffers
 *
 * The functions expect the hardware being able to scatter gather
 * (i.e. the buffers are not linear in physical memory, but fragmented
 * into PAGE_SIZE chunks).  They also assume the driver does not need
 * to touch the video data.
 *
 * (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/moduleparam.h>
#include <linux/slab.h>
#include <linux/interrupt.h>

#include <linux/pci.h>
#include <linux/vmalloc.h>
#include <linux/pagemap.h>
#include <asm/page.h>
#include <asm/pgtable.h>

#include <media/videobuf-vmalloc.h>

#define MAGIC_DMABUF   0x17760309
#define MAGIC_VMAL_MEM 0x18221223

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

static int debug;
module_param(debug, int, 0644);

MODULE_DESCRIPTION("helper module to manage video4linux vmalloc buffers");
MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@infradead.org>");
MODULE_LICENSE("GPL");

#define dprintk(level, fmt, arg...)					\
	if (debug >= level)						\
		printk(KERN_DEBUG "vbuf-vmalloc: " fmt , ## arg)


/***************************************************************************/

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

	dprintk(2, "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;

	dprintk(2, "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_vmalloc_memory *mem;

		dprintk(1, "munmap %p q=%p\n", map, q);
		videobuf_queue_lock(q);

		/* 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_VMAL_MEM);

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

				vfree(mem->vaddr);
				mem->vaddr = NULL;
			}

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

		kfree(map);

		videobuf_queue_unlock(q);
	}

	return;
}

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

/* ---------------------------------------------------------------------
 * vmalloc handlers for the generic methods
 */

/* Allocated area consists on 3 parts:
	struct video_buffer
	struct <driver>_buffer (cx88_buffer, saa7134_buf, ...)
	struct videobuf_dma_sg_memory
 */

static struct videobuf_buffer *__videobuf_alloc_vb(size_t size)
{
	struct videobuf_vmalloc_memory *mem;
	struct videobuf_buffer *vb;

	vb = kzalloc(size + sizeof(*mem), GFP_KERNEL);
	if (!vb)
		return vb;

	mem = vb->priv = ((char *)vb) + size;
	mem->magic = MAGIC_VMAL_MEM;

	dprintk(1, "%s: allocated at %p(%ld+%ld) & %p(%ld)\n",
		__func__, vb, (long)sizeof(*vb), (long)size - sizeof(*vb),
		mem, (long)sizeof(*mem));

	return vb;
}

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

	BUG_ON(!mem);

	MAGIC_CHECK(mem->magic, MAGIC_VMAL_MEM);

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

		/* All handling should be done by __videobuf_mmap_mapper() */
		if (!mem->vaddr) {
			printk(KERN_ERR "memory is not alloced/mmapped.\n");
			return -EINVAL;
		}
		break;
	case V4L2_MEMORY_USERPTR:
		pages = PAGE_ALIGN(vb->size);

		dprintk(1, "%s memory method USERPTR\n", __func__);

		if (vb->baddr) {
			printk(KERN_ERR "USERPTR is currently not supported\n");
			return -EINVAL;
		}

		/* The only USERPTR currently supported is the one needed for
		 * read() method.
		 */

		mem->vaddr = vmalloc_user(pages);
		if (!mem->vaddr) {
			printk(KERN_ERR "vmalloc (%d pages) failed\n", pages);
			return -ENOMEM;
		}
		dprintk(1, "vmalloc is at addr %p (%d pages)\n",
			mem->vaddr, pages);

#if 0
		int rc;
		/* Kernel userptr is used also by read() method. In this case,
		   there's no need to remap, since data will be copied to user
		 */
		if (!vb->baddr)
			return 0;

		/* FIXME: to properly support USERPTR, remap should occur.
		   The code below won't work, since mem->vma = NULL
		 */
		/* Try to remap memory */
		rc = remap_vmalloc_range(mem->vma, (void *)vb->baddr, 0);
		if (rc < 0) {
			printk(KERN_ERR "mmap: remap failed with error %d", rc);
			return -ENOMEM;
		}
#endif

		break;
	case V4L2_MEMORY_OVERLAY:
	default:
		dprintk(1, "%s memory method OVERLAY/unknown\n", __func__);

		/* Currently, doesn't support V4L2_MEMORY_OVERLAY */
		printk(KERN_ERR "Memory method currently unsupported.\n");
		return -EINVAL;
	}

	return 0;
}

static int __videobuf_mmap_mapper(struct videobuf_queue *q,
				  struct videobuf_buffer *buf,
				  struct vm_area_struct *vma)
{
	struct videobuf_vmalloc_memory *mem;
	struct videobuf_mapping *map;
	int retval, pages;

	dprintk(1, "%s\n", __func__);

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

	buf->map = map;
	map->q     = q;

	buf->baddr = vma->vm_start;

	mem = buf->priv;
	BUG_ON(!mem);
	MAGIC_CHECK(mem->magic, MAGIC_VMAL_MEM);

	pages = PAGE_ALIGN(vma->vm_end - vma->vm_start);
	mem->vaddr = vmalloc_user(pages);
	if (!mem->vaddr) {
		printk(KERN_ERR "vmalloc (%d pages) failed\n", pages);
		goto error;
	}
	dprintk(1, "vmalloc is at addr %p (%d pages)\n", mem->vaddr, pages);

	/* Try to remap memory */
	retval = remap_vmalloc_range(vma, mem->vaddr, 0);
	if (retval < 0) {
		printk(KERN_ERR "mmap: remap failed with error %d. ", retval);
		vfree(mem->vaddr);
		goto error;
	}

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

	dprintk(1, "mmap %p: q=%p %08lx-%08lx (%lx) pgoff %08lx buf %d\n",
		map, q, vma->vm_start, vma->vm_end,
		(long int)buf->bsize,
		vma->vm_pgoff, buf->i);

	videobuf_vm_open(vma);

	return 0;

error:
	mem = NULL;
	kfree(map);
	return -ENOMEM;
}

static struct videobuf_qtype_ops qops = {
	.magic        = MAGIC_QTYPE_OPS,

	.alloc_vb     = __videobuf_alloc_vb,
	.iolock       = __videobuf_iolock,
	.mmap_mapper  = __videobuf_mmap_mapper,
	.vaddr        = videobuf_to_vmalloc,
};

void videobuf_queue_vmalloc_init(struct videobuf_queue *q,
			 const 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,
			 struct mutex *ext_lock)
{
	videobuf_queue_core_init(q, ops, dev, irqlock, type, field, msize,
				 priv, &qops, ext_lock);
}
EXPORT_SYMBOL_GPL(videobuf_queue_vmalloc_init);

void *videobuf_to_vmalloc(struct videobuf_buffer *buf)
{
	struct videobuf_vmalloc_memory *mem = buf->priv;
	BUG_ON(!mem);
	MAGIC_CHECK(mem->magic, MAGIC_VMAL_MEM);

	return mem->vaddr;
}
EXPORT_SYMBOL_GPL(videobuf_to_vmalloc);

void videobuf_vmalloc_free(struct videobuf_buffer *buf)
{
	struct videobuf_vmalloc_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_VMAL_MEM);

	vfree(mem->vaddr);
	mem->vaddr = NULL;

	return;
}
EXPORT_SYMBOL_GPL(videobuf_vmalloc_free);
Commit	Line	Data
87b9ad07 MCC	1	/*
	2	* helper functions for vmalloc video4linux capture buffers
	3	*
5d6aaf50	4	* The functions expect the hardware being able to scatter gather
87b9ad07 MCC	5	* (i.e. the buffers are not linear in physical memory, but fragmented
	6	* into PAGE_SIZE chunks). They also assume the driver does not need
	7	* to touch the video data.
	8	*
	9	* (c) 2007 Mauro Carvalho Chehab, <mchehab@infradead.org>
	10	*
	11	* This program is free software; you can redistribute it and/or modify
	12	* it under the terms of the GNU General Public License as published by
	13	* the Free Software Foundation; either version 2
	14	*/
	15
	16	#include <linux/init.h>
	17	#include <linux/module.h>
	18	#include <linux/moduleparam.h>
	19	#include <linux/slab.h>
	20	#include <linux/interrupt.h>
	21
	22	#include <linux/pci.h>
	23	#include <linux/vmalloc.h>
	24	#include <linux/pagemap.h>
	25	#include <asm/page.h>
	26	#include <asm/pgtable.h>
	27
	28	#include <media/videobuf-vmalloc.h>
	29
	30	#define MAGIC_DMABUF 0x17760309
	31	#define MAGIC_VMAL_MEM 0x18221223
	32
7a02264c PO	33	#define MAGIC_CHECK(is, should) \
	34	if (unlikely((is) != (should))) { \
	35	printk(KERN_ERR "magic mismatch: %x (expected %x)\n", \
	36	is, should); \
	37	BUG(); \
	38	}
87b9ad07	39
ff699e6b	40	static int debug;
87b9ad07 MCC	41	module_param(debug, int, 0644);
	42
	43	MODULE_DESCRIPTION("helper module to manage video4linux vmalloc buffers");
	44	MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@infradead.org>");
	45	MODULE_LICENSE("GPL");
	46
7a02264c PO	47	#define dprintk(level, fmt, arg...) \
	48	if (debug >= level) \
	49	printk(KERN_DEBUG "vbuf-vmalloc: " fmt , ## arg)
87b9ad07 MCC	50
	51
	52	/***************************************************************************/
	53
7a02264c	54	static void videobuf_vm_open(struct vm_area_struct *vma)
87b9ad07 MCC	55	{
	56	struct videobuf_mapping *map = vma->vm_private_data;
	57
7a02264c PO	58	dprintk(2, "vm_open %p [count=%u,vma=%08lx-%08lx]\n", map,
7a02264c PO	59	map->count, vma->vm_start, vma->vm_end);
87b9ad07 MCC	60
	61	map->count++;
	62	}
	63
aaea56af	64	static void videobuf_vm_close(struct vm_area_struct *vma)
87b9ad07 MCC	65	{
	66	struct videobuf_mapping *map = vma->vm_private_data;
	67	struct videobuf_queue *q = map->q;
87b9ad07 MCC	68	int i;
87b9ad07 MCC	69
7a02264c	70	dprintk(2, "vm_close %p [count=%u,vma=%08lx-%08lx]\n", map,
aaea56af	71	map->count, vma->vm_start, vma->vm_end);
87b9ad07	72
cca36e2e HV	73	map->count--;
cca36e2e HV	74	if (0 == map->count) {
aaea56af MCC	75	struct videobuf_vmalloc_memory *mem;
	76
	77	dprintk(1, "munmap %p q=%p\n", map, q);
cca36e2e	78	videobuf_queue_lock(q);
aa9479ed MCC	79
	80	/* We need first to cancel streams, before unmapping */
	81	if (q->streaming)
	82	videobuf_queue_cancel(q);
	83
87b9ad07 MCC	84	for (i = 0; i < VIDEO_MAX_FRAME; i++) {
	85	if (NULL == q->bufs[i])
	86	continue;
87b9ad07	87
851c0c96	88	if (q->bufs[i]->map != map)
87b9ad07	89	continue;
123f8ef6	90
aaea56af MCC	91	mem = q->bufs[i]->priv;
	92	if (mem) {
	93	/* This callback is called only if kernel has
	94	allocated memory and this memory is mmapped.
	95	In this case, memory should be freed,
	96	in order to do memory unmap.
	97	*/
aa9479ed	98
aaea56af	99	MAGIC_CHECK(mem->magic, MAGIC_VMAL_MEM);
aa9479ed MCC	100
	101	/* vfree is not atomic - can't be
	102	called with IRQ's disabled
	103	*/
	104	dprintk(1, "%s: buf[%d] freeing (%p)\n",
bb6dbe74	105	__func__, i, mem->vaddr);
aa9479ed	106
bb6dbe74 LP	107	vfree(mem->vaddr);
bb6dbe74 LP	108	mem->vaddr = NULL;
aaea56af MCC	109	}
aaea56af MCC	110
851c0c96	111	q->bufs[i]->map = NULL;
87b9ad07	112	q->bufs[i]->baddr = 0;
87b9ad07	113	}
aa9479ed	114
87b9ad07	115	kfree(map);
aa9479ed	116
cca36e2e	117	videobuf_queue_unlock(q);
87b9ad07	118	}
aa9479ed	119
87b9ad07 MCC	120	return;
	121	}
	122
7a02264c	123	static const struct vm_operations_struct videobuf_vm_ops = {
87b9ad07 MCC	124	.open = videobuf_vm_open,
	125	.close = videobuf_vm_close,
	126	};
	127
	128	/* ---------------------------------------------------------------------
	129	* vmalloc handlers for the generic methods
	130	*/
	131
	132	/* Allocated area consists on 3 parts:
	133	struct video_buffer
	134	struct <driver>_buffer (cx88_buffer, saa7134_buf, ...)
0705135e	135	struct videobuf_dma_sg_memory
87b9ad07 MCC	136	*/
87b9ad07 MCC	137
33c38283	138	static struct videobuf_buffer *__videobuf_alloc_vb(size_t size)
87b9ad07	139	{
384b835a	140	struct videobuf_vmalloc_memory *mem;
87b9ad07 MCC	141	struct videobuf_buffer *vb;
87b9ad07 MCC	142
7a02264c	143	vb = kzalloc(size + sizeof(*mem), GFP_KERNEL);
bee527f9 PO	144	if (!vb)
bee527f9 PO	145	return vb;
87b9ad07	146
7a02264c PO	147	mem = vb->priv = ((char *)vb) + size;
7a02264c PO	148	mem->magic = MAGIC_VMAL_MEM;
87b9ad07	149
7a02264c PO	150	dprintk(1, "%s: allocated at %p(%ld+%ld) & %p(%ld)\n",
	151	__func__, vb, (long)sizeof(vb), (long)size - sizeof(vb),
	152	mem, (long)sizeof(*mem));
87b9ad07 MCC	153
	154	return vb;
	155	}
	156
7a02264c PO	157	static int __videobuf_iolock(struct videobuf_queue *q,
	158	struct videobuf_buffer *vb,
	159	struct v4l2_framebuffer *fbuf)
87b9ad07	160	{
968ced78	161	struct videobuf_vmalloc_memory *mem = vb->priv;
aa9479ed	162	int pages;
87b9ad07 MCC	163
	164	BUG_ON(!mem);
	165
968ced78	166	MAGIC_CHECK(mem->magic, MAGIC_VMAL_MEM);
87b9ad07	167
968ced78 MCC	168	switch (vb->memory) {
	169	case V4L2_MEMORY_MMAP:
	170	dprintk(1, "%s memory method MMAP\n", __func__);
87b9ad07	171
968ced78	172	/* All handling should be done by __videobuf_mmap_mapper() */
bb6dbe74	173	if (!mem->vaddr) {
968ced78 MCC	174	printk(KERN_ERR "memory is not alloced/mmapped.\n");
	175	return -EINVAL;
	176	}
	177	break;
	178	case V4L2_MEMORY_USERPTR:
aa9479ed	179	pages = PAGE_ALIGN(vb->size);
87b9ad07	180
968ced78 MCC	181	dprintk(1, "%s memory method USERPTR\n", __func__);
968ced78 MCC	182
968ced78 MCC	183	if (vb->baddr) {
	184	printk(KERN_ERR "USERPTR is currently not supported\n");
	185	return -EINVAL;
	186	}
87b9ad07	187
968ced78	188	/* The only USERPTR currently supported is the one needed for
7a02264c	189	* read() method.
968ced78 MCC	190	*/
968ced78 MCC	191
bb6dbe74 LP	192	mem->vaddr = vmalloc_user(pages);
bb6dbe74 LP	193	if (!mem->vaddr) {
968ced78 MCC	194	printk(KERN_ERR "vmalloc (%d pages) failed\n", pages);
968ced78 MCC	195	return -ENOMEM;
87b9ad07	196	}
968ced78	197	dprintk(1, "vmalloc is at addr %p (%d pages)\n",
bb6dbe74	198	mem->vaddr, pages);
968ced78 MCC	199
	200	#if 0
	201	int rc;
	202	/* Kernel userptr is used also by read() method. In this case,
	203	there's no need to remap, since data will be copied to user
	204	*/
	205	if (!vb->baddr)
	206	return 0;
	207
	208	/* FIXME: to properly support USERPTR, remap should occur.
de1e575d	209	The code below won't work, since mem->vma = NULL
968ced78 MCC	210	*/
	211	/* Try to remap memory */
	212	rc = remap_vmalloc_range(mem->vma, (void *)vb->baddr, 0);
	213	if (rc < 0) {
7a02264c	214	printk(KERN_ERR "mmap: remap failed with error %d", rc);
968ced78 MCC	215	return -ENOMEM;
	216	}
	217	#endif
	218
	219	break;
968ced78 MCC	220	case V4L2_MEMORY_OVERLAY:
	221	default:
	222	dprintk(1, "%s memory method OVERLAY/unknown\n", __func__);
	223
	224	/* Currently, doesn't support V4L2_MEMORY_OVERLAY */
	225	printk(KERN_ERR "Memory method currently unsupported.\n");
	226	return -EINVAL;
87b9ad07 MCC	227	}
	228
	229	return 0;
	230	}
	231
87b9ad07	232	static int __videobuf_mmap_mapper(struct videobuf_queue *q,
0b62b737 HV	233	struct videobuf_buffer *buf,
0b62b737 HV	234	struct vm_area_struct *vma)
87b9ad07	235	{
384b835a	236	struct videobuf_vmalloc_memory *mem;
87b9ad07	237	struct videobuf_mapping *map;
968ced78	238	int retval, pages;
87b9ad07	239
968ced78	240	dprintk(1, "%s\n", __func__);
87b9ad07 MCC	241
87b9ad07 MCC	242	/* create mapping + update buffer list */
968ced78	243	map = kzalloc(sizeof(struct videobuf_mapping), GFP_KERNEL);
87b9ad07 MCC	244	if (NULL == map)
	245	return -ENOMEM;
	246
0b62b737	247	buf->map = map;
87b9ad07 MCC	248	map->q = q;
87b9ad07 MCC	249
0b62b737	250	buf->baddr = vma->vm_start;
87b9ad07	251
0b62b737	252	mem = buf->priv;
968ced78 MCC	253	BUG_ON(!mem);
968ced78 MCC	254	MAGIC_CHECK(mem->magic, MAGIC_VMAL_MEM);
87b9ad07	255
968ced78	256	pages = PAGE_ALIGN(vma->vm_end - vma->vm_start);
bb6dbe74 LP	257	mem->vaddr = vmalloc_user(pages);
bb6dbe74 LP	258	if (!mem->vaddr) {
968ced78 MCC	259	printk(KERN_ERR "vmalloc (%d pages) failed\n", pages);
	260	goto error;
	261	}
bb6dbe74	262	dprintk(1, "vmalloc is at addr %p (%d pages)\n", mem->vaddr, pages);
851c0c96	263
87b9ad07	264	/* Try to remap memory */
bb6dbe74	265	retval = remap_vmalloc_range(vma, mem->vaddr, 0);
968ced78 MCC	266	if (retval < 0) {
968ced78 MCC	267	printk(KERN_ERR "mmap: remap failed with error %d. ", retval);
bb6dbe74	268	vfree(mem->vaddr);
968ced78	269	goto error;
87b9ad07 MCC	270	}
87b9ad07 MCC	271
968ced78	272	vma->vm_ops = &videobuf_vm_ops;
314e51b9	273	vma->vm_flags \|= VM_DONTEXPAND \| VM_DONTDUMP;
968ced78 MCC	274	vma->vm_private_data = map;
968ced78 MCC	275
7a02264c	276	dprintk(1, "mmap %p: q=%p %08lx-%08lx (%lx) pgoff %08lx buf %d\n",
968ced78	277	map, q, vma->vm_start, vma->vm_end,
0b62b737 HV	278	(long int)buf->bsize,
0b62b737 HV	279	vma->vm_pgoff, buf->i);
87b9ad07 MCC	280
	281	videobuf_vm_open(vma);
	282
968ced78 MCC	283	return 0;
	284
	285	error:
	286	mem = NULL;
	287	kfree(map);
	288	return -ENOMEM;
87b9ad07 MCC	289	}
87b9ad07 MCC	290
87b9ad07 MCC	291	static struct videobuf_qtype_ops qops = {
	292	.magic = MAGIC_QTYPE_OPS,
	293
33c38283	294	.alloc_vb = __videobuf_alloc_vb,
87b9ad07	295	.iolock = __videobuf_iolock,
87b9ad07	296	.mmap_mapper = __videobuf_mmap_mapper,
037c75eb	297	.vaddr = videobuf_to_vmalloc,
87b9ad07 MCC	298	};
87b9ad07 MCC	299
7a02264c	300	void videobuf_queue_vmalloc_init(struct videobuf_queue *q,
38a54f35	301	const struct videobuf_queue_ops *ops,
f8b0bca1	302	struct device *dev,
87b9ad07 MCC	303	spinlock_t *irqlock,
	304	enum v4l2_buf_type type,
	305	enum v4l2_field field,
	306	unsigned int msize,
08bff03e HV	307	void *priv,
08bff03e HV	308	struct mutex *ext_lock)
87b9ad07	309	{
d4cae5a5	310	videobuf_queue_core_init(q, ops, dev, irqlock, type, field, msize,
08bff03e	311	priv, &qops, ext_lock);
87b9ad07	312	}
87b9ad07 MCC	313	EXPORT_SYMBOL_GPL(videobuf_queue_vmalloc_init);
87b9ad07 MCC	314
7a02264c	315	void videobuf_to_vmalloc(struct videobuf_buffer buf)
87b9ad07	316	{
7a02264c PO	317	struct videobuf_vmalloc_memory *mem = buf->priv;
	318	BUG_ON(!mem);
	319	MAGIC_CHECK(mem->magic, MAGIC_VMAL_MEM);
87b9ad07	320
bb6dbe74	321	return mem->vaddr;
87b9ad07 MCC	322	}
	323	EXPORT_SYMBOL_GPL(videobuf_to_vmalloc);
	324
7a02264c	325	void videobuf_vmalloc_free(struct videobuf_buffer *buf)
87b9ad07	326	{
968ced78	327	struct videobuf_vmalloc_memory *mem = buf->priv;
87b9ad07	328
aaea56af MCC	329	/* mmapped memory can't be freed here, otherwise mmapped region
	330	would be released, while still needed. In this case, the memory
	331	release should happen inside videobuf_vm_close().
	332	So, it should free memory only if the memory were allocated for
	333	read() operation.
	334	*/
5993a663	335	if ((buf->memory != V4L2_MEMORY_USERPTR) \|\| buf->baddr)
aaea56af MCC	336	return;
aaea56af MCC	337
968ced78 MCC	338	if (!mem)
	339	return;
	340
	341	MAGIC_CHECK(mem->magic, MAGIC_VMAL_MEM);
87b9ad07	342
bb6dbe74 LP	343	vfree(mem->vaddr);
bb6dbe74 LP	344	mem->vaddr = NULL;
968ced78	345
87b9ad07 MCC	346	return;
	347	}
	348	EXPORT_SYMBOL_GPL(videobuf_vmalloc_free);
	349