Loading...
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 | #include <linux/cpu.h> #include <linux/dma-mapping.h> #include <linux/bootmem.h> #include <linux/gfp.h> #include <linux/highmem.h> #include <linux/export.h> #include <linux/memblock.h> #include <linux/of_address.h> #include <linux/slab.h> #include <linux/types.h> #include <linux/dma-mapping.h> #include <linux/vmalloc.h> #include <linux/swiotlb.h> #include <xen/xen.h> #include <xen/interface/grant_table.h> #include <xen/interface/memory.h> #include <xen/page.h> #include <xen/swiotlb-xen.h> #include <asm/cacheflush.h> #include <asm/xen/hypercall.h> #include <asm/xen/interface.h> unsigned long xen_get_swiotlb_free_pages(unsigned int order) { struct memblock_region *reg; gfp_t flags = __GFP_NOWARN|__GFP_KSWAPD_RECLAIM; for_each_memblock(memory, reg) { if (reg->base < (phys_addr_t)0xffffffff) { flags |= __GFP_DMA; break; } } return __get_free_pages(flags, order); } enum dma_cache_op { DMA_UNMAP, DMA_MAP, }; static bool hypercall_cflush = false; /* functions called by SWIOTLB */ static void dma_cache_maint(dma_addr_t handle, unsigned long offset, size_t size, enum dma_data_direction dir, enum dma_cache_op op) { struct gnttab_cache_flush cflush; unsigned long xen_pfn; size_t left = size; xen_pfn = (handle >> XEN_PAGE_SHIFT) + offset / XEN_PAGE_SIZE; offset %= XEN_PAGE_SIZE; do { size_t len = left; /* buffers in highmem or foreign pages cannot cross page * boundaries */ if (len + offset > XEN_PAGE_SIZE) len = XEN_PAGE_SIZE - offset; cflush.op = 0; cflush.a.dev_bus_addr = xen_pfn << XEN_PAGE_SHIFT; cflush.offset = offset; cflush.length = len; if (op == DMA_UNMAP && dir != DMA_TO_DEVICE) cflush.op = GNTTAB_CACHE_INVAL; if (op == DMA_MAP) { if (dir == DMA_FROM_DEVICE) cflush.op = GNTTAB_CACHE_INVAL; else cflush.op = GNTTAB_CACHE_CLEAN; } if (cflush.op) HYPERVISOR_grant_table_op(GNTTABOP_cache_flush, &cflush, 1); offset = 0; xen_pfn++; left -= len; } while (left); } static void __xen_dma_page_dev_to_cpu(struct device *hwdev, dma_addr_t handle, size_t size, enum dma_data_direction dir) { dma_cache_maint(handle & PAGE_MASK, handle & ~PAGE_MASK, size, dir, DMA_UNMAP); } static void __xen_dma_page_cpu_to_dev(struct device *hwdev, dma_addr_t handle, size_t size, enum dma_data_direction dir) { dma_cache_maint(handle & PAGE_MASK, handle & ~PAGE_MASK, size, dir, DMA_MAP); } void __xen_dma_map_page(struct device *hwdev, struct page *page, dma_addr_t dev_addr, unsigned long offset, size_t size, enum dma_data_direction dir, unsigned long attrs) { if (is_device_dma_coherent(hwdev)) return; if (attrs & DMA_ATTR_SKIP_CPU_SYNC) return; __xen_dma_page_cpu_to_dev(hwdev, dev_addr, size, dir); } void __xen_dma_unmap_page(struct device *hwdev, dma_addr_t handle, size_t size, enum dma_data_direction dir, unsigned long attrs) { if (is_device_dma_coherent(hwdev)) return; if (attrs & DMA_ATTR_SKIP_CPU_SYNC) return; __xen_dma_page_dev_to_cpu(hwdev, handle, size, dir); } void __xen_dma_sync_single_for_cpu(struct device *hwdev, dma_addr_t handle, size_t size, enum dma_data_direction dir) { if (is_device_dma_coherent(hwdev)) return; __xen_dma_page_dev_to_cpu(hwdev, handle, size, dir); } void __xen_dma_sync_single_for_device(struct device *hwdev, dma_addr_t handle, size_t size, enum dma_data_direction dir) { if (is_device_dma_coherent(hwdev)) return; __xen_dma_page_cpu_to_dev(hwdev, handle, size, dir); } bool xen_arch_need_swiotlb(struct device *dev, phys_addr_t phys, dma_addr_t dev_addr) { unsigned int xen_pfn = XEN_PFN_DOWN(phys); unsigned int bfn = XEN_PFN_DOWN(dev_addr); /* * The swiotlb buffer should be used if * - Xen doesn't have the cache flush hypercall * - The Linux page refers to foreign memory * - The device doesn't support coherent DMA request * * The Linux page may be spanned acrros multiple Xen page, although * it's not possible to have a mix of local and foreign Xen page. * Furthermore, range_straddles_page_boundary is already checking * if buffer is physically contiguous in the host RAM. * * Therefore we only need to check the first Xen page to know if we * require a bounce buffer because the device doesn't support coherent * memory and we are not able to flush the cache. */ return (!hypercall_cflush && (xen_pfn != bfn) && !is_device_dma_coherent(dev)); } int xen_create_contiguous_region(phys_addr_t pstart, unsigned int order, unsigned int address_bits, dma_addr_t *dma_handle) { if (!xen_initial_domain()) return -EINVAL; /* we assume that dom0 is mapped 1:1 for now */ *dma_handle = pstart; return 0; } EXPORT_SYMBOL_GPL(xen_create_contiguous_region); void xen_destroy_contiguous_region(phys_addr_t pstart, unsigned int order) { return; } EXPORT_SYMBOL_GPL(xen_destroy_contiguous_region); const struct dma_map_ops *xen_dma_ops; EXPORT_SYMBOL(xen_dma_ops); int __init xen_mm_init(void) { struct gnttab_cache_flush cflush; if (!xen_initial_domain()) return 0; xen_swiotlb_init(1, false); xen_dma_ops = &xen_swiotlb_dma_ops; cflush.op = 0; cflush.a.dev_bus_addr = 0; cflush.offset = 0; cflush.length = 0; if (HYPERVISOR_grant_table_op(GNTTABOP_cache_flush, &cflush, 1) != -ENOSYS) hypercall_cflush = true; return 0; } arch_initcall(xen_mm_init); |