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/dma-map-ops.h> 32 #include <linux/export.h> 33 #include <xen/swiotlb-xen.h> 34 #include <xen/page.h> 35 #include <xen/xen-ops.h> 36 #include <xen/hvc-console.h> 37 38 #include <asm/dma-mapping.h> 39 40 #include <trace/events/swiotlb.h> 41 #define MAX_DMA_BITS 32 42 43 /* 44 * Quick lookup value of the bus address of the IOTLB. 45 */ 46 47 static inline phys_addr_t xen_phys_to_bus(struct device *dev, phys_addr_t paddr) 48 { 49 unsigned long bfn = pfn_to_bfn(XEN_PFN_DOWN(paddr)); 50 phys_addr_t baddr = (phys_addr_t)bfn << XEN_PAGE_SHIFT; 51 52 baddr |= paddr & ~XEN_PAGE_MASK; 53 return baddr; 54 } 55 56 static inline dma_addr_t xen_phys_to_dma(struct device *dev, phys_addr_t paddr) 57 { 58 return phys_to_dma(dev, xen_phys_to_bus(dev, paddr)); 59 } 60 61 static inline phys_addr_t xen_bus_to_phys(struct device *dev, 62 phys_addr_t baddr) 63 { 64 unsigned long xen_pfn = bfn_to_pfn(XEN_PFN_DOWN(baddr)); 65 phys_addr_t paddr = (xen_pfn << XEN_PAGE_SHIFT) | 66 (baddr & ~XEN_PAGE_MASK); 67 68 return paddr; 69 } 70 71 static inline phys_addr_t xen_dma_to_phys(struct device *dev, 72 dma_addr_t dma_addr) 73 { 74 return xen_bus_to_phys(dev, dma_to_phys(dev, dma_addr)); 75 } 76 77 static inline bool range_requires_alignment(phys_addr_t p, size_t size) 78 { 79 phys_addr_t algn = 1ULL << (get_order(size) + PAGE_SHIFT); 80 phys_addr_t bus_addr = pfn_to_bfn(XEN_PFN_DOWN(p)) << XEN_PAGE_SHIFT; 81 82 return IS_ALIGNED(p, algn) && !IS_ALIGNED(bus_addr, algn); 83 } 84 85 static inline int range_straddles_page_boundary(phys_addr_t p, size_t size) 86 { 87 unsigned long next_bfn, xen_pfn = XEN_PFN_DOWN(p); 88 unsigned int i, nr_pages = XEN_PFN_UP(xen_offset_in_page(p) + size); 89 90 next_bfn = pfn_to_bfn(xen_pfn); 91 92 for (i = 1; i < nr_pages; i++) 93 if (pfn_to_bfn(++xen_pfn) != ++next_bfn) 94 return 1; 95 96 return 0; 97 } 98 99 static int is_xen_swiotlb_buffer(struct device *dev, dma_addr_t dma_addr) 100 { 101 unsigned long bfn = XEN_PFN_DOWN(dma_to_phys(dev, dma_addr)); 102 unsigned long xen_pfn = bfn_to_local_pfn(bfn); 103 phys_addr_t paddr = (phys_addr_t)xen_pfn << XEN_PAGE_SHIFT; 104 105 /* If the address is outside our domain, it CAN 106 * have the same virtual address as another address 107 * in our domain. Therefore _only_ check address within our domain. 108 */ 109 if (pfn_valid(PFN_DOWN(paddr))) 110 return is_swiotlb_buffer(dev, paddr); 111 return 0; 112 } 113 114 #ifdef CONFIG_X86 115 int __init xen_swiotlb_fixup(void *buf, unsigned long nslabs) 116 { 117 int rc; 118 unsigned int order = get_order(IO_TLB_SEGSIZE << IO_TLB_SHIFT); 119 unsigned int i, dma_bits = order + PAGE_SHIFT; 120 dma_addr_t dma_handle; 121 phys_addr_t p = virt_to_phys(buf); 122 123 BUILD_BUG_ON(IO_TLB_SEGSIZE & (IO_TLB_SEGSIZE - 1)); 124 BUG_ON(nslabs % IO_TLB_SEGSIZE); 125 126 i = 0; 127 do { 128 do { 129 rc = xen_create_contiguous_region( 130 p + (i << IO_TLB_SHIFT), order, 131 dma_bits, &dma_handle); 132 } while (rc && dma_bits++ < MAX_DMA_BITS); 133 if (rc) 134 return rc; 135 136 i += IO_TLB_SEGSIZE; 137 } while (i < nslabs); 138 return 0; 139 } 140 141 static void * 142 xen_swiotlb_alloc_coherent(struct device *dev, size_t size, 143 dma_addr_t *dma_handle, gfp_t flags, unsigned long attrs) 144 { 145 u64 dma_mask = dev->coherent_dma_mask; 146 int order = get_order(size); 147 phys_addr_t phys; 148 void *ret; 149 150 /* Align the allocation to the Xen page size */ 151 size = ALIGN(size, XEN_PAGE_SIZE); 152 153 ret = (void *)__get_free_pages(flags, get_order(size)); 154 if (!ret) 155 return ret; 156 phys = virt_to_phys(ret); 157 158 *dma_handle = xen_phys_to_dma(dev, phys); 159 if (*dma_handle + size - 1 > dma_mask || 160 range_straddles_page_boundary(phys, size) || 161 range_requires_alignment(phys, size)) { 162 if (xen_create_contiguous_region(phys, order, fls64(dma_mask), 163 dma_handle) != 0) 164 goto out_free_pages; 165 SetPageXenRemapped(virt_to_page(ret)); 166 } 167 168 memset(ret, 0, size); 169 return ret; 170 171 out_free_pages: 172 free_pages((unsigned long)ret, get_order(size)); 173 return NULL; 174 } 175 176 static void 177 xen_swiotlb_free_coherent(struct device *dev, size_t size, void *vaddr, 178 dma_addr_t dma_handle, unsigned long attrs) 179 { 180 phys_addr_t phys = virt_to_phys(vaddr); 181 int order = get_order(size); 182 183 /* Convert the size to actually allocated. */ 184 size = ALIGN(size, XEN_PAGE_SIZE); 185 186 if (WARN_ON_ONCE(dma_handle + size - 1 > dev->coherent_dma_mask) || 187 WARN_ON_ONCE(range_straddles_page_boundary(phys, size) || 188 range_requires_alignment(phys, size))) 189 return; 190 191 if (TestClearPageXenRemapped(virt_to_page(vaddr))) 192 xen_destroy_contiguous_region(phys, order); 193 free_pages((unsigned long)vaddr, get_order(size)); 194 } 195 #endif /* CONFIG_X86 */ 196 197 /* 198 * Map a single buffer of the indicated size for DMA in streaming mode. The 199 * physical address to use is returned. 200 * 201 * Once the device is given the dma address, the device owns this memory until 202 * either xen_swiotlb_unmap_page or xen_swiotlb_dma_sync_single is performed. 203 */ 204 static dma_addr_t xen_swiotlb_map_page(struct device *dev, struct page *page, 205 unsigned long offset, size_t size, 206 enum dma_data_direction dir, 207 unsigned long attrs) 208 { 209 phys_addr_t map, phys = page_to_phys(page) + offset; 210 dma_addr_t dev_addr = xen_phys_to_dma(dev, phys); 211 212 BUG_ON(dir == DMA_NONE); 213 /* 214 * If the address happens to be in the device's DMA window, 215 * we can safely return the device addr and not worry about bounce 216 * buffering it. 217 */ 218 if (dma_capable(dev, dev_addr, size, true) && 219 !range_straddles_page_boundary(phys, size) && 220 !xen_arch_need_swiotlb(dev, phys, dev_addr) && 221 !is_swiotlb_force_bounce(dev)) 222 goto done; 223 224 /* 225 * Oh well, have to allocate and map a bounce buffer. 226 */ 227 trace_swiotlb_bounced(dev, dev_addr, size); 228 229 map = swiotlb_tbl_map_single(dev, phys, size, size, 0, dir, attrs); 230 if (map == (phys_addr_t)DMA_MAPPING_ERROR) 231 return DMA_MAPPING_ERROR; 232 233 phys = map; 234 dev_addr = xen_phys_to_dma(dev, map); 235 236 /* 237 * Ensure that the address returned is DMA'ble 238 */ 239 if (unlikely(!dma_capable(dev, dev_addr, size, true))) { 240 swiotlb_tbl_unmap_single(dev, map, size, dir, 241 attrs | DMA_ATTR_SKIP_CPU_SYNC); 242 return DMA_MAPPING_ERROR; 243 } 244 245 done: 246 if (!dev_is_dma_coherent(dev) && !(attrs & DMA_ATTR_SKIP_CPU_SYNC)) { 247 if (pfn_valid(PFN_DOWN(dma_to_phys(dev, dev_addr)))) 248 arch_sync_dma_for_device(phys, size, dir); 249 else 250 xen_dma_sync_for_device(dev, dev_addr, size, dir); 251 } 252 return dev_addr; 253 } 254 255 /* 256 * Unmap a single streaming mode DMA translation. The dma_addr and size must 257 * match what was provided for in a previous xen_swiotlb_map_page call. All 258 * other usages are undefined. 259 * 260 * After this call, reads by the cpu to the buffer are guaranteed to see 261 * whatever the device wrote there. 262 */ 263 static void xen_swiotlb_unmap_page(struct device *hwdev, dma_addr_t dev_addr, 264 size_t size, enum dma_data_direction dir, unsigned long attrs) 265 { 266 phys_addr_t paddr = xen_dma_to_phys(hwdev, dev_addr); 267 268 BUG_ON(dir == DMA_NONE); 269 270 if (!dev_is_dma_coherent(hwdev) && !(attrs & DMA_ATTR_SKIP_CPU_SYNC)) { 271 if (pfn_valid(PFN_DOWN(dma_to_phys(hwdev, dev_addr)))) 272 arch_sync_dma_for_cpu(paddr, size, dir); 273 else 274 xen_dma_sync_for_cpu(hwdev, dev_addr, size, dir); 275 } 276 277 /* NOTE: We use dev_addr here, not paddr! */ 278 if (is_xen_swiotlb_buffer(hwdev, dev_addr)) 279 swiotlb_tbl_unmap_single(hwdev, paddr, size, dir, attrs); 280 } 281 282 static void 283 xen_swiotlb_sync_single_for_cpu(struct device *dev, dma_addr_t dma_addr, 284 size_t size, enum dma_data_direction dir) 285 { 286 phys_addr_t paddr = xen_dma_to_phys(dev, dma_addr); 287 288 if (!dev_is_dma_coherent(dev)) { 289 if (pfn_valid(PFN_DOWN(dma_to_phys(dev, dma_addr)))) 290 arch_sync_dma_for_cpu(paddr, size, dir); 291 else 292 xen_dma_sync_for_cpu(dev, dma_addr, size, dir); 293 } 294 295 if (is_xen_swiotlb_buffer(dev, dma_addr)) 296 swiotlb_sync_single_for_cpu(dev, paddr, size, dir); 297 } 298 299 static void 300 xen_swiotlb_sync_single_for_device(struct device *dev, dma_addr_t dma_addr, 301 size_t size, enum dma_data_direction dir) 302 { 303 phys_addr_t paddr = xen_dma_to_phys(dev, dma_addr); 304 305 if (is_xen_swiotlb_buffer(dev, dma_addr)) 306 swiotlb_sync_single_for_device(dev, paddr, size, dir); 307 308 if (!dev_is_dma_coherent(dev)) { 309 if (pfn_valid(PFN_DOWN(dma_to_phys(dev, dma_addr)))) 310 arch_sync_dma_for_device(paddr, size, dir); 311 else 312 xen_dma_sync_for_device(dev, dma_addr, size, dir); 313 } 314 } 315 316 /* 317 * Unmap a set of streaming mode DMA translations. Again, cpu read rules 318 * concerning calls here are the same as for swiotlb_unmap_page() above. 319 */ 320 static void 321 xen_swiotlb_unmap_sg(struct device *hwdev, struct scatterlist *sgl, int nelems, 322 enum dma_data_direction dir, unsigned long attrs) 323 { 324 struct scatterlist *sg; 325 int i; 326 327 BUG_ON(dir == DMA_NONE); 328 329 for_each_sg(sgl, sg, nelems, i) 330 xen_swiotlb_unmap_page(hwdev, sg->dma_address, sg_dma_len(sg), 331 dir, attrs); 332 333 } 334 335 static int 336 xen_swiotlb_map_sg(struct device *dev, struct scatterlist *sgl, int nelems, 337 enum dma_data_direction dir, unsigned long attrs) 338 { 339 struct scatterlist *sg; 340 int i; 341 342 BUG_ON(dir == DMA_NONE); 343 344 for_each_sg(sgl, sg, nelems, i) { 345 sg->dma_address = xen_swiotlb_map_page(dev, sg_page(sg), 346 sg->offset, sg->length, dir, attrs); 347 if (sg->dma_address == DMA_MAPPING_ERROR) 348 goto out_unmap; 349 sg_dma_len(sg) = sg->length; 350 } 351 352 return nelems; 353 out_unmap: 354 xen_swiotlb_unmap_sg(dev, sgl, i, dir, attrs | DMA_ATTR_SKIP_CPU_SYNC); 355 sg_dma_len(sgl) = 0; 356 return -EIO; 357 } 358 359 static void 360 xen_swiotlb_sync_sg_for_cpu(struct device *dev, struct scatterlist *sgl, 361 int nelems, enum dma_data_direction dir) 362 { 363 struct scatterlist *sg; 364 int i; 365 366 for_each_sg(sgl, sg, nelems, i) { 367 xen_swiotlb_sync_single_for_cpu(dev, sg->dma_address, 368 sg->length, dir); 369 } 370 } 371 372 static void 373 xen_swiotlb_sync_sg_for_device(struct device *dev, struct scatterlist *sgl, 374 int nelems, enum dma_data_direction dir) 375 { 376 struct scatterlist *sg; 377 int i; 378 379 for_each_sg(sgl, sg, nelems, i) { 380 xen_swiotlb_sync_single_for_device(dev, sg->dma_address, 381 sg->length, dir); 382 } 383 } 384 385 /* 386 * Return whether the given device DMA address mask can be supported 387 * properly. For example, if your device can only drive the low 24-bits 388 * during bus mastering, then you would pass 0x00ffffff as the mask to 389 * this function. 390 */ 391 static int 392 xen_swiotlb_dma_supported(struct device *hwdev, u64 mask) 393 { 394 return xen_phys_to_dma(hwdev, default_swiotlb_limit()) <= mask; 395 } 396 397 const struct dma_map_ops xen_swiotlb_dma_ops = { 398 #ifdef CONFIG_X86 399 .alloc = xen_swiotlb_alloc_coherent, 400 .free = xen_swiotlb_free_coherent, 401 #else 402 .alloc = dma_direct_alloc, 403 .free = dma_direct_free, 404 #endif 405 .sync_single_for_cpu = xen_swiotlb_sync_single_for_cpu, 406 .sync_single_for_device = xen_swiotlb_sync_single_for_device, 407 .sync_sg_for_cpu = xen_swiotlb_sync_sg_for_cpu, 408 .sync_sg_for_device = xen_swiotlb_sync_sg_for_device, 409 .map_sg = xen_swiotlb_map_sg, 410 .unmap_sg = xen_swiotlb_unmap_sg, 411 .map_page = xen_swiotlb_map_page, 412 .unmap_page = xen_swiotlb_unmap_page, 413 .dma_supported = xen_swiotlb_dma_supported, 414 .mmap = dma_common_mmap, 415 .get_sgtable = dma_common_get_sgtable, 416 .alloc_pages = dma_common_alloc_pages, 417 .free_pages = dma_common_free_pages, 418 .max_mapping_size = swiotlb_max_mapping_size, 419 }; 420