blob: 2f858a2df94a8e2f3d4b33eba0b4731c31a27216 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001#ifndef _ASM_SPARC64_DMA_MAPPING_H
2#define _ASM_SPARC64_DMA_MAPPING_H
3
Linus Torvalds1da177e2005-04-16 15:20:36 -07004
5#ifdef CONFIG_PCI
David S. Miller42f14232006-05-23 02:07:22 -07006
7/* we implement the API below in terms of the existing PCI one,
8 * so include it */
9#include <linux/pci.h>
10/* need struct page definitions */
11#include <linux/mm.h>
12
13static inline int
14dma_supported(struct device *dev, u64 mask)
15{
16 BUG_ON(dev->bus != &pci_bus_type);
17
18 return pci_dma_supported(to_pci_dev(dev), mask);
19}
20
21static inline int
22dma_set_mask(struct device *dev, u64 dma_mask)
23{
24 BUG_ON(dev->bus != &pci_bus_type);
25
26 return pci_set_dma_mask(to_pci_dev(dev), dma_mask);
27}
28
29static inline void *
30dma_alloc_coherent(struct device *dev, size_t size, dma_addr_t *dma_handle,
31 gfp_t flag)
32{
33 BUG_ON(dev->bus != &pci_bus_type);
34
35 return pci_iommu_ops->alloc_consistent(to_pci_dev(dev), size, dma_handle, flag);
36}
37
38static inline void
39dma_free_coherent(struct device *dev, size_t size, void *cpu_addr,
40 dma_addr_t dma_handle)
41{
42 BUG_ON(dev->bus != &pci_bus_type);
43
44 pci_free_consistent(to_pci_dev(dev), size, cpu_addr, dma_handle);
45}
46
47static inline dma_addr_t
48dma_map_single(struct device *dev, void *cpu_addr, size_t size,
49 enum dma_data_direction direction)
50{
51 BUG_ON(dev->bus != &pci_bus_type);
52
53 return pci_map_single(to_pci_dev(dev), cpu_addr, size, (int)direction);
54}
55
56static inline void
57dma_unmap_single(struct device *dev, dma_addr_t dma_addr, size_t size,
58 enum dma_data_direction direction)
59{
60 BUG_ON(dev->bus != &pci_bus_type);
61
62 pci_unmap_single(to_pci_dev(dev), dma_addr, size, (int)direction);
63}
64
65static inline dma_addr_t
66dma_map_page(struct device *dev, struct page *page,
67 unsigned long offset, size_t size,
68 enum dma_data_direction direction)
69{
70 BUG_ON(dev->bus != &pci_bus_type);
71
72 return pci_map_page(to_pci_dev(dev), page, offset, size, (int)direction);
73}
74
75static inline void
76dma_unmap_page(struct device *dev, dma_addr_t dma_address, size_t size,
77 enum dma_data_direction direction)
78{
79 BUG_ON(dev->bus != &pci_bus_type);
80
81 pci_unmap_page(to_pci_dev(dev), dma_address, size, (int)direction);
82}
83
84static inline int
85dma_map_sg(struct device *dev, struct scatterlist *sg, int nents,
86 enum dma_data_direction direction)
87{
88 BUG_ON(dev->bus != &pci_bus_type);
89
90 return pci_map_sg(to_pci_dev(dev), sg, nents, (int)direction);
91}
92
93static inline void
94dma_unmap_sg(struct device *dev, struct scatterlist *sg, int nhwentries,
95 enum dma_data_direction direction)
96{
97 BUG_ON(dev->bus != &pci_bus_type);
98
99 pci_unmap_sg(to_pci_dev(dev), sg, nhwentries, (int)direction);
100}
101
102static inline void
103dma_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle, size_t size,
104 enum dma_data_direction direction)
105{
106 BUG_ON(dev->bus != &pci_bus_type);
107
108 pci_dma_sync_single_for_cpu(to_pci_dev(dev), dma_handle,
109 size, (int)direction);
110}
111
112static inline void
113dma_sync_single_for_device(struct device *dev, dma_addr_t dma_handle, size_t size,
114 enum dma_data_direction direction)
115{
116 BUG_ON(dev->bus != &pci_bus_type);
117
118 pci_dma_sync_single_for_device(to_pci_dev(dev), dma_handle,
119 size, (int)direction);
120}
121
122static inline void
123dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg, int nelems,
124 enum dma_data_direction direction)
125{
126 BUG_ON(dev->bus != &pci_bus_type);
127
128 pci_dma_sync_sg_for_cpu(to_pci_dev(dev), sg, nelems, (int)direction);
129}
130
131static inline void
132dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg, int nelems,
133 enum dma_data_direction direction)
134{
135 BUG_ON(dev->bus != &pci_bus_type);
136
137 pci_dma_sync_sg_for_device(to_pci_dev(dev), sg, nelems, (int)direction);
138}
139
140static inline int
141dma_mapping_error(dma_addr_t dma_addr)
142{
143 return pci_dma_mapping_error(dma_addr);
144}
145
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146#else
147
148struct device;
149
150static inline void *dma_alloc_coherent(struct device *dev, size_t size,
Al Viro970a9e72005-10-21 03:21:53 -0400151 dma_addr_t *dma_handle, gfp_t flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152{
153 BUG();
154 return NULL;
155}
156
157static inline void dma_free_coherent(struct device *dev, size_t size,
158 void *vaddr, dma_addr_t dma_handle)
159{
160 BUG();
161}
162
Randy Dunlap72335892006-07-05 20:18:39 -0700163static inline void
164dma_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle, size_t size,
165 enum dma_data_direction direction)
166{
167 BUG();
168}
169
170static inline void
171dma_sync_single_for_device(struct device *dev, dma_addr_t dma_handle, size_t size,
172 enum dma_data_direction direction)
173{
174 BUG();
175}
176
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177#endif /* PCI */
178
David S. Miller36321422006-06-25 02:07:52 -0700179
180/* Now for the API extensions over the pci_ one */
181
182#define dma_alloc_noncoherent(d, s, h, f) dma_alloc_coherent(d, s, h, f)
183#define dma_free_noncoherent(d, s, v, h) dma_free_coherent(d, s, v, h)
Ralf Baechlef67637e2006-12-06 20:38:54 -0800184#define dma_is_consistent(d, h) (1)
David S. Miller36321422006-06-25 02:07:52 -0700185
186static inline int
187dma_get_cache_alignment(void)
188{
189 /* no easy way to get cache size on all processors, so return
190 * the maximum possible, to be safe */
191 return (1 << INTERNODE_CACHE_SHIFT);
192}
193
194static inline void
195dma_sync_single_range_for_cpu(struct device *dev, dma_addr_t dma_handle,
196 unsigned long offset, size_t size,
197 enum dma_data_direction direction)
198{
199 /* just sync everything, that's all the pci API can do */
200 dma_sync_single_for_cpu(dev, dma_handle, offset+size, direction);
201}
202
203static inline void
204dma_sync_single_range_for_device(struct device *dev, dma_addr_t dma_handle,
205 unsigned long offset, size_t size,
206 enum dma_data_direction direction)
207{
208 /* just sync everything, that's all the pci API can do */
209 dma_sync_single_for_device(dev, dma_handle, offset+size, direction);
210}
211
212static inline void
Ralf Baechled3fa72e2006-12-06 20:38:56 -0800213dma_cache_sync(struct device *dev, void *vaddr, size_t size,
David S. Miller36321422006-06-25 02:07:52 -0700214 enum dma_data_direction direction)
215{
216 /* could define this in terms of the dma_cache ... operations,
217 * but if you get this on a platform, you should convert the platform
218 * to using the generic device DMA API */
219 BUG();
220}
221
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222#endif /* _ASM_SPARC64_DMA_MAPPING_H */