[linux-2.6-block.git] / drivers / ieee1394 / dma.c

/*
 * DMA region bookkeeping routines
 *
 * Copyright (C) 2002 Maas Digital LLC
 *
 * This code is licensed under the GPL.  See the file COPYING in the root
 * directory of the kernel sources for details.
 */

#include <linux/mm.h>
#include <linux/module.h>
#include <linux/pci.h>
#include <linux/slab.h>
#include <linux/vmalloc.h>
#include <linux/scatterlist.h>

#include "dma.h"

/* dma_prog_region */

void dma_prog_region_init(struct dma_prog_region *prog)
{
	prog->kvirt = NULL;
	prog->dev = NULL;
	prog->n_pages = 0;
	prog->bus_addr = 0;
}

int dma_prog_region_alloc(struct dma_prog_region *prog, unsigned long n_bytes,
			  struct pci_dev *dev)
{
	/* round up to page size */
	n_bytes = PAGE_ALIGN(n_bytes);

	prog->n_pages = n_bytes >> PAGE_SHIFT;

	prog->kvirt = pci_alloc_consistent(dev, n_bytes, &prog->bus_addr);
	if (!prog->kvirt) {
		printk(KERN_ERR
		       "dma_prog_region_alloc: pci_alloc_consistent() failed\n");
		dma_prog_region_free(prog);
		return -ENOMEM;
	}

	prog->dev = dev;

	return 0;
}

void dma_prog_region_free(struct dma_prog_region *prog)
{
	if (prog->kvirt) {
		pci_free_consistent(prog->dev, prog->n_pages << PAGE_SHIFT,
				    prog->kvirt, prog->bus_addr);
	}

	prog->kvirt = NULL;
	prog->dev = NULL;
	prog->n_pages = 0;
	prog->bus_addr = 0;
}

/* dma_region */

/**
 * dma_region_init - clear out all fields but do not allocate anything
 */
void dma_region_init(struct dma_region *dma)
{
	dma->kvirt = NULL;
	dma->dev = NULL;
	dma->n_pages = 0;
	dma->n_dma_pages = 0;
	dma->sglist = NULL;
}

/**
 * dma_region_alloc - allocate the buffer and map it to the IOMMU
 */
int dma_region_alloc(struct dma_region *dma, unsigned long n_bytes,
		     struct pci_dev *dev, int direction)
{
	unsigned int i;

	/* round up to page size */
	n_bytes = PAGE_ALIGN(n_bytes);

	dma->n_pages = n_bytes >> PAGE_SHIFT;

	dma->kvirt = vmalloc_32(n_bytes);
	if (!dma->kvirt) {
		printk(KERN_ERR "dma_region_alloc: vmalloc_32() failed\n");
		goto err;
	}

	/* Clear the ram out, no junk to the user */
	memset(dma->kvirt, 0, n_bytes);

	/* allocate scatter/gather list */
	dma->sglist = vmalloc(dma->n_pages * sizeof(*dma->sglist));
	if (!dma->sglist) {
		printk(KERN_ERR "dma_region_alloc: vmalloc(sglist) failed\n");
		goto err;
	}

	sg_init_table(dma->sglist, dma->n_pages);

	/* fill scatter/gather list with pages */
	for (i = 0; i < dma->n_pages; i++) {
		unsigned long va =
		    (unsigned long)dma->kvirt + (i << PAGE_SHIFT);

		sg_set_page(&dma->sglist[i], vmalloc_to_page((void *)va),
				PAGE_SIZE, 0);
	}

	/* map sglist to the IOMMU */
	dma->n_dma_pages =
	    pci_map_sg(dev, dma->sglist, dma->n_pages, direction);

	if (dma->n_dma_pages == 0) {
		printk(KERN_ERR "dma_region_alloc: pci_map_sg() failed\n");
		goto err;
	}

	dma->dev = dev;
	dma->direction = direction;

	return 0;

      err:
	dma_region_free(dma);
	return -ENOMEM;
}

/**
 * dma_region_free - unmap and free the buffer
 */
void dma_region_free(struct dma_region *dma)
{
	if (dma->n_dma_pages) {
		pci_unmap_sg(dma->dev, dma->sglist, dma->n_pages,
			     dma->direction);
		dma->n_dma_pages = 0;
		dma->dev = NULL;
	}

	vfree(dma->sglist);
	dma->sglist = NULL;

	vfree(dma->kvirt);
	dma->kvirt = NULL;
	dma->n_pages = 0;
}

/* find the scatterlist index and remaining offset corresponding to a
   given offset from the beginning of the buffer */
static inline int dma_region_find(struct dma_region *dma, unsigned long offset,
				  unsigned int start, unsigned long *rem)
{
	int i;
	unsigned long off = offset;

	for (i = start; i < dma->n_dma_pages; i++) {
		if (off < sg_dma_len(&dma->sglist[i])) {
			*rem = off;
			break;
		}

		off -= sg_dma_len(&dma->sglist[i]);
	}

	BUG_ON(i >= dma->n_dma_pages);

	return i;
}

/**
 * dma_region_offset_to_bus - get bus address of an offset within a DMA region
 *
 * Returns the DMA bus address of the byte with the given @offset relative to
 * the beginning of the @dma.
 */
dma_addr_t dma_region_offset_to_bus(struct dma_region * dma,
				    unsigned long offset)
{
	unsigned long rem = 0;

	struct scatterlist *sg =
	    &dma->sglist[dma_region_find(dma, offset, 0, &rem)];
	return sg_dma_address(sg) + rem;
}

/**
 * dma_region_sync_for_cpu - sync the CPU's view of the buffer
 */
void dma_region_sync_for_cpu(struct dma_region *dma, unsigned long offset,
			     unsigned long len)
{
	int first, last;
	unsigned long rem = 0;

	if (!len)
		len = 1;

	first = dma_region_find(dma, offset, 0, &rem);
	last = dma_region_find(dma, rem + len - 1, first, &rem);

	pci_dma_sync_sg_for_cpu(dma->dev, &dma->sglist[first], last - first + 1,
				dma->direction);
}

/**
 * dma_region_sync_for_device - sync the IO bus' view of the buffer
 */
void dma_region_sync_for_device(struct dma_region *dma, unsigned long offset,
				unsigned long len)
{
	int first, last;
	unsigned long rem = 0;

	if (!len)
		len = 1;

	first = dma_region_find(dma, offset, 0, &rem);
	last = dma_region_find(dma, rem + len - 1, first, &rem);

	pci_dma_sync_sg_for_device(dma->dev, &dma->sglist[first],
				   last - first + 1, dma->direction);
}

#ifdef CONFIG_MMU

static int dma_region_pagefault(struct vm_area_struct *vma,
				struct vm_fault *vmf)
{
	struct dma_region *dma = (struct dma_region *)vma->vm_private_data;

	if (!dma->kvirt)
		return VM_FAULT_SIGBUS;

	if (vmf->pgoff >= dma->n_pages)
		return VM_FAULT_SIGBUS;

	vmf->page = vmalloc_to_page(dma->kvirt + (vmf->pgoff << PAGE_SHIFT));
	get_page(vmf->page);
	return 0;
}

static const struct vm_operations_struct dma_region_vm_ops = {
	.fault = dma_region_pagefault,
};

/**
 * dma_region_mmap - map the buffer into a user space process
 */
int dma_region_mmap(struct dma_region *dma, struct file *file,
		    struct vm_area_struct *vma)
{
	unsigned long size;

	if (!dma->kvirt)
		return -EINVAL;

	/* must be page-aligned (XXX: comment is wrong, we could allow pgoff) */
	if (vma->vm_pgoff != 0)
		return -EINVAL;

	/* check the length */
	size = vma->vm_end - vma->vm_start;
	if (size > (dma->n_pages << PAGE_SHIFT))
		return -EINVAL;

	vma->vm_ops = &dma_region_vm_ops;
	vma->vm_private_data = dma;
	vma->vm_file = file;
	vma->vm_flags |= VM_RESERVED | VM_ALWAYSDUMP;

	return 0;
}

#else				/* CONFIG_MMU */

int dma_region_mmap(struct dma_region *dma, struct file *file,
		    struct vm_area_struct *vma)
{
	return -EINVAL;
}

#endif				/* CONFIG_MMU */
Commit	Line	Data
1da177e4 LT	1	/*
	2	* DMA region bookkeeping routines
	3	*
	4	* Copyright (C) 2002 Maas Digital LLC
	5	*
	6	* This code is licensed under the GPL. See the file COPYING in the root
	7	* directory of the kernel sources for details.
	8	*/
	9
de4394f1	10	#include <linux/mm.h>
1da177e4	11	#include <linux/module.h>
de4394f1	12	#include <linux/pci.h>
1da177e4	13	#include <linux/slab.h>
de4394f1	14	#include <linux/vmalloc.h>
11763609	15	#include <linux/scatterlist.h>
de4394f1	16
1da177e4 LT	17	#include "dma.h"
	18
	19	/* dma_prog_region */
	20
	21	void dma_prog_region_init(struct dma_prog_region *prog)
	22	{
	23	prog->kvirt = NULL;
	24	prog->dev = NULL;
	25	prog->n_pages = 0;
	26	prog->bus_addr = 0;
	27	}
	28
6649e92d JMH	29	int dma_prog_region_alloc(struct dma_prog_region *prog, unsigned long n_bytes,
6649e92d JMH	30	struct pci_dev *dev)
1da177e4 LT	31	{
	32	/* round up to page size */
	33	n_bytes = PAGE_ALIGN(n_bytes);
	34
	35	prog->n_pages = n_bytes >> PAGE_SHIFT;
	36
	37	prog->kvirt = pci_alloc_consistent(dev, n_bytes, &prog->bus_addr);
	38	if (!prog->kvirt) {
6649e92d JMH	39	printk(KERN_ERR
6649e92d JMH	40	"dma_prog_region_alloc: pci_alloc_consistent() failed\n");
1da177e4 LT	41	dma_prog_region_free(prog);
	42	return -ENOMEM;
	43	}
	44
	45	prog->dev = dev;
	46
	47	return 0;
	48	}
	49
	50	void dma_prog_region_free(struct dma_prog_region *prog)
	51	{
	52	if (prog->kvirt) {
6649e92d JMH	53	pci_free_consistent(prog->dev, prog->n_pages << PAGE_SHIFT,
6649e92d JMH	54	prog->kvirt, prog->bus_addr);
1da177e4 LT	55	}
	56
	57	prog->kvirt = NULL;
	58	prog->dev = NULL;
	59	prog->n_pages = 0;
	60	prog->bus_addr = 0;
	61	}
	62
	63	/* dma_region */
	64
afd6546d SR	65	/**
	66	* dma_region_init - clear out all fields but do not allocate anything
	67	*/
1da177e4 LT	68	void dma_region_init(struct dma_region *dma)
	69	{
	70	dma->kvirt = NULL;
	71	dma->dev = NULL;
	72	dma->n_pages = 0;
	73	dma->n_dma_pages = 0;
	74	dma->sglist = NULL;
	75	}
	76
afd6546d SR	77	/**
	78	* dma_region_alloc - allocate the buffer and map it to the IOMMU
	79	*/
6649e92d JMH	80	int dma_region_alloc(struct dma_region *dma, unsigned long n_bytes,
6649e92d JMH	81	struct pci_dev *dev, int direction)
1da177e4 LT	82	{
	83	unsigned int i;
	84
	85	/* round up to page size */
	86	n_bytes = PAGE_ALIGN(n_bytes);
	87
	88	dma->n_pages = n_bytes >> PAGE_SHIFT;
	89
	90	dma->kvirt = vmalloc_32(n_bytes);
	91	if (!dma->kvirt) {
	92	printk(KERN_ERR "dma_region_alloc: vmalloc_32() failed\n");
	93	goto err;
	94	}
	95
	96	/* Clear the ram out, no junk to the user */
	97	memset(dma->kvirt, 0, n_bytes);
	98
	99	/* allocate scatter/gather list */
	100	dma->sglist = vmalloc(dma->n_pages * sizeof(*dma->sglist));
	101	if (!dma->sglist) {
	102	printk(KERN_ERR "dma_region_alloc: vmalloc(sglist) failed\n");
	103	goto err;
	104	}
	105
9e66269d	106	sg_init_table(dma->sglist, dma->n_pages);
1da177e4 LT	107
	108	/* fill scatter/gather list with pages */
	109	for (i = 0; i < dma->n_pages; i++) {
6649e92d JMH	110	unsigned long va =
6649e92d JMH	111	(unsigned long)dma->kvirt + (i << PAGE_SHIFT);
1da177e4	112
642f1490 JA	113	sg_set_page(&dma->sglist[i], vmalloc_to_page((void *)va),
642f1490 JA	114	PAGE_SIZE, 0);
1da177e4 LT	115	}
	116
	117	/* map sglist to the IOMMU */
6649e92d JMH	118	dma->n_dma_pages =
6649e92d JMH	119	pci_map_sg(dev, dma->sglist, dma->n_pages, direction);
1da177e4 LT	120
	121	if (dma->n_dma_pages == 0) {
	122	printk(KERN_ERR "dma_region_alloc: pci_map_sg() failed\n");
	123	goto err;
	124	}
	125
	126	dma->dev = dev;
	127	dma->direction = direction;
	128
	129	return 0;
	130
6649e92d	131	err:
1da177e4 LT	132	dma_region_free(dma);
	133	return -ENOMEM;
	134	}
	135
afd6546d SR	136	/**
	137	* dma_region_free - unmap and free the buffer
	138	*/
1da177e4 LT	139	void dma_region_free(struct dma_region *dma)
	140	{
	141	if (dma->n_dma_pages) {
6649e92d JMH	142	pci_unmap_sg(dma->dev, dma->sglist, dma->n_pages,
6649e92d JMH	143	dma->direction);
1da177e4 LT	144	dma->n_dma_pages = 0;
	145	dma->dev = NULL;
	146	}
	147
	148	vfree(dma->sglist);
	149	dma->sglist = NULL;
	150
	151	vfree(dma->kvirt);
	152	dma->kvirt = NULL;
	153	dma->n_pages = 0;
	154	}
	155
	156	/* find the scatterlist index and remaining offset corresponding to a
	157	given offset from the beginning of the buffer */
6649e92d	158	static inline int dma_region_find(struct dma_region *dma, unsigned long offset,
9bb2bcdb	159	unsigned int start, unsigned long *rem)
1da177e4 LT	160	{
	161	int i;
	162	unsigned long off = offset;
	163
9bb2bcdb	164	for (i = start; i < dma->n_dma_pages; i++) {
1da177e4 LT	165	if (off < sg_dma_len(&dma->sglist[i])) {
	166	*rem = off;
	167	break;
	168	}
	169
	170	off -= sg_dma_len(&dma->sglist[i]);
	171	}
	172
	173	BUG_ON(i >= dma->n_dma_pages);
	174
	175	return i;
	176	}
	177
afd6546d SR	178	/**
	179	* dma_region_offset_to_bus - get bus address of an offset within a DMA region
	180	*
	181	* Returns the DMA bus address of the byte with the given @offset relative to
	182	* the beginning of the @dma.
	183	*/
6649e92d JMH	184	dma_addr_t dma_region_offset_to_bus(struct dma_region * dma,
6649e92d JMH	185	unsigned long offset)
1da177e4	186	{
1934b8b6	187	unsigned long rem = 0;
1da177e4	188
6649e92d	189	struct scatterlist *sg =
9bb2bcdb	190	&dma->sglist[dma_region_find(dma, offset, 0, &rem)];
1da177e4 LT	191	return sg_dma_address(sg) + rem;
	192	}
	193
afd6546d SR	194	/**
	195	* dma_region_sync_for_cpu - sync the CPU's view of the buffer
	196	*/
6649e92d JMH	197	void dma_region_sync_for_cpu(struct dma_region *dma, unsigned long offset,
6649e92d JMH	198	unsigned long len)
1da177e4 LT	199	{
1da177e4 LT	200	int first, last;
9bb2bcdb	201	unsigned long rem = 0;
1da177e4 LT	202
	203	if (!len)
	204	len = 1;
	205
9bb2bcdb BC	206	first = dma_region_find(dma, offset, 0, &rem);
9bb2bcdb BC	207	last = dma_region_find(dma, rem + len - 1, first, &rem);
1da177e4	208
6649e92d JMH	209	pci_dma_sync_sg_for_cpu(dma->dev, &dma->sglist[first], last - first + 1,
6649e92d JMH	210	dma->direction);
1da177e4 LT	211	}
1da177e4 LT	212
afd6546d SR	213	/**
	214	* dma_region_sync_for_device - sync the IO bus' view of the buffer
	215	*/
6649e92d JMH	216	void dma_region_sync_for_device(struct dma_region *dma, unsigned long offset,
6649e92d JMH	217	unsigned long len)
1da177e4 LT	218	{
1da177e4 LT	219	int first, last;
9bb2bcdb	220	unsigned long rem = 0;
1da177e4 LT	221
	222	if (!len)
	223	len = 1;
	224
9bb2bcdb BC	225	first = dma_region_find(dma, offset, 0, &rem);
9bb2bcdb BC	226	last = dma_region_find(dma, rem + len - 1, first, &rem);
1da177e4	227
6649e92d JMH	228	pci_dma_sync_sg_for_device(dma->dev, &dma->sglist[first],
6649e92d JMH	229	last - first + 1, dma->direction);
1da177e4 LT	230	}
	231
	232	#ifdef CONFIG_MMU
	233
61db8121	234	static int dma_region_pagefault(struct vm_area_struct *vma,
c7ea990f	235	struct vm_fault *vmf)
1da177e4	236	{
61db8121	237	struct dma_region dma = (struct dma_region )vma->vm_private_data;
1da177e4 LT	238
1da177e4 LT	239	if (!dma->kvirt)
c7ea990f	240	return VM_FAULT_SIGBUS;
61db8121 NP	241
61db8121 NP	242	if (vmf->pgoff >= dma->n_pages)
c7ea990f	243	return VM_FAULT_SIGBUS;
61db8121	244
c7ea990f	245	vmf->page = vmalloc_to_page(dma->kvirt + (vmf->pgoff << PAGE_SHIFT));
61db8121 NP	246	get_page(vmf->page);
61db8121 NP	247	return 0;
1da177e4 LT	248	}
1da177e4 LT	249
f0f37e2f	250	static const struct vm_operations_struct dma_region_vm_ops = {
61db8121	251	.fault = dma_region_pagefault,
1da177e4 LT	252	};
1da177e4 LT	253
afd6546d SR	254	/**
	255	* dma_region_mmap - map the buffer into a user space process
	256	*/
6649e92d JMH	257	int dma_region_mmap(struct dma_region dma, struct file file,
6649e92d JMH	258	struct vm_area_struct *vma)
1da177e4 LT	259	{
	260	unsigned long size;
	261
	262	if (!dma->kvirt)
	263	return -EINVAL;
	264
61db8121	265	/* must be page-aligned (XXX: comment is wrong, we could allow pgoff) */
1da177e4 LT	266	if (vma->vm_pgoff != 0)
	267	return -EINVAL;
	268
	269	/* check the length */
	270	size = vma->vm_end - vma->vm_start;
	271	if (size > (dma->n_pages << PAGE_SHIFT))
	272	return -EINVAL;
	273
	274	vma->vm_ops = &dma_region_vm_ops;
	275	vma->vm_private_data = dma;
	276	vma->vm_file = file;
435f9726	277	vma->vm_flags \|= VM_RESERVED \| VM_ALWAYSDUMP;
1da177e4 LT	278
	279	return 0;
	280	}
	281
6649e92d	282	#else /* CONFIG_MMU */
1da177e4	283
6649e92d JMH	284	int dma_region_mmap(struct dma_region dma, struct file file,
6649e92d JMH	285	struct vm_area_struct *vma)
1da177e4 LT	286	{
	287	return -EINVAL;
	288	}
	289
6649e92d	290	#endif /* CONFIG_MMU */