ia64/linux-2.6.18-xen.hg

view include/asm-generic/dma-mapping.h @ 782:9ab1c319531f

merge with linux-2.6.18-xen.hg
author Isaku Yamahata <yamahata@valinux.co.jp>
date Wed Jan 28 13:07:23 2009 +0900 (2009-01-28)
parents 831230e53067
children
line source
1 /* Copyright (C) 2002 by James.Bottomley@HansenPartnership.com
2 *
3 * Implements the generic device dma API via the existing pci_ one
4 * for unconverted architectures
5 */
7 #ifndef _ASM_GENERIC_DMA_MAPPING_H
8 #define _ASM_GENERIC_DMA_MAPPING_H
11 #ifdef CONFIG_PCI
13 /* we implement the API below in terms of the existing PCI one,
14 * so include it */
15 #include <linux/pci.h>
16 /* need struct page definitions */
17 #include <linux/mm.h>
19 static inline int
20 dma_supported(struct device *dev, u64 mask)
21 {
22 BUG_ON(dev->bus != &pci_bus_type);
24 return pci_dma_supported(to_pci_dev(dev), mask);
25 }
27 static inline int
28 dma_set_mask(struct device *dev, u64 dma_mask)
29 {
30 BUG_ON(dev->bus != &pci_bus_type);
32 return pci_set_dma_mask(to_pci_dev(dev), dma_mask);
33 }
35 static inline void *
36 dma_alloc_coherent(struct device *dev, size_t size, dma_addr_t *dma_handle,
37 gfp_t flag)
38 {
39 BUG_ON(dev->bus != &pci_bus_type);
41 return pci_alloc_consistent(to_pci_dev(dev), size, dma_handle);
42 }
44 static inline void
45 dma_free_coherent(struct device *dev, size_t size, void *cpu_addr,
46 dma_addr_t dma_handle)
47 {
48 BUG_ON(dev->bus != &pci_bus_type);
50 pci_free_consistent(to_pci_dev(dev), size, cpu_addr, dma_handle);
51 }
53 static inline dma_addr_t
54 dma_map_single(struct device *dev, void *cpu_addr, size_t size,
55 enum dma_data_direction direction)
56 {
57 BUG_ON(dev->bus != &pci_bus_type);
59 return pci_map_single(to_pci_dev(dev), cpu_addr, size, (int)direction);
60 }
62 static inline void
63 dma_unmap_single(struct device *dev, dma_addr_t dma_addr, size_t size,
64 enum dma_data_direction direction)
65 {
66 BUG_ON(dev->bus != &pci_bus_type);
68 pci_unmap_single(to_pci_dev(dev), dma_addr, size, (int)direction);
69 }
71 static inline dma_addr_t
72 dma_map_page(struct device *dev, struct page *page,
73 unsigned long offset, size_t size,
74 enum dma_data_direction direction)
75 {
76 BUG_ON(dev->bus != &pci_bus_type);
78 return pci_map_page(to_pci_dev(dev), page, offset, size, (int)direction);
79 }
81 static inline void
82 dma_unmap_page(struct device *dev, dma_addr_t dma_address, size_t size,
83 enum dma_data_direction direction)
84 {
85 BUG_ON(dev->bus != &pci_bus_type);
87 pci_unmap_page(to_pci_dev(dev), dma_address, size, (int)direction);
88 }
90 static inline int
91 dma_map_sg(struct device *dev, struct scatterlist *sg, int nents,
92 enum dma_data_direction direction)
93 {
94 BUG_ON(dev->bus != &pci_bus_type);
96 return pci_map_sg(to_pci_dev(dev), sg, nents, (int)direction);
97 }
99 static inline void
100 dma_unmap_sg(struct device *dev, struct scatterlist *sg, int nhwentries,
101 enum dma_data_direction direction)
102 {
103 BUG_ON(dev->bus != &pci_bus_type);
105 pci_unmap_sg(to_pci_dev(dev), sg, nhwentries, (int)direction);
106 }
108 static inline void
109 dma_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle, size_t size,
110 enum dma_data_direction direction)
111 {
112 BUG_ON(dev->bus != &pci_bus_type);
114 pci_dma_sync_single_for_cpu(to_pci_dev(dev), dma_handle,
115 size, (int)direction);
116 }
118 static inline void
119 dma_sync_single_for_device(struct device *dev, dma_addr_t dma_handle, size_t size,
120 enum dma_data_direction direction)
121 {
122 BUG_ON(dev->bus != &pci_bus_type);
124 pci_dma_sync_single_for_device(to_pci_dev(dev), dma_handle,
125 size, (int)direction);
126 }
128 static inline void
129 dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg, int nelems,
130 enum dma_data_direction direction)
131 {
132 BUG_ON(dev->bus != &pci_bus_type);
134 pci_dma_sync_sg_for_cpu(to_pci_dev(dev), sg, nelems, (int)direction);
135 }
137 static inline void
138 dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg, int nelems,
139 enum dma_data_direction direction)
140 {
141 BUG_ON(dev->bus != &pci_bus_type);
143 pci_dma_sync_sg_for_device(to_pci_dev(dev), sg, nelems, (int)direction);
144 }
146 static inline int
147 dma_mapping_error(dma_addr_t dma_addr)
148 {
149 return pci_dma_mapping_error(dma_addr);
150 }
153 #else
155 static inline int
156 dma_supported(struct device *dev, u64 mask)
157 {
158 return 0;
159 }
161 static inline int
162 dma_set_mask(struct device *dev, u64 dma_mask)
163 {
164 BUG();
165 return 0;
166 }
168 static inline void *
169 dma_alloc_coherent(struct device *dev, size_t size, dma_addr_t *dma_handle,
170 gfp_t flag)
171 {
172 BUG();
173 return NULL;
174 }
176 static inline void
177 dma_free_coherent(struct device *dev, size_t size, void *cpu_addr,
178 dma_addr_t dma_handle)
179 {
180 BUG();
181 }
183 static inline dma_addr_t
184 dma_map_single(struct device *dev, void *cpu_addr, size_t size,
185 enum dma_data_direction direction)
186 {
187 BUG();
188 return 0;
189 }
191 static inline void
192 dma_unmap_single(struct device *dev, dma_addr_t dma_addr, size_t size,
193 enum dma_data_direction direction)
194 {
195 BUG();
196 }
198 static inline dma_addr_t
199 dma_map_page(struct device *dev, struct page *page,
200 unsigned long offset, size_t size,
201 enum dma_data_direction direction)
202 {
203 BUG();
204 return 0;
205 }
207 static inline void
208 dma_unmap_page(struct device *dev, dma_addr_t dma_address, size_t size,
209 enum dma_data_direction direction)
210 {
211 BUG();
212 }
214 static inline int
215 dma_map_sg(struct device *dev, struct scatterlist *sg, int nents,
216 enum dma_data_direction direction)
217 {
218 BUG();
219 return 0;
220 }
222 static inline void
223 dma_unmap_sg(struct device *dev, struct scatterlist *sg, int nhwentries,
224 enum dma_data_direction direction)
225 {
226 BUG();
227 }
229 static inline void
230 dma_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle, size_t size,
231 enum dma_data_direction direction)
232 {
233 BUG();
234 }
236 static inline void
237 dma_sync_single_for_device(struct device *dev, dma_addr_t dma_handle, size_t size,
238 enum dma_data_direction direction)
239 {
240 BUG();
241 }
243 static inline void
244 dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg, int nelems,
245 enum dma_data_direction direction)
246 {
247 BUG();
248 }
250 static inline void
251 dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg, int nelems,
252 enum dma_data_direction direction)
253 {
254 BUG();
255 }
257 static inline int
258 dma_error(dma_addr_t dma_addr)
259 {
260 return 0;
261 }
263 #endif
265 /* Now for the API extensions over the pci_ one */
267 #define dma_alloc_noncoherent(d, s, h, f) dma_alloc_coherent(d, s, h, f)
268 #define dma_free_noncoherent(d, s, v, h) dma_free_coherent(d, s, v, h)
269 #define dma_is_consistent(d) (1)
271 static inline int
272 dma_get_cache_alignment(void)
273 {
274 /* no easy way to get cache size on all processors, so return
275 * the maximum possible, to be safe */
276 return (1 << INTERNODE_CACHE_SHIFT);
277 }
279 static inline void
280 dma_sync_single_range_for_cpu(struct device *dev, dma_addr_t dma_handle,
281 unsigned long offset, size_t size,
282 enum dma_data_direction direction)
283 {
284 /* just sync everything, that's all the pci API can do */
285 dma_sync_single_for_cpu(dev, dma_handle, offset+size, direction);
286 }
288 static inline void
289 dma_sync_single_range_for_device(struct device *dev, dma_addr_t dma_handle,
290 unsigned long offset, size_t size,
291 enum dma_data_direction direction)
292 {
293 /* just sync everything, that's all the pci API can do */
294 dma_sync_single_for_device(dev, dma_handle, offset+size, direction);
295 }
297 static inline void
298 dma_cache_sync(void *vaddr, size_t size,
299 enum dma_data_direction direction)
300 {
301 /* could define this in terms of the dma_cache ... operations,
302 * but if you get this on a platform, you should convert the platform
303 * to using the generic device DMA API */
304 BUG();
305 }
307 #endif