Branch data Line data Source code
1 : : /* SPDX-License-Identifier: GPL-2.0 */
2 : : #ifndef _LINUX_DMA_MAPPING_H
3 : : #define _LINUX_DMA_MAPPING_H
4 : :
5 : : #include <linux/sizes.h>
6 : : #include <linux/string.h>
7 : : #include <linux/device.h>
8 : : #include <linux/err.h>
9 : : #include <linux/dma-debug.h>
10 : : #include <linux/dma-direction.h>
11 : : #include <linux/scatterlist.h>
12 : : #include <linux/bug.h>
13 : : #include <linux/mem_encrypt.h>
14 : : #include <linux/instr.h>
15 : :
16 : : /**
17 : : * List of possible attributes associated with a DMA mapping. The semantics
18 : : * of each attribute should be defined in Documentation/DMA-attributes.txt.
19 : : */
20 : :
21 : : /*
22 : : * DMA_ATTR_WEAK_ORDERING: Specifies that reads and writes to the mapping
23 : : * may be weakly ordered, that is that reads and writes may pass each other.
24 : : */
25 : : #define DMA_ATTR_WEAK_ORDERING (1UL << 1)
26 : : /*
27 : : * DMA_ATTR_WRITE_COMBINE: Specifies that writes to the mapping may be
28 : : * buffered to improve performance.
29 : : */
30 : : #define DMA_ATTR_WRITE_COMBINE (1UL << 2)
31 : : /*
32 : : * DMA_ATTR_NON_CONSISTENT: Lets the platform to choose to return either
33 : : * consistent or non-consistent memory as it sees fit.
34 : : */
35 : : #define DMA_ATTR_NON_CONSISTENT (1UL << 3)
36 : : /*
37 : : * DMA_ATTR_NO_KERNEL_MAPPING: Lets the platform to avoid creating a kernel
38 : : * virtual mapping for the allocated buffer.
39 : : */
40 : : #define DMA_ATTR_NO_KERNEL_MAPPING (1UL << 4)
41 : : /*
42 : : * DMA_ATTR_SKIP_CPU_SYNC: Allows platform code to skip synchronization of
43 : : * the CPU cache for the given buffer assuming that it has been already
44 : : * transferred to 'device' domain.
45 : : */
46 : : #define DMA_ATTR_SKIP_CPU_SYNC (1UL << 5)
47 : : /*
48 : : * DMA_ATTR_FORCE_CONTIGUOUS: Forces contiguous allocation of the buffer
49 : : * in physical memory.
50 : : */
51 : : #define DMA_ATTR_FORCE_CONTIGUOUS (1UL << 6)
52 : : /*
53 : : * DMA_ATTR_ALLOC_SINGLE_PAGES: This is a hint to the DMA-mapping subsystem
54 : : * that it's probably not worth the time to try to allocate memory to in a way
55 : : * that gives better TLB efficiency.
56 : : */
57 : : #define DMA_ATTR_ALLOC_SINGLE_PAGES (1UL << 7)
58 : : /*
59 : : * DMA_ATTR_NO_WARN: This tells the DMA-mapping subsystem to suppress
60 : : * allocation failure reports (similarly to __GFP_NOWARN).
61 : : */
62 : : #define DMA_ATTR_NO_WARN (1UL << 8)
63 : :
64 : : /*
65 : : * DMA_ATTR_PRIVILEGED: used to indicate that the buffer is fully
66 : : * accessible at an elevated privilege level (and ideally inaccessible or
67 : : * at least read-only at lesser-privileged levels).
68 : : */
69 : : #define DMA_ATTR_PRIVILEGED (1UL << 9)
70 : :
71 : : /*
72 : : * A dma_addr_t can hold any valid DMA or bus address for the platform.
73 : : * It can be given to a device to use as a DMA source or target. A CPU cannot
74 : : * reference a dma_addr_t directly because there may be translation between
75 : : * its physical address space and the bus address space.
76 : : */
77 : : struct dma_map_ops {
78 : : void* (*alloc)(struct device *dev, size_t size,
79 : : dma_addr_t *dma_handle, gfp_t gfp,
80 : : unsigned long attrs);
81 : : void (*free)(struct device *dev, size_t size,
82 : : void *vaddr, dma_addr_t dma_handle,
83 : : unsigned long attrs);
84 : : int (*mmap)(struct device *, struct vm_area_struct *,
85 : : void *, dma_addr_t, size_t,
86 : : unsigned long attrs);
87 : :
88 : : int (*get_sgtable)(struct device *dev, struct sg_table *sgt, void *,
89 : : dma_addr_t, size_t, unsigned long attrs);
90 : :
91 : : dma_addr_t (*map_page)(struct device *dev, struct page *page,
92 : : unsigned long offset, size_t size,
93 : : enum dma_data_direction dir,
94 : : unsigned long attrs);
95 : : void (*unmap_page)(struct device *dev, dma_addr_t dma_handle,
96 : : size_t size, enum dma_data_direction dir,
97 : : unsigned long attrs);
98 : : /*
99 : : * map_sg returns 0 on error and a value > 0 on success.
100 : : * It should never return a value < 0.
101 : : */
102 : : int (*map_sg)(struct device *dev, struct scatterlist *sg,
103 : : int nents, enum dma_data_direction dir,
104 : : unsigned long attrs);
105 : : void (*unmap_sg)(struct device *dev,
106 : : struct scatterlist *sg, int nents,
107 : : enum dma_data_direction dir,
108 : : unsigned long attrs);
109 : : dma_addr_t (*map_resource)(struct device *dev, phys_addr_t phys_addr,
110 : : size_t size, enum dma_data_direction dir,
111 : : unsigned long attrs);
112 : : void (*unmap_resource)(struct device *dev, dma_addr_t dma_handle,
113 : : size_t size, enum dma_data_direction dir,
114 : : unsigned long attrs);
115 : : void (*sync_single_for_cpu)(struct device *dev,
116 : : dma_addr_t dma_handle, size_t size,
117 : : enum dma_data_direction dir);
118 : : void (*sync_single_for_device)(struct device *dev,
119 : : dma_addr_t dma_handle, size_t size,
120 : : enum dma_data_direction dir);
121 : : void (*sync_sg_for_cpu)(struct device *dev,
122 : : struct scatterlist *sg, int nents,
123 : : enum dma_data_direction dir);
124 : : void (*sync_sg_for_device)(struct device *dev,
125 : : struct scatterlist *sg, int nents,
126 : : enum dma_data_direction dir);
127 : : void (*cache_sync)(struct device *dev, void *vaddr, size_t size,
128 : : enum dma_data_direction direction);
129 : : int (*dma_supported)(struct device *dev, u64 mask);
130 : : u64 (*get_required_mask)(struct device *dev);
131 : : size_t (*max_mapping_size)(struct device *dev);
132 : : unsigned long (*get_merge_boundary)(struct device *dev);
133 : : };
134 : :
135 : : #define DMA_MAPPING_ERROR (~(dma_addr_t)0)
136 : :
137 : : extern const struct dma_map_ops dma_virt_ops;
138 : : extern const struct dma_map_ops dma_dummy_ops;
139 : :
140 : : #define DMA_BIT_MASK(n) (((n) == 64) ? ~0ULL : ((1ULL<<(n))-1))
141 : :
142 : : #define DMA_MASK_NONE 0x0ULL
143 : :
144 : 55974 : static inline int valid_dma_direction(int dma_direction)
145 : : {
146 [ # # ]: 55974 : return ((dma_direction == DMA_BIDIRECTIONAL) ||
147 : : (dma_direction == DMA_TO_DEVICE) ||
148 : : (dma_direction == DMA_FROM_DEVICE));
149 : : }
150 : :
151 : : #ifdef CONFIG_DMA_DECLARE_COHERENT
152 : : /*
153 : : * These three functions are only for dma allocator.
154 : : * Don't use them in device drivers.
155 : : */
156 : : int dma_alloc_from_dev_coherent(struct device *dev, ssize_t size,
157 : : dma_addr_t *dma_handle, void **ret);
158 : : int dma_release_from_dev_coherent(struct device *dev, int order, void *vaddr);
159 : :
160 : : int dma_mmap_from_dev_coherent(struct device *dev, struct vm_area_struct *vma,
161 : : void *cpu_addr, size_t size, int *ret);
162 : :
163 : : void *dma_alloc_from_global_coherent(struct device *dev, ssize_t size, dma_addr_t *dma_handle);
164 : : int dma_release_from_global_coherent(int order, void *vaddr);
165 : : int dma_mmap_from_global_coherent(struct vm_area_struct *vma, void *cpu_addr,
166 : : size_t size, int *ret);
167 : :
168 : : #else
169 : : #define dma_alloc_from_dev_coherent(dev, size, handle, ret) (0)
170 : : #define dma_release_from_dev_coherent(dev, order, vaddr) (0)
171 : : #define dma_mmap_from_dev_coherent(dev, vma, vaddr, order, ret) (0)
172 : :
173 : : static inline void *dma_alloc_from_global_coherent(struct device *dev, ssize_t size,
174 : : dma_addr_t *dma_handle)
175 : : {
176 : : return NULL;
177 : : }
178 : :
179 : : static inline int dma_release_from_global_coherent(int order, void *vaddr)
180 : : {
181 : : return 0;
182 : : }
183 : :
184 : : static inline int dma_mmap_from_global_coherent(struct vm_area_struct *vma,
185 : : void *cpu_addr, size_t size,
186 : : int *ret)
187 : : {
188 : : return 0;
189 : : }
190 : : #endif /* CONFIG_DMA_DECLARE_COHERENT */
191 : :
192 : 56699 : static inline bool dma_is_direct(const struct dma_map_ops *ops)
193 : : {
194 [ + - - - : 56699 : return likely(!ops);
+ - + - +
- - - - -
- - - - ]
195 : : }
196 : :
197 : : /*
198 : : * All the dma_direct_* declarations are here just for the indirect call bypass,
199 : : * and must not be used directly drivers!
200 : : */
201 : : dma_addr_t dma_direct_map_page(struct device *dev, struct page *page,
202 : : unsigned long offset, size_t size, enum dma_data_direction dir,
203 : : unsigned long attrs);
204 : : int dma_direct_map_sg(struct device *dev, struct scatterlist *sgl, int nents,
205 : : enum dma_data_direction dir, unsigned long attrs);
206 : : dma_addr_t dma_direct_map_resource(struct device *dev, phys_addr_t paddr,
207 : : size_t size, enum dma_data_direction dir, unsigned long attrs);
208 : :
209 : : #if defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_DEVICE) || \
210 : : defined(CONFIG_SWIOTLB)
211 : : void dma_direct_sync_single_for_device(struct device *dev,
212 : : dma_addr_t addr, size_t size, enum dma_data_direction dir);
213 : : void dma_direct_sync_sg_for_device(struct device *dev,
214 : : struct scatterlist *sgl, int nents, enum dma_data_direction dir);
215 : : #else
216 : : static inline void dma_direct_sync_single_for_device(struct device *dev,
217 : : dma_addr_t addr, size_t size, enum dma_data_direction dir)
218 : : {
219 : : }
220 : : static inline void dma_direct_sync_sg_for_device(struct device *dev,
221 : : struct scatterlist *sgl, int nents, enum dma_data_direction dir)
222 : : {
223 : : }
224 : : #endif
225 : :
226 : : #if defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_CPU) || \
227 : : defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_CPU_ALL) || \
228 : : defined(CONFIG_SWIOTLB)
229 : : void dma_direct_unmap_page(struct device *dev, dma_addr_t addr,
230 : : size_t size, enum dma_data_direction dir, unsigned long attrs);
231 : : void dma_direct_unmap_sg(struct device *dev, struct scatterlist *sgl,
232 : : int nents, enum dma_data_direction dir, unsigned long attrs);
233 : : void dma_direct_sync_single_for_cpu(struct device *dev,
234 : : dma_addr_t addr, size_t size, enum dma_data_direction dir);
235 : : void dma_direct_sync_sg_for_cpu(struct device *dev,
236 : : struct scatterlist *sgl, int nents, enum dma_data_direction dir);
237 : : #else
238 : : static inline void dma_direct_unmap_page(struct device *dev, dma_addr_t addr,
239 : : size_t size, enum dma_data_direction dir, unsigned long attrs)
240 : : {
241 : : }
242 : : static inline void dma_direct_unmap_sg(struct device *dev,
243 : : struct scatterlist *sgl, int nents, enum dma_data_direction dir,
244 : : unsigned long attrs)
245 : : {
246 : : }
247 : : static inline void dma_direct_sync_single_for_cpu(struct device *dev,
248 : : dma_addr_t addr, size_t size, enum dma_data_direction dir)
249 : : {
250 : : }
251 : : static inline void dma_direct_sync_sg_for_cpu(struct device *dev,
252 : : struct scatterlist *sgl, int nents, enum dma_data_direction dir)
253 : : {
254 : : }
255 : : #endif
256 : :
257 : : size_t dma_direct_max_mapping_size(struct device *dev);
258 : :
259 : : #ifdef CONFIG_HAS_DMA
260 : : #include <asm/dma-mapping.h>
261 : :
262 : 56699 : static inline const struct dma_map_ops *get_dma_ops(struct device *dev)
263 : : {
264 [ - - + - : 56699 : if (dev->dma_ops)
- - + - +
- + - - -
- - - - -
- ]
265 : : return dev->dma_ops;
266 : 56699 : return get_arch_dma_ops(dev->bus);
267 : : }
268 : :
269 : 0 : static inline void set_dma_ops(struct device *dev,
270 : : const struct dma_map_ops *dma_ops)
271 : : {
272 [ # # ]: 0 : dev->dma_ops = dma_ops;
273 : 0 : }
274 : :
275 : 14 : static inline dma_addr_t dma_map_page_attrs(struct device *dev,
276 : : struct page *page, size_t offset, size_t size,
277 : : enum dma_data_direction dir, unsigned long attrs)
278 : : {
279 [ + - ]: 14 : const struct dma_map_ops *ops = get_dma_ops(dev);
280 : 14 : dma_addr_t addr;
281 : :
282 [ - + ]: 14 : BUG_ON(!valid_dma_direction(dir));
283 [ + - ]: 14 : if (dma_is_direct(ops))
284 : 14 : addr = dma_direct_map_page(dev, page, offset, size, dir, attrs);
285 : : else
286 : 0 : addr = ops->map_page(dev, page, offset, size, dir, attrs);
287 : 14 : debug_dma_map_page(dev, page, offset, size, dir, addr);
288 : 14 : instr_dma_map_page(addr, dev, page, offset, size, dir, attrs);
289 : :
290 : 14 : return addr;
291 : : }
292 : :
293 : 14 : static inline void dma_unmap_page_attrs(struct device *dev, dma_addr_t addr,
294 : : size_t size, enum dma_data_direction dir, unsigned long attrs)
295 : : {
296 [ + - ]: 14 : const struct dma_map_ops *ops = get_dma_ops(dev);
297 : :
298 [ - + ]: 14 : BUG_ON(!valid_dma_direction(dir));
299 [ + - ]: 14 : if (dma_is_direct(ops))
300 : 14 : dma_direct_unmap_page(dev, addr, size, dir, attrs);
301 [ # # ]: 0 : else if (ops->unmap_page)
302 : 0 : ops->unmap_page(dev, addr, size, dir, attrs);
303 : 14 : debug_dma_unmap_page(dev, addr, size, dir);
304 : 14 : instr_dma_unmap_page(dev, addr, size, dir, attrs);
305 : 14 : }
306 : :
307 : : /*
308 : : * dma_maps_sg_attrs returns 0 on error and > 0 on success.
309 : : * It should never return a value < 0.
310 : : */
311 : 27973 : static inline int dma_map_sg_attrs(struct device *dev, struct scatterlist *sg,
312 : : int nents, enum dma_data_direction dir,
313 : : unsigned long attrs)
314 : : {
315 [ + - ]: 27973 : const struct dma_map_ops *ops = get_dma_ops(dev);
316 : 27973 : int ents;
317 : :
318 [ - + ]: 27973 : BUG_ON(!valid_dma_direction(dir));
319 [ + - ]: 27973 : if (dma_is_direct(ops))
320 : 27973 : ents = dma_direct_map_sg(dev, sg, nents, dir, attrs);
321 : : else
322 : 0 : ents = ops->map_sg(dev, sg, nents, dir, attrs);
323 [ - + ]: 27973 : BUG_ON(ents < 0);
324 : 27973 : debug_dma_map_sg(dev, sg, nents, ents, dir);
325 : 27973 : instr_dma_map_sg(ents, dev, sg, nents, dir, attrs);
326 : :
327 : 27973 : return ents;
328 : : }
329 : :
330 : 27973 : static inline void dma_unmap_sg_attrs(struct device *dev, struct scatterlist *sg,
331 : : int nents, enum dma_data_direction dir,
332 : : unsigned long attrs)
333 : : {
334 [ + - ]: 27973 : const struct dma_map_ops *ops = get_dma_ops(dev);
335 : :
336 [ - + ]: 27973 : BUG_ON(!valid_dma_direction(dir));
337 : 27973 : debug_dma_unmap_sg(dev, sg, nents, dir);
338 [ + - ]: 27973 : if (dma_is_direct(ops))
339 : 27973 : dma_direct_unmap_sg(dev, sg, nents, dir, attrs);
340 [ # # ]: 0 : else if (ops->unmap_sg)
341 : 0 : ops->unmap_sg(dev, sg, nents, dir, attrs);
342 : 27973 : instr_dma_unmap_sg(dev, sg, nents, dir, attrs);
343 : 27973 : }
344 : :
345 : 0 : static inline dma_addr_t dma_map_resource(struct device *dev,
346 : : phys_addr_t phys_addr,
347 : : size_t size,
348 : : enum dma_data_direction dir,
349 : : unsigned long attrs)
350 : : {
351 [ # # ]: 0 : const struct dma_map_ops *ops = get_dma_ops(dev);
352 : 0 : dma_addr_t addr = DMA_MAPPING_ERROR;
353 : :
354 [ # # ]: 0 : BUG_ON(!valid_dma_direction(dir));
355 : :
356 : : /* Don't allow RAM to be mapped */
357 [ # # # # ]: 0 : if (WARN_ON_ONCE(pfn_valid(PHYS_PFN(phys_addr))))
358 : : return DMA_MAPPING_ERROR;
359 : :
360 [ # # ]: 0 : if (dma_is_direct(ops))
361 : 0 : addr = dma_direct_map_resource(dev, phys_addr, size, dir, attrs);
362 [ # # ]: 0 : else if (ops->map_resource)
363 : 0 : addr = ops->map_resource(dev, phys_addr, size, dir, attrs);
364 : :
365 : 0 : debug_dma_map_resource(dev, phys_addr, size, dir, addr);
366 : 0 : return addr;
367 : : }
368 : :
369 : 0 : static inline void dma_unmap_resource(struct device *dev, dma_addr_t addr,
370 : : size_t size, enum dma_data_direction dir,
371 : : unsigned long attrs)
372 : : {
373 [ # # ]: 0 : const struct dma_map_ops *ops = get_dma_ops(dev);
374 : :
375 [ # # ]: 0 : BUG_ON(!valid_dma_direction(dir));
376 [ # # # # ]: 0 : if (!dma_is_direct(ops) && ops->unmap_resource)
377 : 0 : ops->unmap_resource(dev, addr, size, dir, attrs);
378 : 0 : debug_dma_unmap_resource(dev, addr, size, dir);
379 : 0 : }
380 : :
381 : 0 : static inline void dma_sync_single_for_cpu(struct device *dev, dma_addr_t addr,
382 : : size_t size,
383 : : enum dma_data_direction dir)
384 : : {
385 [ # # ]: 0 : const struct dma_map_ops *ops = get_dma_ops(dev);
386 : :
387 [ # # ]: 0 : BUG_ON(!valid_dma_direction(dir));
388 [ # # ]: 0 : if (dma_is_direct(ops))
389 : 0 : dma_direct_sync_single_for_cpu(dev, addr, size, dir);
390 [ # # ]: 0 : else if (ops->sync_single_for_cpu)
391 : 0 : ops->sync_single_for_cpu(dev, addr, size, dir);
392 : 0 : debug_dma_sync_single_for_cpu(dev, addr, size, dir);
393 : 0 : }
394 : :
395 : 0 : static inline void dma_sync_single_for_device(struct device *dev,
396 : : dma_addr_t addr, size_t size,
397 : : enum dma_data_direction dir)
398 : : {
399 [ # # ]: 0 : const struct dma_map_ops *ops = get_dma_ops(dev);
400 : :
401 [ # # ]: 0 : BUG_ON(!valid_dma_direction(dir));
402 [ # # ]: 0 : if (dma_is_direct(ops))
403 : 0 : dma_direct_sync_single_for_device(dev, addr, size, dir);
404 [ # # ]: 0 : else if (ops->sync_single_for_device)
405 : 0 : ops->sync_single_for_device(dev, addr, size, dir);
406 : 0 : debug_dma_sync_single_for_device(dev, addr, size, dir);
407 : 0 : }
408 : :
409 : : static inline void
410 : : dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg,
411 : : int nelems, enum dma_data_direction dir)
412 : : {
413 : : const struct dma_map_ops *ops = get_dma_ops(dev);
414 : :
415 : : BUG_ON(!valid_dma_direction(dir));
416 : : if (dma_is_direct(ops))
417 : : dma_direct_sync_sg_for_cpu(dev, sg, nelems, dir);
418 : : else if (ops->sync_sg_for_cpu)
419 : : ops->sync_sg_for_cpu(dev, sg, nelems, dir);
420 : : debug_dma_sync_sg_for_cpu(dev, sg, nelems, dir);
421 : : }
422 : :
423 : : static inline void
424 : 0 : dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg,
425 : : int nelems, enum dma_data_direction dir)
426 : : {
427 [ # # ]: 0 : const struct dma_map_ops *ops = get_dma_ops(dev);
428 : :
429 [ # # ]: 0 : BUG_ON(!valid_dma_direction(dir));
430 [ # # ]: 0 : if (dma_is_direct(ops))
431 : 0 : dma_direct_sync_sg_for_device(dev, sg, nelems, dir);
432 [ # # ]: 0 : else if (ops->sync_sg_for_device)
433 : 0 : ops->sync_sg_for_device(dev, sg, nelems, dir);
434 : 0 : debug_dma_sync_sg_for_device(dev, sg, nelems, dir);
435 : :
436 : 0 : }
437 : :
438 : 28 : static inline int dma_mapping_error(struct device *dev, dma_addr_t dma_addr)
439 : : {
440 : 28 : debug_dma_mapping_error(dev, dma_addr);
441 : :
442 [ + - - + : 28 : if (dma_addr == DMA_MAPPING_ERROR)
- - # # #
# # # #
# ]
443 : 0 : return -ENOMEM;
444 : : return 0;
445 : : }
446 : :
447 : : void *dma_alloc_attrs(struct device *dev, size_t size, dma_addr_t *dma_handle,
448 : : gfp_t flag, unsigned long attrs);
449 : : void dma_free_attrs(struct device *dev, size_t size, void *cpu_addr,
450 : : dma_addr_t dma_handle, unsigned long attrs);
451 : : void *dmam_alloc_attrs(struct device *dev, size_t size, dma_addr_t *dma_handle,
452 : : gfp_t gfp, unsigned long attrs);
453 : : void dmam_free_coherent(struct device *dev, size_t size, void *vaddr,
454 : : dma_addr_t dma_handle);
455 : : void dma_cache_sync(struct device *dev, void *vaddr, size_t size,
456 : : enum dma_data_direction dir);
457 : : int dma_get_sgtable_attrs(struct device *dev, struct sg_table *sgt,
458 : : void *cpu_addr, dma_addr_t dma_addr, size_t size,
459 : : unsigned long attrs);
460 : : int dma_mmap_attrs(struct device *dev, struct vm_area_struct *vma,
461 : : void *cpu_addr, dma_addr_t dma_addr, size_t size,
462 : : unsigned long attrs);
463 : : bool dma_can_mmap(struct device *dev);
464 : : int dma_supported(struct device *dev, u64 mask);
465 : : int dma_set_mask(struct device *dev, u64 mask);
466 : : int dma_set_coherent_mask(struct device *dev, u64 mask);
467 : : u64 dma_get_required_mask(struct device *dev);
468 : : size_t dma_max_mapping_size(struct device *dev);
469 : : unsigned long dma_get_merge_boundary(struct device *dev);
470 : : #else /* CONFIG_HAS_DMA */
471 : : static inline dma_addr_t dma_map_page_attrs(struct device *dev,
472 : : struct page *page, size_t offset, size_t size,
473 : : enum dma_data_direction dir, unsigned long attrs)
474 : : {
475 : : return DMA_MAPPING_ERROR;
476 : : }
477 : : static inline void dma_unmap_page_attrs(struct device *dev, dma_addr_t addr,
478 : : size_t size, enum dma_data_direction dir, unsigned long attrs)
479 : : {
480 : : }
481 : : static inline int dma_map_sg_attrs(struct device *dev, struct scatterlist *sg,
482 : : int nents, enum dma_data_direction dir, unsigned long attrs)
483 : : {
484 : : return 0;
485 : : }
486 : : static inline void dma_unmap_sg_attrs(struct device *dev,
487 : : struct scatterlist *sg, int nents, enum dma_data_direction dir,
488 : : unsigned long attrs)
489 : : {
490 : : }
491 : : static inline dma_addr_t dma_map_resource(struct device *dev,
492 : : phys_addr_t phys_addr, size_t size, enum dma_data_direction dir,
493 : : unsigned long attrs)
494 : : {
495 : : return DMA_MAPPING_ERROR;
496 : : }
497 : : static inline void dma_unmap_resource(struct device *dev, dma_addr_t addr,
498 : : size_t size, enum dma_data_direction dir, unsigned long attrs)
499 : : {
500 : : }
501 : : static inline void dma_sync_single_for_cpu(struct device *dev, dma_addr_t addr,
502 : : size_t size, enum dma_data_direction dir)
503 : : {
504 : : }
505 : : static inline void dma_sync_single_for_device(struct device *dev,
506 : : dma_addr_t addr, size_t size, enum dma_data_direction dir)
507 : : {
508 : : }
509 : : static inline void dma_sync_sg_for_cpu(struct device *dev,
510 : : struct scatterlist *sg, int nelems, enum dma_data_direction dir)
511 : : {
512 : : }
513 : : static inline void dma_sync_sg_for_device(struct device *dev,
514 : : struct scatterlist *sg, int nelems, enum dma_data_direction dir)
515 : : {
516 : : }
517 : : static inline int dma_mapping_error(struct device *dev, dma_addr_t dma_addr)
518 : : {
519 : : return -ENOMEM;
520 : : }
521 : : static inline void *dma_alloc_attrs(struct device *dev, size_t size,
522 : : dma_addr_t *dma_handle, gfp_t flag, unsigned long attrs)
523 : : {
524 : : return NULL;
525 : : }
526 : : static void dma_free_attrs(struct device *dev, size_t size, void *cpu_addr,
527 : : dma_addr_t dma_handle, unsigned long attrs)
528 : : {
529 : : }
530 : : static inline void *dmam_alloc_attrs(struct device *dev, size_t size,
531 : : dma_addr_t *dma_handle, gfp_t gfp, unsigned long attrs)
532 : : {
533 : : return NULL;
534 : : }
535 : : static inline void dmam_free_coherent(struct device *dev, size_t size,
536 : : void *vaddr, dma_addr_t dma_handle)
537 : : {
538 : : }
539 : : static inline void dma_cache_sync(struct device *dev, void *vaddr, size_t size,
540 : : enum dma_data_direction dir)
541 : : {
542 : : }
543 : : static inline int dma_get_sgtable_attrs(struct device *dev,
544 : : struct sg_table *sgt, void *cpu_addr, dma_addr_t dma_addr,
545 : : size_t size, unsigned long attrs)
546 : : {
547 : : return -ENXIO;
548 : : }
549 : : static inline int dma_mmap_attrs(struct device *dev, struct vm_area_struct *vma,
550 : : void *cpu_addr, dma_addr_t dma_addr, size_t size,
551 : : unsigned long attrs)
552 : : {
553 : : return -ENXIO;
554 : : }
555 : : static inline bool dma_can_mmap(struct device *dev)
556 : : {
557 : : return false;
558 : : }
559 : : static inline int dma_supported(struct device *dev, u64 mask)
560 : : {
561 : : return 0;
562 : : }
563 : : static inline int dma_set_mask(struct device *dev, u64 mask)
564 : : {
565 : : return -EIO;
566 : : }
567 : : static inline int dma_set_coherent_mask(struct device *dev, u64 mask)
568 : : {
569 : : return -EIO;
570 : : }
571 : : static inline u64 dma_get_required_mask(struct device *dev)
572 : : {
573 : : return 0;
574 : : }
575 : : static inline size_t dma_max_mapping_size(struct device *dev)
576 : : {
577 : : return 0;
578 : : }
579 : : static inline unsigned long dma_get_merge_boundary(struct device *dev)
580 : : {
581 : : return 0;
582 : : }
583 : : #endif /* CONFIG_HAS_DMA */
584 : :
585 : 14 : static inline dma_addr_t dma_map_single_attrs(struct device *dev, void *ptr,
586 : : size_t size, enum dma_data_direction dir, unsigned long attrs)
587 : : {
588 : 14 : dma_addr_t ret;
589 : : /* DMA must never operate on areas that might be remapped. */
590 [ - + - - : 14 : if (dev_WARN_ONCE(dev, is_vmalloc_addr(ptr),
- - + - ]
591 : : "rejecting DMA map of vmalloc memory\n"))
592 : : return DMA_MAPPING_ERROR;
593 : 14 : debug_dma_map_single(dev, ptr, size);
594 [ + - ]: 28 : ret = dma_map_page_attrs(dev, virt_to_page(ptr), offset_in_page(ptr),
595 : : size, dir, attrs);
596 : 14 : instr_dma_map_single(ret, dev, ptr, size, dir, attrs);
597 : 14 : return ret;
598 : : }
599 : :
600 : 14 : static inline void dma_unmap_single_attrs(struct device *dev, dma_addr_t addr,
601 : : size_t size, enum dma_data_direction dir, unsigned long attrs)
602 : : {
603 : 14 : instr_dma_unmap_single(dev, addr, size, dir, attrs);
604 : 14 : return dma_unmap_page_attrs(dev, addr, size, dir, attrs);
605 : : }
606 : :
607 : : static inline void dma_sync_single_range_for_cpu(struct device *dev,
608 : : dma_addr_t addr, unsigned long offset, size_t size,
609 : : enum dma_data_direction dir)
610 : : {
611 : : return dma_sync_single_for_cpu(dev, addr + offset, size, dir);
612 : : }
613 : :
614 : 0 : static inline void dma_sync_single_range_for_device(struct device *dev,
615 : : dma_addr_t addr, unsigned long offset, size_t size,
616 : : enum dma_data_direction dir)
617 : : {
618 : 0 : return dma_sync_single_for_device(dev, addr + offset, size, dir);
619 : : }
620 : :
621 : : #define dma_map_single(d, a, s, r) dma_map_single_attrs(d, a, s, r, 0)
622 : : #define dma_unmap_single(d, a, s, r) dma_unmap_single_attrs(d, a, s, r, 0)
623 : : #define dma_map_sg(d, s, n, r) dma_map_sg_attrs(d, s, n, r, 0)
624 : : #define dma_unmap_sg(d, s, n, r) dma_unmap_sg_attrs(d, s, n, r, 0)
625 : : #define dma_map_page(d, p, o, s, r) dma_map_page_attrs(d, p, o, s, r, 0)
626 : : #define dma_unmap_page(d, a, s, r) dma_unmap_page_attrs(d, a, s, r, 0)
627 : : #define dma_get_sgtable(d, t, v, h, s) dma_get_sgtable_attrs(d, t, v, h, s, 0)
628 : : #define dma_mmap_coherent(d, v, c, h, s) dma_mmap_attrs(d, v, c, h, s, 0)
629 : :
630 : : extern int dma_common_mmap(struct device *dev, struct vm_area_struct *vma,
631 : : void *cpu_addr, dma_addr_t dma_addr, size_t size,
632 : : unsigned long attrs);
633 : :
634 : : struct page **dma_common_find_pages(void *cpu_addr);
635 : : void *dma_common_contiguous_remap(struct page *page, size_t size,
636 : : pgprot_t prot, const void *caller);
637 : :
638 : : void *dma_common_pages_remap(struct page **pages, size_t size,
639 : : pgprot_t prot, const void *caller);
640 : : void dma_common_free_remap(void *cpu_addr, size_t size);
641 : :
642 : : bool dma_in_atomic_pool(void *start, size_t size);
643 : : void *dma_alloc_from_pool(size_t size, struct page **ret_page, gfp_t flags);
644 : : bool dma_free_from_pool(void *start, size_t size);
645 : :
646 : : int
647 : : dma_common_get_sgtable(struct device *dev, struct sg_table *sgt, void *cpu_addr,
648 : : dma_addr_t dma_addr, size_t size, unsigned long attrs);
649 : :
650 : 324 : static inline void *dma_alloc_coherent(struct device *dev, size_t size,
651 : : dma_addr_t *dma_handle, gfp_t gfp)
652 : : {
653 : :
654 : 324 : return dma_alloc_attrs(dev, size, dma_handle, gfp,
655 : 0 : (gfp & __GFP_NOWARN) ? DMA_ATTR_NO_WARN : 0);
656 : : }
657 : :
658 : 149 : static inline void dma_free_coherent(struct device *dev, size_t size,
659 : : void *cpu_addr, dma_addr_t dma_handle)
660 : : {
661 : 149 : return dma_free_attrs(dev, size, cpu_addr, dma_handle, 0);
662 : : }
663 : :
664 : :
665 : 0 : static inline u64 dma_get_mask(struct device *dev)
666 : : {
667 [ # # # # : 0 : if (dev->dma_mask && *dev->dma_mask)
# # # # #
# # # # #
# # ]
668 : 0 : return *dev->dma_mask;
669 : : return DMA_BIT_MASK(32);
670 : : }
671 : :
672 : : /*
673 : : * Set both the DMA mask and the coherent DMA mask to the same thing.
674 : : * Note that we don't check the return value from dma_set_coherent_mask()
675 : : * as the DMA API guarantees that the coherent DMA mask can be set to
676 : : * the same or smaller than the streaming DMA mask.
677 : : */
678 : 28 : static inline int dma_set_mask_and_coherent(struct device *dev, u64 mask)
679 : : {
680 : 28 : int rc = dma_set_mask(dev, mask);
681 [ + - ]: 28 : if (rc == 0)
682 : 28 : dma_set_coherent_mask(dev, mask);
683 : 28 : return rc;
684 : : }
685 : :
686 : : /*
687 : : * Similar to the above, except it deals with the case where the device
688 : : * does not have dev->dma_mask appropriately setup.
689 : : */
690 : 0 : static inline int dma_coerce_mask_and_coherent(struct device *dev, u64 mask)
691 : : {
692 : 0 : dev->dma_mask = &dev->coherent_dma_mask;
693 : 0 : return dma_set_mask_and_coherent(dev, mask);
694 : : }
695 : :
696 : : /**
697 : : * dma_addressing_limited - return if the device is addressing limited
698 : : * @dev: device to check
699 : : *
700 : : * Return %true if the devices DMA mask is too small to address all memory in
701 : : * the system, else %false. Lack of addressing bits is the prime reason for
702 : : * bounce buffering, but might not be the only one.
703 : : */
704 : 0 : static inline bool dma_addressing_limited(struct device *dev)
705 : : {
706 [ # # # # ]: 0 : return min_not_zero(dma_get_mask(dev), dev->bus_dma_limit) <
707 : 0 : dma_get_required_mask(dev);
708 : : }
709 : :
710 : : #ifdef CONFIG_ARCH_HAS_SETUP_DMA_OPS
711 : : void arch_setup_dma_ops(struct device *dev, u64 dma_base, u64 size,
712 : : const struct iommu_ops *iommu, bool coherent);
713 : : #else
714 : : static inline void arch_setup_dma_ops(struct device *dev, u64 dma_base,
715 : : u64 size, const struct iommu_ops *iommu, bool coherent)
716 : : {
717 : : }
718 : : #endif /* CONFIG_ARCH_HAS_SETUP_DMA_OPS */
719 : :
720 : : #ifdef CONFIG_ARCH_HAS_TEARDOWN_DMA_OPS
721 : : void arch_teardown_dma_ops(struct device *dev);
722 : : #else
723 : 170 : static inline void arch_teardown_dma_ops(struct device *dev)
724 : : {
725 [ - - ]: 170 : }
726 : : #endif /* CONFIG_ARCH_HAS_TEARDOWN_DMA_OPS */
727 : :
728 : 108432 : static inline unsigned int dma_get_max_seg_size(struct device *dev)
729 : : {
730 [ + - + - : 108432 : if (dev->dma_parms && dev->dma_parms->max_segment_size)
- - - - ]
731 : 108432 : return dev->dma_parms->max_segment_size;
732 : : return SZ_64K;
733 : : }
734 : :
735 : 280 : static inline int dma_set_max_seg_size(struct device *dev, unsigned int size)
736 : : {
737 [ + - ]: 280 : if (dev->dma_parms) {
738 : 280 : dev->dma_parms->max_segment_size = size;
739 : 280 : return 0;
740 : : }
741 : : return -EIO;
742 : : }
743 : :
744 : 108432 : static inline unsigned long dma_get_seg_boundary(struct device *dev)
745 : : {
746 [ + - + - : 108432 : if (dev->dma_parms && dev->dma_parms->segment_boundary_mask)
# # # # ]
747 : 108432 : return dev->dma_parms->segment_boundary_mask;
748 : : return DMA_BIT_MASK(32);
749 : : }
750 : :
751 : 280 : static inline int dma_set_seg_boundary(struct device *dev, unsigned long mask)
752 : : {
753 [ + - ]: 280 : if (dev->dma_parms) {
754 : 280 : dev->dma_parms->segment_boundary_mask = mask;
755 : 280 : return 0;
756 : : }
757 : : return -EIO;
758 : : }
759 : :
760 : 84 : static inline int dma_get_cache_alignment(void)
761 : : {
762 : : #ifdef ARCH_DMA_MINALIGN
763 : : return ARCH_DMA_MINALIGN;
764 : : #endif
765 : 84 : return 1;
766 : : }
767 : :
768 : : #ifdef CONFIG_DMA_DECLARE_COHERENT
769 : : int dma_declare_coherent_memory(struct device *dev, phys_addr_t phys_addr,
770 : : dma_addr_t device_addr, size_t size);
771 : : #else
772 : : static inline int
773 : 0 : dma_declare_coherent_memory(struct device *dev, phys_addr_t phys_addr,
774 : : dma_addr_t device_addr, size_t size)
775 : : {
776 : 0 : return -ENOSYS;
777 : : }
778 : : #endif /* CONFIG_DMA_DECLARE_COHERENT */
779 : :
780 : 56 : static inline void *dmam_alloc_coherent(struct device *dev, size_t size,
781 : : dma_addr_t *dma_handle, gfp_t gfp)
782 : : {
783 : 56 : return dmam_alloc_attrs(dev, size, dma_handle, gfp,
784 : : (gfp & __GFP_NOWARN) ? DMA_ATTR_NO_WARN : 0);
785 : : }
786 : :
787 : : static inline void *dma_alloc_wc(struct device *dev, size_t size,
788 : : dma_addr_t *dma_addr, gfp_t gfp)
789 : : {
790 : : unsigned long attrs = DMA_ATTR_WRITE_COMBINE;
791 : :
792 : : if (gfp & __GFP_NOWARN)
793 : : attrs |= DMA_ATTR_NO_WARN;
794 : :
795 : : return dma_alloc_attrs(dev, size, dma_addr, gfp, attrs);
796 : : }
797 : :
798 : : static inline void dma_free_wc(struct device *dev, size_t size,
799 : : void *cpu_addr, dma_addr_t dma_addr)
800 : : {
801 : : return dma_free_attrs(dev, size, cpu_addr, dma_addr,
802 : : DMA_ATTR_WRITE_COMBINE);
803 : : }
804 : :
805 : : static inline int dma_mmap_wc(struct device *dev,
806 : : struct vm_area_struct *vma,
807 : : void *cpu_addr, dma_addr_t dma_addr,
808 : : size_t size)
809 : : {
810 : : return dma_mmap_attrs(dev, vma, cpu_addr, dma_addr, size,
811 : : DMA_ATTR_WRITE_COMBINE);
812 : : }
813 : :
814 : : #ifdef CONFIG_NEED_DMA_MAP_STATE
815 : : #define DEFINE_DMA_UNMAP_ADDR(ADDR_NAME) dma_addr_t ADDR_NAME
816 : : #define DEFINE_DMA_UNMAP_LEN(LEN_NAME) __u32 LEN_NAME
817 : : #define dma_unmap_addr(PTR, ADDR_NAME) ((PTR)->ADDR_NAME)
818 : : #define dma_unmap_addr_set(PTR, ADDR_NAME, VAL) (((PTR)->ADDR_NAME) = (VAL))
819 : : #define dma_unmap_len(PTR, LEN_NAME) ((PTR)->LEN_NAME)
820 : : #define dma_unmap_len_set(PTR, LEN_NAME, VAL) (((PTR)->LEN_NAME) = (VAL))
821 : : #else
822 : : #define DEFINE_DMA_UNMAP_ADDR(ADDR_NAME)
823 : : #define DEFINE_DMA_UNMAP_LEN(LEN_NAME)
824 : : #define dma_unmap_addr(PTR, ADDR_NAME) (0)
825 : : #define dma_unmap_addr_set(PTR, ADDR_NAME, VAL) do { } while (0)
826 : : #define dma_unmap_len(PTR, LEN_NAME) (0)
827 : : #define dma_unmap_len_set(PTR, LEN_NAME, VAL) do { } while (0)
828 : : #endif
829 : :
830 : : #endif
|
