Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-only
2 : : /*
3 : : * A fairly generic DMA-API to IOMMU-API glue layer.
4 : : *
5 : : * Copyright (C) 2014-2015 ARM Ltd.
6 : : *
7 : : * based in part on arch/arm/mm/dma-mapping.c:
8 : : * Copyright (C) 2000-2004 Russell King
9 : : */
10 : :
11 : : #include <linux/acpi_iort.h>
12 : : #include <linux/device.h>
13 : : #include <linux/dma-contiguous.h>
14 : : #include <linux/dma-iommu.h>
15 : : #include <linux/dma-noncoherent.h>
16 : : #include <linux/gfp.h>
17 : : #include <linux/huge_mm.h>
18 : : #include <linux/iommu.h>
19 : : #include <linux/iova.h>
20 : : #include <linux/irq.h>
21 : : #include <linux/mm.h>
22 : : #include <linux/mutex.h>
23 : : #include <linux/pci.h>
24 : : #include <linux/scatterlist.h>
25 : : #include <linux/vmalloc.h>
26 : : #include <linux/crash_dump.h>
27 : :
28 : : struct iommu_dma_msi_page {
29 : : struct list_head list;
30 : : dma_addr_t iova;
31 : : phys_addr_t phys;
32 : : };
33 : :
34 : : enum iommu_dma_cookie_type {
35 : : IOMMU_DMA_IOVA_COOKIE,
36 : : IOMMU_DMA_MSI_COOKIE,
37 : : };
38 : :
39 : : struct iommu_dma_cookie {
40 : : enum iommu_dma_cookie_type type;
41 : : union {
42 : : /* Full allocator for IOMMU_DMA_IOVA_COOKIE */
43 : : struct iova_domain iovad;
44 : : /* Trivial linear page allocator for IOMMU_DMA_MSI_COOKIE */
45 : : dma_addr_t msi_iova;
46 : : };
47 : : struct list_head msi_page_list;
48 : :
49 : : /* Domain for flush queue callback; NULL if flush queue not in use */
50 : : struct iommu_domain *fq_domain;
51 : : };
52 : :
53 : 0 : static inline size_t cookie_msi_granule(struct iommu_dma_cookie *cookie)
54 : : {
55 : 0 : if (cookie->type == IOMMU_DMA_IOVA_COOKIE)
56 : 0 : return cookie->iovad.granule;
57 : : return PAGE_SIZE;
58 : : }
59 : :
60 : 0 : static struct iommu_dma_cookie *cookie_alloc(enum iommu_dma_cookie_type type)
61 : : {
62 : 0 : struct iommu_dma_cookie *cookie;
63 : :
64 : 0 : cookie = kzalloc(sizeof(*cookie), GFP_KERNEL);
65 [ # # # # ]: 0 : if (cookie) {
66 : 0 : INIT_LIST_HEAD(&cookie->msi_page_list);
67 : 0 : cookie->type = type;
68 : : }
69 : 0 : return cookie;
70 : : }
71 : :
72 : : /**
73 : : * iommu_get_dma_cookie - Acquire DMA-API resources for a domain
74 : : * @domain: IOMMU domain to prepare for DMA-API usage
75 : : *
76 : : * IOMMU drivers should normally call this from their domain_alloc
77 : : * callback when domain->type == IOMMU_DOMAIN_DMA.
78 : : */
79 : 0 : int iommu_get_dma_cookie(struct iommu_domain *domain)
80 : : {
81 [ # # ]: 0 : if (domain->iova_cookie)
82 : : return -EEXIST;
83 : :
84 : 0 : domain->iova_cookie = cookie_alloc(IOMMU_DMA_IOVA_COOKIE);
85 [ # # ]: 0 : if (!domain->iova_cookie)
86 : 0 : return -ENOMEM;
87 : :
88 : : return 0;
89 : : }
90 : : EXPORT_SYMBOL(iommu_get_dma_cookie);
91 : :
92 : : /**
93 : : * iommu_get_msi_cookie - Acquire just MSI remapping resources
94 : : * @domain: IOMMU domain to prepare
95 : : * @base: Start address of IOVA region for MSI mappings
96 : : *
97 : : * Users who manage their own IOVA allocation and do not want DMA API support,
98 : : * but would still like to take advantage of automatic MSI remapping, can use
99 : : * this to initialise their own domain appropriately. Users should reserve a
100 : : * contiguous IOVA region, starting at @base, large enough to accommodate the
101 : : * number of PAGE_SIZE mappings necessary to cover every MSI doorbell address
102 : : * used by the devices attached to @domain.
103 : : */
104 : 0 : int iommu_get_msi_cookie(struct iommu_domain *domain, dma_addr_t base)
105 : : {
106 : 0 : struct iommu_dma_cookie *cookie;
107 : :
108 [ # # ]: 0 : if (domain->type != IOMMU_DOMAIN_UNMANAGED)
109 : : return -EINVAL;
110 : :
111 [ # # ]: 0 : if (domain->iova_cookie)
112 : : return -EEXIST;
113 : :
114 : 0 : cookie = cookie_alloc(IOMMU_DMA_MSI_COOKIE);
115 [ # # ]: 0 : if (!cookie)
116 : : return -ENOMEM;
117 : :
118 : 0 : cookie->msi_iova = base;
119 : 0 : domain->iova_cookie = cookie;
120 : 0 : return 0;
121 : : }
122 : : EXPORT_SYMBOL(iommu_get_msi_cookie);
123 : :
124 : : /**
125 : : * iommu_put_dma_cookie - Release a domain's DMA mapping resources
126 : : * @domain: IOMMU domain previously prepared by iommu_get_dma_cookie() or
127 : : * iommu_get_msi_cookie()
128 : : *
129 : : * IOMMU drivers should normally call this from their domain_free callback.
130 : : */
131 : 0 : void iommu_put_dma_cookie(struct iommu_domain *domain)
132 : : {
133 : 0 : struct iommu_dma_cookie *cookie = domain->iova_cookie;
134 : 0 : struct iommu_dma_msi_page *msi, *tmp;
135 : :
136 [ # # ]: 0 : if (!cookie)
137 : : return;
138 : :
139 [ # # # # ]: 0 : if (cookie->type == IOMMU_DMA_IOVA_COOKIE && cookie->iovad.granule)
140 : 0 : put_iova_domain(&cookie->iovad);
141 : :
142 [ # # ]: 0 : list_for_each_entry_safe(msi, tmp, &cookie->msi_page_list, list) {
143 : 0 : list_del(&msi->list);
144 : 0 : kfree(msi);
145 : : }
146 : 0 : kfree(cookie);
147 : 0 : domain->iova_cookie = NULL;
148 : : }
149 : : EXPORT_SYMBOL(iommu_put_dma_cookie);
150 : :
151 : : /**
152 : : * iommu_dma_get_resv_regions - Reserved region driver helper
153 : : * @dev: Device from iommu_get_resv_regions()
154 : : * @list: Reserved region list from iommu_get_resv_regions()
155 : : *
156 : : * IOMMU drivers can use this to implement their .get_resv_regions callback
157 : : * for general non-IOMMU-specific reservations. Currently, this covers GICv3
158 : : * ITS region reservation on ACPI based ARM platforms that may require HW MSI
159 : : * reservation.
160 : : */
161 : 0 : void iommu_dma_get_resv_regions(struct device *dev, struct list_head *list)
162 : : {
163 : :
164 : 0 : if (!is_of_node(dev_iommu_fwspec_get(dev)->iommu_fwnode))
165 : 0 : iort_iommu_msi_get_resv_regions(dev, list);
166 : :
167 : 0 : }
168 : : EXPORT_SYMBOL(iommu_dma_get_resv_regions);
169 : :
170 : 0 : static int cookie_init_hw_msi_region(struct iommu_dma_cookie *cookie,
171 : : phys_addr_t start, phys_addr_t end)
172 : : {
173 : 0 : struct iova_domain *iovad = &cookie->iovad;
174 : 0 : struct iommu_dma_msi_page *msi_page;
175 : 0 : int i, num_pages;
176 : :
177 : 0 : start -= iova_offset(iovad, start);
178 : 0 : num_pages = iova_align(iovad, end - start) >> iova_shift(iovad);
179 : :
180 [ # # ]: 0 : for (i = 0; i < num_pages; i++) {
181 : 0 : msi_page = kmalloc(sizeof(*msi_page), GFP_KERNEL);
182 [ # # ]: 0 : if (!msi_page)
183 : : return -ENOMEM;
184 : :
185 : 0 : msi_page->phys = start;
186 : 0 : msi_page->iova = start;
187 : 0 : INIT_LIST_HEAD(&msi_page->list);
188 : 0 : list_add(&msi_page->list, &cookie->msi_page_list);
189 : 0 : start += iovad->granule;
190 : : }
191 : :
192 : : return 0;
193 : : }
194 : :
195 : 0 : static int iova_reserve_pci_windows(struct pci_dev *dev,
196 : : struct iova_domain *iovad)
197 : : {
198 : 0 : struct pci_host_bridge *bridge = pci_find_host_bridge(dev->bus);
199 : 0 : struct resource_entry *window;
200 : 0 : unsigned long lo, hi;
201 : 0 : phys_addr_t start = 0, end;
202 : :
203 [ # # ]: 0 : resource_list_for_each_entry(window, &bridge->windows) {
204 [ # # ]: 0 : if (resource_type(window->res) != IORESOURCE_MEM)
205 : 0 : continue;
206 : :
207 : 0 : lo = iova_pfn(iovad, window->res->start - window->offset);
208 : 0 : hi = iova_pfn(iovad, window->res->end - window->offset);
209 : 0 : reserve_iova(iovad, lo, hi);
210 : : }
211 : :
212 : : /* Get reserved DMA windows from host bridge */
213 [ # # ]: 0 : resource_list_for_each_entry(window, &bridge->dma_ranges) {
214 : 0 : end = window->res->start - window->offset;
215 : 0 : resv_iova:
216 [ # # ]: 0 : if (end > start) {
217 : 0 : lo = iova_pfn(iovad, start);
218 : 0 : hi = iova_pfn(iovad, end);
219 : 0 : reserve_iova(iovad, lo, hi);
220 : : } else {
221 : : /* dma_ranges list should be sorted */
222 : 0 : dev_err(&dev->dev, "Failed to reserve IOVA\n");
223 : 0 : return -EINVAL;
224 : : }
225 : :
226 : 0 : start = window->res->end - window->offset + 1;
227 : : /* If window is last entry */
228 [ # # # # ]: 0 : if (window->node.next == &bridge->dma_ranges &&
229 : : end != ~(phys_addr_t)0) {
230 : 0 : end = ~(phys_addr_t)0;
231 : 0 : goto resv_iova;
232 : : }
233 : : }
234 : :
235 : : return 0;
236 : : }
237 : :
238 : : static int iova_reserve_iommu_regions(struct device *dev,
239 : : struct iommu_domain *domain)
240 : : {
241 : : struct iommu_dma_cookie *cookie = domain->iova_cookie;
242 : : struct iova_domain *iovad = &cookie->iovad;
243 : : struct iommu_resv_region *region;
244 : : LIST_HEAD(resv_regions);
245 : : int ret = 0;
246 : :
247 : : if (dev_is_pci(dev)) {
248 : : ret = iova_reserve_pci_windows(to_pci_dev(dev), iovad);
249 : : if (ret)
250 : : return ret;
251 : : }
252 : :
253 : : iommu_get_resv_regions(dev, &resv_regions);
254 : : list_for_each_entry(region, &resv_regions, list) {
255 : : unsigned long lo, hi;
256 : :
257 : : /* We ARE the software that manages these! */
258 : : if (region->type == IOMMU_RESV_SW_MSI)
259 : : continue;
260 : :
261 : : lo = iova_pfn(iovad, region->start);
262 : : hi = iova_pfn(iovad, region->start + region->length - 1);
263 : : reserve_iova(iovad, lo, hi);
264 : :
265 : : if (region->type == IOMMU_RESV_MSI)
266 : : ret = cookie_init_hw_msi_region(cookie, region->start,
267 : : region->start + region->length);
268 : : if (ret)
269 : : break;
270 : : }
271 : : iommu_put_resv_regions(dev, &resv_regions);
272 : :
273 : : return ret;
274 : : }
275 : :
276 : 0 : static void iommu_dma_flush_iotlb_all(struct iova_domain *iovad)
277 : : {
278 : 0 : struct iommu_dma_cookie *cookie;
279 : 0 : struct iommu_domain *domain;
280 : :
281 : 0 : cookie = container_of(iovad, struct iommu_dma_cookie, iovad);
282 : 0 : domain = cookie->fq_domain;
283 : : /*
284 : : * The IOMMU driver supporting DOMAIN_ATTR_DMA_USE_FLUSH_QUEUE
285 : : * implies that ops->flush_iotlb_all must be non-NULL.
286 : : */
287 : 0 : domain->ops->flush_iotlb_all(domain);
288 : 0 : }
289 : :
290 : : /**
291 : : * iommu_dma_init_domain - Initialise a DMA mapping domain
292 : : * @domain: IOMMU domain previously prepared by iommu_get_dma_cookie()
293 : : * @base: IOVA at which the mappable address space starts
294 : : * @size: Size of IOVA space
295 : : * @dev: Device the domain is being initialised for
296 : : *
297 : : * @base and @size should be exact multiples of IOMMU page granularity to
298 : : * avoid rounding surprises. If necessary, we reserve the page at address 0
299 : : * to ensure it is an invalid IOVA. It is safe to reinitialise a domain, but
300 : : * any change which could make prior IOVAs invalid will fail.
301 : : */
302 : 0 : static int iommu_dma_init_domain(struct iommu_domain *domain, dma_addr_t base,
303 : : u64 size, struct device *dev)
304 : : {
305 : 0 : struct iommu_dma_cookie *cookie = domain->iova_cookie;
306 : 0 : unsigned long order, base_pfn;
307 : 0 : struct iova_domain *iovad;
308 : 0 : int attr;
309 : :
310 [ # # # # ]: 0 : if (!cookie || cookie->type != IOMMU_DMA_IOVA_COOKIE)
311 : : return -EINVAL;
312 : :
313 : 0 : iovad = &cookie->iovad;
314 : :
315 : : /* Use the smallest supported page size for IOVA granularity */
316 [ # # ]: 0 : order = __ffs(domain->pgsize_bitmap);
317 : 0 : base_pfn = max_t(unsigned long, 1, base >> order);
318 : :
319 : : /* Check the domain allows at least some access to the device... */
320 [ # # ]: 0 : if (domain->geometry.force_aperture) {
321 [ # # ]: 0 : if (base > domain->geometry.aperture_end ||
322 [ # # ]: 0 : base + size <= domain->geometry.aperture_start) {
323 : 0 : pr_warn("specified DMA range outside IOMMU capability\n");
324 : 0 : return -EFAULT;
325 : : }
326 : : /* ...then finally give it a kicking to make sure it fits */
327 : 0 : base_pfn = max_t(unsigned long, base_pfn,
328 : : domain->geometry.aperture_start >> order);
329 : : }
330 : :
331 : : /* start_pfn is always nonzero for an already-initialised domain */
332 [ # # ]: 0 : if (iovad->start_pfn) {
333 [ # # # # ]: 0 : if (1UL << order != iovad->granule ||
334 : : base_pfn != iovad->start_pfn) {
335 : 0 : pr_warn("Incompatible range for DMA domain\n");
336 : 0 : return -EFAULT;
337 : : }
338 : :
339 : : return 0;
340 : : }
341 : :
342 : 0 : init_iova_domain(iovad, 1UL << order, base_pfn);
343 : :
344 [ # # # # ]: 0 : if (!cookie->fq_domain && !iommu_domain_get_attr(domain,
345 [ # # ]: 0 : DOMAIN_ATTR_DMA_USE_FLUSH_QUEUE, &attr) && attr) {
346 : 0 : cookie->fq_domain = domain;
347 : 0 : init_iova_flush_queue(iovad, iommu_dma_flush_iotlb_all, NULL);
348 : : }
349 : :
350 [ # # ]: 0 : if (!dev)
351 : : return 0;
352 : :
353 : 0 : return iova_reserve_iommu_regions(dev, domain);
354 : : }
355 : :
356 : 0 : static int iommu_dma_deferred_attach(struct device *dev,
357 : : struct iommu_domain *domain)
358 : : {
359 : 0 : const struct iommu_ops *ops = domain->ops;
360 : :
361 [ # # ]: 0 : if (!is_kdump_kernel())
362 : : return 0;
363 : :
364 [ # # # # ]: 0 : if (unlikely(ops->is_attach_deferred &&
365 : : ops->is_attach_deferred(domain, dev)))
366 : 0 : return iommu_attach_device(domain, dev);
367 : :
368 : : return 0;
369 : : }
370 : :
371 : : /**
372 : : * dma_info_to_prot - Translate DMA API directions and attributes to IOMMU API
373 : : * page flags.
374 : : * @dir: Direction of DMA transfer
375 : : * @coherent: Is the DMA master cache-coherent?
376 : : * @attrs: DMA attributes for the mapping
377 : : *
378 : : * Return: corresponding IOMMU API page protection flags
379 : : */
380 : 0 : static int dma_info_to_prot(enum dma_data_direction dir, bool coherent,
381 : : unsigned long attrs)
382 : : {
383 : 0 : int prot = coherent ? IOMMU_CACHE : 0;
384 : :
385 [ # # # # ]: 0 : if (attrs & DMA_ATTR_PRIVILEGED)
386 : 0 : prot |= IOMMU_PRIV;
387 : :
388 [ # # # # : 0 : switch (dir) {
# # # # #
# # # ]
389 : 0 : case DMA_BIDIRECTIONAL:
390 : 0 : return prot | IOMMU_READ | IOMMU_WRITE;
391 : 0 : case DMA_TO_DEVICE:
392 : 0 : return prot | IOMMU_READ;
393 : 0 : case DMA_FROM_DEVICE:
394 : 0 : return prot | IOMMU_WRITE;
395 : : default:
396 : : return 0;
397 : : }
398 : : }
399 : :
400 : : static dma_addr_t iommu_dma_alloc_iova(struct iommu_domain *domain,
401 : : size_t size, u64 dma_limit, struct device *dev)
402 : : {
403 : : struct iommu_dma_cookie *cookie = domain->iova_cookie;
404 : : struct iova_domain *iovad = &cookie->iovad;
405 : : unsigned long shift, iova_len, iova = 0;
406 : :
407 : : if (cookie->type == IOMMU_DMA_MSI_COOKIE) {
408 : : cookie->msi_iova += size;
409 : : return cookie->msi_iova - size;
410 : : }
411 : :
412 : : shift = iova_shift(iovad);
413 : : iova_len = size >> shift;
414 : : /*
415 : : * Freeing non-power-of-two-sized allocations back into the IOVA caches
416 : : * will come back to bite us badly, so we have to waste a bit of space
417 : : * rounding up anything cacheable to make sure that can't happen. The
418 : : * order of the unadjusted size will still match upon freeing.
419 : : */
420 : : if (iova_len < (1 << (IOVA_RANGE_CACHE_MAX_SIZE - 1)))
421 : : iova_len = roundup_pow_of_two(iova_len);
422 : :
423 : : dma_limit = min_not_zero(dma_limit, dev->bus_dma_limit);
424 : :
425 : : if (domain->geometry.force_aperture)
426 : : dma_limit = min(dma_limit, (u64)domain->geometry.aperture_end);
427 : :
428 : : /* Try to get PCI devices a SAC address */
429 : : if (dma_limit > DMA_BIT_MASK(32) && dev_is_pci(dev))
430 : : iova = alloc_iova_fast(iovad, iova_len,
431 : : DMA_BIT_MASK(32) >> shift, false);
432 : :
433 : : if (!iova)
434 : : iova = alloc_iova_fast(iovad, iova_len, dma_limit >> shift,
435 : : true);
436 : :
437 : : return (dma_addr_t)iova << shift;
438 : : }
439 : :
440 : 0 : static void iommu_dma_free_iova(struct iommu_dma_cookie *cookie,
441 : : dma_addr_t iova, size_t size)
442 : : {
443 : 0 : struct iova_domain *iovad = &cookie->iovad;
444 : :
445 : : /* The MSI case is only ever cleaning up its most recent allocation */
446 [ # # ]: 0 : if (cookie->type == IOMMU_DMA_MSI_COOKIE)
447 : 0 : cookie->msi_iova -= size;
448 [ # # ]: 0 : else if (cookie->fq_domain) /* non-strict mode */
449 : 0 : queue_iova(iovad, iova_pfn(iovad, iova),
450 : 0 : size >> iova_shift(iovad), 0);
451 : : else
452 : 0 : free_iova_fast(iovad, iova_pfn(iovad, iova),
453 : 0 : size >> iova_shift(iovad));
454 : 0 : }
455 : :
456 : 0 : static void __iommu_dma_unmap(struct device *dev, dma_addr_t dma_addr,
457 : : size_t size)
458 : : {
459 : 0 : struct iommu_domain *domain = iommu_get_dma_domain(dev);
460 : 0 : struct iommu_dma_cookie *cookie = domain->iova_cookie;
461 : 0 : struct iova_domain *iovad = &cookie->iovad;
462 : 0 : size_t iova_off = iova_offset(iovad, dma_addr);
463 : 0 : struct iommu_iotlb_gather iotlb_gather;
464 : 0 : size_t unmapped;
465 : :
466 : 0 : dma_addr -= iova_off;
467 : 0 : size = iova_align(iovad, size + iova_off);
468 : 0 : iommu_iotlb_gather_init(&iotlb_gather);
469 : :
470 : 0 : unmapped = iommu_unmap_fast(domain, dma_addr, size, &iotlb_gather);
471 [ # # ]: 0 : WARN_ON(unmapped != size);
472 : :
473 [ # # ]: 0 : if (!cookie->fq_domain)
474 [ # # ]: 0 : iommu_tlb_sync(domain, &iotlb_gather);
475 : 0 : iommu_dma_free_iova(cookie, dma_addr, size);
476 : 0 : }
477 : :
478 : 0 : static dma_addr_t __iommu_dma_map(struct device *dev, phys_addr_t phys,
479 : : size_t size, int prot, u64 dma_mask)
480 : : {
481 : 0 : struct iommu_domain *domain = iommu_get_dma_domain(dev);
482 : 0 : struct iommu_dma_cookie *cookie = domain->iova_cookie;
483 : 0 : struct iova_domain *iovad = &cookie->iovad;
484 : 0 : size_t iova_off = iova_offset(iovad, phys);
485 : 0 : dma_addr_t iova;
486 : :
487 [ # # ]: 0 : if (unlikely(iommu_dma_deferred_attach(dev, domain)))
488 : : return DMA_MAPPING_ERROR;
489 : :
490 : 0 : size = iova_align(iovad, size + iova_off);
491 : :
492 : 0 : iova = iommu_dma_alloc_iova(domain, size, dma_mask, dev);
493 [ # # ]: 0 : if (!iova)
494 : : return DMA_MAPPING_ERROR;
495 : :
496 [ # # ]: 0 : if (iommu_map_atomic(domain, iova, phys - iova_off, size, prot)) {
497 : 0 : iommu_dma_free_iova(cookie, iova, size);
498 : 0 : return DMA_MAPPING_ERROR;
499 : : }
500 : 0 : return iova + iova_off;
501 : : }
502 : :
503 : : static void __iommu_dma_free_pages(struct page **pages, int count)
504 : : {
505 : : while (count--)
506 : : __free_page(pages[count]);
507 : : kvfree(pages);
508 : : }
509 : :
510 : : static struct page **__iommu_dma_alloc_pages(struct device *dev,
511 : : unsigned int count, unsigned long order_mask, gfp_t gfp)
512 : : {
513 : : struct page **pages;
514 : : unsigned int i = 0, nid = dev_to_node(dev);
515 : :
516 : : order_mask &= (2U << MAX_ORDER) - 1;
517 : : if (!order_mask)
518 : : return NULL;
519 : :
520 : : pages = kvzalloc(count * sizeof(*pages), GFP_KERNEL);
521 : : if (!pages)
522 : : return NULL;
523 : :
524 : : /* IOMMU can map any pages, so himem can also be used here */
525 : : gfp |= __GFP_NOWARN | __GFP_HIGHMEM;
526 : :
527 : : while (count) {
528 : : struct page *page = NULL;
529 : : unsigned int order_size;
530 : :
531 : : /*
532 : : * Higher-order allocations are a convenience rather
533 : : * than a necessity, hence using __GFP_NORETRY until
534 : : * falling back to minimum-order allocations.
535 : : */
536 : : for (order_mask &= (2U << __fls(count)) - 1;
537 : : order_mask; order_mask &= ~order_size) {
538 : : unsigned int order = __fls(order_mask);
539 : : gfp_t alloc_flags = gfp;
540 : :
541 : : order_size = 1U << order;
542 : : if (order_mask > order_size)
543 : : alloc_flags |= __GFP_NORETRY;
544 : : page = alloc_pages_node(nid, alloc_flags, order);
545 : : if (!page)
546 : : continue;
547 : : if (!order)
548 : : break;
549 : : if (!PageCompound(page)) {
550 : : split_page(page, order);
551 : : break;
552 : : } else if (!split_huge_page(page)) {
553 : : break;
554 : : }
555 : : __free_pages(page, order);
556 : : }
557 : : if (!page) {
558 : : __iommu_dma_free_pages(pages, i);
559 : : return NULL;
560 : : }
561 : : count -= order_size;
562 : : while (order_size--)
563 : : pages[i++] = page++;
564 : : }
565 : : return pages;
566 : : }
567 : :
568 : : /**
569 : : * iommu_dma_alloc_remap - Allocate and map a buffer contiguous in IOVA space
570 : : * @dev: Device to allocate memory for. Must be a real device
571 : : * attached to an iommu_dma_domain
572 : : * @size: Size of buffer in bytes
573 : : * @dma_handle: Out argument for allocated DMA handle
574 : : * @gfp: Allocation flags
575 : : * @attrs: DMA attributes for this allocation
576 : : *
577 : : * If @size is less than PAGE_SIZE, then a full CPU page will be allocated,
578 : : * but an IOMMU which supports smaller pages might not map the whole thing.
579 : : *
580 : : * Return: Mapped virtual address, or NULL on failure.
581 : : */
582 : : static void *iommu_dma_alloc_remap(struct device *dev, size_t size,
583 : : dma_addr_t *dma_handle, gfp_t gfp, unsigned long attrs)
584 : : {
585 : : struct iommu_domain *domain = iommu_get_dma_domain(dev);
586 : : struct iommu_dma_cookie *cookie = domain->iova_cookie;
587 : : struct iova_domain *iovad = &cookie->iovad;
588 : : bool coherent = dev_is_dma_coherent(dev);
589 : : int ioprot = dma_info_to_prot(DMA_BIDIRECTIONAL, coherent, attrs);
590 : : pgprot_t prot = dma_pgprot(dev, PAGE_KERNEL, attrs);
591 : : unsigned int count, min_size, alloc_sizes = domain->pgsize_bitmap;
592 : : struct page **pages;
593 : : struct sg_table sgt;
594 : : dma_addr_t iova;
595 : : void *vaddr;
596 : :
597 : : *dma_handle = DMA_MAPPING_ERROR;
598 : :
599 : : if (unlikely(iommu_dma_deferred_attach(dev, domain)))
600 : : return NULL;
601 : :
602 : : min_size = alloc_sizes & -alloc_sizes;
603 : : if (min_size < PAGE_SIZE) {
604 : : min_size = PAGE_SIZE;
605 : : alloc_sizes |= PAGE_SIZE;
606 : : } else {
607 : : size = ALIGN(size, min_size);
608 : : }
609 : : if (attrs & DMA_ATTR_ALLOC_SINGLE_PAGES)
610 : : alloc_sizes = min_size;
611 : :
612 : : count = PAGE_ALIGN(size) >> PAGE_SHIFT;
613 : : pages = __iommu_dma_alloc_pages(dev, count, alloc_sizes >> PAGE_SHIFT,
614 : : gfp);
615 : : if (!pages)
616 : : return NULL;
617 : :
618 : : size = iova_align(iovad, size);
619 : : iova = iommu_dma_alloc_iova(domain, size, dev->coherent_dma_mask, dev);
620 : : if (!iova)
621 : : goto out_free_pages;
622 : :
623 : : if (sg_alloc_table_from_pages(&sgt, pages, count, 0, size, GFP_KERNEL))
624 : : goto out_free_iova;
625 : :
626 : : if (!(ioprot & IOMMU_CACHE)) {
627 : : struct scatterlist *sg;
628 : : int i;
629 : :
630 : : for_each_sg(sgt.sgl, sg, sgt.orig_nents, i)
631 : : arch_dma_prep_coherent(sg_page(sg), sg->length);
632 : : }
633 : :
634 : : if (iommu_map_sg_atomic(domain, iova, sgt.sgl, sgt.orig_nents, ioprot)
635 : : < size)
636 : : goto out_free_sg;
637 : :
638 : : vaddr = dma_common_pages_remap(pages, size, prot,
639 : : __builtin_return_address(0));
640 : : if (!vaddr)
641 : : goto out_unmap;
642 : :
643 : : *dma_handle = iova;
644 : : sg_free_table(&sgt);
645 : : return vaddr;
646 : :
647 : : out_unmap:
648 : : __iommu_dma_unmap(dev, iova, size);
649 : : out_free_sg:
650 : : sg_free_table(&sgt);
651 : : out_free_iova:
652 : : iommu_dma_free_iova(cookie, iova, size);
653 : : out_free_pages:
654 : : __iommu_dma_free_pages(pages, count);
655 : : return NULL;
656 : : }
657 : :
658 : : /**
659 : : * __iommu_dma_mmap - Map a buffer into provided user VMA
660 : : * @pages: Array representing buffer from __iommu_dma_alloc()
661 : : * @size: Size of buffer in bytes
662 : : * @vma: VMA describing requested userspace mapping
663 : : *
664 : : * Maps the pages of the buffer in @pages into @vma. The caller is responsible
665 : : * for verifying the correct size and protection of @vma beforehand.
666 : : */
667 : : static int __iommu_dma_mmap(struct page **pages, size_t size,
668 : : struct vm_area_struct *vma)
669 : : {
670 : : return vm_map_pages(vma, pages, PAGE_ALIGN(size) >> PAGE_SHIFT);
671 : : }
672 : :
673 : 0 : static void iommu_dma_sync_single_for_cpu(struct device *dev,
674 : : dma_addr_t dma_handle, size_t size, enum dma_data_direction dir)
675 : : {
676 : 0 : phys_addr_t phys;
677 : :
678 : 0 : if (dev_is_dma_coherent(dev))
679 : 0 : return;
680 : :
681 : : phys = iommu_iova_to_phys(iommu_get_dma_domain(dev), dma_handle);
682 : : arch_sync_dma_for_cpu(phys, size, dir);
683 : : }
684 : :
685 : 0 : static void iommu_dma_sync_single_for_device(struct device *dev,
686 : : dma_addr_t dma_handle, size_t size, enum dma_data_direction dir)
687 : : {
688 : 0 : phys_addr_t phys;
689 : :
690 : 0 : if (dev_is_dma_coherent(dev))
691 : 0 : return;
692 : :
693 : : phys = iommu_iova_to_phys(iommu_get_dma_domain(dev), dma_handle);
694 : : arch_sync_dma_for_device(phys, size, dir);
695 : : }
696 : :
697 : 0 : static void iommu_dma_sync_sg_for_cpu(struct device *dev,
698 : : struct scatterlist *sgl, int nelems,
699 : : enum dma_data_direction dir)
700 : : {
701 : 0 : struct scatterlist *sg;
702 : 0 : int i;
703 : :
704 : 0 : if (dev_is_dma_coherent(dev))
705 : 0 : return;
706 : :
707 : : for_each_sg(sgl, sg, nelems, i)
708 : : arch_sync_dma_for_cpu(sg_phys(sg), sg->length, dir);
709 : : }
710 : :
711 : 0 : static void iommu_dma_sync_sg_for_device(struct device *dev,
712 : : struct scatterlist *sgl, int nelems,
713 : : enum dma_data_direction dir)
714 : : {
715 : 0 : struct scatterlist *sg;
716 : 0 : int i;
717 : :
718 : 0 : if (dev_is_dma_coherent(dev))
719 : 0 : return;
720 : :
721 : : for_each_sg(sgl, sg, nelems, i)
722 : : arch_sync_dma_for_device(sg_phys(sg), sg->length, dir);
723 : : }
724 : :
725 : 0 : static dma_addr_t iommu_dma_map_page(struct device *dev, struct page *page,
726 : : unsigned long offset, size_t size, enum dma_data_direction dir,
727 : : unsigned long attrs)
728 : : {
729 : 0 : phys_addr_t phys = page_to_phys(page) + offset;
730 [ # # ]: 0 : bool coherent = dev_is_dma_coherent(dev);
731 [ # # ]: 0 : int prot = dma_info_to_prot(dir, coherent, attrs);
732 : 0 : dma_addr_t dma_handle;
733 : :
734 [ # # ]: 0 : dma_handle = __iommu_dma_map(dev, phys, size, prot, dma_get_mask(dev));
735 : 0 : if (!coherent && !(attrs & DMA_ATTR_SKIP_CPU_SYNC) &&
736 : : dma_handle != DMA_MAPPING_ERROR)
737 : : arch_sync_dma_for_device(phys, size, dir);
738 : 0 : return dma_handle;
739 : : }
740 : :
741 : 0 : static void iommu_dma_unmap_page(struct device *dev, dma_addr_t dma_handle,
742 : : size_t size, enum dma_data_direction dir, unsigned long attrs)
743 : : {
744 : 0 : if (!(attrs & DMA_ATTR_SKIP_CPU_SYNC))
745 : : iommu_dma_sync_single_for_cpu(dev, dma_handle, size, dir);
746 : 0 : __iommu_dma_unmap(dev, dma_handle, size);
747 : 0 : }
748 : :
749 : : /*
750 : : * Prepare a successfully-mapped scatterlist to give back to the caller.
751 : : *
752 : : * At this point the segments are already laid out by iommu_dma_map_sg() to
753 : : * avoid individually crossing any boundaries, so we merely need to check a
754 : : * segment's start address to avoid concatenating across one.
755 : : */
756 : 0 : static int __finalise_sg(struct device *dev, struct scatterlist *sg, int nents,
757 : : dma_addr_t dma_addr)
758 : : {
759 : 0 : struct scatterlist *s, *cur = sg;
760 [ # # ]: 0 : unsigned long seg_mask = dma_get_seg_boundary(dev);
761 [ # # ]: 0 : unsigned int cur_len = 0, max_len = dma_get_max_seg_size(dev);
762 : 0 : int i, count = 0;
763 : :
764 [ # # ]: 0 : for_each_sg(sg, s, nents, i) {
765 : : /* Restore this segment's original unaligned fields first */
766 : 0 : unsigned int s_iova_off = sg_dma_address(s);
767 : 0 : unsigned int s_length = sg_dma_len(s);
768 : 0 : unsigned int s_iova_len = s->length;
769 : :
770 : 0 : s->offset += s_iova_off;
771 : 0 : s->length = s_length;
772 : 0 : sg_dma_address(s) = DMA_MAPPING_ERROR;
773 : 0 : sg_dma_len(s) = 0;
774 : :
775 : : /*
776 : : * Now fill in the real DMA data. If...
777 : : * - there is a valid output segment to append to
778 : : * - and this segment starts on an IOVA page boundary
779 : : * - but doesn't fall at a segment boundary
780 : : * - and wouldn't make the resulting output segment too long
781 : : */
782 [ # # # # ]: 0 : if (cur_len && !s_iova_off && (dma_addr & seg_mask) &&
783 [ # # ]: 0 : (max_len - cur_len >= s_length)) {
784 : : /* ...then concatenate it with the previous one */
785 : 0 : cur_len += s_length;
786 : : } else {
787 : : /* Otherwise start the next output segment */
788 [ # # ]: 0 : if (i > 0)
789 : 0 : cur = sg_next(cur);
790 : 0 : cur_len = s_length;
791 : 0 : count++;
792 : :
793 : 0 : sg_dma_address(cur) = dma_addr + s_iova_off;
794 : : }
795 : :
796 : 0 : sg_dma_len(cur) = cur_len;
797 : 0 : dma_addr += s_iova_len;
798 : :
799 [ # # ]: 0 : if (s_length + s_iova_off < s_iova_len)
800 : 0 : cur_len = 0;
801 : : }
802 : 0 : return count;
803 : : }
804 : :
805 : : /*
806 : : * If mapping failed, then just restore the original list,
807 : : * but making sure the DMA fields are invalidated.
808 : : */
809 : 0 : static void __invalidate_sg(struct scatterlist *sg, int nents)
810 : : {
811 : 0 : struct scatterlist *s;
812 : 0 : int i;
813 : :
814 [ # # ]: 0 : for_each_sg(sg, s, nents, i) {
815 [ # # ]: 0 : if (sg_dma_address(s) != DMA_MAPPING_ERROR)
816 : 0 : s->offset += sg_dma_address(s);
817 [ # # ]: 0 : if (sg_dma_len(s))
818 : 0 : s->length = sg_dma_len(s);
819 : 0 : sg_dma_address(s) = DMA_MAPPING_ERROR;
820 : 0 : sg_dma_len(s) = 0;
821 : : }
822 : 0 : }
823 : :
824 : : /*
825 : : * The DMA API client is passing in a scatterlist which could describe
826 : : * any old buffer layout, but the IOMMU API requires everything to be
827 : : * aligned to IOMMU pages. Hence the need for this complicated bit of
828 : : * impedance-matching, to be able to hand off a suitably-aligned list,
829 : : * but still preserve the original offsets and sizes for the caller.
830 : : */
831 : 0 : static int iommu_dma_map_sg(struct device *dev, struct scatterlist *sg,
832 : : int nents, enum dma_data_direction dir, unsigned long attrs)
833 : : {
834 : 0 : struct iommu_domain *domain = iommu_get_dma_domain(dev);
835 : 0 : struct iommu_dma_cookie *cookie = domain->iova_cookie;
836 : 0 : struct iova_domain *iovad = &cookie->iovad;
837 : 0 : struct scatterlist *s, *prev = NULL;
838 [ # # ]: 0 : int prot = dma_info_to_prot(dir, dev_is_dma_coherent(dev), attrs);
839 : 0 : dma_addr_t iova;
840 : 0 : size_t iova_len = 0;
841 [ # # ]: 0 : unsigned long mask = dma_get_seg_boundary(dev);
842 : 0 : int i;
843 : :
844 [ # # ]: 0 : if (unlikely(iommu_dma_deferred_attach(dev, domain)))
845 : : return 0;
846 : :
847 : : if (!(attrs & DMA_ATTR_SKIP_CPU_SYNC))
848 : : iommu_dma_sync_sg_for_device(dev, sg, nents, dir);
849 : :
850 : : /*
851 : : * Work out how much IOVA space we need, and align the segments to
852 : : * IOVA granules for the IOMMU driver to handle. With some clever
853 : : * trickery we can modify the list in-place, but reversibly, by
854 : : * stashing the unaligned parts in the as-yet-unused DMA fields.
855 : : */
856 [ # # ]: 0 : for_each_sg(sg, s, nents, i) {
857 [ # # ]: 0 : size_t s_iova_off = iova_offset(iovad, s->offset);
858 : 0 : size_t s_length = s->length;
859 : 0 : size_t pad_len = (mask - iova_len + 1) & mask;
860 : :
861 : 0 : sg_dma_address(s) = s_iova_off;
862 : 0 : sg_dma_len(s) = s_length;
863 : 0 : s->offset -= s_iova_off;
864 [ # # ]: 0 : s_length = iova_align(iovad, s_length + s_iova_off);
865 : 0 : s->length = s_length;
866 : :
867 : : /*
868 : : * Due to the alignment of our single IOVA allocation, we can
869 : : * depend on these assumptions about the segment boundary mask:
870 : : * - If mask size >= IOVA size, then the IOVA range cannot
871 : : * possibly fall across a boundary, so we don't care.
872 : : * - If mask size < IOVA size, then the IOVA range must start
873 : : * exactly on a boundary, therefore we can lay things out
874 : : * based purely on segment lengths without needing to know
875 : : * the actual addresses beforehand.
876 : : * - The mask must be a power of 2, so pad_len == 0 if
877 : : * iova_len == 0, thus we cannot dereference prev the first
878 : : * time through here (i.e. before it has a meaningful value).
879 : : */
880 [ # # # # ]: 0 : if (pad_len && pad_len < s_length - 1) {
881 : 0 : prev->length += pad_len;
882 : 0 : iova_len += pad_len;
883 : : }
884 : :
885 : 0 : iova_len += s_length;
886 : 0 : prev = s;
887 : : }
888 : :
889 [ # # ]: 0 : iova = iommu_dma_alloc_iova(domain, iova_len, dma_get_mask(dev), dev);
890 [ # # ]: 0 : if (!iova)
891 : 0 : goto out_restore_sg;
892 : :
893 : : /*
894 : : * We'll leave any physical concatenation to the IOMMU driver's
895 : : * implementation - it knows better than we do.
896 : : */
897 [ # # ]: 0 : if (iommu_map_sg_atomic(domain, iova, sg, nents, prot) < iova_len)
898 : 0 : goto out_free_iova;
899 : :
900 : 0 : return __finalise_sg(dev, sg, nents, iova);
901 : :
902 : : out_free_iova:
903 : 0 : iommu_dma_free_iova(cookie, iova, iova_len);
904 : 0 : out_restore_sg:
905 : 0 : __invalidate_sg(sg, nents);
906 : 0 : return 0;
907 : : }
908 : :
909 : 0 : static void iommu_dma_unmap_sg(struct device *dev, struct scatterlist *sg,
910 : : int nents, enum dma_data_direction dir, unsigned long attrs)
911 : : {
912 : 0 : dma_addr_t start, end;
913 : 0 : struct scatterlist *tmp;
914 : 0 : int i;
915 : :
916 : 0 : if (!(attrs & DMA_ATTR_SKIP_CPU_SYNC))
917 : : iommu_dma_sync_sg_for_cpu(dev, sg, nents, dir);
918 : :
919 : : /*
920 : : * The scatterlist segments are mapped into a single
921 : : * contiguous IOVA allocation, so this is incredibly easy.
922 : : */
923 : 0 : start = sg_dma_address(sg);
924 [ # # ]: 0 : for_each_sg(sg_next(sg), tmp, nents - 1, i) {
925 [ # # ]: 0 : if (sg_dma_len(tmp) == 0)
926 : : break;
927 : 0 : sg = tmp;
928 : : }
929 : 0 : end = sg_dma_address(sg) + sg_dma_len(sg);
930 : 0 : __iommu_dma_unmap(dev, start, end - start);
931 : 0 : }
932 : :
933 : 0 : static dma_addr_t iommu_dma_map_resource(struct device *dev, phys_addr_t phys,
934 : : size_t size, enum dma_data_direction dir, unsigned long attrs)
935 : : {
936 [ # # ]: 0 : return __iommu_dma_map(dev, phys, size,
937 : : dma_info_to_prot(dir, false, attrs) | IOMMU_MMIO,
938 : : dma_get_mask(dev));
939 : : }
940 : :
941 : 0 : static void iommu_dma_unmap_resource(struct device *dev, dma_addr_t handle,
942 : : size_t size, enum dma_data_direction dir, unsigned long attrs)
943 : : {
944 : 0 : __iommu_dma_unmap(dev, handle, size);
945 : 0 : }
946 : :
947 : : static void __iommu_dma_free(struct device *dev, size_t size, void *cpu_addr)
948 : : {
949 : : size_t alloc_size = PAGE_ALIGN(size);
950 : : int count = alloc_size >> PAGE_SHIFT;
951 : : struct page *page = NULL, **pages = NULL;
952 : :
953 : : /* Non-coherent atomic allocation? Easy */
954 : : if (IS_ENABLED(CONFIG_DMA_DIRECT_REMAP) &&
955 : : dma_free_from_pool(cpu_addr, alloc_size))
956 : : return;
957 : :
958 : : if (IS_ENABLED(CONFIG_DMA_REMAP) && is_vmalloc_addr(cpu_addr)) {
959 : : /*
960 : : * If it the address is remapped, then it's either non-coherent
961 : : * or highmem CMA, or an iommu_dma_alloc_remap() construction.
962 : : */
963 : : pages = dma_common_find_pages(cpu_addr);
964 : : if (!pages)
965 : : page = vmalloc_to_page(cpu_addr);
966 : : dma_common_free_remap(cpu_addr, alloc_size);
967 : : } else {
968 : : /* Lowmem means a coherent atomic or CMA allocation */
969 : : page = virt_to_page(cpu_addr);
970 : : }
971 : :
972 : : if (pages)
973 : : __iommu_dma_free_pages(pages, count);
974 : : if (page)
975 : : dma_free_contiguous(dev, page, alloc_size);
976 : : }
977 : :
978 : 0 : static void iommu_dma_free(struct device *dev, size_t size, void *cpu_addr,
979 : : dma_addr_t handle, unsigned long attrs)
980 : : {
981 : 0 : __iommu_dma_unmap(dev, handle, size);
982 : 0 : __iommu_dma_free(dev, size, cpu_addr);
983 : 0 : }
984 : :
985 : : static void *iommu_dma_alloc_pages(struct device *dev, size_t size,
986 : : struct page **pagep, gfp_t gfp, unsigned long attrs)
987 : : {
988 : : bool coherent = dev_is_dma_coherent(dev);
989 : : size_t alloc_size = PAGE_ALIGN(size);
990 : : int node = dev_to_node(dev);
991 : : struct page *page = NULL;
992 : : void *cpu_addr;
993 : :
994 : : page = dma_alloc_contiguous(dev, alloc_size, gfp);
995 : : if (!page)
996 : : page = alloc_pages_node(node, gfp, get_order(alloc_size));
997 : : if (!page)
998 : : return NULL;
999 : :
1000 : : if (IS_ENABLED(CONFIG_DMA_REMAP) && (!coherent || PageHighMem(page))) {
1001 : : pgprot_t prot = dma_pgprot(dev, PAGE_KERNEL, attrs);
1002 : :
1003 : : cpu_addr = dma_common_contiguous_remap(page, alloc_size,
1004 : : prot, __builtin_return_address(0));
1005 : : if (!cpu_addr)
1006 : : goto out_free_pages;
1007 : :
1008 : : if (!coherent)
1009 : : arch_dma_prep_coherent(page, size);
1010 : : } else {
1011 : : cpu_addr = page_address(page);
1012 : : }
1013 : :
1014 : : *pagep = page;
1015 : : memset(cpu_addr, 0, alloc_size);
1016 : : return cpu_addr;
1017 : : out_free_pages:
1018 : : dma_free_contiguous(dev, page, alloc_size);
1019 : : return NULL;
1020 : : }
1021 : :
1022 : 0 : static void *iommu_dma_alloc(struct device *dev, size_t size,
1023 : : dma_addr_t *handle, gfp_t gfp, unsigned long attrs)
1024 : : {
1025 [ # # ]: 0 : bool coherent = dev_is_dma_coherent(dev);
1026 [ # # ]: 0 : int ioprot = dma_info_to_prot(DMA_BIDIRECTIONAL, coherent, attrs);
1027 : 0 : struct page *page = NULL;
1028 : 0 : void *cpu_addr;
1029 : :
1030 : 0 : gfp |= __GFP_ZERO;
1031 : :
1032 : 0 : if (IS_ENABLED(CONFIG_DMA_REMAP) && gfpflags_allow_blocking(gfp) &&
1033 : : !(attrs & DMA_ATTR_FORCE_CONTIGUOUS))
1034 : : return iommu_dma_alloc_remap(dev, size, handle, gfp, attrs);
1035 : :
1036 : 0 : if (IS_ENABLED(CONFIG_DMA_DIRECT_REMAP) &&
1037 : : !gfpflags_allow_blocking(gfp) && !coherent)
1038 : : cpu_addr = dma_alloc_from_pool(PAGE_ALIGN(size), &page, gfp);
1039 : : else
1040 : 0 : cpu_addr = iommu_dma_alloc_pages(dev, size, &page, gfp, attrs);
1041 [ # # ]: 0 : if (!cpu_addr)
1042 : : return NULL;
1043 : :
1044 : 0 : *handle = __iommu_dma_map(dev, page_to_phys(page), size, ioprot,
1045 : : dev->coherent_dma_mask);
1046 [ # # ]: 0 : if (*handle == DMA_MAPPING_ERROR) {
1047 : 0 : __iommu_dma_free(dev, size, cpu_addr);
1048 : 0 : return NULL;
1049 : : }
1050 : :
1051 : : return cpu_addr;
1052 : : }
1053 : :
1054 : 0 : static int iommu_dma_mmap(struct device *dev, struct vm_area_struct *vma,
1055 : : void *cpu_addr, dma_addr_t dma_addr, size_t size,
1056 : : unsigned long attrs)
1057 : : {
1058 : 0 : unsigned long nr_pages = PAGE_ALIGN(size) >> PAGE_SHIFT;
1059 : 0 : unsigned long pfn, off = vma->vm_pgoff;
1060 : 0 : int ret;
1061 : :
1062 : 0 : vma->vm_page_prot = dma_pgprot(dev, vma->vm_page_prot, attrs);
1063 : :
1064 : 0 : if (dma_mmap_from_dev_coherent(dev, vma, cpu_addr, size, &ret))
1065 : : return ret;
1066 : :
1067 [ # # # # ]: 0 : if (off >= nr_pages || vma_pages(vma) > nr_pages - off)
1068 : : return -ENXIO;
1069 : :
1070 : 0 : if (IS_ENABLED(CONFIG_DMA_REMAP) && is_vmalloc_addr(cpu_addr)) {
1071 : : struct page **pages = dma_common_find_pages(cpu_addr);
1072 : :
1073 : : if (pages)
1074 : : return __iommu_dma_mmap(pages, size, vma);
1075 : : pfn = vmalloc_to_pfn(cpu_addr);
1076 : : } else {
1077 [ # # ]: 0 : pfn = page_to_pfn(virt_to_page(cpu_addr));
1078 : : }
1079 : :
1080 : 0 : return remap_pfn_range(vma, vma->vm_start, pfn + off,
1081 : : vma->vm_end - vma->vm_start,
1082 : : vma->vm_page_prot);
1083 : : }
1084 : :
1085 : 0 : static int iommu_dma_get_sgtable(struct device *dev, struct sg_table *sgt,
1086 : : void *cpu_addr, dma_addr_t dma_addr, size_t size,
1087 : : unsigned long attrs)
1088 : : {
1089 : 0 : struct page *page;
1090 : 0 : int ret;
1091 : :
1092 : 0 : if (IS_ENABLED(CONFIG_DMA_REMAP) && is_vmalloc_addr(cpu_addr)) {
1093 : : struct page **pages = dma_common_find_pages(cpu_addr);
1094 : :
1095 : : if (pages) {
1096 : : return sg_alloc_table_from_pages(sgt, pages,
1097 : : PAGE_ALIGN(size) >> PAGE_SHIFT,
1098 : : 0, size, GFP_KERNEL);
1099 : : }
1100 : :
1101 : : page = vmalloc_to_page(cpu_addr);
1102 : : } else {
1103 [ # # ]: 0 : page = virt_to_page(cpu_addr);
1104 : : }
1105 : :
1106 : 0 : ret = sg_alloc_table(sgt, 1, GFP_KERNEL);
1107 [ # # ]: 0 : if (!ret)
1108 [ # # ]: 0 : sg_set_page(sgt->sgl, page, PAGE_ALIGN(size), 0);
1109 : 0 : return ret;
1110 : : }
1111 : :
1112 : 0 : static unsigned long iommu_dma_get_merge_boundary(struct device *dev)
1113 : : {
1114 : 0 : struct iommu_domain *domain = iommu_get_dma_domain(dev);
1115 : :
1116 : 0 : return (1UL << __ffs(domain->pgsize_bitmap)) - 1;
1117 : : }
1118 : :
1119 : : static const struct dma_map_ops iommu_dma_ops = {
1120 : : .alloc = iommu_dma_alloc,
1121 : : .free = iommu_dma_free,
1122 : : .mmap = iommu_dma_mmap,
1123 : : .get_sgtable = iommu_dma_get_sgtable,
1124 : : .map_page = iommu_dma_map_page,
1125 : : .unmap_page = iommu_dma_unmap_page,
1126 : : .map_sg = iommu_dma_map_sg,
1127 : : .unmap_sg = iommu_dma_unmap_sg,
1128 : : .sync_single_for_cpu = iommu_dma_sync_single_for_cpu,
1129 : : .sync_single_for_device = iommu_dma_sync_single_for_device,
1130 : : .sync_sg_for_cpu = iommu_dma_sync_sg_for_cpu,
1131 : : .sync_sg_for_device = iommu_dma_sync_sg_for_device,
1132 : : .map_resource = iommu_dma_map_resource,
1133 : : .unmap_resource = iommu_dma_unmap_resource,
1134 : : .get_merge_boundary = iommu_dma_get_merge_boundary,
1135 : : };
1136 : :
1137 : : /*
1138 : : * The IOMMU core code allocates the default DMA domain, which the underlying
1139 : : * IOMMU driver needs to support via the dma-iommu layer.
1140 : : */
1141 : 0 : void iommu_setup_dma_ops(struct device *dev, u64 dma_base, u64 size)
1142 : : {
1143 : 0 : struct iommu_domain *domain = iommu_get_domain_for_dev(dev);
1144 : :
1145 [ # # ]: 0 : if (!domain)
1146 : 0 : goto out_err;
1147 : :
1148 : : /*
1149 : : * The IOMMU core code allocates the default DMA domain, which the
1150 : : * underlying IOMMU driver needs to support via the dma-iommu layer.
1151 : : */
1152 [ # # ]: 0 : if (domain->type == IOMMU_DOMAIN_DMA) {
1153 [ # # ]: 0 : if (iommu_dma_init_domain(domain, dma_base, size, dev))
1154 : 0 : goto out_err;
1155 : 0 : dev->dma_ops = &iommu_dma_ops;
1156 : : }
1157 : :
1158 : : return;
1159 : 0 : out_err:
1160 [ # # ]: 0 : pr_warn("Failed to set up IOMMU for device %s; retaining platform DMA ops\n",
1161 : : dev_name(dev));
1162 : : }
1163 : :
1164 : 0 : static struct iommu_dma_msi_page *iommu_dma_get_msi_page(struct device *dev,
1165 : : phys_addr_t msi_addr, struct iommu_domain *domain)
1166 : : {
1167 : 0 : struct iommu_dma_cookie *cookie = domain->iova_cookie;
1168 : 0 : struct iommu_dma_msi_page *msi_page;
1169 : 0 : dma_addr_t iova;
1170 : 0 : int prot = IOMMU_WRITE | IOMMU_NOEXEC | IOMMU_MMIO;
1171 [ # # ]: 0 : size_t size = cookie_msi_granule(cookie);
1172 : :
1173 : 0 : msi_addr &= ~(phys_addr_t)(size - 1);
1174 [ # # ]: 0 : list_for_each_entry(msi_page, &cookie->msi_page_list, list)
1175 [ # # ]: 0 : if (msi_page->phys == msi_addr)
1176 : 0 : return msi_page;
1177 : :
1178 : 0 : msi_page = kzalloc(sizeof(*msi_page), GFP_KERNEL);
1179 [ # # ]: 0 : if (!msi_page)
1180 : : return NULL;
1181 : :
1182 [ # # ]: 0 : iova = iommu_dma_alloc_iova(domain, size, dma_get_mask(dev), dev);
1183 [ # # ]: 0 : if (!iova)
1184 : 0 : goto out_free_page;
1185 : :
1186 [ # # ]: 0 : if (iommu_map(domain, iova, msi_addr, size, prot))
1187 : 0 : goto out_free_iova;
1188 : :
1189 : 0 : INIT_LIST_HEAD(&msi_page->list);
1190 : 0 : msi_page->phys = msi_addr;
1191 : 0 : msi_page->iova = iova;
1192 : 0 : list_add(&msi_page->list, &cookie->msi_page_list);
1193 : 0 : return msi_page;
1194 : :
1195 : : out_free_iova:
1196 : 0 : iommu_dma_free_iova(cookie, iova, size);
1197 : 0 : out_free_page:
1198 : 0 : kfree(msi_page);
1199 : 0 : return NULL;
1200 : : }
1201 : :
1202 : 0 : int iommu_dma_prepare_msi(struct msi_desc *desc, phys_addr_t msi_addr)
1203 : : {
1204 : 0 : struct device *dev = msi_desc_to_dev(desc);
1205 : 0 : struct iommu_domain *domain = iommu_get_domain_for_dev(dev);
1206 : 0 : struct iommu_dma_msi_page *msi_page;
1207 : 0 : static DEFINE_MUTEX(msi_prepare_lock); /* see below */
1208 : :
1209 [ # # # # ]: 0 : if (!domain || !domain->iova_cookie) {
1210 : 0 : desc->iommu_cookie = NULL;
1211 : 0 : return 0;
1212 : : }
1213 : :
1214 : : /*
1215 : : * In fact the whole prepare operation should already be serialised by
1216 : : * irq_domain_mutex further up the callchain, but that's pretty subtle
1217 : : * on its own, so consider this locking as failsafe documentation...
1218 : : */
1219 : 0 : mutex_lock(&msi_prepare_lock);
1220 : 0 : msi_page = iommu_dma_get_msi_page(dev, msi_addr, domain);
1221 : 0 : mutex_unlock(&msi_prepare_lock);
1222 : :
1223 [ # # ]: 0 : msi_desc_set_iommu_cookie(desc, msi_page);
1224 : :
1225 [ # # ]: 0 : if (!msi_page)
1226 : 0 : return -ENOMEM;
1227 : : return 0;
1228 : : }
1229 : :
1230 : 0 : void iommu_dma_compose_msi_msg(struct msi_desc *desc,
1231 : : struct msi_msg *msg)
1232 : : {
1233 : 0 : struct device *dev = msi_desc_to_dev(desc);
1234 : 0 : const struct iommu_domain *domain = iommu_get_domain_for_dev(dev);
1235 : 0 : const struct iommu_dma_msi_page *msi_page;
1236 : :
1237 [ # # ]: 0 : msi_page = msi_desc_get_iommu_cookie(desc);
1238 : :
1239 [ # # # # : 0 : if (!domain || !domain->iova_cookie || WARN_ON(!msi_page))
# # # # ]
1240 : : return;
1241 : :
1242 : 0 : msg->address_hi = upper_32_bits(msi_page->iova);
1243 [ # # ]: 0 : msg->address_lo &= cookie_msi_granule(domain->iova_cookie) - 1;
1244 : 0 : msg->address_lo += lower_32_bits(msi_page->iova);
1245 : : }
1246 : :
1247 : 28 : static int iommu_dma_init(void)
1248 : : {
1249 : 28 : return iova_cache_get();
1250 : : }
1251 : : arch_initcall(iommu_dma_init);
|
