Merge master.kernel.org:/pub/scm/linux/kernel/git/dtor/input
[linux-2.6] / arch / powerpc / kernel / dma_64.c
1 /*
2  * Copyright (C) 2004 IBM Corporation
3  *
4  * Implements the generic device dma API for ppc64. Handles
5  * the pci and vio busses
6  */
7
8 #include <linux/device.h>
9 #include <linux/dma-mapping.h>
10 /* Include the busses we support */
11 #include <linux/pci.h>
12 #include <asm/vio.h>
13 #include <asm/ibmebus.h>
14 #include <asm/scatterlist.h>
15 #include <asm/bug.h>
16
17 static struct dma_mapping_ops *get_dma_ops(struct device *dev)
18 {
19 #ifdef CONFIG_PCI
20         if (dev->bus == &pci_bus_type)
21                 return &pci_dma_ops;
22 #endif
23 #ifdef CONFIG_IBMVIO
24         if (dev->bus == &vio_bus_type)
25                 return &vio_dma_ops;
26 #endif
27 #ifdef CONFIG_IBMEBUS
28         if (dev->bus == &ibmebus_bus_type)
29                 return &ibmebus_dma_ops;
30 #endif
31         return NULL;
32 }
33
34 int dma_supported(struct device *dev, u64 mask)
35 {
36         struct dma_mapping_ops *dma_ops = get_dma_ops(dev);
37
38         if (dma_ops)
39                 return dma_ops->dma_supported(dev, mask);
40         BUG();
41         return 0;
42 }
43 EXPORT_SYMBOL(dma_supported);
44
45 int dma_set_mask(struct device *dev, u64 dma_mask)
46 {
47 #ifdef CONFIG_PCI
48         if (dev->bus == &pci_bus_type)
49                 return pci_set_dma_mask(to_pci_dev(dev), dma_mask);
50 #endif
51 #ifdef CONFIG_IBMVIO
52         if (dev->bus == &vio_bus_type)
53                 return -EIO;
54 #endif /* CONFIG_IBMVIO */
55 #ifdef CONFIG_IBMEBUS
56         if (dev->bus == &ibmebus_bus_type)
57                 return -EIO;
58 #endif
59         BUG();
60         return 0;
61 }
62 EXPORT_SYMBOL(dma_set_mask);
63
64 void *dma_alloc_coherent(struct device *dev, size_t size,
65                 dma_addr_t *dma_handle, gfp_t flag)
66 {
67         struct dma_mapping_ops *dma_ops = get_dma_ops(dev);
68
69         if (dma_ops)
70                 return dma_ops->alloc_coherent(dev, size, dma_handle, flag);
71         BUG();
72         return NULL;
73 }
74 EXPORT_SYMBOL(dma_alloc_coherent);
75
76 void dma_free_coherent(struct device *dev, size_t size, void *cpu_addr,
77                 dma_addr_t dma_handle)
78 {
79         struct dma_mapping_ops *dma_ops = get_dma_ops(dev);
80
81         if (dma_ops)
82                 dma_ops->free_coherent(dev, size, cpu_addr, dma_handle);
83         else
84                 BUG();
85 }
86 EXPORT_SYMBOL(dma_free_coherent);
87
88 dma_addr_t dma_map_single(struct device *dev, void *cpu_addr, size_t size,
89                 enum dma_data_direction direction)
90 {
91         struct dma_mapping_ops *dma_ops = get_dma_ops(dev);
92
93         if (dma_ops)
94                 return dma_ops->map_single(dev, cpu_addr, size, direction);
95         BUG();
96         return (dma_addr_t)0;
97 }
98 EXPORT_SYMBOL(dma_map_single);
99
100 void dma_unmap_single(struct device *dev, dma_addr_t dma_addr, size_t size,
101                 enum dma_data_direction direction)
102 {
103         struct dma_mapping_ops *dma_ops = get_dma_ops(dev);
104
105         if (dma_ops)
106                 dma_ops->unmap_single(dev, dma_addr, size, direction);
107         else
108                 BUG();
109 }
110 EXPORT_SYMBOL(dma_unmap_single);
111
112 dma_addr_t dma_map_page(struct device *dev, struct page *page,
113                 unsigned long offset, size_t size,
114                 enum dma_data_direction direction)
115 {
116         struct dma_mapping_ops *dma_ops = get_dma_ops(dev);
117
118         if (dma_ops)
119                 return dma_ops->map_single(dev,
120                                 (page_address(page) + offset), size, direction);
121         BUG();
122         return (dma_addr_t)0;
123 }
124 EXPORT_SYMBOL(dma_map_page);
125
126 void dma_unmap_page(struct device *dev, dma_addr_t dma_address, size_t size,
127                 enum dma_data_direction direction)
128 {
129         struct dma_mapping_ops *dma_ops = get_dma_ops(dev);
130
131         if (dma_ops)
132                 dma_ops->unmap_single(dev, dma_address, size, direction);
133         else
134                 BUG();
135 }
136 EXPORT_SYMBOL(dma_unmap_page);
137
138 int dma_map_sg(struct device *dev, struct scatterlist *sg, int nents,
139                 enum dma_data_direction direction)
140 {
141         struct dma_mapping_ops *dma_ops = get_dma_ops(dev);
142
143         if (dma_ops)
144                 return dma_ops->map_sg(dev, sg, nents, direction);
145         BUG();
146         return 0;
147 }
148 EXPORT_SYMBOL(dma_map_sg);
149
150 void dma_unmap_sg(struct device *dev, struct scatterlist *sg, int nhwentries,
151                 enum dma_data_direction direction)
152 {
153         struct dma_mapping_ops *dma_ops = get_dma_ops(dev);
154
155         if (dma_ops)
156                 dma_ops->unmap_sg(dev, sg, nhwentries, direction);
157         else
158                 BUG();
159 }
160 EXPORT_SYMBOL(dma_unmap_sg);