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