// SPDX-License-Identifier: GPL-2.0-only /* * Copyright 2010 * by Konrad Rzeszutek Wilk <[email protected]> * * This code provides a IOMMU for Xen PV guests with PCI passthrough. * * PV guests under Xen are running in an non-contiguous memory architecture. * * When PCI pass-through is utilized, this necessitates an IOMMU for * translating bus (DMA) to virtual and vice-versa and also providing a * mechanism to have contiguous pages for device drivers operations (say DMA * operations). * * Specifically, under Xen the Linux idea of pages is an illusion. It * assumes that pages start at zero and go up to the available memory. To * help with that, the Linux Xen MMU provides a lookup mechanism to * translate the page frame numbers (PFN) to machine frame numbers (MFN) * and vice-versa. The MFN are the "real" frame numbers. Furthermore * memory is not contiguous. Xen hypervisor stitches memory for guests * from different pools, which means there is no guarantee that PFN==MFN * and PFN+1==MFN+1. Lastly with Xen 4.0, pages (in debug mode) are * allocated in descending order (high to low), meaning the guest might * never get any MFN's under the 4GB mark. */ #define pr_fmt(fmt) … #include <linux/memblock.h> #include <linux/dma-direct.h> #include <linux/dma-map-ops.h> #include <linux/export.h> #include <xen/swiotlb-xen.h> #include <xen/page.h> #include <xen/xen-ops.h> #include <xen/hvc-console.h> #include <asm/dma-mapping.h> #include <trace/events/swiotlb.h> #define MAX_DMA_BITS … /* * Quick lookup value of the bus address of the IOTLB. */ static inline phys_addr_t xen_phys_to_bus(struct device *dev, phys_addr_t paddr) { … } static inline dma_addr_t xen_phys_to_dma(struct device *dev, phys_addr_t paddr) { … } static inline phys_addr_t xen_bus_to_phys(struct device *dev, phys_addr_t baddr) { … } static inline phys_addr_t xen_dma_to_phys(struct device *dev, dma_addr_t dma_addr) { … } static inline int range_straddles_page_boundary(phys_addr_t p, size_t size) { … } static struct io_tlb_pool *xen_swiotlb_find_pool(struct device *dev, dma_addr_t dma_addr) { … } #ifdef CONFIG_X86 int xen_swiotlb_fixup(void *buf, unsigned long nslabs) { … } static void * xen_swiotlb_alloc_coherent(struct device *dev, size_t size, dma_addr_t *dma_handle, gfp_t flags, unsigned long attrs) { … } static void xen_swiotlb_free_coherent(struct device *dev, size_t size, void *vaddr, dma_addr_t dma_handle, unsigned long attrs) { … } #endif /* CONFIG_X86 */ /* * Map a single buffer of the indicated size for DMA in streaming mode. The * physical address to use is returned. * * Once the device is given the dma address, the device owns this memory until * either xen_swiotlb_unmap_page or xen_swiotlb_dma_sync_single is performed. */ static dma_addr_t xen_swiotlb_map_page(struct device *dev, struct page *page, unsigned long offset, size_t size, enum dma_data_direction dir, unsigned long attrs) { … } /* * Unmap a single streaming mode DMA translation. The dma_addr and size must * match what was provided for in a previous xen_swiotlb_map_page call. All * other usages are undefined. * * After this call, reads by the cpu to the buffer are guaranteed to see * whatever the device wrote there. */ static void xen_swiotlb_unmap_page(struct device *hwdev, dma_addr_t dev_addr, size_t size, enum dma_data_direction dir, unsigned long attrs) { … } static void xen_swiotlb_sync_single_for_cpu(struct device *dev, dma_addr_t dma_addr, size_t size, enum dma_data_direction dir) { … } static void xen_swiotlb_sync_single_for_device(struct device *dev, dma_addr_t dma_addr, size_t size, enum dma_data_direction dir) { … } /* * Unmap a set of streaming mode DMA translations. Again, cpu read rules * concerning calls here are the same as for swiotlb_unmap_page() above. */ static void xen_swiotlb_unmap_sg(struct device *hwdev, struct scatterlist *sgl, int nelems, enum dma_data_direction dir, unsigned long attrs) { … } static int xen_swiotlb_map_sg(struct device *dev, struct scatterlist *sgl, int nelems, enum dma_data_direction dir, unsigned long attrs) { … } static void xen_swiotlb_sync_sg_for_cpu(struct device *dev, struct scatterlist *sgl, int nelems, enum dma_data_direction dir) { … } static void xen_swiotlb_sync_sg_for_device(struct device *dev, struct scatterlist *sgl, int nelems, enum dma_data_direction dir) { … } /* * Return whether the given device DMA address mask can be supported * properly. For example, if your device can only drive the low 24-bits * during bus mastering, then you would pass 0x00ffffff as the mask to * this function. */ static int xen_swiotlb_dma_supported(struct device *hwdev, u64 mask) { … } const struct dma_map_ops xen_swiotlb_dma_ops = …;
Codebase Browser
linux