1 #ifndef ASMARM_DMA_MAPPING_H
2 #define ASMARM_DMA_MAPPING_H
6 #include <linux/mm_types.h>
7 #include <linux/scatterlist.h>
8 #include <linux/dma-attrs.h>
9 #include <linux/dma-debug.h>
11 #include <asm-generic/dma-coherent.h>
12 #include <asm/memory.h>
14 #define DMA_ERROR_CODE (~0)
15 extern struct dma_map_ops arm_dma_ops
;
17 static inline struct dma_map_ops
*get_dma_ops(struct device
*dev
)
19 if (dev
&& dev
->archdata
.dma_ops
)
20 return dev
->archdata
.dma_ops
;
24 static inline void set_dma_ops(struct device
*dev
, struct dma_map_ops
*ops
)
27 dev
->archdata
.dma_ops
= ops
;
30 #include <asm-generic/dma-mapping-common.h>
32 static inline int dma_set_mask(struct device
*dev
, u64 mask
)
34 return get_dma_ops(dev
)->set_dma_mask(dev
, mask
);
37 #ifdef __arch_page_to_dma
38 #error Please update to __arch_pfn_to_dma
42 * dma_to_pfn/pfn_to_dma/dma_to_virt/virt_to_dma are architecture private
43 * functions used internally by the DMA-mapping API to provide DMA
44 * addresses. They must not be used by drivers.
46 #ifndef __arch_pfn_to_dma
47 static inline dma_addr_t
pfn_to_dma(struct device
*dev
, unsigned long pfn
)
49 return (dma_addr_t
)__pfn_to_bus(pfn
);
52 static inline unsigned long dma_to_pfn(struct device
*dev
, dma_addr_t addr
)
54 return __bus_to_pfn(addr
);
57 static inline void *dma_to_virt(struct device
*dev
, dma_addr_t addr
)
59 return (void *)__bus_to_virt((unsigned long)addr
);
62 static inline dma_addr_t
virt_to_dma(struct device
*dev
, void *addr
)
64 return (dma_addr_t
)__virt_to_bus((unsigned long)(addr
));
67 static inline dma_addr_t
pfn_to_dma(struct device
*dev
, unsigned long pfn
)
69 return __arch_pfn_to_dma(dev
, pfn
);
72 static inline unsigned long dma_to_pfn(struct device
*dev
, dma_addr_t addr
)
74 return __arch_dma_to_pfn(dev
, addr
);
77 static inline void *dma_to_virt(struct device
*dev
, dma_addr_t addr
)
79 return __arch_dma_to_virt(dev
, addr
);
82 static inline dma_addr_t
virt_to_dma(struct device
*dev
, void *addr
)
84 return __arch_virt_to_dma(dev
, addr
);
89 * DMA errors are defined by all-bits-set in the DMA address.
91 static inline int dma_mapping_error(struct device
*dev
, dma_addr_t dma_addr
)
93 return dma_addr
== DMA_ERROR_CODE
;
97 * Dummy noncoherent implementation. We don't provide a dma_cache_sync
98 * function so drivers using this API are highlighted with build warnings.
100 static inline void *dma_alloc_noncoherent(struct device
*dev
, size_t size
,
101 dma_addr_t
*handle
, gfp_t gfp
)
106 static inline void dma_free_noncoherent(struct device
*dev
, size_t size
,
107 void *cpu_addr
, dma_addr_t handle
)
111 extern int dma_supported(struct device
*dev
, u64 mask
);
114 * arm_dma_alloc - allocate consistent memory for DMA
115 * @dev: valid struct device pointer, or NULL for ISA and EISA-like devices
116 * @size: required memory size
117 * @handle: bus-specific DMA address
118 * @attrs: optinal attributes that specific mapping properties
120 * Allocate some memory for a device for performing DMA. This function
121 * allocates pages, and will return the CPU-viewed address, and sets @handle
122 * to be the device-viewed address.
124 extern void *arm_dma_alloc(struct device
*dev
, size_t size
, dma_addr_t
*handle
,
125 gfp_t gfp
, struct dma_attrs
*attrs
);
127 #define dma_alloc_coherent(d, s, h, f) dma_alloc_attrs(d, s, h, f, NULL)
129 static inline void *dma_alloc_attrs(struct device
*dev
, size_t size
,
130 dma_addr_t
*dma_handle
, gfp_t flag
,
131 struct dma_attrs
*attrs
)
133 struct dma_map_ops
*ops
= get_dma_ops(dev
);
137 cpu_addr
= ops
->alloc(dev
, size
, dma_handle
, flag
, attrs
);
138 debug_dma_alloc_coherent(dev
, size
, *dma_handle
, cpu_addr
);
143 * arm_dma_free - free memory allocated by arm_dma_alloc
144 * @dev: valid struct device pointer, or NULL for ISA and EISA-like devices
145 * @size: size of memory originally requested in dma_alloc_coherent
146 * @cpu_addr: CPU-view address returned from dma_alloc_coherent
147 * @handle: device-view address returned from dma_alloc_coherent
148 * @attrs: optinal attributes that specific mapping properties
150 * Free (and unmap) a DMA buffer previously allocated by
153 * References to memory and mappings associated with cpu_addr/handle
154 * during and after this call executing are illegal.
156 extern void arm_dma_free(struct device
*dev
, size_t size
, void *cpu_addr
,
157 dma_addr_t handle
, struct dma_attrs
*attrs
);
159 #define dma_free_coherent(d, s, c, h) dma_free_attrs(d, s, c, h, NULL)
161 static inline void dma_free_attrs(struct device
*dev
, size_t size
,
162 void *cpu_addr
, dma_addr_t dma_handle
,
163 struct dma_attrs
*attrs
)
165 struct dma_map_ops
*ops
= get_dma_ops(dev
);
168 debug_dma_free_coherent(dev
, size
, cpu_addr
, dma_handle
);
169 ops
->free(dev
, size
, cpu_addr
, dma_handle
, attrs
);
173 * arm_dma_mmap - map a coherent DMA allocation into user space
174 * @dev: valid struct device pointer, or NULL for ISA and EISA-like devices
175 * @vma: vm_area_struct describing requested user mapping
176 * @cpu_addr: kernel CPU-view address returned from dma_alloc_coherent
177 * @handle: device-view address returned from dma_alloc_coherent
178 * @size: size of memory originally requested in dma_alloc_coherent
179 * @attrs: optinal attributes that specific mapping properties
181 * Map a coherent DMA buffer previously allocated by dma_alloc_coherent
182 * into user space. The coherent DMA buffer must not be freed by the
183 * driver until the user space mapping has been released.
185 extern int arm_dma_mmap(struct device
*dev
, struct vm_area_struct
*vma
,
186 void *cpu_addr
, dma_addr_t dma_addr
, size_t size
,
187 struct dma_attrs
*attrs
);
189 #define dma_mmap_coherent(d, v, c, h, s) dma_mmap_attrs(d, v, c, h, s, NULL)
191 static inline int dma_mmap_attrs(struct device
*dev
, struct vm_area_struct
*vma
,
192 void *cpu_addr
, dma_addr_t dma_addr
,
193 size_t size
, struct dma_attrs
*attrs
)
195 struct dma_map_ops
*ops
= get_dma_ops(dev
);
197 return ops
->mmap(dev
, vma
, cpu_addr
, dma_addr
, size
, attrs
);
200 static inline void *dma_alloc_writecombine(struct device
*dev
, size_t size
,
201 dma_addr_t
*dma_handle
, gfp_t flag
)
203 DEFINE_DMA_ATTRS(attrs
);
204 dma_set_attr(DMA_ATTR_WRITE_COMBINE
, &attrs
);
205 return dma_alloc_attrs(dev
, size
, dma_handle
, flag
, &attrs
);
208 static inline void dma_free_writecombine(struct device
*dev
, size_t size
,
209 void *cpu_addr
, dma_addr_t dma_handle
)
211 DEFINE_DMA_ATTRS(attrs
);
212 dma_set_attr(DMA_ATTR_WRITE_COMBINE
, &attrs
);
213 return dma_free_attrs(dev
, size
, cpu_addr
, dma_handle
, &attrs
);
216 static inline int dma_mmap_writecombine(struct device
*dev
, struct vm_area_struct
*vma
,
217 void *cpu_addr
, dma_addr_t dma_addr
, size_t size
)
219 DEFINE_DMA_ATTRS(attrs
);
220 dma_set_attr(DMA_ATTR_WRITE_COMBINE
, &attrs
);
221 return dma_mmap_attrs(dev
, vma
, cpu_addr
, dma_addr
, size
, &attrs
);
225 * This can be called during boot to increase the size of the consistent
226 * DMA region above it's default value of 2MB. It must be called before the
227 * memory allocator is initialised, i.e. before any core_initcall.
229 extern void __init
init_consistent_dma_size(unsigned long size
);
232 * For SA-1111, IXP425, and ADI systems the dma-mapping functions are "magic"
233 * and utilize bounce buffers as needed to work around limited DMA windows.
235 * On the SA-1111, a bug limits DMA to only certain regions of RAM.
236 * On the IXP425, the PCI inbound window is 64MB (256MB total RAM)
237 * On some ADI engineering systems, PCI inbound window is 32MB (12MB total RAM)
239 * The following are helper functions used by the dmabounce subystem
244 * dmabounce_register_dev
246 * @dev: valid struct device pointer
247 * @small_buf_size: size of buffers to use with small buffer pool
248 * @large_buf_size: size of buffers to use with large buffer pool (can be 0)
249 * @needs_bounce_fn: called to determine whether buffer needs bouncing
251 * This function should be called by low-level platform code to register
252 * a device as requireing DMA buffer bouncing. The function will allocate
253 * appropriate DMA pools for the device.
255 extern int dmabounce_register_dev(struct device
*, unsigned long,
256 unsigned long, int (*)(struct device
*, dma_addr_t
, size_t));
259 * dmabounce_unregister_dev
261 * @dev: valid struct device pointer
263 * This function should be called by low-level platform code when device
264 * that was previously registered with dmabounce_register_dev is removed
268 extern void dmabounce_unregister_dev(struct device
*);
273 * The scatter list versions of the above methods.
275 extern int arm_dma_map_sg(struct device
*, struct scatterlist
*, int,
276 enum dma_data_direction
, struct dma_attrs
*attrs
);
277 extern void arm_dma_unmap_sg(struct device
*, struct scatterlist
*, int,
278 enum dma_data_direction
, struct dma_attrs
*attrs
);
279 extern void arm_dma_sync_sg_for_cpu(struct device
*, struct scatterlist
*, int,
280 enum dma_data_direction
);
281 extern void arm_dma_sync_sg_for_device(struct device
*, struct scatterlist
*, int,
282 enum dma_data_direction
);
284 #endif /* __KERNEL__ */
This page took 0.037043 seconds and 6 git commands to generate.