[linux-2.6-block.git] / drivers / media / v4l2-core / 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 int __videobuf_dc_alloc(struct device *dev,
			       struct videobuf_dma_contig_memory *mem,
			       unsigned long size, gfp_t flags)
{
	mem->size = size;
	mem->vaddr = dma_alloc_coherent(dev, mem->size,
					&mem->dma_handle, flags);

	if (!mem->vaddr) {
		dev_err(dev, "memory alloc size %ld failed\n", mem->size);
		return -ENOMEM;
	}

	dev_dbg(dev, "dma mapped data is at %p (%ld)\n", mem->vaddr, mem->size);

	return 0;
}

static void __videobuf_dc_free(struct device *dev,
			       struct videobuf_dma_contig_memory *mem)
{
	dma_free_coherent(dev, mem->size, mem->vaddr, mem->dma_handle);

	mem->vaddr = NULL;
}

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);

				__videobuf_dc_free(q->dev, mem);
				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(size_t size)
{
	struct videobuf_dma_contig_memory *mem;
	struct videobuf_buffer *vb;

	vb = kzalloc(size + sizeof(*mem), GFP_KERNEL);
	if (vb) {
		vb->priv = ((char *)vb) + size;
		mem = vb->priv;
		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 */
		if (__videobuf_dc_alloc(q->dev, mem, PAGE_ALIGN(vb->size),
					GFP_KERNEL))
			return -ENOMEM;
		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);

	if (__videobuf_dc_alloc(q->dev, mem, PAGE_ALIGN(buf->bsize),
				GFP_KERNEL | __GFP_COMP))
		goto error;

	/* Try to remap memory */
	size = vma->vm_end - vma->vm_start;
	vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);

	/* the "vm_pgoff" is just used in v4l2 to find the
	 * corresponding buffer data structure which is allocated
	 * earlier and it does not mean the offset from the physical
	 * buffer start address as usual. So set it to 0 to pass
	 * the sanity check in vm_iomap_memory().
	 */
	vma->vm_pgoff = 0;

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