[deliverable/linux.git] / drivers / media / video / 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);
		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_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->vmalloc);

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

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

		kfree(map);

		mutex_unlock(&q->vb_lock);
	}

	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(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->vmalloc) {
			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->vmalloc = vmalloc_user(pages);
		if (!mem->vmalloc) {
			printk(KERN_ERR "vmalloc (%d pages) failed\n", pages);
			return -ENOMEM;
		}
		dprintk(1, "vmalloc is at addr %p (%d pages)\n",
			mem->vmalloc, 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_sync(struct videobuf_queue *q,
			   struct videobuf_buffer *buf)
{
	return 0;
}

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

	dprintk(1, "%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 (NULL == 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) {
		dprintk(1, "mmap app bug: offset invalid [offset=0x%lx]\n",
			(vma->vm_pgoff << PAGE_SHIFT));
		return -EINVAL;
	}

	/* create mapping + update buffer list */
	map = kzalloc(sizeof(struct videobuf_mapping), GFP_KERNEL);
	if (NULL == 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_VMAL_MEM);

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

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

	vma->vm_ops          = &videobuf_vm_ops;
	vma->vm_flags       |= VM_DONTEXPAND | VM_RESERVED;
	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) q->bufs[first]->bsize,
		vma->vm_pgoff, first);

	videobuf_vm_open(vma);

	return 0;

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

static struct videobuf_qtype_ops qops = {
	.magic        = MAGIC_QTYPE_OPS,

	.alloc        = __videobuf_alloc,
	.iolock       = __videobuf_iolock,
	.sync         = __videobuf_sync,
	.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)
{
	videobuf_queue_core_init(q, ops, dev, irqlock, type, field, msize,
				 priv, &qops);
}
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->vmalloc;
}
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->vmalloc);
	mem->vmalloc = 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 MCC	72
	73	map->count--;
	74	if (0 == map->count) {
aaea56af MCC	75	struct videobuf_vmalloc_memory *mem;
	76
	77	dprintk(1, "munmap %p q=%p\n", map, q);
64f9477f	78	mutex_lock(&q->vb_lock);
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",
	105	__func__, i, mem->vmalloc);
	106
aaea56af MCC	107	vfree(mem->vmalloc);
	108	mem->vmalloc = NULL;
	109	}
	110
851c0c96	111	q->bufs[i]->map = NULL;
87b9ad07	112	q->bufs[i]->baddr = 0;
87b9ad07	113	}
aa9479ed	114
87b9ad07	115	kfree(map);
aa9479ed MCC	116
aa9479ed MCC	117	mutex_unlock(&q->vb_lock);
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
a4cf4cac	138	static struct videobuf_buffer *__videobuf_alloc(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 MCC	172	/* All handling should be done by __videobuf_mmap_mapper() */
	173	if (!mem->vmalloc) {
	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	*/
	191
	192	mem->vmalloc = vmalloc_user(pages);
	193	if (!mem->vmalloc) {
	194	printk(KERN_ERR "vmalloc (%d pages) failed\n", pages);
	195	return -ENOMEM;
87b9ad07	196	}
968ced78 MCC	197	dprintk(1, "vmalloc is at addr %p (%d pages)\n",
	198	mem->vmalloc, pages);
	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
	232	static int __videobuf_sync(struct videobuf_queue *q,
	233	struct videobuf_buffer *buf)
	234	{
	235	return 0;
	236	}
	237
87b9ad07 MCC	238	static int __videobuf_mmap_mapper(struct videobuf_queue *q,
	239	struct vm_area_struct *vma)
	240	{
384b835a	241	struct videobuf_vmalloc_memory *mem;
87b9ad07 MCC	242	struct videobuf_mapping *map;
87b9ad07 MCC	243	unsigned int first;
968ced78	244	int retval, pages;
87b9ad07 MCC	245	unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
87b9ad07 MCC	246
968ced78 MCC	247	dprintk(1, "%s\n", __func__);
968ced78 MCC	248	if (!(vma->vm_flags & VM_WRITE) \|\| !(vma->vm_flags & VM_SHARED))
87b9ad07 MCC	249	return -EINVAL;
	250
	251	/* look for first buffer to map */
	252	for (first = 0; first < VIDEO_MAX_FRAME; first++) {
	253	if (NULL == q->bufs[first])
	254	continue;
	255
	256	if (V4L2_MEMORY_MMAP != q->bufs[first]->memory)
	257	continue;
	258	if (q->bufs[first]->boff == offset)
	259	break;
	260	}
	261	if (VIDEO_MAX_FRAME == first) {
7a02264c	262	dprintk(1, "mmap app bug: offset invalid [offset=0x%lx]\n",
87b9ad07 MCC	263	(vma->vm_pgoff << PAGE_SHIFT));
	264	return -EINVAL;
	265	}
87b9ad07 MCC	266
87b9ad07 MCC	267	/* create mapping + update buffer list */
968ced78	268	map = kzalloc(sizeof(struct videobuf_mapping), GFP_KERNEL);
87b9ad07 MCC	269	if (NULL == map)
	270	return -ENOMEM;
	271
968ced78	272	q->bufs[first]->map = map;
87b9ad07 MCC	273	map->start = vma->vm_start;
	274	map->end = vma->vm_end;
	275	map->q = q;
	276
	277	q->bufs[first]->baddr = vma->vm_start;
	278
968ced78 MCC	279	mem = q->bufs[first]->priv;
	280	BUG_ON(!mem);
	281	MAGIC_CHECK(mem->magic, MAGIC_VMAL_MEM);
87b9ad07	282
968ced78 MCC	283	pages = PAGE_ALIGN(vma->vm_end - vma->vm_start);
	284	mem->vmalloc = vmalloc_user(pages);
	285	if (!mem->vmalloc) {
	286	printk(KERN_ERR "vmalloc (%d pages) failed\n", pages);
	287	goto error;
	288	}
7a02264c	289	dprintk(1, "vmalloc is at addr %p (%d pages)\n", mem->vmalloc, pages);
851c0c96	290
87b9ad07	291	/* Try to remap memory */
968ced78 MCC	292	retval = remap_vmalloc_range(vma, mem->vmalloc, 0);
	293	if (retval < 0) {
	294	printk(KERN_ERR "mmap: remap failed with error %d. ", retval);
	295	vfree(mem->vmalloc);
	296	goto error;
87b9ad07 MCC	297	}
87b9ad07 MCC	298
968ced78 MCC	299	vma->vm_ops = &videobuf_vm_ops;
	300	vma->vm_flags \|= VM_DONTEXPAND \| VM_RESERVED;
	301	vma->vm_private_data = map;
	302
7a02264c	303	dprintk(1, "mmap %p: q=%p %08lx-%08lx (%lx) pgoff %08lx buf %d\n",
968ced78	304	map, q, vma->vm_start, vma->vm_end,
87b9ad07	305	(long int) q->bufs[first]->bsize,
968ced78	306	vma->vm_pgoff, first);
87b9ad07 MCC	307
	308	videobuf_vm_open(vma);
	309
968ced78 MCC	310	return 0;
	311
	312	error:
	313	mem = NULL;
	314	kfree(map);
	315	return -ENOMEM;
87b9ad07 MCC	316	}
87b9ad07 MCC	317
87b9ad07 MCC	318	static struct videobuf_qtype_ops qops = {
	319	.magic = MAGIC_QTYPE_OPS,
	320
	321	.alloc = __videobuf_alloc,
	322	.iolock = __videobuf_iolock,
	323	.sync = __videobuf_sync,
87b9ad07	324	.mmap_mapper = __videobuf_mmap_mapper,
037c75eb	325	.vaddr = videobuf_to_vmalloc,
87b9ad07 MCC	326	};
87b9ad07 MCC	327
7a02264c	328	void videobuf_queue_vmalloc_init(struct videobuf_queue *q,
38a54f35	329	const struct videobuf_queue_ops *ops,
f8b0bca1	330	struct device *dev,
87b9ad07 MCC	331	spinlock_t *irqlock,
	332	enum v4l2_buf_type type,
	333	enum v4l2_field field,
	334	unsigned int msize,
	335	void *priv)
	336	{
d4cae5a5 MCC	337	videobuf_queue_core_init(q, ops, dev, irqlock, type, field, msize,
d4cae5a5 MCC	338	priv, &qops);
87b9ad07	339	}
87b9ad07 MCC	340	EXPORT_SYMBOL_GPL(videobuf_queue_vmalloc_init);
87b9ad07 MCC	341
7a02264c	342	void videobuf_to_vmalloc(struct videobuf_buffer buf)
87b9ad07	343	{
7a02264c PO	344	struct videobuf_vmalloc_memory *mem = buf->priv;
	345	BUG_ON(!mem);
	346	MAGIC_CHECK(mem->magic, MAGIC_VMAL_MEM);
87b9ad07 MCC	347
	348	return mem->vmalloc;
	349	}
	350	EXPORT_SYMBOL_GPL(videobuf_to_vmalloc);
	351
7a02264c	352	void videobuf_vmalloc_free(struct videobuf_buffer *buf)
87b9ad07	353	{
968ced78	354	struct videobuf_vmalloc_memory *mem = buf->priv;
87b9ad07	355
aaea56af MCC	356	/* mmapped memory can't be freed here, otherwise mmapped region
	357	would be released, while still needed. In this case, the memory
	358	release should happen inside videobuf_vm_close().
	359	So, it should free memory only if the memory were allocated for
	360	read() operation.
	361	*/
5993a663	362	if ((buf->memory != V4L2_MEMORY_USERPTR) \|\| buf->baddr)
aaea56af MCC	363	return;
aaea56af MCC	364
968ced78 MCC	365	if (!mem)
	366	return;
	367
	368	MAGIC_CHECK(mem->magic, MAGIC_VMAL_MEM);
87b9ad07 MCC	369
87b9ad07 MCC	370	vfree(mem->vmalloc);
968ced78 MCC	371	mem->vmalloc = NULL;
968ced78 MCC	372
87b9ad07 MCC	373	return;
	374	}
	375	EXPORT_SYMBOL_GPL(videobuf_vmalloc_free);
	376