[deliverable/linux.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;
	int is_userptr;
};

#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(map->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(map->q->dev, "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_DC_MEM);

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

		mutex_unlock(&q->vb_lock);
	}
}

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->is_userptr = 0;
	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);
	mem->is_userptr = 0;
	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++;
	}

	if (!ret)
		mem->is_userptr = 1;

 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) {
		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 vm_area_struct *vma)
{
	struct videobuf_dma_contig_memory *mem;
	struct videobuf_mapping *map;
	unsigned int first;
	int retval;
	unsigned long size, offset = vma->vm_pgoff << PAGE_SHIFT;

	dev_dbg(q->dev, "%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 (!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) {
		dev_dbg(q->dev, "invalid user space offset [offset=0x%lx]\n",
			offset);
		return -EINVAL;
	}

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

	mem->size = PAGE_ALIGN(q->bufs[first]->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) q->bufs[first]->bsize,
		vma->vm_pgoff, first);

	videobuf_vm_open(vma);

	return 0;

error:
	kfree(map);
	return -ENOMEM;
}

static struct videobuf_qtype_ops qops = {
	.magic        = MAGIC_QTYPE_OPS,

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