drivers/xen/swiotlb-xen.c

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