Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6
[linux-2.6] / arch / sparc / kernel / dma.c
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
38 void *dma_alloc_coherent(struct device *dev, size_t size,
39                          dma_addr_t *dma_handle, gfp_t flag)
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 }
47 EXPORT_SYMBOL(dma_alloc_coherent);
48
49 void dma_free_coherent(struct device *dev, size_t size,
50                        void *cpu_addr, dma_addr_t dma_handle)
51 {
52 #ifdef CONFIG_PCI
53         if (dev->bus == &pci_bus_type) {
54                 pci_free_consistent(to_pci_dev(dev), size,
55                                     cpu_addr, dma_handle);
56                 return;
57         }
58 #endif
59         sbus_free_consistent(dev, size, cpu_addr, dma_handle);
60 }
61 EXPORT_SYMBOL(dma_free_coherent);
62
63 dma_addr_t dma_map_single(struct device *dev, void *cpu_addr,
64                           size_t size, enum dma_data_direction direction)
65 {
66 #ifdef CONFIG_PCI
67         if (dev->bus == &pci_bus_type)
68                 return pci_map_single(to_pci_dev(dev), cpu_addr,
69                                       size, (int)direction);
70 #endif
71         return sbus_map_single(dev, cpu_addr, size, (int)direction);
72 }
73 EXPORT_SYMBOL(dma_map_single);
74
75 void dma_unmap_single(struct device *dev, dma_addr_t dma_addr,
76                       size_t size,
77                       enum dma_data_direction direction)
78 {
79 #ifdef CONFIG_PCI
80         if (dev->bus == &pci_bus_type) {
81                 pci_unmap_single(to_pci_dev(dev), dma_addr,
82                                  size, (int)direction);
83                 return;
84         }
85 #endif
86         sbus_unmap_single(dev, dma_addr, size, (int)direction);
87 }
88 EXPORT_SYMBOL(dma_unmap_single);
89
90 dma_addr_t dma_map_page(struct device *dev, struct page *page,
91                         unsigned long offset, size_t size,
92                         enum dma_data_direction direction)
93 {
94 #ifdef CONFIG_PCI
95         if (dev->bus == &pci_bus_type)
96                 return pci_map_page(to_pci_dev(dev), page, offset,
97                                     size, (int)direction);
98 #endif
99         return sbus_map_single(dev, page_address(page) + offset,
100                                size, (int)direction);
101 }
102 EXPORT_SYMBOL(dma_map_page);
103
104 void dma_unmap_page(struct device *dev, dma_addr_t dma_address,
105                     size_t size, enum dma_data_direction direction)
106 {
107 #ifdef CONFIG_PCI
108         if (dev->bus == &pci_bus_type) {
109                 pci_unmap_page(to_pci_dev(dev), dma_address,
110                                size, (int)direction);
111                 return;
112         }
113 #endif
114         sbus_unmap_single(dev, dma_address, size, (int)direction);
115 }
116 EXPORT_SYMBOL(dma_unmap_page);
117
118 int dma_map_sg(struct device *dev, struct scatterlist *sg,
119                              int nents, enum dma_data_direction direction)
120 {
121 #ifdef CONFIG_PCI
122         if (dev->bus == &pci_bus_type)
123                 return pci_map_sg(to_pci_dev(dev), sg, nents, (int)direction);
124 #endif
125         return sbus_map_sg(dev, sg, nents, direction);
126 }
127 EXPORT_SYMBOL(dma_map_sg);
128
129 void dma_unmap_sg(struct device *dev, struct scatterlist *sg,
130                   int nents, enum dma_data_direction direction)
131 {
132 #ifdef CONFIG_PCI
133         if (dev->bus == &pci_bus_type) {
134                 pci_unmap_sg(to_pci_dev(dev), sg, nents, (int)direction);
135                 return;
136         }
137 #endif
138         sbus_unmap_sg(dev, sg, nents, (int)direction);
139 }
140 EXPORT_SYMBOL(dma_unmap_sg);
141
142 void dma_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle,
143                              size_t size, enum dma_data_direction direction)
144 {
145 #ifdef CONFIG_PCI
146         if (dev->bus == &pci_bus_type) {
147                 pci_dma_sync_single_for_cpu(to_pci_dev(dev), dma_handle,
148                                             size, (int)direction);
149                 return;
150         }
151 #endif
152         sbus_dma_sync_single_for_cpu(dev, dma_handle, size, (int) direction);
153 }
154 EXPORT_SYMBOL(dma_sync_single_for_cpu);
155
156 void dma_sync_single_for_device(struct device *dev, dma_addr_t dma_handle,
157                                 size_t size, enum dma_data_direction direction)
158 {
159 #ifdef CONFIG_PCI
160         if (dev->bus == &pci_bus_type) {
161                 pci_dma_sync_single_for_device(to_pci_dev(dev), dma_handle,
162                                                size, (int)direction);
163                 return;
164         }
165 #endif
166         sbus_dma_sync_single_for_device(dev, dma_handle, size, (int) direction);
167 }
168 EXPORT_SYMBOL(dma_sync_single_for_device);
169
170 void dma_sync_single_range_for_cpu(struct device *dev,
171                                    dma_addr_t dma_handle,
172                                    unsigned long offset,
173                                    size_t size,
174                                    enum dma_data_direction direction)
175 {
176         dma_sync_single_for_cpu(dev, dma_handle+offset, size, direction);
177 }
178 EXPORT_SYMBOL(dma_sync_single_range_for_cpu);
179
180 void dma_sync_single_range_for_device(struct device *dev, dma_addr_t dma_handle,
181                                       unsigned long offset, size_t size,
182                                       enum dma_data_direction direction)
183 {
184         dma_sync_single_for_device(dev, dma_handle+offset, size, direction);
185 }
186 EXPORT_SYMBOL(dma_sync_single_range_for_device);
187
188 void dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg,
189                          int nelems, enum dma_data_direction direction)
190 {
191 #ifdef CONFIG_PCI
192         if (dev->bus == &pci_bus_type) {
193                 pci_dma_sync_sg_for_cpu(to_pci_dev(dev), sg,
194                                         nelems, (int)direction);
195                 return;
196         }
197 #endif
198         BUG();
199 }
200 EXPORT_SYMBOL(dma_sync_sg_for_cpu);
201
202 void dma_sync_sg_for_device(struct device *dev,
203                             struct scatterlist *sg, int nelems,
204                             enum dma_data_direction direction)
205 {
206 #ifdef CONFIG_PCI
207         if (dev->bus == &pci_bus_type) {
208                 pci_dma_sync_sg_for_device(to_pci_dev(dev), sg,
209                                            nelems, (int)direction);
210                 return;
211         }
212 #endif
213         BUG();
214 }
215 EXPORT_SYMBOL(dma_sync_sg_for_device);
216
217 int dma_mapping_error(struct device *dev, dma_addr_t dma_addr)
218 {
219         return (dma_addr == DMA_ERROR_CODE);
220 }
221 EXPORT_SYMBOL(dma_mapping_error);
222
223 int dma_get_cache_alignment(void)
224 {
225         return 32;
226 }
227 EXPORT_SYMBOL(dma_get_cache_alignment);