Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0
2 : : /*
3 : : * arch-independent dma-mapping routines
4 : : *
5 : : * Copyright (c) 2006 SUSE Linux Products GmbH
6 : : * Copyright (c) 2006 Tejun Heo <teheo@suse.de>
7 : : */
8 : : #include <linux/memblock.h> /* for max_pfn */
9 : : #include <linux/acpi.h>
10 : : #include <linux/dma-direct.h>
11 : : #include <linux/dma-noncoherent.h>
12 : : #include <linux/export.h>
13 : : #include <linux/gfp.h>
14 : : #include <linux/of_device.h>
15 : : #include <linux/slab.h>
16 : : #include <linux/vmalloc.h>
17 : : #include <linux/drifuzz.h>
18 : :
19 : : /*
20 : : * Managed DMA API
21 : : */
22 : : struct dma_devres {
23 : : size_t size;
24 : : void *vaddr;
25 : : dma_addr_t dma_handle;
26 : : unsigned long attrs;
27 : : };
28 : :
29 : 0 : static void dmam_release(struct device *dev, void *res)
30 : : {
31 : 0 : struct dma_devres *this = res;
32 : :
33 : 0 : dma_free_attrs(dev, this->size, this->vaddr, this->dma_handle,
34 : : this->attrs);
35 : 0 : }
36 : :
37 : 0 : static int dmam_match(struct device *dev, void *res, void *match_data)
38 : : {
39 : 0 : struct dma_devres *this = res, *match = match_data;
40 : :
41 [ # # ]: 0 : if (this->vaddr == match->vaddr) {
42 [ # # # # : 0 : WARN_ON(this->size != match->size ||
# # ]
43 : : this->dma_handle != match->dma_handle);
44 : : return 1;
45 : : }
46 : : return 0;
47 : : }
48 : :
49 : : /**
50 : : * dmam_free_coherent - Managed dma_free_coherent()
51 : : * @dev: Device to free coherent memory for
52 : : * @size: Size of allocation
53 : : * @vaddr: Virtual address of the memory to free
54 : : * @dma_handle: DMA handle of the memory to free
55 : : *
56 : : * Managed dma_free_coherent().
57 : : */
58 : 0 : void dmam_free_coherent(struct device *dev, size_t size, void *vaddr,
59 : : dma_addr_t dma_handle)
60 : : {
61 : 0 : struct dma_devres match_data = { size, vaddr, dma_handle };
62 : :
63 : 0 : dma_free_coherent(dev, size, vaddr, dma_handle);
64 [ # # ]: 0 : WARN_ON(devres_destroy(dev, dmam_release, dmam_match, &match_data));
65 : 0 : }
66 : : EXPORT_SYMBOL(dmam_free_coherent);
67 : :
68 : : /**
69 : : * dmam_alloc_attrs - Managed dma_alloc_attrs()
70 : : * @dev: Device to allocate non_coherent memory for
71 : : * @size: Size of allocation
72 : : * @dma_handle: Out argument for allocated DMA handle
73 : : * @gfp: Allocation flags
74 : : * @attrs: Flags in the DMA_ATTR_* namespace.
75 : : *
76 : : * Managed dma_alloc_attrs(). Memory allocated using this function will be
77 : : * automatically released on driver detach.
78 : : *
79 : : * RETURNS:
80 : : * Pointer to allocated memory on success, NULL on failure.
81 : : */
82 : 22 : void *dmam_alloc_attrs(struct device *dev, size_t size, dma_addr_t *dma_handle,
83 : : gfp_t gfp, unsigned long attrs)
84 : : {
85 : 22 : struct dma_devres *dr;
86 : 22 : void *vaddr;
87 : :
88 : 22 : dr = devres_alloc(dmam_release, sizeof(*dr), gfp);
89 [ + - ]: 22 : if (!dr)
90 : : return NULL;
91 : :
92 : 22 : vaddr = dma_alloc_attrs(dev, size, dma_handle, gfp, attrs);
93 [ - + ]: 22 : if (!vaddr) {
94 : 0 : devres_free(dr);
95 : 0 : return NULL;
96 : : }
97 : :
98 : 22 : dr->vaddr = vaddr;
99 : 22 : dr->dma_handle = *dma_handle;
100 : 22 : dr->size = size;
101 : 22 : dr->attrs = attrs;
102 : :
103 : 22 : devres_add(dev, dr);
104 : :
105 : 22 : return vaddr;
106 : : }
107 : : EXPORT_SYMBOL(dmam_alloc_attrs);
108 : :
109 : : /*
110 : : * Create scatter-list for the already allocated DMA buffer.
111 : : */
112 : 0 : int dma_common_get_sgtable(struct device *dev, struct sg_table *sgt,
113 : : void *cpu_addr, dma_addr_t dma_addr, size_t size,
114 : : unsigned long attrs)
115 : : {
116 [ # # ]: 0 : struct page *page = virt_to_page(cpu_addr);
117 : 0 : int ret;
118 : :
119 : 0 : ret = sg_alloc_table(sgt, 1, GFP_KERNEL);
120 [ # # ]: 0 : if (!ret)
121 [ # # ]: 0 : sg_set_page(sgt->sgl, page, PAGE_ALIGN(size), 0);
122 : 0 : return ret;
123 : : }
124 : :
125 : : /*
126 : : * The whole dma_get_sgtable() idea is fundamentally unsafe - it seems
127 : : * that the intention is to allow exporting memory allocated via the
128 : : * coherent DMA APIs through the dma_buf API, which only accepts a
129 : : * scattertable. This presents a couple of problems:
130 : : * 1. Not all memory allocated via the coherent DMA APIs is backed by
131 : : * a struct page
132 : : * 2. Passing coherent DMA memory into the streaming APIs is not allowed
133 : : * as we will try to flush the memory through a different alias to that
134 : : * actually being used (and the flushes are redundant.)
135 : : */
136 : 0 : int dma_get_sgtable_attrs(struct device *dev, struct sg_table *sgt,
137 : : void *cpu_addr, dma_addr_t dma_addr, size_t size,
138 : : unsigned long attrs)
139 : : {
140 [ # # ]: 0 : const struct dma_map_ops *ops = get_dma_ops(dev);
141 : :
142 [ # # ]: 0 : if (dma_is_direct(ops))
143 : 0 : return dma_direct_get_sgtable(dev, sgt, cpu_addr, dma_addr,
144 : : size, attrs);
145 [ # # ]: 0 : if (!ops->get_sgtable)
146 : : return -ENXIO;
147 : 0 : return ops->get_sgtable(dev, sgt, cpu_addr, dma_addr, size, attrs);
148 : : }
149 : : EXPORT_SYMBOL(dma_get_sgtable_attrs);
150 : :
151 : : #ifdef CONFIG_MMU
152 : : /*
153 : : * Return the page attributes used for mapping dma_alloc_* memory, either in
154 : : * kernel space if remapping is needed, or to userspace through dma_mmap_*.
155 : : */
156 : 0 : pgprot_t dma_pgprot(struct device *dev, pgprot_t prot, unsigned long attrs)
157 : : {
158 : 0 : if (dev_is_dma_coherent(dev) ||
159 : : (IS_ENABLED(CONFIG_DMA_NONCOHERENT_CACHE_SYNC) &&
160 : : (attrs & DMA_ATTR_NON_CONSISTENT)))
161 : 0 : return prot;
162 : : #ifdef CONFIG_ARCH_HAS_DMA_WRITE_COMBINE
163 : : if (attrs & DMA_ATTR_WRITE_COMBINE)
164 : : return pgprot_writecombine(prot);
165 : : #endif
166 : : return pgprot_dmacoherent(prot);
167 : : }
168 : : #endif /* CONFIG_MMU */
169 : :
170 : : /*
171 : : * Create userspace mapping for the DMA-coherent memory.
172 : : */
173 : 0 : int dma_common_mmap(struct device *dev, struct vm_area_struct *vma,
174 : : void *cpu_addr, dma_addr_t dma_addr, size_t size,
175 : : unsigned long attrs)
176 : : {
177 : : #ifdef CONFIG_MMU
178 [ # # ]: 0 : unsigned long user_count = vma_pages(vma);
179 : 0 : unsigned long count = PAGE_ALIGN(size) >> PAGE_SHIFT;
180 : 0 : unsigned long off = vma->vm_pgoff;
181 : 0 : int ret = -ENXIO;
182 : :
183 [ # # ]: 0 : vma->vm_page_prot = dma_pgprot(dev, vma->vm_page_prot, attrs);
184 : :
185 : 0 : if (dma_mmap_from_dev_coherent(dev, vma, cpu_addr, size, &ret))
186 : : return ret;
187 : :
188 [ # # # # ]: 0 : if (off >= count || user_count > count - off)
189 : : return -ENXIO;
190 : :
191 : 0 : return remap_pfn_range(vma, vma->vm_start,
192 [ # # ]: 0 : page_to_pfn(virt_to_page(cpu_addr)) + vma->vm_pgoff,
193 : : user_count << PAGE_SHIFT, vma->vm_page_prot);
194 : : #else
195 : : return -ENXIO;
196 : : #endif /* CONFIG_MMU */
197 : : }
198 : :
199 : : /**
200 : : * dma_can_mmap - check if a given device supports dma_mmap_*
201 : : * @dev: device to check
202 : : *
203 : : * Returns %true if @dev supports dma_mmap_coherent() and dma_mmap_attrs() to
204 : : * map DMA allocations to userspace.
205 : : */
206 : 0 : bool dma_can_mmap(struct device *dev)
207 : : {
208 [ # # ]: 0 : const struct dma_map_ops *ops = get_dma_ops(dev);
209 : :
210 [ # # ]: 0 : if (dma_is_direct(ops))
211 : 0 : return dma_direct_can_mmap(dev);
212 : 0 : return ops->mmap != NULL;
213 : : }
214 : : EXPORT_SYMBOL_GPL(dma_can_mmap);
215 : :
216 : : /**
217 : : * dma_mmap_attrs - map a coherent DMA allocation into user space
218 : : * @dev: valid struct device pointer, or NULL for ISA and EISA-like devices
219 : : * @vma: vm_area_struct describing requested user mapping
220 : : * @cpu_addr: kernel CPU-view address returned from dma_alloc_attrs
221 : : * @dma_addr: device-view address returned from dma_alloc_attrs
222 : : * @size: size of memory originally requested in dma_alloc_attrs
223 : : * @attrs: attributes of mapping properties requested in dma_alloc_attrs
224 : : *
225 : : * Map a coherent DMA buffer previously allocated by dma_alloc_attrs into user
226 : : * space. The coherent DMA buffer must not be freed by the driver until the
227 : : * user space mapping has been released.
228 : : */
229 : 0 : int dma_mmap_attrs(struct device *dev, struct vm_area_struct *vma,
230 : : void *cpu_addr, dma_addr_t dma_addr, size_t size,
231 : : unsigned long attrs)
232 : : {
233 [ # # ]: 0 : const struct dma_map_ops *ops = get_dma_ops(dev);
234 : :
235 [ # # ]: 0 : if (dma_is_direct(ops))
236 : 0 : return dma_direct_mmap(dev, vma, cpu_addr, dma_addr, size,
237 : : attrs);
238 [ # # ]: 0 : if (!ops->mmap)
239 : : return -ENXIO;
240 : 0 : return ops->mmap(dev, vma, cpu_addr, dma_addr, size, attrs);
241 : : }
242 : : EXPORT_SYMBOL(dma_mmap_attrs);
243 : :
244 : 0 : u64 dma_get_required_mask(struct device *dev)
245 : : {
246 [ # # ]: 0 : const struct dma_map_ops *ops = get_dma_ops(dev);
247 : :
248 [ # # ]: 0 : if (dma_is_direct(ops))
249 : 0 : return dma_direct_get_required_mask(dev);
250 [ # # ]: 0 : if (ops->get_required_mask)
251 : 0 : return ops->get_required_mask(dev);
252 : :
253 : : /*
254 : : * We require every DMA ops implementation to at least support a 32-bit
255 : : * DMA mask (and use bounce buffering if that isn't supported in
256 : : * hardware). As the direct mapping code has its own routine to
257 : : * actually report an optimal mask we default to 32-bit here as that
258 : : * is the right thing for most IOMMUs, and at least not actively
259 : : * harmful in general.
260 : : */
261 : : return DMA_BIT_MASK(32);
262 : : }
263 : : EXPORT_SYMBOL_GPL(dma_get_required_mask);
264 : :
265 : 22 : void *dma_alloc_attrs(struct device *dev, size_t size, dma_addr_t *dma_handle,
266 : : gfp_t flag, unsigned long attrs)
267 : : {
268 [ + - ]: 22 : const struct dma_map_ops *ops = get_dma_ops(dev);
269 : 22 : void *cpu_addr;
270 : :
271 [ - + ]: 22 : WARN_ON_ONCE(!dev->coherent_dma_mask);
272 : :
273 : 22 : if (dma_alloc_from_dev_coherent(dev, size, dma_handle, &cpu_addr))
274 : : return cpu_addr;
275 : :
276 : : /* let the implementation decide on the zone to allocate from: */
277 : 22 : flag &= ~(__GFP_DMA | __GFP_DMA32 | __GFP_HIGHMEM);
278 : :
279 [ + - ]: 22 : if (dma_is_direct(ops))
280 : 22 : cpu_addr = dma_direct_alloc(dev, size, dma_handle, flag, attrs);
281 [ # # ]: 0 : else if (ops->alloc)
282 : 0 : cpu_addr = ops->alloc(dev, size, dma_handle, flag, attrs);
283 : : else
284 : : return NULL;
285 : :
286 : 22 : debug_dma_alloc_coherent(dev, size, *dma_handle, cpu_addr);
287 [ + - ]: 22 : handle_const_dma_init(*dma_handle, virt_to_phys(cpu_addr), size);
288 : 22 : return cpu_addr;
289 : : }
290 : : EXPORT_SYMBOL(dma_alloc_attrs);
291 : :
292 : 0 : void dma_free_attrs(struct device *dev, size_t size, void *cpu_addr,
293 : : dma_addr_t dma_handle, unsigned long attrs)
294 : : {
295 [ # # ]: 0 : const struct dma_map_ops *ops = get_dma_ops(dev);
296 : :
297 : 0 : if (dma_release_from_dev_coherent(dev, get_order(size), cpu_addr))
298 : : return;
299 : : /*
300 : : * On non-coherent platforms which implement DMA-coherent buffers via
301 : : * non-cacheable remaps, ops->free() may call vunmap(). Thus getting
302 : : * this far in IRQ context is a) at risk of a BUG_ON() or trying to
303 : : * sleep on some machines, and b) an indication that the driver is
304 : : * probably misusing the coherent API anyway.
305 : : */
306 [ # # ]: 0 : WARN_ON(irqs_disabled());
307 : :
308 [ # # ]: 0 : if (!cpu_addr)
309 : : return;
310 : :
311 : 0 : debug_dma_free_coherent(dev, size, cpu_addr, dma_handle);
312 [ # # ]: 0 : if (dma_is_direct(ops))
313 : 0 : dma_direct_free(dev, size, cpu_addr, dma_handle, attrs);
314 [ # # ]: 0 : else if (ops->free)
315 : 0 : ops->free(dev, size, cpu_addr, dma_handle, attrs);
316 : 0 : handle_const_dma_exit(dma_handle);
317 : : }
318 : : EXPORT_SYMBOL(dma_free_attrs);
319 : :
320 : 44 : int dma_supported(struct device *dev, u64 mask)
321 : : {
322 [ + - ]: 44 : const struct dma_map_ops *ops = get_dma_ops(dev);
323 : :
324 [ + - ]: 44 : if (dma_is_direct(ops))
325 : 44 : return dma_direct_supported(dev, mask);
326 [ # # ]: 0 : if (!ops->dma_supported)
327 : : return 1;
328 : 0 : return ops->dma_supported(dev, mask);
329 : : }
330 : : EXPORT_SYMBOL(dma_supported);
331 : :
332 : : #ifdef CONFIG_ARCH_HAS_DMA_SET_MASK
333 : : void arch_dma_set_mask(struct device *dev, u64 mask);
334 : : #else
335 : : #define arch_dma_set_mask(dev, mask) do { } while (0)
336 : : #endif
337 : :
338 : 22 : int dma_set_mask(struct device *dev, u64 mask)
339 : : {
340 : : /*
341 : : * Truncate the mask to the actually supported dma_addr_t width to
342 : : * avoid generating unsupportable addresses.
343 : : */
344 : 22 : mask = (dma_addr_t)mask;
345 : :
346 [ + - - + ]: 22 : if (!dev->dma_mask || !dma_supported(dev, mask))
347 : 0 : return -EIO;
348 : :
349 : 22 : arch_dma_set_mask(dev, mask);
350 : 22 : *dev->dma_mask = mask;
351 : 22 : return 0;
352 : : }
353 : : EXPORT_SYMBOL(dma_set_mask);
354 : :
355 : : #ifndef CONFIG_ARCH_HAS_DMA_SET_COHERENT_MASK
356 : 22 : int dma_set_coherent_mask(struct device *dev, u64 mask)
357 : : {
358 : : /*
359 : : * Truncate the mask to the actually supported dma_addr_t width to
360 : : * avoid generating unsupportable addresses.
361 : : */
362 : 22 : mask = (dma_addr_t)mask;
363 : :
364 [ + - ]: 22 : if (!dma_supported(dev, mask))
365 : : return -EIO;
366 : :
367 : 22 : dev->coherent_dma_mask = mask;
368 : 22 : return 0;
369 : : }
370 : : EXPORT_SYMBOL(dma_set_coherent_mask);
371 : : #endif
372 : :
373 : 0 : void dma_cache_sync(struct device *dev, void *vaddr, size_t size,
374 : : enum dma_data_direction dir)
375 : : {
376 [ # # ]: 0 : const struct dma_map_ops *ops = get_dma_ops(dev);
377 : :
378 [ # # ]: 0 : BUG_ON(!valid_dma_direction(dir));
379 : :
380 [ # # ]: 0 : if (dma_is_direct(ops))
381 : : arch_dma_cache_sync(dev, vaddr, size, dir);
382 [ # # ]: 0 : else if (ops->cache_sync)
383 : 0 : ops->cache_sync(dev, vaddr, size, dir);
384 : 0 : }
385 : : EXPORT_SYMBOL(dma_cache_sync);
386 : :
387 : 33 : size_t dma_max_mapping_size(struct device *dev)
388 : : {
389 [ + - ]: 33 : const struct dma_map_ops *ops = get_dma_ops(dev);
390 : 33 : size_t size = SIZE_MAX;
391 : :
392 [ + - ]: 33 : if (dma_is_direct(ops))
393 : 33 : size = dma_direct_max_mapping_size(dev);
394 [ # # # # ]: 0 : else if (ops && ops->max_mapping_size)
395 : 0 : size = ops->max_mapping_size(dev);
396 : :
397 : 33 : return size;
398 : : }
399 : : EXPORT_SYMBOL_GPL(dma_max_mapping_size);
400 : :
401 : 0 : unsigned long dma_get_merge_boundary(struct device *dev)
402 : : {
403 [ # # ]: 0 : const struct dma_map_ops *ops = get_dma_ops(dev);
404 : :
405 [ # # # # ]: 0 : if (!ops || !ops->get_merge_boundary)
406 : : return 0; /* can't merge */
407 : :
408 : 0 : return ops->get_merge_boundary(dev);
409 : : }
410 : : EXPORT_SYMBOL_GPL(dma_get_merge_boundary);
|
