1 #ifndef _ASM_X86_DMA_MAPPING_H
2 #define _ASM_X86_DMA_MAPPING_H
5 * IOMMU interface. See Documentation/DMA-mapping.txt and DMA-API.txt for
9 #include <linux/scatterlist.h>
11 #include <asm/swiotlb.h>
12 #include <asm-generic/dma-coherent.h>
14 extern dma_addr_t bad_dma_address
;
15 extern int iommu_merge
;
16 extern struct device x86_dma_fallback_dev
;
17 extern int panic_on_overflow
;
19 struct dma_mapping_ops
{
20 int (*mapping_error
)(struct device
*dev
,
22 void* (*alloc_coherent
)(struct device
*dev
, size_t size
,
23 dma_addr_t
*dma_handle
, gfp_t gfp
);
24 void (*free_coherent
)(struct device
*dev
, size_t size
,
25 void *vaddr
, dma_addr_t dma_handle
);
26 dma_addr_t (*map_single
)(struct device
*hwdev
, phys_addr_t ptr
,
27 size_t size
, int direction
);
28 void (*unmap_single
)(struct device
*dev
, dma_addr_t addr
,
29 size_t size
, int direction
);
30 void (*sync_single_for_cpu
)(struct device
*hwdev
,
31 dma_addr_t dma_handle
, size_t size
,
33 void (*sync_single_for_device
)(struct device
*hwdev
,
34 dma_addr_t dma_handle
, size_t size
,
36 void (*sync_single_range_for_cpu
)(struct device
*hwdev
,
37 dma_addr_t dma_handle
, unsigned long offset
,
38 size_t size
, int direction
);
39 void (*sync_single_range_for_device
)(struct device
*hwdev
,
40 dma_addr_t dma_handle
, unsigned long offset
,
41 size_t size
, int direction
);
42 void (*sync_sg_for_cpu
)(struct device
*hwdev
,
43 struct scatterlist
*sg
, int nelems
,
45 void (*sync_sg_for_device
)(struct device
*hwdev
,
46 struct scatterlist
*sg
, int nelems
,
48 int (*map_sg
)(struct device
*hwdev
, struct scatterlist
*sg
,
49 int nents
, int direction
);
50 void (*unmap_sg
)(struct device
*hwdev
,
51 struct scatterlist
*sg
, int nents
,
53 int (*dma_supported
)(struct device
*hwdev
, u64 mask
);
57 extern struct dma_mapping_ops
*dma_ops
;
59 static inline struct dma_mapping_ops
*get_dma_ops(struct device
*dev
)
64 if (unlikely(!dev
) || !dev
->archdata
.dma_ops
)
67 return dev
->archdata
.dma_ops
;
68 #endif /* _ASM_X86_DMA_MAPPING_H */
71 /* Make sure we keep the same behaviour */
72 static inline int dma_mapping_error(struct device
*dev
, dma_addr_t dma_addr
)
77 struct dma_mapping_ops
*ops
= get_dma_ops(dev
);
78 if (ops
->mapping_error
)
79 return ops
->mapping_error(dev
, dma_addr
);
81 return (dma_addr
== bad_dma_address
);
85 #define dma_alloc_noncoherent(d, s, h, f) dma_alloc_coherent(d, s, h, f)
86 #define dma_free_noncoherent(d, s, v, h) dma_free_coherent(d, s, v, h)
87 #define dma_is_consistent(d, h) (1)
89 extern int dma_supported(struct device
*hwdev
, u64 mask
);
90 extern int dma_set_mask(struct device
*dev
, u64 mask
);
92 extern void *dma_generic_alloc_coherent(struct device
*dev
, size_t size
,
93 dma_addr_t
*dma_addr
, gfp_t flag
);
95 static inline dma_addr_t
96 dma_map_single(struct device
*hwdev
, void *ptr
, size_t size
,
99 struct dma_mapping_ops
*ops
= get_dma_ops(hwdev
);
101 BUG_ON(!valid_dma_direction(direction
));
102 return ops
->map_single(hwdev
, virt_to_phys(ptr
), size
, direction
);
106 dma_unmap_single(struct device
*dev
, dma_addr_t addr
, size_t size
,
109 struct dma_mapping_ops
*ops
= get_dma_ops(dev
);
111 BUG_ON(!valid_dma_direction(direction
));
112 if (ops
->unmap_single
)
113 ops
->unmap_single(dev
, addr
, size
, direction
);
117 dma_map_sg(struct device
*hwdev
, struct scatterlist
*sg
,
118 int nents
, int direction
)
120 struct dma_mapping_ops
*ops
= get_dma_ops(hwdev
);
122 BUG_ON(!valid_dma_direction(direction
));
123 return ops
->map_sg(hwdev
, sg
, nents
, direction
);
127 dma_unmap_sg(struct device
*hwdev
, struct scatterlist
*sg
, int nents
,
130 struct dma_mapping_ops
*ops
= get_dma_ops(hwdev
);
132 BUG_ON(!valid_dma_direction(direction
));
134 ops
->unmap_sg(hwdev
, sg
, nents
, direction
);
138 dma_sync_single_for_cpu(struct device
*hwdev
, dma_addr_t dma_handle
,
139 size_t size
, int direction
)
141 struct dma_mapping_ops
*ops
= get_dma_ops(hwdev
);
143 BUG_ON(!valid_dma_direction(direction
));
144 if (ops
->sync_single_for_cpu
)
145 ops
->sync_single_for_cpu(hwdev
, dma_handle
, size
, direction
);
146 flush_write_buffers();
150 dma_sync_single_for_device(struct device
*hwdev
, dma_addr_t dma_handle
,
151 size_t size
, int direction
)
153 struct dma_mapping_ops
*ops
= get_dma_ops(hwdev
);
155 BUG_ON(!valid_dma_direction(direction
));
156 if (ops
->sync_single_for_device
)
157 ops
->sync_single_for_device(hwdev
, dma_handle
, size
, direction
);
158 flush_write_buffers();
162 dma_sync_single_range_for_cpu(struct device
*hwdev
, dma_addr_t dma_handle
,
163 unsigned long offset
, size_t size
, int direction
)
165 struct dma_mapping_ops
*ops
= get_dma_ops(hwdev
);
167 BUG_ON(!valid_dma_direction(direction
));
168 if (ops
->sync_single_range_for_cpu
)
169 ops
->sync_single_range_for_cpu(hwdev
, dma_handle
, offset
,
171 flush_write_buffers();
175 dma_sync_single_range_for_device(struct device
*hwdev
, dma_addr_t dma_handle
,
176 unsigned long offset
, size_t size
,
179 struct dma_mapping_ops
*ops
= get_dma_ops(hwdev
);
181 BUG_ON(!valid_dma_direction(direction
));
182 if (ops
->sync_single_range_for_device
)
183 ops
->sync_single_range_for_device(hwdev
, dma_handle
,
184 offset
, size
, direction
);
185 flush_write_buffers();
189 dma_sync_sg_for_cpu(struct device
*hwdev
, struct scatterlist
*sg
,
190 int nelems
, int direction
)
192 struct dma_mapping_ops
*ops
= get_dma_ops(hwdev
);
194 BUG_ON(!valid_dma_direction(direction
));
195 if (ops
->sync_sg_for_cpu
)
196 ops
->sync_sg_for_cpu(hwdev
, sg
, nelems
, direction
);
197 flush_write_buffers();
201 dma_sync_sg_for_device(struct device
*hwdev
, struct scatterlist
*sg
,
202 int nelems
, int direction
)
204 struct dma_mapping_ops
*ops
= get_dma_ops(hwdev
);
206 BUG_ON(!valid_dma_direction(direction
));
207 if (ops
->sync_sg_for_device
)
208 ops
->sync_sg_for_device(hwdev
, sg
, nelems
, direction
);
210 flush_write_buffers();
213 static inline dma_addr_t
dma_map_page(struct device
*dev
, struct page
*page
,
214 size_t offset
, size_t size
,
217 struct dma_mapping_ops
*ops
= get_dma_ops(dev
);
219 BUG_ON(!valid_dma_direction(direction
));
220 return ops
->map_single(dev
, page_to_phys(page
) + offset
,
224 static inline void dma_unmap_page(struct device
*dev
, dma_addr_t addr
,
225 size_t size
, int direction
)
227 dma_unmap_single(dev
, addr
, size
, direction
);
231 dma_cache_sync(struct device
*dev
, void *vaddr
, size_t size
,
232 enum dma_data_direction dir
)
234 flush_write_buffers();
237 static inline int dma_get_cache_alignment(void)
239 /* no easy way to get cache size on all x86, so return the
240 * maximum possible, to be safe */
241 return boot_cpu_data
.x86_clflush_size
;
244 static inline unsigned long dma_alloc_coherent_mask(struct device
*dev
,
247 unsigned long dma_mask
= 0;
249 dma_mask
= dev
->coherent_dma_mask
;
251 dma_mask
= (gfp
& GFP_DMA
) ? DMA_24BIT_MASK
: DMA_32BIT_MASK
;
256 static inline gfp_t
dma_alloc_coherent_gfp_flags(struct device
*dev
, gfp_t gfp
)
258 unsigned long dma_mask
= dma_alloc_coherent_mask(dev
, gfp
);
260 if (dma_mask
<= DMA_24BIT_MASK
)
263 if (dma_mask
<= DMA_32BIT_MASK
&& !(gfp
& GFP_DMA
))
270 dma_alloc_coherent(struct device
*dev
, size_t size
, dma_addr_t
*dma_handle
,
273 struct dma_mapping_ops
*ops
= get_dma_ops(dev
);
276 gfp
&= ~(__GFP_DMA
| __GFP_HIGHMEM
| __GFP_DMA32
);
278 if (dma_alloc_from_coherent(dev
, size
, dma_handle
, &memory
))
282 dev
= &x86_dma_fallback_dev
;
286 if (!is_device_dma_capable(dev
))
289 if (!ops
->alloc_coherent
)
292 return ops
->alloc_coherent(dev
, size
, dma_handle
,
293 dma_alloc_coherent_gfp_flags(dev
, gfp
));
296 static inline void dma_free_coherent(struct device
*dev
, size_t size
,
297 void *vaddr
, dma_addr_t bus
)
299 struct dma_mapping_ops
*ops
= get_dma_ops(dev
);
301 WARN_ON(irqs_disabled()); /* for portability */
303 if (dma_release_from_coherent(dev
, get_order(size
), vaddr
))
306 if (ops
->free_coherent
)
307 ops
->free_coherent(dev
, size
, vaddr
, bus
);