aboutsummaryrefslogtreecommitdiffstats
path: root/include/asm-x86/dma-mapping_64.h
diff options
context:
space:
mode:
Diffstat (limited to 'include/asm-x86/dma-mapping_64.h')
-rw-r--r--include/asm-x86/dma-mapping_64.h203
1 files changed, 203 insertions, 0 deletions
diff --git a/include/asm-x86/dma-mapping_64.h b/include/asm-x86/dma-mapping_64.h
new file mode 100644
index 000000000000..6897e2a436e5
--- /dev/null
+++ b/include/asm-x86/dma-mapping_64.h
@@ -0,0 +1,203 @@
1#ifndef _X8664_DMA_MAPPING_H
2#define _X8664_DMA_MAPPING_H 1
3
4/*
5 * IOMMU interface. See Documentation/DMA-mapping.txt and DMA-API.txt for
6 * documentation.
7 */
8
9
10#include <asm/scatterlist.h>
11#include <asm/io.h>
12#include <asm/swiotlb.h>
13
14struct dma_mapping_ops {
15 int (*mapping_error)(dma_addr_t dma_addr);
16 void* (*alloc_coherent)(struct device *dev, size_t size,
17 dma_addr_t *dma_handle, gfp_t gfp);
18 void (*free_coherent)(struct device *dev, size_t size,
19 void *vaddr, dma_addr_t dma_handle);
20 dma_addr_t (*map_single)(struct device *hwdev, void *ptr,
21 size_t size, int direction);
22 /* like map_single, but doesn't check the device mask */
23 dma_addr_t (*map_simple)(struct device *hwdev, char *ptr,
24 size_t size, int direction);
25 void (*unmap_single)(struct device *dev, dma_addr_t addr,
26 size_t size, int direction);
27 void (*sync_single_for_cpu)(struct device *hwdev,
28 dma_addr_t dma_handle, size_t size,
29 int direction);
30 void (*sync_single_for_device)(struct device *hwdev,
31 dma_addr_t dma_handle, size_t size,
32 int direction);
33 void (*sync_single_range_for_cpu)(struct device *hwdev,
34 dma_addr_t dma_handle, unsigned long offset,
35 size_t size, int direction);
36 void (*sync_single_range_for_device)(struct device *hwdev,
37 dma_addr_t dma_handle, unsigned long offset,
38 size_t size, int direction);
39 void (*sync_sg_for_cpu)(struct device *hwdev,
40 struct scatterlist *sg, int nelems,
41 int direction);
42 void (*sync_sg_for_device)(struct device *hwdev,
43 struct scatterlist *sg, int nelems,
44 int direction);
45 int (*map_sg)(struct device *hwdev, struct scatterlist *sg,
46 int nents, int direction);
47 void (*unmap_sg)(struct device *hwdev,
48 struct scatterlist *sg, int nents,
49 int direction);
50 int (*dma_supported)(struct device *hwdev, u64 mask);
51 int is_phys;
52};
53
54extern dma_addr_t bad_dma_address;
55extern const struct dma_mapping_ops* dma_ops;
56extern int iommu_merge;
57
58static inline int dma_mapping_error(dma_addr_t dma_addr)
59{
60 if (dma_ops->mapping_error)
61 return dma_ops->mapping_error(dma_addr);
62
63 return (dma_addr == bad_dma_address);
64}
65
66#define dma_alloc_noncoherent(d, s, h, f) dma_alloc_coherent(d, s, h, f)
67#define dma_free_noncoherent(d, s, v, h) dma_free_coherent(d, s, v, h)
68
69#define dma_alloc_noncoherent(d, s, h, f) dma_alloc_coherent(d, s, h, f)
70#define dma_free_noncoherent(d, s, v, h) dma_free_coherent(d, s, v, h)
71
72extern void *dma_alloc_coherent(struct device *dev, size_t size,
73 dma_addr_t *dma_handle, gfp_t gfp);
74extern void dma_free_coherent(struct device *dev, size_t size, void *vaddr,
75 dma_addr_t dma_handle);
76
77static inline dma_addr_t
78dma_map_single(struct device *hwdev, void *ptr, size_t size,
79 int direction)
80{
81 BUG_ON(!valid_dma_direction(direction));
82 return dma_ops->map_single(hwdev, ptr, size, direction);
83}
84
85static inline void
86dma_unmap_single(struct device *dev, dma_addr_t addr,size_t size,
87 int direction)
88{
89 BUG_ON(!valid_dma_direction(direction));
90 dma_ops->unmap_single(dev, addr, size, direction);
91}
92
93#define dma_map_page(dev,page,offset,size,dir) \
94 dma_map_single((dev), page_address(page)+(offset), (size), (dir))
95
96#define dma_unmap_page dma_unmap_single
97
98static inline void
99dma_sync_single_for_cpu(struct device *hwdev, dma_addr_t dma_handle,
100 size_t size, int direction)
101{
102 BUG_ON(!valid_dma_direction(direction));
103 if (dma_ops->sync_single_for_cpu)
104 dma_ops->sync_single_for_cpu(hwdev, dma_handle, size,
105 direction);
106 flush_write_buffers();
107}
108
109static inline void
110dma_sync_single_for_device(struct device *hwdev, dma_addr_t dma_handle,
111 size_t size, int direction)
112{
113 BUG_ON(!valid_dma_direction(direction));
114 if (dma_ops->sync_single_for_device)
115 dma_ops->sync_single_for_device(hwdev, dma_handle, size,
116 direction);
117 flush_write_buffers();
118}
119
120static inline void
121dma_sync_single_range_for_cpu(struct device *hwdev, dma_addr_t dma_handle,
122 unsigned long offset, size_t size, int direction)
123{
124 BUG_ON(!valid_dma_direction(direction));
125 if (dma_ops->sync_single_range_for_cpu) {
126 dma_ops->sync_single_range_for_cpu(hwdev, dma_handle, offset, size, direction);
127 }
128
129 flush_write_buffers();
130}
131
132static inline void
133dma_sync_single_range_for_device(struct device *hwdev, dma_addr_t dma_handle,
134 unsigned long offset, size_t size, int direction)
135{
136 BUG_ON(!valid_dma_direction(direction));
137 if (dma_ops->sync_single_range_for_device)
138 dma_ops->sync_single_range_for_device(hwdev, dma_handle,
139 offset, size, direction);
140
141 flush_write_buffers();
142}
143
144static inline void
145dma_sync_sg_for_cpu(struct device *hwdev, struct scatterlist *sg,
146 int nelems, int direction)
147{
148 BUG_ON(!valid_dma_direction(direction));
149 if (dma_ops->sync_sg_for_cpu)
150 dma_ops->sync_sg_for_cpu(hwdev, sg, nelems, direction);
151 flush_write_buffers();
152}
153
154static inline void
155dma_sync_sg_for_device(struct device *hwdev, struct scatterlist *sg,
156 int nelems, int direction)
157{
158 BUG_ON(!valid_dma_direction(direction));
159 if (dma_ops->sync_sg_for_device) {
160 dma_ops->sync_sg_for_device(hwdev, sg, nelems, direction);
161 }
162
163 flush_write_buffers();
164}
165
166static inline int
167dma_map_sg(struct device *hwdev, struct scatterlist *sg, int nents, int direction)
168{
169 BUG_ON(!valid_dma_direction(direction));
170 return dma_ops->map_sg(hwdev, sg, nents, direction);
171}
172
173static inline void
174dma_unmap_sg(struct device *hwdev, struct scatterlist *sg, int nents,
175 int direction)
176{
177 BUG_ON(!valid_dma_direction(direction));
178 dma_ops->unmap_sg(hwdev, sg, nents, direction);
179}
180
181extern int dma_supported(struct device *hwdev, u64 mask);
182
183/* same for gart, swiotlb, and nommu */
184static inline int dma_get_cache_alignment(void)
185{
186 return boot_cpu_data.x86_clflush_size;
187}
188
189#define dma_is_consistent(d, h) 1
190
191extern int dma_set_mask(struct device *dev, u64 mask);
192
193static inline void
194dma_cache_sync(struct device *dev, void *vaddr, size_t size,
195 enum dma_data_direction dir)
196{
197 flush_write_buffers();
198}
199
200extern struct device fallback_dev;
201extern int panic_on_overflow;
202
203#endif /* _X8664_DMA_MAPPING_H */
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-26 11:33:56 -0500