[deliverable/linux.git] / arch / sparc / kernel / dma.c

/* dma.c: PCI and SBUS DMA accessors for 32-bit sparc.
 *
 * Copyright (C) 2008 David S. Miller <davem@davemloft.net>
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/dma-mapping.h>
#include <linux/scatterlist.h>
#include <linux/mm.h>

#ifdef CONFIG_PCI
#include <linux/pci.h>
#endif

#include "dma.h"

int dma_supported(struct device *dev, u64 mask)
{
#ifdef CONFIG_PCI
	if (dev->bus == &pci_bus_type)
		return pci_dma_supported(to_pci_dev(dev), mask);
#endif
	return 0;
}
EXPORT_SYMBOL(dma_supported);

int dma_set_mask(struct device *dev, u64 dma_mask)
{
#ifdef CONFIG_PCI
	if (dev->bus == &pci_bus_type)
		return pci_set_dma_mask(to_pci_dev(dev), dma_mask);
#endif
	return -EOPNOTSUPP;
}
EXPORT_SYMBOL(dma_set_mask);

static void *dma32_alloc_coherent(struct device *dev, size_t size,
				  dma_addr_t *dma_handle, gfp_t flag)
{
#ifdef CONFIG_PCI
	if (dev->bus == &pci_bus_type)
		return pci_alloc_consistent(to_pci_dev(dev), size, dma_handle);
#endif
	return sbus_alloc_consistent(dev, size, dma_handle);
}

static void dma32_free_coherent(struct device *dev, size_t size,
				void *cpu_addr, dma_addr_t dma_handle)
{
#ifdef CONFIG_PCI
	if (dev->bus == &pci_bus_type) {
		pci_free_consistent(to_pci_dev(dev), size,
				    cpu_addr, dma_handle);
		return;
	}
#endif
	sbus_free_consistent(dev, size, cpu_addr, dma_handle);
}

static dma_addr_t dma32_map_page(struct device *dev, struct page *page,
				 unsigned long offset, size_t size,
				 enum dma_data_direction direction)
{
#ifdef CONFIG_PCI
	if (dev->bus == &pci_bus_type)
		return pci_map_page(to_pci_dev(dev), page, offset,
				    size, (int)direction);
#endif
	return sbus_map_single(dev, page_address(page) + offset,
			       size, (int)direction);
}

static void dma32_unmap_page(struct device *dev, dma_addr_t dma_address,
			     size_t size, enum dma_data_direction direction)
{
#ifdef CONFIG_PCI
	if (dev->bus == &pci_bus_type) {
		pci_unmap_page(to_pci_dev(dev), dma_address,
			       size, (int)direction);
		return;
	}
#endif
	sbus_unmap_single(dev, dma_address, size, (int)direction);
}

static int dma32_map_sg(struct device *dev, struct scatterlist *sg,
			int nents, enum dma_data_direction direction)
{
#ifdef CONFIG_PCI
	if (dev->bus == &pci_bus_type)
		return pci_map_sg(to_pci_dev(dev), sg, nents, (int)direction);
#endif
	return sbus_map_sg(dev, sg, nents, direction);
}

void dma32_unmap_sg(struct device *dev, struct scatterlist *sg,
		    int nents, enum dma_data_direction direction)
{
#ifdef CONFIG_PCI
	if (dev->bus == &pci_bus_type) {
		pci_unmap_sg(to_pci_dev(dev), sg, nents, (int)direction);
		return;
	}
#endif
	sbus_unmap_sg(dev, sg, nents, (int)direction);
}

static void dma32_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle,
				      size_t size,
				      enum dma_data_direction direction)
{
#ifdef CONFIG_PCI
	if (dev->bus == &pci_bus_type) {
		pci_dma_sync_single_for_cpu(to_pci_dev(dev), dma_handle,
					    size, (int)direction);
		return;
	}
#endif
	sbus_dma_sync_single_for_cpu(dev, dma_handle, size, (int) direction);
}

static void dma32_sync_single_for_device(struct device *dev,
					 dma_addr_t dma_handle, size_t size,
					 enum dma_data_direction direction)
{
#ifdef CONFIG_PCI
	if (dev->bus == &pci_bus_type) {
		pci_dma_sync_single_for_device(to_pci_dev(dev), dma_handle,
					       size, (int)direction);
		return;
	}
#endif
	sbus_dma_sync_single_for_device(dev, dma_handle, size, (int) direction);
}

static void dma32_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg,
				  int nelems, enum dma_data_direction direction)
{
#ifdef CONFIG_PCI
	if (dev->bus == &pci_bus_type) {
		pci_dma_sync_sg_for_cpu(to_pci_dev(dev), sg,
					nelems, (int)direction);
		return;
	}
#endif
	BUG();
}

static void dma32_sync_sg_for_device(struct device *dev,
				     struct scatterlist *sg, int nelems,
				     enum dma_data_direction direction)
{
#ifdef CONFIG_PCI
	if (dev->bus == &pci_bus_type) {
		pci_dma_sync_sg_for_device(to_pci_dev(dev), sg,
					   nelems, (int)direction);
		return;
	}
#endif
	BUG();
}

static const struct dma_ops dma32_dma_ops = {
	.alloc_coherent		= dma32_alloc_coherent,
	.free_coherent		= dma32_free_coherent,
	.map_page		= dma32_map_page,
	.unmap_page		= dma32_unmap_page,
	.map_sg			= dma32_map_sg,
	.unmap_sg		= dma32_unmap_sg,
	.sync_single_for_cpu	= dma32_sync_single_for_cpu,
	.sync_single_for_device	= dma32_sync_single_for_device,
	.sync_sg_for_cpu	= dma32_sync_sg_for_cpu,
	.sync_sg_for_device	= dma32_sync_sg_for_device,
};

const struct dma_ops *dma_ops = &dma32_dma_ops;
EXPORT_SYMBOL(dma_ops);
Commit	Line	Data
944c67df DM	1	/* dma.c: PCI and SBUS DMA accessors for 32-bit sparc.
	2	*
	3	* Copyright (C) 2008 David S. Miller <davem@davemloft.net>
	4	*/
	5
	6	#include <linux/kernel.h>
	7	#include <linux/module.h>
	8	#include <linux/dma-mapping.h>
	9	#include <linux/scatterlist.h>
	10	#include <linux/mm.h>
	11
	12	#ifdef CONFIG_PCI
	13	#include <linux/pci.h>
	14	#endif
	15
	16	#include "dma.h"
	17
	18	int dma_supported(struct device *dev, u64 mask)
	19	{
	20	#ifdef CONFIG_PCI
	21	if (dev->bus == &pci_bus_type)
	22	return pci_dma_supported(to_pci_dev(dev), mask);
	23	#endif
	24	return 0;
	25	}
	26	EXPORT_SYMBOL(dma_supported);
	27
	28	int dma_set_mask(struct device *dev, u64 dma_mask)
	29	{
	30	#ifdef CONFIG_PCI
	31	if (dev->bus == &pci_bus_type)
	32	return pci_set_dma_mask(to_pci_dev(dev), dma_mask);
	33	#endif
	34	return -EOPNOTSUPP;
	35	}
	36	EXPORT_SYMBOL(dma_set_mask);
	37
d6986415 FT	38	static void dma32_alloc_coherent(struct device dev, size_t size,
d6986415 FT	39	dma_addr_t *dma_handle, gfp_t flag)
944c67df DM	40	{
	41	#ifdef CONFIG_PCI
	42	if (dev->bus == &pci_bus_type)
	43	return pci_alloc_consistent(to_pci_dev(dev), size, dma_handle);
	44	#endif
	45	return sbus_alloc_consistent(dev, size, dma_handle);
	46	}
944c67df	47
d6986415 FT	48	static void dma32_free_coherent(struct device *dev, size_t size,
d6986415 FT	49	void *cpu_addr, dma_addr_t dma_handle)
944c67df DM	50	{
	51	#ifdef CONFIG_PCI
	52	if (dev->bus == &pci_bus_type) {
	53	pci_free_consistent(to_pci_dev(dev), size,
	54	cpu_addr, dma_handle);
	55	return;
	56	}
	57	#endif
	58	sbus_free_consistent(dev, size, cpu_addr, dma_handle);
	59	}
944c67df	60
d6986415 FT	61	static dma_addr_t dma32_map_page(struct device dev, struct page page,
	62	unsigned long offset, size_t size,
	63	enum dma_data_direction direction)
944c67df DM	64	{
	65	#ifdef CONFIG_PCI
	66	if (dev->bus == &pci_bus_type)
	67	return pci_map_page(to_pci_dev(dev), page, offset,
	68	size, (int)direction);
	69	#endif
	70	return sbus_map_single(dev, page_address(page) + offset,
	71	size, (int)direction);
	72	}
944c67df	73
d6986415 FT	74	static void dma32_unmap_page(struct device *dev, dma_addr_t dma_address,
d6986415 FT	75	size_t size, enum dma_data_direction direction)
944c67df DM	76	{
	77	#ifdef CONFIG_PCI
	78	if (dev->bus == &pci_bus_type) {
	79	pci_unmap_page(to_pci_dev(dev), dma_address,
	80	size, (int)direction);
	81	return;
	82	}
	83	#endif
	84	sbus_unmap_single(dev, dma_address, size, (int)direction);
	85	}
944c67df	86
d6986415 FT	87	static int dma32_map_sg(struct device dev, struct scatterlist sg,
d6986415 FT	88	int nents, enum dma_data_direction direction)
944c67df DM	89	{
	90	#ifdef CONFIG_PCI
	91	if (dev->bus == &pci_bus_type)
	92	return pci_map_sg(to_pci_dev(dev), sg, nents, (int)direction);
	93	#endif
	94	return sbus_map_sg(dev, sg, nents, direction);
	95	}
944c67df	96
d6986415 FT	97	void dma32_unmap_sg(struct device dev, struct scatterlist sg,
d6986415 FT	98	int nents, enum dma_data_direction direction)
944c67df DM	99	{
	100	#ifdef CONFIG_PCI
	101	if (dev->bus == &pci_bus_type) {
	102	pci_unmap_sg(to_pci_dev(dev), sg, nents, (int)direction);
	103	return;
	104	}
	105	#endif
	106	sbus_unmap_sg(dev, sg, nents, (int)direction);
	107	}
944c67df	108
d6986415 FT	109	static void dma32_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle,
	110	size_t size,
	111	enum dma_data_direction direction)
944c67df DM	112	{
	113	#ifdef CONFIG_PCI
	114	if (dev->bus == &pci_bus_type) {
	115	pci_dma_sync_single_for_cpu(to_pci_dev(dev), dma_handle,
	116	size, (int)direction);
	117	return;
	118	}
	119	#endif
	120	sbus_dma_sync_single_for_cpu(dev, dma_handle, size, (int) direction);
	121	}
944c67df	122
d6986415 FT	123	static void dma32_sync_single_for_device(struct device *dev,
	124	dma_addr_t dma_handle, size_t size,
	125	enum dma_data_direction direction)
944c67df DM	126	{
	127	#ifdef CONFIG_PCI
	128	if (dev->bus == &pci_bus_type) {
	129	pci_dma_sync_single_for_device(to_pci_dev(dev), dma_handle,
	130	size, (int)direction);
	131	return;
	132	}
	133	#endif
	134	sbus_dma_sync_single_for_device(dev, dma_handle, size, (int) direction);
	135	}
944c67df	136
d6986415 FT	137	static void dma32_sync_sg_for_cpu(struct device dev, struct scatterlist sg,
d6986415 FT	138	int nelems, enum dma_data_direction direction)
944c67df DM	139	{
	140	#ifdef CONFIG_PCI
	141	if (dev->bus == &pci_bus_type) {
	142	pci_dma_sync_sg_for_cpu(to_pci_dev(dev), sg,
	143	nelems, (int)direction);
	144	return;
	145	}
	146	#endif
	147	BUG();
	148	}
944c67df	149
d6986415 FT	150	static void dma32_sync_sg_for_device(struct device *dev,
	151	struct scatterlist *sg, int nelems,
	152	enum dma_data_direction direction)
944c67df DM	153	{
	154	#ifdef CONFIG_PCI
	155	if (dev->bus == &pci_bus_type) {
	156	pci_dma_sync_sg_for_device(to_pci_dev(dev), sg,
	157	nelems, (int)direction);
	158	return;
	159	}
	160	#endif
	161	BUG();
	162	}
d6986415 FT	163
	164	static const struct dma_ops dma32_dma_ops = {
	165	.alloc_coherent = dma32_alloc_coherent,
	166	.free_coherent = dma32_free_coherent,
	167	.map_page = dma32_map_page,
	168	.unmap_page = dma32_unmap_page,
	169	.map_sg = dma32_map_sg,
	170	.unmap_sg = dma32_unmap_sg,
	171	.sync_single_for_cpu = dma32_sync_single_for_cpu,
	172	.sync_single_for_device = dma32_sync_single_for_device,
	173	.sync_sg_for_cpu = dma32_sync_sg_for_cpu,
	174	.sync_sg_for_device = dma32_sync_sg_for_device,
	175	};
	176
	177	const struct dma_ops *dma_ops = &dma32_dma_ops;
	178	EXPORT_SYMBOL(dma_ops);