Merge branch 'stable/for-linus-5.2' of git://git.kernel.org/pub/scm/linux/kernel...
[sfrench/cifs-2.6.git] / drivers / xen / swiotlb-xen.c
1 /*
2  *  Copyright 2010
3  *  by Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
4  *
5  * This code provides a IOMMU for Xen PV guests with PCI passthrough.
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License v2.0 as published by
9  * the Free Software Foundation
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * PV guests under Xen are running in an non-contiguous memory architecture.
17  *
18  * When PCI pass-through is utilized, this necessitates an IOMMU for
19  * translating bus (DMA) to virtual and vice-versa and also providing a
20  * mechanism to have contiguous pages for device drivers operations (say DMA
21  * operations).
22  *
23  * Specifically, under Xen the Linux idea of pages is an illusion. It
24  * assumes that pages start at zero and go up to the available memory. To
25  * help with that, the Linux Xen MMU provides a lookup mechanism to
26  * translate the page frame numbers (PFN) to machine frame numbers (MFN)
27  * and vice-versa. The MFN are the "real" frame numbers. Furthermore
28  * memory is not contiguous. Xen hypervisor stitches memory for guests
29  * from different pools, which means there is no guarantee that PFN==MFN
30  * and PFN+1==MFN+1. Lastly with Xen 4.0, pages (in debug mode) are
31  * allocated in descending order (high to low), meaning the guest might
32  * never get any MFN's under the 4GB mark.
33  *
34  */
35
36 #define pr_fmt(fmt) "xen:" KBUILD_MODNAME ": " fmt
37
38 #include <linux/memblock.h>
39 #include <linux/dma-direct.h>
40 #include <linux/export.h>
41 #include <xen/swiotlb-xen.h>
42 #include <xen/page.h>
43 #include <xen/xen-ops.h>
44 #include <xen/hvc-console.h>
45
46 #include <asm/dma-mapping.h>
47 #include <asm/xen/page-coherent.h>
48
49 #include <trace/events/swiotlb.h>
50 /*
51  * Used to do a quick range check in swiotlb_tbl_unmap_single and
52  * swiotlb_tbl_sync_single_*, to see if the memory was in fact allocated by this
53  * API.
54  */
55
56 static char *xen_io_tlb_start, *xen_io_tlb_end;
57 static unsigned long xen_io_tlb_nslabs;
58 /*
59  * Quick lookup value of the bus address of the IOTLB.
60  */
61
62 static u64 start_dma_addr;
63
64 /*
65  * Both of these functions should avoid XEN_PFN_PHYS because phys_addr_t
66  * can be 32bit when dma_addr_t is 64bit leading to a loss in
67  * information if the shift is done before casting to 64bit.
68  */
69 static inline dma_addr_t xen_phys_to_bus(phys_addr_t paddr)
70 {
71         unsigned long bfn = pfn_to_bfn(XEN_PFN_DOWN(paddr));
72         dma_addr_t dma = (dma_addr_t)bfn << XEN_PAGE_SHIFT;
73
74         dma |= paddr & ~XEN_PAGE_MASK;
75
76         return dma;
77 }
78
79 static inline phys_addr_t xen_bus_to_phys(dma_addr_t baddr)
80 {
81         unsigned long xen_pfn = bfn_to_pfn(XEN_PFN_DOWN(baddr));
82         dma_addr_t dma = (dma_addr_t)xen_pfn << XEN_PAGE_SHIFT;
83         phys_addr_t paddr = dma;
84
85         paddr |= baddr & ~XEN_PAGE_MASK;
86
87         return paddr;
88 }
89
90 static inline dma_addr_t xen_virt_to_bus(void *address)
91 {
92         return xen_phys_to_bus(virt_to_phys(address));
93 }
94
95 static int check_pages_physically_contiguous(unsigned long xen_pfn,
96                                              unsigned int offset,
97                                              size_t length)
98 {
99         unsigned long next_bfn;
100         int i;
101         int nr_pages;
102
103         next_bfn = pfn_to_bfn(xen_pfn);
104         nr_pages = (offset + length + XEN_PAGE_SIZE-1) >> XEN_PAGE_SHIFT;
105
106         for (i = 1; i < nr_pages; i++) {
107                 if (pfn_to_bfn(++xen_pfn) != ++next_bfn)
108                         return 0;
109         }
110         return 1;
111 }
112
113 static inline int range_straddles_page_boundary(phys_addr_t p, size_t size)
114 {
115         unsigned long xen_pfn = XEN_PFN_DOWN(p);
116         unsigned int offset = p & ~XEN_PAGE_MASK;
117
118         if (offset + size <= XEN_PAGE_SIZE)
119                 return 0;
120         if (check_pages_physically_contiguous(xen_pfn, offset, size))
121                 return 0;
122         return 1;
123 }
124
125 static int is_xen_swiotlb_buffer(dma_addr_t dma_addr)
126 {
127         unsigned long bfn = XEN_PFN_DOWN(dma_addr);
128         unsigned long xen_pfn = bfn_to_local_pfn(bfn);
129         phys_addr_t paddr = XEN_PFN_PHYS(xen_pfn);
130
131         /* If the address is outside our domain, it CAN
132          * have the same virtual address as another address
133          * in our domain. Therefore _only_ check address within our domain.
134          */
135         if (pfn_valid(PFN_DOWN(paddr))) {
136                 return paddr >= virt_to_phys(xen_io_tlb_start) &&
137                        paddr < virt_to_phys(xen_io_tlb_end);
138         }
139         return 0;
140 }
141
142 static int max_dma_bits = 32;
143
144 static int
145 xen_swiotlb_fixup(void *buf, size_t size, unsigned long nslabs)
146 {
147         int i, rc;
148         int dma_bits;
149         dma_addr_t dma_handle;
150         phys_addr_t p = virt_to_phys(buf);
151
152         dma_bits = get_order(IO_TLB_SEGSIZE << IO_TLB_SHIFT) + PAGE_SHIFT;
153
154         i = 0;
155         do {
156                 int slabs = min(nslabs - i, (unsigned long)IO_TLB_SEGSIZE);
157
158                 do {
159                         rc = xen_create_contiguous_region(
160                                 p + (i << IO_TLB_SHIFT),
161                                 get_order(slabs << IO_TLB_SHIFT),
162                                 dma_bits, &dma_handle);
163                 } while (rc && dma_bits++ < max_dma_bits);
164                 if (rc)
165                         return rc;
166
167                 i += slabs;
168         } while (i < nslabs);
169         return 0;
170 }
171 static unsigned long xen_set_nslabs(unsigned long nr_tbl)
172 {
173         if (!nr_tbl) {
174                 xen_io_tlb_nslabs = (64 * 1024 * 1024 >> IO_TLB_SHIFT);
175                 xen_io_tlb_nslabs = ALIGN(xen_io_tlb_nslabs, IO_TLB_SEGSIZE);
176         } else
177                 xen_io_tlb_nslabs = nr_tbl;
178
179         return xen_io_tlb_nslabs << IO_TLB_SHIFT;
180 }
181
182 enum xen_swiotlb_err {
183         XEN_SWIOTLB_UNKNOWN = 0,
184         XEN_SWIOTLB_ENOMEM,
185         XEN_SWIOTLB_EFIXUP
186 };
187
188 static const char *xen_swiotlb_error(enum xen_swiotlb_err err)
189 {
190         switch (err) {
191         case XEN_SWIOTLB_ENOMEM:
192                 return "Cannot allocate Xen-SWIOTLB buffer\n";
193         case XEN_SWIOTLB_EFIXUP:
194                 return "Failed to get contiguous memory for DMA from Xen!\n"\
195                     "You either: don't have the permissions, do not have"\
196                     " enough free memory under 4GB, or the hypervisor memory"\
197                     " is too fragmented!";
198         default:
199                 break;
200         }
201         return "";
202 }
203 int __ref xen_swiotlb_init(int verbose, bool early)
204 {
205         unsigned long bytes, order;
206         int rc = -ENOMEM;
207         enum xen_swiotlb_err m_ret = XEN_SWIOTLB_UNKNOWN;
208         unsigned int repeat = 3;
209
210         xen_io_tlb_nslabs = swiotlb_nr_tbl();
211 retry:
212         bytes = xen_set_nslabs(xen_io_tlb_nslabs);
213         order = get_order(xen_io_tlb_nslabs << IO_TLB_SHIFT);
214         /*
215          * Get IO TLB memory from any location.
216          */
217         if (early) {
218                 xen_io_tlb_start = memblock_alloc(PAGE_ALIGN(bytes),
219                                                   PAGE_SIZE);
220                 if (!xen_io_tlb_start)
221                         panic("%s: Failed to allocate %lu bytes align=0x%lx\n",
222                               __func__, PAGE_ALIGN(bytes), PAGE_SIZE);
223         } else {
224 #define SLABS_PER_PAGE (1 << (PAGE_SHIFT - IO_TLB_SHIFT))
225 #define IO_TLB_MIN_SLABS ((1<<20) >> IO_TLB_SHIFT)
226                 while ((SLABS_PER_PAGE << order) > IO_TLB_MIN_SLABS) {
227                         xen_io_tlb_start = (void *)xen_get_swiotlb_free_pages(order);
228                         if (xen_io_tlb_start)
229                                 break;
230                         order--;
231                 }
232                 if (order != get_order(bytes)) {
233                         pr_warn("Warning: only able to allocate %ld MB for software IO TLB\n",
234                                 (PAGE_SIZE << order) >> 20);
235                         xen_io_tlb_nslabs = SLABS_PER_PAGE << order;
236                         bytes = xen_io_tlb_nslabs << IO_TLB_SHIFT;
237                 }
238         }
239         if (!xen_io_tlb_start) {
240                 m_ret = XEN_SWIOTLB_ENOMEM;
241                 goto error;
242         }
243         xen_io_tlb_end = xen_io_tlb_start + bytes;
244         /*
245          * And replace that memory with pages under 4GB.
246          */
247         rc = xen_swiotlb_fixup(xen_io_tlb_start,
248                                bytes,
249                                xen_io_tlb_nslabs);
250         if (rc) {
251                 if (early)
252                         memblock_free(__pa(xen_io_tlb_start),
253                                       PAGE_ALIGN(bytes));
254                 else {
255                         free_pages((unsigned long)xen_io_tlb_start, order);
256                         xen_io_tlb_start = NULL;
257                 }
258                 m_ret = XEN_SWIOTLB_EFIXUP;
259                 goto error;
260         }
261         start_dma_addr = xen_virt_to_bus(xen_io_tlb_start);
262         if (early) {
263                 if (swiotlb_init_with_tbl(xen_io_tlb_start, xen_io_tlb_nslabs,
264                          verbose))
265                         panic("Cannot allocate SWIOTLB buffer");
266                 rc = 0;
267         } else
268                 rc = swiotlb_late_init_with_tbl(xen_io_tlb_start, xen_io_tlb_nslabs);
269
270         if (!rc)
271                 swiotlb_set_max_segment(PAGE_SIZE);
272
273         return rc;
274 error:
275         if (repeat--) {
276                 xen_io_tlb_nslabs = max(1024UL, /* Min is 2MB */
277                                         (xen_io_tlb_nslabs >> 1));
278                 pr_info("Lowering to %luMB\n",
279                         (xen_io_tlb_nslabs << IO_TLB_SHIFT) >> 20);
280                 goto retry;
281         }
282         pr_err("%s (rc:%d)\n", xen_swiotlb_error(m_ret), rc);
283         if (early)
284                 panic("%s (rc:%d)", xen_swiotlb_error(m_ret), rc);
285         else
286                 free_pages((unsigned long)xen_io_tlb_start, order);
287         return rc;
288 }
289
290 static void *
291 xen_swiotlb_alloc_coherent(struct device *hwdev, size_t size,
292                            dma_addr_t *dma_handle, gfp_t flags,
293                            unsigned long attrs)
294 {
295         void *ret;
296         int order = get_order(size);
297         u64 dma_mask = DMA_BIT_MASK(32);
298         phys_addr_t phys;
299         dma_addr_t dev_addr;
300
301         /*
302         * Ignore region specifiers - the kernel's ideas of
303         * pseudo-phys memory layout has nothing to do with the
304         * machine physical layout.  We can't allocate highmem
305         * because we can't return a pointer to it.
306         */
307         flags &= ~(__GFP_DMA | __GFP_HIGHMEM);
308
309         /* Convert the size to actually allocated. */
310         size = 1UL << (order + XEN_PAGE_SHIFT);
311
312         /* On ARM this function returns an ioremap'ped virtual address for
313          * which virt_to_phys doesn't return the corresponding physical
314          * address. In fact on ARM virt_to_phys only works for kernel direct
315          * mapped RAM memory. Also see comment below.
316          */
317         ret = xen_alloc_coherent_pages(hwdev, size, dma_handle, flags, attrs);
318
319         if (!ret)
320                 return ret;
321
322         if (hwdev && hwdev->coherent_dma_mask)
323                 dma_mask = hwdev->coherent_dma_mask;
324
325         /* At this point dma_handle is the physical address, next we are
326          * going to set it to the machine address.
327          * Do not use virt_to_phys(ret) because on ARM it doesn't correspond
328          * to *dma_handle. */
329         phys = *dma_handle;
330         dev_addr = xen_phys_to_bus(phys);
331         if (((dev_addr + size - 1 <= dma_mask)) &&
332             !range_straddles_page_boundary(phys, size))
333                 *dma_handle = dev_addr;
334         else {
335                 if (xen_create_contiguous_region(phys, order,
336                                                  fls64(dma_mask), dma_handle) != 0) {
337                         xen_free_coherent_pages(hwdev, size, ret, (dma_addr_t)phys, attrs);
338                         return NULL;
339                 }
340         }
341         memset(ret, 0, size);
342         return ret;
343 }
344
345 static void
346 xen_swiotlb_free_coherent(struct device *hwdev, size_t size, void *vaddr,
347                           dma_addr_t dev_addr, unsigned long attrs)
348 {
349         int order = get_order(size);
350         phys_addr_t phys;
351         u64 dma_mask = DMA_BIT_MASK(32);
352
353         if (hwdev && hwdev->coherent_dma_mask)
354                 dma_mask = hwdev->coherent_dma_mask;
355
356         /* do not use virt_to_phys because on ARM it doesn't return you the
357          * physical address */
358         phys = xen_bus_to_phys(dev_addr);
359
360         /* Convert the size to actually allocated. */
361         size = 1UL << (order + XEN_PAGE_SHIFT);
362
363         if (((dev_addr + size - 1 <= dma_mask)) ||
364             range_straddles_page_boundary(phys, size))
365                 xen_destroy_contiguous_region(phys, order);
366
367         xen_free_coherent_pages(hwdev, size, vaddr, (dma_addr_t)phys, attrs);
368 }
369
370 /*
371  * Map a single buffer of the indicated size for DMA in streaming mode.  The
372  * physical address to use is returned.
373  *
374  * Once the device is given the dma address, the device owns this memory until
375  * either xen_swiotlb_unmap_page or xen_swiotlb_dma_sync_single is performed.
376  */
377 static dma_addr_t xen_swiotlb_map_page(struct device *dev, struct page *page,
378                                 unsigned long offset, size_t size,
379                                 enum dma_data_direction dir,
380                                 unsigned long attrs)
381 {
382         phys_addr_t map, phys = page_to_phys(page) + offset;
383         dma_addr_t dev_addr = xen_phys_to_bus(phys);
384
385         BUG_ON(dir == DMA_NONE);
386         /*
387          * If the address happens to be in the device's DMA window,
388          * we can safely return the device addr and not worry about bounce
389          * buffering it.
390          */
391         if (dma_capable(dev, dev_addr, size) &&
392             !range_straddles_page_boundary(phys, size) &&
393                 !xen_arch_need_swiotlb(dev, phys, dev_addr) &&
394                 swiotlb_force != SWIOTLB_FORCE)
395                 goto done;
396
397         /*
398          * Oh well, have to allocate and map a bounce buffer.
399          */
400         trace_swiotlb_bounced(dev, dev_addr, size, swiotlb_force);
401
402         map = swiotlb_tbl_map_single(dev, start_dma_addr, phys, size, dir,
403                                      attrs);
404         if (map == DMA_MAPPING_ERROR)
405                 return DMA_MAPPING_ERROR;
406
407         dev_addr = xen_phys_to_bus(map);
408
409         /*
410          * Ensure that the address returned is DMA'ble
411          */
412         if (unlikely(!dma_capable(dev, dev_addr, size))) {
413                 swiotlb_tbl_unmap_single(dev, map, size, dir,
414                                 attrs | DMA_ATTR_SKIP_CPU_SYNC);
415                 return DMA_MAPPING_ERROR;
416         }
417
418         page = pfn_to_page(map >> PAGE_SHIFT);
419         offset = map & ~PAGE_MASK;
420 done:
421         /*
422          * we are not interested in the dma_addr returned by xen_dma_map_page,
423          * only in the potential cache flushes executed by the function.
424          */
425         xen_dma_map_page(dev, page, dev_addr, offset, size, dir, attrs);
426         return dev_addr;
427 }
428
429 /*
430  * Unmap a single streaming mode DMA translation.  The dma_addr and size must
431  * match what was provided for in a previous xen_swiotlb_map_page call.  All
432  * other usages are undefined.
433  *
434  * After this call, reads by the cpu to the buffer are guaranteed to see
435  * whatever the device wrote there.
436  */
437 static void xen_unmap_single(struct device *hwdev, dma_addr_t dev_addr,
438                              size_t size, enum dma_data_direction dir,
439                              unsigned long attrs)
440 {
441         phys_addr_t paddr = xen_bus_to_phys(dev_addr);
442
443         BUG_ON(dir == DMA_NONE);
444
445         xen_dma_unmap_page(hwdev, dev_addr, size, dir, attrs);
446
447         /* NOTE: We use dev_addr here, not paddr! */
448         if (is_xen_swiotlb_buffer(dev_addr))
449                 swiotlb_tbl_unmap_single(hwdev, paddr, size, dir, attrs);
450 }
451
452 static void xen_swiotlb_unmap_page(struct device *hwdev, dma_addr_t dev_addr,
453                             size_t size, enum dma_data_direction dir,
454                             unsigned long attrs)
455 {
456         xen_unmap_single(hwdev, dev_addr, size, dir, attrs);
457 }
458
459 static void
460 xen_swiotlb_sync_single_for_cpu(struct device *dev, dma_addr_t dma_addr,
461                 size_t size, enum dma_data_direction dir)
462 {
463         phys_addr_t paddr = xen_bus_to_phys(dma_addr);
464
465         xen_dma_sync_single_for_cpu(dev, dma_addr, size, dir);
466
467         if (is_xen_swiotlb_buffer(dma_addr))
468                 swiotlb_tbl_sync_single(dev, paddr, size, dir, SYNC_FOR_CPU);
469 }
470
471 static void
472 xen_swiotlb_sync_single_for_device(struct device *dev, dma_addr_t dma_addr,
473                 size_t size, enum dma_data_direction dir)
474 {
475         phys_addr_t paddr = xen_bus_to_phys(dma_addr);
476
477         if (is_xen_swiotlb_buffer(dma_addr))
478                 swiotlb_tbl_sync_single(dev, paddr, size, dir, SYNC_FOR_DEVICE);
479
480         xen_dma_sync_single_for_device(dev, dma_addr, size, dir);
481 }
482
483 /*
484  * Unmap a set of streaming mode DMA translations.  Again, cpu read rules
485  * concerning calls here are the same as for swiotlb_unmap_page() above.
486  */
487 static void
488 xen_swiotlb_unmap_sg(struct device *hwdev, struct scatterlist *sgl, int nelems,
489                 enum dma_data_direction dir, unsigned long attrs)
490 {
491         struct scatterlist *sg;
492         int i;
493
494         BUG_ON(dir == DMA_NONE);
495
496         for_each_sg(sgl, sg, nelems, i)
497                 xen_unmap_single(hwdev, sg->dma_address, sg_dma_len(sg), dir, attrs);
498
499 }
500
501 static int
502 xen_swiotlb_map_sg(struct device *dev, struct scatterlist *sgl, int nelems,
503                 enum dma_data_direction dir, unsigned long attrs)
504 {
505         struct scatterlist *sg;
506         int i;
507
508         BUG_ON(dir == DMA_NONE);
509
510         for_each_sg(sgl, sg, nelems, i) {
511                 sg->dma_address = xen_swiotlb_map_page(dev, sg_page(sg),
512                                 sg->offset, sg->length, dir, attrs);
513                 if (sg->dma_address == DMA_MAPPING_ERROR)
514                         goto out_unmap;
515                 sg_dma_len(sg) = sg->length;
516         }
517
518         return nelems;
519 out_unmap:
520         xen_swiotlb_unmap_sg(dev, sgl, i, dir, attrs | DMA_ATTR_SKIP_CPU_SYNC);
521         sg_dma_len(sgl) = 0;
522         return 0;
523 }
524
525 static void
526 xen_swiotlb_sync_sg_for_cpu(struct device *dev, struct scatterlist *sgl,
527                             int nelems, enum dma_data_direction dir)
528 {
529         struct scatterlist *sg;
530         int i;
531
532         for_each_sg(sgl, sg, nelems, i) {
533                 xen_swiotlb_sync_single_for_cpu(dev, sg->dma_address,
534                                 sg->length, dir);
535         }
536 }
537
538 static void
539 xen_swiotlb_sync_sg_for_device(struct device *dev, struct scatterlist *sgl,
540                                int nelems, enum dma_data_direction dir)
541 {
542         struct scatterlist *sg;
543         int i;
544
545         for_each_sg(sgl, sg, nelems, i) {
546                 xen_swiotlb_sync_single_for_device(dev, sg->dma_address,
547                                 sg->length, dir);
548         }
549 }
550
551 /*
552  * Return whether the given device DMA address mask can be supported
553  * properly.  For example, if your device can only drive the low 24-bits
554  * during bus mastering, then you would pass 0x00ffffff as the mask to
555  * this function.
556  */
557 static int
558 xen_swiotlb_dma_supported(struct device *hwdev, u64 mask)
559 {
560         return xen_virt_to_bus(xen_io_tlb_end - 1) <= mask;
561 }
562
563 /*
564  * Create userspace mapping for the DMA-coherent memory.
565  * This function should be called with the pages from the current domain only,
566  * passing pages mapped from other domains would lead to memory corruption.
567  */
568 static int
569 xen_swiotlb_dma_mmap(struct device *dev, struct vm_area_struct *vma,
570                      void *cpu_addr, dma_addr_t dma_addr, size_t size,
571                      unsigned long attrs)
572 {
573 #ifdef CONFIG_ARM
574         if (xen_get_dma_ops(dev)->mmap)
575                 return xen_get_dma_ops(dev)->mmap(dev, vma, cpu_addr,
576                                                     dma_addr, size, attrs);
577 #endif
578         return dma_common_mmap(dev, vma, cpu_addr, dma_addr, size, attrs);
579 }
580
581 /*
582  * This function should be called with the pages from the current domain only,
583  * passing pages mapped from other domains would lead to memory corruption.
584  */
585 static int
586 xen_swiotlb_get_sgtable(struct device *dev, struct sg_table *sgt,
587                         void *cpu_addr, dma_addr_t handle, size_t size,
588                         unsigned long attrs)
589 {
590 #ifdef CONFIG_ARM
591         if (xen_get_dma_ops(dev)->get_sgtable) {
592 #if 0
593         /*
594          * This check verifies that the page belongs to the current domain and
595          * is not one mapped from another domain.
596          * This check is for debug only, and should not go to production build
597          */
598                 unsigned long bfn = PHYS_PFN(dma_to_phys(dev, handle));
599                 BUG_ON (!page_is_ram(bfn));
600 #endif
601                 return xen_get_dma_ops(dev)->get_sgtable(dev, sgt, cpu_addr,
602                                                            handle, size, attrs);
603         }
604 #endif
605         return dma_common_get_sgtable(dev, sgt, cpu_addr, handle, size, attrs);
606 }
607
608 const struct dma_map_ops xen_swiotlb_dma_ops = {
609         .alloc = xen_swiotlb_alloc_coherent,
610         .free = xen_swiotlb_free_coherent,
611         .sync_single_for_cpu = xen_swiotlb_sync_single_for_cpu,
612         .sync_single_for_device = xen_swiotlb_sync_single_for_device,
613         .sync_sg_for_cpu = xen_swiotlb_sync_sg_for_cpu,
614         .sync_sg_for_device = xen_swiotlb_sync_sg_for_device,
615         .map_sg = xen_swiotlb_map_sg,
616         .unmap_sg = xen_swiotlb_unmap_sg,
617         .map_page = xen_swiotlb_map_page,
618         .unmap_page = xen_swiotlb_unmap_page,
619         .dma_supported = xen_swiotlb_dma_supported,
620         .mmap = xen_swiotlb_dma_mmap,
621         .get_sgtable = xen_swiotlb_get_sgtable,
622 };