[net-next-2.6.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 void *__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_free(struct videobuf_queue *q)
{
	unsigned int i;

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

	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 int __videobuf_copy_to_user(struct videobuf_queue *q,
				   char __user *data, size_t count,
				   int nonblocking)
{
	struct videobuf_vmalloc_memory *mem = q->read_buf->priv;
	BUG_ON(!mem);
	MAGIC_CHECK(mem->magic, MAGIC_VMAL_MEM);

	BUG_ON(!mem->vmalloc);

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

	if (copy_to_user(data, mem->vmalloc+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_vmalloc_memory *mem = q->read_buf->priv;
	BUG_ON(!mem);
	MAGIC_CHECK(mem->magic, MAGIC_VMAL_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->vmalloc;
		fc += (q->read_buf->size >> 2) - 1;
		*fc = q->read_buf->field_count >> 1;
		dprintk(1, "vbihack: %d\n", *fc);
	}

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

	if ((count == -EFAULT) && (0 == pos))
		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_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	*/
	137
	138	static void *__videobuf_alloc(size_t size)
	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
	238	static int __videobuf_mmap_free(struct videobuf_queue *q)
	239	{
	240	unsigned int i;
	241
968ced78	242	dprintk(1, "%s\n", __func__);
87b9ad07 MCC	243	for (i = 0; i < VIDEO_MAX_FRAME; i++) {
87b9ad07 MCC	244	if (q->bufs[i]) {
851c0c96	245	if (q->bufs[i]->map)
87b9ad07 MCC	246	return -EBUSY;
	247	}
	248	}
	249
	250	return 0;
	251	}
	252
	253	static int __videobuf_mmap_mapper(struct videobuf_queue *q,
	254	struct vm_area_struct *vma)
	255	{
384b835a	256	struct videobuf_vmalloc_memory *mem;
87b9ad07 MCC	257	struct videobuf_mapping *map;
87b9ad07 MCC	258	unsigned int first;
968ced78	259	int retval, pages;
87b9ad07 MCC	260	unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
87b9ad07 MCC	261
968ced78 MCC	262	dprintk(1, "%s\n", __func__);
968ced78 MCC	263	if (!(vma->vm_flags & VM_WRITE) \|\| !(vma->vm_flags & VM_SHARED))
87b9ad07 MCC	264	return -EINVAL;
	265
	266	/* look for first buffer to map */
	267	for (first = 0; first < VIDEO_MAX_FRAME; first++) {
	268	if (NULL == q->bufs[first])
	269	continue;
	270
	271	if (V4L2_MEMORY_MMAP != q->bufs[first]->memory)
	272	continue;
	273	if (q->bufs[first]->boff == offset)
	274	break;
	275	}
	276	if (VIDEO_MAX_FRAME == first) {
7a02264c	277	dprintk(1, "mmap app bug: offset invalid [offset=0x%lx]\n",
87b9ad07 MCC	278	(vma->vm_pgoff << PAGE_SHIFT));
	279	return -EINVAL;
	280	}
87b9ad07 MCC	281
87b9ad07 MCC	282	/* create mapping + update buffer list */
968ced78	283	map = kzalloc(sizeof(struct videobuf_mapping), GFP_KERNEL);
87b9ad07 MCC	284	if (NULL == map)
	285	return -ENOMEM;
	286
968ced78	287	q->bufs[first]->map = map;
87b9ad07 MCC	288	map->start = vma->vm_start;
	289	map->end = vma->vm_end;
	290	map->q = q;
	291
	292	q->bufs[first]->baddr = vma->vm_start;
	293
968ced78 MCC	294	mem = q->bufs[first]->priv;
	295	BUG_ON(!mem);
	296	MAGIC_CHECK(mem->magic, MAGIC_VMAL_MEM);
87b9ad07	297
968ced78 MCC	298	pages = PAGE_ALIGN(vma->vm_end - vma->vm_start);
	299	mem->vmalloc = vmalloc_user(pages);
	300	if (!mem->vmalloc) {
	301	printk(KERN_ERR "vmalloc (%d pages) failed\n", pages);
	302	goto error;
	303	}
7a02264c	304	dprintk(1, "vmalloc is at addr %p (%d pages)\n", mem->vmalloc, pages);
851c0c96	305
87b9ad07	306	/* Try to remap memory */
968ced78 MCC	307	retval = remap_vmalloc_range(vma, mem->vmalloc, 0);
	308	if (retval < 0) {
	309	printk(KERN_ERR "mmap: remap failed with error %d. ", retval);
	310	vfree(mem->vmalloc);
	311	goto error;
87b9ad07 MCC	312	}
87b9ad07 MCC	313
968ced78 MCC	314	vma->vm_ops = &videobuf_vm_ops;
	315	vma->vm_flags \|= VM_DONTEXPAND \| VM_RESERVED;
	316	vma->vm_private_data = map;
	317
7a02264c	318	dprintk(1, "mmap %p: q=%p %08lx-%08lx (%lx) pgoff %08lx buf %d\n",
968ced78	319	map, q, vma->vm_start, vma->vm_end,
87b9ad07	320	(long int) q->bufs[first]->bsize,
968ced78	321	vma->vm_pgoff, first);
87b9ad07 MCC	322
	323	videobuf_vm_open(vma);
	324
968ced78 MCC	325	return 0;
	326
	327	error:
	328	mem = NULL;
	329	kfree(map);
	330	return -ENOMEM;
87b9ad07 MCC	331	}
87b9ad07 MCC	332
7a02264c PO	333	static int __videobuf_copy_to_user(struct videobuf_queue *q,
	334	char __user *data, size_t count,
	335	int nonblocking)
87b9ad07	336	{
7a02264c PO	337	struct videobuf_vmalloc_memory *mem = q->read_buf->priv;
	338	BUG_ON(!mem);
	339	MAGIC_CHECK(mem->magic, MAGIC_VMAL_MEM);
87b9ad07	340
7a02264c	341	BUG_ON(!mem->vmalloc);
87b9ad07 MCC	342
	343	/* copy to userspace */
	344	if (count > q->read_buf->size - q->read_off)
	345	count = q->read_buf->size - q->read_off;
	346
	347	if (copy_to_user(data, mem->vmalloc+q->read_off, count))
	348	return -EFAULT;
	349
	350	return count;
	351	}
	352
7a02264c PO	353	static int __videobuf_copy_stream(struct videobuf_queue *q,
	354	char __user *data, size_t count, size_t pos,
	355	int vbihack, int nonblocking)
87b9ad07	356	{
7a02264c PO	357	unsigned int *fc;
	358	struct videobuf_vmalloc_memory *mem = q->read_buf->priv;
	359	BUG_ON(!mem);
	360	MAGIC_CHECK(mem->magic, MAGIC_VMAL_MEM);
87b9ad07 MCC	361
	362	if (vbihack) {
	363	/* dirty, undocumented hack -- pass the frame counter
	364	* within the last four bytes of each vbi data block.
	365	* We need that one to maintain backward compatibility
	366	* to all vbi decoding software out there ... */
7a02264c PO	367	fc = (unsigned int *)mem->vmalloc;
7a02264c PO	368	fc += (q->read_buf->size >> 2) - 1;
87b9ad07	369	*fc = q->read_buf->field_count >> 1;
7a02264c	370	dprintk(1, "vbihack: %d\n", *fc);
87b9ad07 MCC	371	}
	372
	373	/* copy stuff using the common method */
7a02264c	374	count = __videobuf_copy_to_user(q, data, count, nonblocking);
87b9ad07	375
7a02264c	376	if ((count == -EFAULT) && (0 == pos))
87b9ad07 MCC	377	return -EFAULT;
	378
	379	return count;
	380	}
	381
	382	static struct videobuf_qtype_ops qops = {
	383	.magic = MAGIC_QTYPE_OPS,
	384
	385	.alloc = __videobuf_alloc,
	386	.iolock = __videobuf_iolock,
	387	.sync = __videobuf_sync,
	388	.mmap_free = __videobuf_mmap_free,
	389	.mmap_mapper = __videobuf_mmap_mapper,
13bcd5d0	390	.video_copy_to_user = __videobuf_copy_to_user,
87b9ad07	391	.copy_stream = __videobuf_copy_stream,
59d34489	392	.vmalloc = videobuf_to_vmalloc,
87b9ad07 MCC	393	};
87b9ad07 MCC	394
7a02264c	395	void videobuf_queue_vmalloc_init(struct videobuf_queue *q,
38a54f35	396	const struct videobuf_queue_ops *ops,
f8b0bca1	397	struct device *dev,
87b9ad07 MCC	398	spinlock_t *irqlock,
	399	enum v4l2_buf_type type,
	400	enum v4l2_field field,
	401	unsigned int msize,
	402	void *priv)
	403	{
d4cae5a5 MCC	404	videobuf_queue_core_init(q, ops, dev, irqlock, type, field, msize,
d4cae5a5 MCC	405	priv, &qops);
87b9ad07	406	}
87b9ad07 MCC	407	EXPORT_SYMBOL_GPL(videobuf_queue_vmalloc_init);
87b9ad07 MCC	408
7a02264c	409	void videobuf_to_vmalloc(struct videobuf_buffer buf)
87b9ad07	410	{
7a02264c PO	411	struct videobuf_vmalloc_memory *mem = buf->priv;
	412	BUG_ON(!mem);
	413	MAGIC_CHECK(mem->magic, MAGIC_VMAL_MEM);
87b9ad07 MCC	414
	415	return mem->vmalloc;
	416	}
	417	EXPORT_SYMBOL_GPL(videobuf_to_vmalloc);
	418
7a02264c	419	void videobuf_vmalloc_free(struct videobuf_buffer *buf)
87b9ad07	420	{
968ced78	421	struct videobuf_vmalloc_memory *mem = buf->priv;
87b9ad07	422
aaea56af MCC	423	/* mmapped memory can't be freed here, otherwise mmapped region
	424	would be released, while still needed. In this case, the memory
	425	release should happen inside videobuf_vm_close().
	426	So, it should free memory only if the memory were allocated for
	427	read() operation.
	428	*/
5993a663	429	if ((buf->memory != V4L2_MEMORY_USERPTR) \|\| buf->baddr)
aaea56af MCC	430	return;
aaea56af MCC	431
968ced78 MCC	432	if (!mem)
	433	return;
	434
	435	MAGIC_CHECK(mem->magic, MAGIC_VMAL_MEM);
87b9ad07 MCC	436
87b9ad07 MCC	437	vfree(mem->vmalloc);
968ced78 MCC	438	mem->vmalloc = NULL;
968ced78 MCC	439
87b9ad07 MCC	440	return;
	441	}
	442	EXPORT_SYMBOL_GPL(videobuf_vmalloc_free);
	443