[GitHub/mt8127/android_kernel_alcatel_ttab.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/mm.h>
#include <linux/pagemap.h>
#include <linux/dma-mapping.h>
#include <linux/sched.h>
#include <linux/slab.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(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(q->dev, "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_DC_MEM);

				/* vfree is not atomic - can't be
				   called with IRQ's disabled
				 */
				dev_dbg(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);

		videobuf_queue_unlock(q);
	}
}

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

/**
 * videobuf_dma_contig_user_put() - reset pointer to user space buffer
 * @mem: per-buffer private videobuf-dma-contig data
 *
 * This function resets the user space pointer
 */
static void videobuf_dma_contig_user_put(struct videobuf_dma_contig_memory *mem)
{
	mem->dma_handle = 0;
	mem->size = 0;
}

/**
 * videobuf_dma_contig_user_get() - setup user space memory pointer
 * @mem: per-buffer private videobuf-dma-contig data
 * @vb: video buffer to map
 *
 * This function validates and sets up a pointer to user space memory.
 * Only physically contiguous pfn-mapped memory is accepted.
 *
 * Returns 0 if successful.
 */
static int videobuf_dma_contig_user_get(struct videobuf_dma_contig_memory *mem,
					struct videobuf_buffer *vb)
{
	struct mm_struct *mm = current->mm;
	struct vm_area_struct *vma;
	unsigned long prev_pfn, this_pfn;
	unsigned long pages_done, user_address;
	unsigned int offset;
	int ret;

	offset = vb->baddr & ~PAGE_MASK;
	mem->size = PAGE_ALIGN(vb->size + offset);
	ret = -EINVAL;

	down_read(&mm->mmap_sem);

	vma = find_vma(mm, vb->baddr);
	if (!vma)
		goto out_up;

	if ((vb->baddr + mem->size) > vma->vm_end)
		goto out_up;

	pages_done = 0;
	prev_pfn = 0; /* kill warning */
	user_address = vb->baddr;

	while (pages_done < (mem->size >> PAGE_SHIFT)) {
		ret = follow_pfn(vma, user_address, &this_pfn);
		if (ret)
			break;

		if (pages_done == 0)
			mem->dma_handle = (this_pfn << PAGE_SHIFT) + offset;
		else if (this_pfn != (prev_pfn + 1))
			ret = -EFAULT;

		if (ret)
			break;

		prev_pfn = this_pfn;
		user_address += PAGE_SIZE;
		pages_done++;
	}

 out_up:
	up_read(&current->mm->mmap_sem);

	return ret;
}

static struct videobuf_buffer *__videobuf_alloc_vb(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_vaddr(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__);

		/* handle pointer from user space */
		if (vb->baddr)
			return videobuf_dma_contig_user_get(mem, vb);

		/* allocate memory for the read() method */
		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_mmap_mapper(struct videobuf_queue *q,
				  struct videobuf_buffer *buf,
				  struct vm_area_struct *vma)
{
	struct videobuf_dma_contig_memory *mem;
	struct videobuf_mapping *map;
	int retval;
	unsigned long size;

	dev_dbg(q->dev, "%s\n", __func__);

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

	mem->size = PAGE_ALIGN(buf->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)buf->bsize,
		vma->vm_pgoff, buf->i);

	videobuf_vm_open(vma);

	return 0;

error:
	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_vaddr,
};

void videobuf_queue_dma_contig_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_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)
		return;

	if (!mem)
		return;

	MAGIC_CHECK(mem->magic, MAGIC_DC_MEM);

	/* handle user space pointer case */
	if (buf->baddr) {
		videobuf_dma_contig_user_put(mem);
		return;
	}

	/* read() method */
	if (mem->vaddr) {
		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>
f19ad390	19	#include <linux/mm.h>
720b17e7	20	#include <linux/pagemap.h>
2cc45cf2	21	#include <linux/dma-mapping.h>
f39c1ab3	22	#include <linux/sched.h>
5a0e3ad6	23	#include <linux/slab.h>
2cc45cf2 MD	24	#include <media/videobuf-dma-contig.h>
	25
	26	struct videobuf_dma_contig_memory {
	27	u32 magic;
	28	void *vaddr;
	29	dma_addr_t dma_handle;
	30	unsigned long size;
	31	};
	32
	33	#define MAGIC_DC_MEM 0x0733ac61
c60f2b5c GL	34	#define MAGIC_CHECK(is, should) \
	35	if (unlikely((is) != (should))) { \
	36	pr_err("magic mismatch: %x expected %x\n", (is), (should)); \
	37	BUG(); \
2cc45cf2 MD	38	}
	39
	40	static void
	41	videobuf_vm_open(struct vm_area_struct *vma)
	42	{
	43	struct videobuf_mapping *map = vma->vm_private_data;
	44
	45	dev_dbg(map->q->dev, "vm_open %p [count=%u,vma=%08lx-%08lx]\n",
	46	map, map->count, vma->vm_start, vma->vm_end);
	47
	48	map->count++;
	49	}
	50
	51	static void videobuf_vm_close(struct vm_area_struct *vma)
	52	{
	53	struct videobuf_mapping *map = vma->vm_private_data;
	54	struct videobuf_queue *q = map->q;
	55	int i;
	56
f35f1bb8	57	dev_dbg(q->dev, "vm_close %p [count=%u,vma=%08lx-%08lx]\n",
2cc45cf2 MD	58	map, map->count, vma->vm_start, vma->vm_end);
	59
	60	map->count--;
	61	if (0 == map->count) {
	62	struct videobuf_dma_contig_memory *mem;
	63
f35f1bb8	64	dev_dbg(q->dev, "munmap %p q=%p\n", map, q);
97397687	65	videobuf_queue_lock(q);
2cc45cf2 MD	66
	67	/* We need first to cancel streams, before unmapping */
	68	if (q->streaming)
	69	videobuf_queue_cancel(q);
	70
	71	for (i = 0; i < VIDEO_MAX_FRAME; i++) {
	72	if (NULL == q->bufs[i])
	73	continue;
	74
	75	if (q->bufs[i]->map != map)
	76	continue;
	77
	78	mem = q->bufs[i]->priv;
	79	if (mem) {
	80	/* This callback is called only if kernel has
	81	allocated memory and this memory is mmapped.
	82	In this case, memory should be freed,
	83	in order to do memory unmap.
	84	*/
	85
	86	MAGIC_CHECK(mem->magic, MAGIC_DC_MEM);
	87
	88	/* vfree is not atomic - can't be
	89	called with IRQ's disabled
	90	*/
f35f1bb8	91	dev_dbg(q->dev, "buf[%d] freeing %p\n",
2cc45cf2 MD	92	i, mem->vaddr);
	93
	94	dma_free_coherent(q->dev, mem->size,
	95	mem->vaddr, mem->dma_handle);
	96	mem->vaddr = NULL;
	97	}
	98
	99	q->bufs[i]->map = NULL;
	100	q->bufs[i]->baddr = 0;
	101	}
	102
	103	kfree(map);
	104
97397687	105	videobuf_queue_unlock(q);
2cc45cf2 MD	106	}
	107	}
	108
f0f37e2f	109	static const struct vm_operations_struct videobuf_vm_ops = {
2cc45cf2 MD	110	.open = videobuf_vm_open,
	111	.close = videobuf_vm_close,
	112	};
	113
720b17e7 MD	114	/**
	115	* videobuf_dma_contig_user_put() - reset pointer to user space buffer
	116	* @mem: per-buffer private videobuf-dma-contig data
	117	*
	118	* This function resets the user space pointer
	119	*/
	120	static void videobuf_dma_contig_user_put(struct videobuf_dma_contig_memory *mem)
	121	{
720b17e7 MD	122	mem->dma_handle = 0;
	123	mem->size = 0;
	124	}
	125
	126	/**
	127	* videobuf_dma_contig_user_get() - setup user space memory pointer
	128	* @mem: per-buffer private videobuf-dma-contig data
	129	* @vb: video buffer to map
	130	*
	131	* This function validates and sets up a pointer to user space memory.
	132	* Only physically contiguous pfn-mapped memory is accepted.
	133	*
	134	* Returns 0 if successful.
	135	*/
	136	static int videobuf_dma_contig_user_get(struct videobuf_dma_contig_memory *mem,
	137	struct videobuf_buffer *vb)
	138	{
	139	struct mm_struct *mm = current->mm;
	140	struct vm_area_struct *vma;
	141	unsigned long prev_pfn, this_pfn;
	142	unsigned long pages_done, user_address;
31bedfa5	143	unsigned int offset;
720b17e7 MD	144	int ret;
720b17e7 MD	145
31bedfa5 MK	146	offset = vb->baddr & ~PAGE_MASK;
31bedfa5 MK	147	mem->size = PAGE_ALIGN(vb->size + offset);
720b17e7 MD	148	ret = -EINVAL;
	149
	150	down_read(&mm->mmap_sem);
	151
	152	vma = find_vma(mm, vb->baddr);
	153	if (!vma)
	154	goto out_up;
	155
	156	if ((vb->baddr + mem->size) > vma->vm_end)
	157	goto out_up;
	158
	159	pages_done = 0;
	160	prev_pfn = 0; /* kill warning */
	161	user_address = vb->baddr;
	162
	163	while (pages_done < (mem->size >> PAGE_SHIFT)) {
	164	ret = follow_pfn(vma, user_address, &this_pfn);
	165	if (ret)
	166	break;
	167
	168	if (pages_done == 0)
31bedfa5	169	mem->dma_handle = (this_pfn << PAGE_SHIFT) + offset;
720b17e7 MD	170	else if (this_pfn != (prev_pfn + 1))
	171	ret = -EFAULT;
	172
	173	if (ret)
	174	break;
	175
	176	prev_pfn = this_pfn;
	177	user_address += PAGE_SIZE;
	178	pages_done++;
	179	}
	180
720b17e7 MD	181	out_up:
	182	up_read(&current->mm->mmap_sem);
	183
	184	return ret;
	185	}
	186
33c38283	187	static struct videobuf_buffer *__videobuf_alloc_vb(size_t size)
2cc45cf2 MD	188	{
	189	struct videobuf_dma_contig_memory *mem;
	190	struct videobuf_buffer *vb;
	191
	192	vb = kzalloc(size + sizeof(*mem), GFP_KERNEL);
	193	if (vb) {
	194	mem = vb->priv = ((char *)vb) + size;
	195	mem->magic = MAGIC_DC_MEM;
	196	}
	197
	198	return vb;
	199	}
	200
037c75eb	201	static void __videobuf_to_vaddr(struct videobuf_buffer buf)
2cc45cf2 MD	202	{
	203	struct videobuf_dma_contig_memory *mem = buf->priv;
	204
	205	BUG_ON(!mem);
	206	MAGIC_CHECK(mem->magic, MAGIC_DC_MEM);
	207
	208	return mem->vaddr;
	209	}
	210
	211	static int __videobuf_iolock(struct videobuf_queue *q,
	212	struct videobuf_buffer *vb,
	213	struct v4l2_framebuffer *fbuf)
	214	{
	215	struct videobuf_dma_contig_memory *mem = vb->priv;
	216
	217	BUG_ON(!mem);
	218	MAGIC_CHECK(mem->magic, MAGIC_DC_MEM);
	219
	220	switch (vb->memory) {
	221	case V4L2_MEMORY_MMAP:
	222	dev_dbg(q->dev, "%s memory method MMAP\n", __func__);
	223
	224	/* All handling should be done by __videobuf_mmap_mapper() */
	225	if (!mem->vaddr) {
	226	dev_err(q->dev, "memory is not alloced/mmapped.\n");
	227	return -EINVAL;
	228	}
	229	break;
	230	case V4L2_MEMORY_USERPTR:
	231	dev_dbg(q->dev, "%s memory method USERPTR\n", __func__);
	232
720b17e7	233	/* handle pointer from user space */
2cc45cf2	234	if (vb->baddr)
720b17e7	235	return videobuf_dma_contig_user_get(mem, vb);
2cc45cf2	236
720b17e7	237	/* allocate memory for the read() method */
2cc45cf2 MD	238	mem->size = PAGE_ALIGN(vb->size);
	239	mem->vaddr = dma_alloc_coherent(q->dev, mem->size,
	240	&mem->dma_handle, GFP_KERNEL);
	241	if (!mem->vaddr) {
	242	dev_err(q->dev, "dma_alloc_coherent %ld failed\n",
	243	mem->size);
	244	return -ENOMEM;
	245	}
	246
	247	dev_dbg(q->dev, "dma_alloc_coherent data is at %p (%ld)\n",
	248	mem->vaddr, mem->size);
	249	break;
	250	case V4L2_MEMORY_OVERLAY:
	251	default:
	252	dev_dbg(q->dev, "%s memory method OVERLAY/unknown\n",
	253	__func__);
	254	return -EINVAL;
	255	}
	256
	257	return 0;
	258	}
	259
2cc45cf2	260	static int __videobuf_mmap_mapper(struct videobuf_queue *q,
0b62b737	261	struct videobuf_buffer *buf,
2cc45cf2 MD	262	struct vm_area_struct *vma)
	263	{
	264	struct videobuf_dma_contig_memory *mem;
	265	struct videobuf_mapping *map;
2cc45cf2	266	int retval;
0b62b737	267	unsigned long size;
2cc45cf2 MD	268
2cc45cf2 MD	269	dev_dbg(q->dev, "%s\n", __func__);
2cc45cf2 MD	270
	271	/* create mapping + update buffer list */
	272	map = kzalloc(sizeof(struct videobuf_mapping), GFP_KERNEL);
	273	if (!map)
	274	return -ENOMEM;
	275
0b62b737	276	buf->map = map;
2cc45cf2 MD	277	map->q = q;
2cc45cf2 MD	278
0b62b737	279	buf->baddr = vma->vm_start;
2cc45cf2	280
0b62b737	281	mem = buf->priv;
2cc45cf2 MD	282	BUG_ON(!mem);
	283	MAGIC_CHECK(mem->magic, MAGIC_DC_MEM);
	284
0b62b737	285	mem->size = PAGE_ALIGN(buf->bsize);
2cc45cf2 MD	286	mem->vaddr = dma_alloc_coherent(q->dev, mem->size,
	287	&mem->dma_handle, GFP_KERNEL);
	288	if (!mem->vaddr) {
	289	dev_err(q->dev, "dma_alloc_coherent size %ld failed\n",
	290	mem->size);
	291	goto error;
	292	}
	293	dev_dbg(q->dev, "dma_alloc_coherent data is at addr %p (size %ld)\n",
	294	mem->vaddr, mem->size);
	295
	296	/* Try to remap memory */
	297
	298	size = vma->vm_end - vma->vm_start;
	299	size = (size < mem->size) ? size : mem->size;
	300
	301	vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
	302	retval = remap_pfn_range(vma, vma->vm_start,
71460af5	303	mem->dma_handle >> PAGE_SHIFT,
2cc45cf2 MD	304	size, vma->vm_page_prot);
	305	if (retval) {
	306	dev_err(q->dev, "mmap: remap failed with error %d. ", retval);
	307	dma_free_coherent(q->dev, mem->size,
	308	mem->vaddr, mem->dma_handle);
	309	goto error;
	310	}
	311
	312	vma->vm_ops = &videobuf_vm_ops;
	313	vma->vm_flags \|= VM_DONTEXPAND;
	314	vma->vm_private_data = map;
	315
	316	dev_dbg(q->dev, "mmap %p: q=%p %08lx-%08lx (%lx) pgoff %08lx buf %d\n",
	317	map, q, vma->vm_start, vma->vm_end,
0b62b737 HV	318	(long int)buf->bsize,
0b62b737 HV	319	vma->vm_pgoff, buf->i);
2cc45cf2 MD	320
	321	videobuf_vm_open(vma);
	322
	323	return 0;
	324
	325	error:
	326	kfree(map);
	327	return -ENOMEM;
	328	}
	329
2cc45cf2 MD	330	static struct videobuf_qtype_ops qops = {
	331	.magic = MAGIC_QTYPE_OPS,
	332
33c38283	333	.alloc_vb = __videobuf_alloc_vb,
2cc45cf2	334	.iolock = __videobuf_iolock,
2cc45cf2	335	.mmap_mapper = __videobuf_mmap_mapper,
037c75eb	336	.vaddr = __videobuf_to_vaddr,
2cc45cf2 MD	337	};
	338
	339	void videobuf_queue_dma_contig_init(struct videobuf_queue *q,
38a54f35	340	const struct videobuf_queue_ops *ops,
2cc45cf2 MD	341	struct device *dev,
	342	spinlock_t *irqlock,
	343	enum v4l2_buf_type type,
	344	enum v4l2_field field,
	345	unsigned int msize,
08bff03e HV	346	void *priv,
08bff03e HV	347	struct mutex *ext_lock)
2cc45cf2 MD	348	{
2cc45cf2 MD	349	videobuf_queue_core_init(q, ops, dev, irqlock, type, field, msize,
08bff03e	350	priv, &qops, ext_lock);
2cc45cf2 MD	351	}
	352	EXPORT_SYMBOL_GPL(videobuf_queue_dma_contig_init);
	353
	354	dma_addr_t videobuf_to_dma_contig(struct videobuf_buffer *buf)
	355	{
	356	struct videobuf_dma_contig_memory *mem = buf->priv;
	357
	358	BUG_ON(!mem);
	359	MAGIC_CHECK(mem->magic, MAGIC_DC_MEM);
	360
	361	return mem->dma_handle;
	362	}
	363	EXPORT_SYMBOL_GPL(videobuf_to_dma_contig);
	364
	365	void videobuf_dma_contig_free(struct videobuf_queue *q,
	366	struct videobuf_buffer *buf)
	367	{
	368	struct videobuf_dma_contig_memory *mem = buf->priv;
	369
	370	/* mmapped memory can't be freed here, otherwise mmapped region
	371	would be released, while still needed. In this case, the memory
	372	release should happen inside videobuf_vm_close().
	373	So, it should free memory only if the memory were allocated for
	374	read() operation.
	375	*/
720b17e7	376	if (buf->memory != V4L2_MEMORY_USERPTR)
2cc45cf2 MD	377	return;
	378
	379	if (!mem)
	380	return;
	381
	382	MAGIC_CHECK(mem->magic, MAGIC_DC_MEM);
	383
720b17e7 MD	384	/* handle user space pointer case */
	385	if (buf->baddr) {
	386	videobuf_dma_contig_user_put(mem);
	387	return;
	388	}
	389
	390	/* read() method */
b2b476f5 PO	391	if (mem->vaddr) {
	392	dma_free_coherent(q->dev, mem->size, mem->vaddr, mem->dma_handle);
	393	mem->vaddr = NULL;
	394	}
2cc45cf2 MD	395	}
	396	EXPORT_SYMBOL_GPL(videobuf_dma_contig_free);
	397
	398	MODULE_DESCRIPTION("helper module to manage video4linux dma contig buffers");
	399	MODULE_AUTHOR("Magnus Damm");
	400	MODULE_LICENSE("GPL");