From mboxrd@z Thu Jan 1 00:00:00 1970 From: Christoph Hellwig Date: Fri, 16 Jun 2017 18:10:22 +0000 Subject: [PATCH 07/44] xen-swiotlb: consolidate xen_swiotlb_dma_ops Message-Id: <20170616181059.19206-8-hch@lst.de> List-Id: References: <20170616181059.19206-1-hch@lst.de> In-Reply-To: <20170616181059.19206-1-hch@lst.de> MIME-Version: 1.0 Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit To: x86@kernel.org, linux-arm-kernel@lists.infradead.org, xen-devel@lists.xenproject.org, linux-c6x-dev@linux-c6x.org, linux-hexagon@vger.kernel.org, linux-ia64@vger.kernel.org, linux-mips@linux-mips.org, openrisc@lists.librecores.org, linuxppc-dev@lists.ozlabs.org, linux-s390@vger.kernel.org, linux-sh@vger.kernel.org, sparclinux@vger.kernel.org, linux-xtensa@linux-xtensa.org, dmaengine@vger.kernel.org, linux-tegra@vger.kernel.org, dri-devel@lists.freedesktop.org, linux-samsung-soc@vger.kernel.org, iommu@lists.linux-foundation.org, netdev@vger.kernel.org Cc: linux-kernel@vger.kernel.org ARM and x86 had duplicated versions of the dma_ops structure, the only difference is that x86 hasn't wired up the set_dma_mask, mmap, and get_sgtable ops yet. On x86 all of them are identical to the generic version, so they aren't needed but harmless. All the symbols used only for xen_swiotlb_dma_ops can now be marked static as well. Signed-off-by: Christoph Hellwig Reviewed-by: Konrad Rzeszutek Wilk --- arch/arm/xen/mm.c | 17 -------- arch/x86/xen/pci-swiotlb-xen.c | 14 ------- drivers/xen/swiotlb-xen.c | 93 ++++++++++++++++++++++-------------------- include/xen/swiotlb-xen.h | 62 +--------------------------- 4 files changed, 49 insertions(+), 137 deletions(-) diff --git a/arch/arm/xen/mm.c b/arch/arm/xen/mm.c index f0325d96b97a..785d2a562a23 100644 --- a/arch/arm/xen/mm.c +++ b/arch/arm/xen/mm.c @@ -185,23 +185,6 @@ EXPORT_SYMBOL_GPL(xen_destroy_contiguous_region); const struct dma_map_ops *xen_dma_ops; EXPORT_SYMBOL(xen_dma_ops); -static const struct dma_map_ops xen_swiotlb_dma_ops = { - .alloc = xen_swiotlb_alloc_coherent, - .free = xen_swiotlb_free_coherent, - .sync_single_for_cpu = xen_swiotlb_sync_single_for_cpu, - .sync_single_for_device = xen_swiotlb_sync_single_for_device, - .sync_sg_for_cpu = xen_swiotlb_sync_sg_for_cpu, - .sync_sg_for_device = xen_swiotlb_sync_sg_for_device, - .map_sg = xen_swiotlb_map_sg_attrs, - .unmap_sg = xen_swiotlb_unmap_sg_attrs, - .map_page = xen_swiotlb_map_page, - .unmap_page = xen_swiotlb_unmap_page, - .dma_supported = xen_swiotlb_dma_supported, - .set_dma_mask = xen_swiotlb_set_dma_mask, - .mmap = xen_swiotlb_dma_mmap, - .get_sgtable = xen_swiotlb_get_sgtable, -}; - int __init xen_mm_init(void) { struct gnttab_cache_flush cflush; diff --git a/arch/x86/xen/pci-swiotlb-xen.c b/arch/x86/xen/pci-swiotlb-xen.c index 42b08f8fc2ca..37c6056a7bba 100644 --- a/arch/x86/xen/pci-swiotlb-xen.c +++ b/arch/x86/xen/pci-swiotlb-xen.c @@ -18,20 +18,6 @@ int xen_swiotlb __read_mostly; -static const struct dma_map_ops xen_swiotlb_dma_ops = { - .alloc = xen_swiotlb_alloc_coherent, - .free = xen_swiotlb_free_coherent, - .sync_single_for_cpu = xen_swiotlb_sync_single_for_cpu, - .sync_single_for_device = xen_swiotlb_sync_single_for_device, - .sync_sg_for_cpu = xen_swiotlb_sync_sg_for_cpu, - .sync_sg_for_device = xen_swiotlb_sync_sg_for_device, - .map_sg = xen_swiotlb_map_sg_attrs, - .unmap_sg = xen_swiotlb_unmap_sg_attrs, - .map_page = xen_swiotlb_map_page, - .unmap_page = xen_swiotlb_unmap_page, - .dma_supported = xen_swiotlb_dma_supported, -}; - /* * pci_xen_swiotlb_detect - set xen_swiotlb to 1 if necessary * diff --git a/drivers/xen/swiotlb-xen.c b/drivers/xen/swiotlb-xen.c index 8dab0d3dc172..a0f006daab48 100644 --- a/drivers/xen/swiotlb-xen.c +++ b/drivers/xen/swiotlb-xen.c @@ -295,7 +295,8 @@ int __ref xen_swiotlb_init(int verbose, bool early) free_pages((unsigned long)xen_io_tlb_start, order); return rc; } -void * + +static void * xen_swiotlb_alloc_coherent(struct device *hwdev, size_t size, dma_addr_t *dma_handle, gfp_t flags, unsigned long attrs) @@ -346,9 +347,8 @@ xen_swiotlb_alloc_coherent(struct device *hwdev, size_t size, memset(ret, 0, size); return ret; } -EXPORT_SYMBOL_GPL(xen_swiotlb_alloc_coherent); -void +static void xen_swiotlb_free_coherent(struct device *hwdev, size_t size, void *vaddr, dma_addr_t dev_addr, unsigned long attrs) { @@ -369,8 +369,6 @@ xen_swiotlb_free_coherent(struct device *hwdev, size_t size, void *vaddr, xen_free_coherent_pages(hwdev, size, vaddr, (dma_addr_t)phys, attrs); } -EXPORT_SYMBOL_GPL(xen_swiotlb_free_coherent); - /* * Map a single buffer of the indicated size for DMA in streaming mode. The @@ -379,7 +377,7 @@ EXPORT_SYMBOL_GPL(xen_swiotlb_free_coherent); * 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. */ -dma_addr_t xen_swiotlb_map_page(struct device *dev, struct page *page, +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) @@ -429,7 +427,6 @@ dma_addr_t xen_swiotlb_map_page(struct device *dev, struct page *page, return DMA_ERROR_CODE; } -EXPORT_SYMBOL_GPL(xen_swiotlb_map_page); /* * Unmap a single streaming mode DMA translation. The dma_addr and size must @@ -467,13 +464,12 @@ static void xen_unmap_single(struct device *hwdev, dma_addr_t dev_addr, dma_mark_clean(phys_to_virt(paddr), size); } -void xen_swiotlb_unmap_page(struct device *hwdev, dma_addr_t dev_addr, +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) { xen_unmap_single(hwdev, dev_addr, size, dir, attrs); } -EXPORT_SYMBOL_GPL(xen_swiotlb_unmap_page); /* * Make physical memory consistent for a single streaming mode DMA translation @@ -516,7 +512,6 @@ xen_swiotlb_sync_single_for_cpu(struct device *hwdev, dma_addr_t dev_addr, { xen_swiotlb_sync_single(hwdev, dev_addr, size, dir, SYNC_FOR_CPU); } -EXPORT_SYMBOL_GPL(xen_swiotlb_sync_single_for_cpu); void xen_swiotlb_sync_single_for_device(struct device *hwdev, dma_addr_t dev_addr, @@ -524,7 +519,25 @@ xen_swiotlb_sync_single_for_device(struct device *hwdev, dma_addr_t dev_addr, { xen_swiotlb_sync_single(hwdev, dev_addr, size, dir, SYNC_FOR_DEVICE); } -EXPORT_SYMBOL_GPL(xen_swiotlb_sync_single_for_device); + +/* + * 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_attrs(struct device *hwdev, struct scatterlist *sgl, + int nelems, enum dma_data_direction dir, + unsigned long attrs) +{ + struct scatterlist *sg; + int i; + + BUG_ON(dir = DMA_NONE); + + for_each_sg(sgl, sg, nelems, i) + xen_unmap_single(hwdev, sg->dma_address, sg_dma_len(sg), dir, attrs); + +} /* * Map a set of buffers described by scatterlist in streaming mode for DMA. @@ -542,7 +555,7 @@ EXPORT_SYMBOL_GPL(xen_swiotlb_sync_single_for_device); * Device ownership issues as mentioned above for xen_swiotlb_map_page are the * same here. */ -int +static int xen_swiotlb_map_sg_attrs(struct device *hwdev, struct scatterlist *sgl, int nelems, enum dma_data_direction dir, unsigned long attrs) @@ -599,27 +612,6 @@ xen_swiotlb_map_sg_attrs(struct device *hwdev, struct scatterlist *sgl, } return nelems; } -EXPORT_SYMBOL_GPL(xen_swiotlb_map_sg_attrs); - -/* - * Unmap a set of streaming mode DMA translations. Again, cpu read rules - * concerning calls here are the same as for swiotlb_unmap_page() above. - */ -void -xen_swiotlb_unmap_sg_attrs(struct device *hwdev, struct scatterlist *sgl, - int nelems, enum dma_data_direction dir, - unsigned long attrs) -{ - struct scatterlist *sg; - int i; - - BUG_ON(dir = DMA_NONE); - - for_each_sg(sgl, sg, nelems, i) - xen_unmap_single(hwdev, sg->dma_address, sg_dma_len(sg), dir, attrs); - -} -EXPORT_SYMBOL_GPL(xen_swiotlb_unmap_sg_attrs); /* * Make physical memory consistent for a set of streaming mode DMA translations @@ -641,21 +633,19 @@ xen_swiotlb_sync_sg(struct device *hwdev, struct scatterlist *sgl, sg_dma_len(sg), dir, target); } -void +static void xen_swiotlb_sync_sg_for_cpu(struct device *hwdev, struct scatterlist *sg, int nelems, enum dma_data_direction dir) { xen_swiotlb_sync_sg(hwdev, sg, nelems, dir, SYNC_FOR_CPU); } -EXPORT_SYMBOL_GPL(xen_swiotlb_sync_sg_for_cpu); -void +static void xen_swiotlb_sync_sg_for_device(struct device *hwdev, struct scatterlist *sg, int nelems, enum dma_data_direction dir) { xen_swiotlb_sync_sg(hwdev, sg, nelems, dir, SYNC_FOR_DEVICE); } -EXPORT_SYMBOL_GPL(xen_swiotlb_sync_sg_for_device); /* * Return whether the given device DMA address mask can be supported @@ -663,14 +653,13 @@ EXPORT_SYMBOL_GPL(xen_swiotlb_sync_sg_for_device); * during bus mastering, then you would pass 0x00ffffff as the mask to * this function. */ -int +static int xen_swiotlb_dma_supported(struct device *hwdev, u64 mask) { return xen_virt_to_bus(xen_io_tlb_end - 1) <= mask; } -EXPORT_SYMBOL_GPL(xen_swiotlb_dma_supported); -int +static int xen_swiotlb_set_dma_mask(struct device *dev, u64 dma_mask) { if (!dev->dma_mask || !xen_swiotlb_dma_supported(dev, dma_mask)) @@ -680,14 +669,13 @@ xen_swiotlb_set_dma_mask(struct device *dev, u64 dma_mask) return 0; } -EXPORT_SYMBOL_GPL(xen_swiotlb_set_dma_mask); /* * Create userspace mapping for the DMA-coherent memory. * This function should be called with the pages from the current domain only, * passing pages mapped from other domains would lead to memory corruption. */ -int +static int xen_swiotlb_dma_mmap(struct device *dev, struct vm_area_struct *vma, void *cpu_addr, dma_addr_t dma_addr, size_t size, unsigned long attrs) @@ -699,13 +687,12 @@ xen_swiotlb_dma_mmap(struct device *dev, struct vm_area_struct *vma, #endif return dma_common_mmap(dev, vma, cpu_addr, dma_addr, size); } -EXPORT_SYMBOL_GPL(xen_swiotlb_dma_mmap); /* * This function should be called with the pages from the current domain only, * passing pages mapped from other domains would lead to memory corruption. */ -int +static int xen_swiotlb_get_sgtable(struct device *dev, struct sg_table *sgt, void *cpu_addr, dma_addr_t handle, size_t size, unsigned long attrs) @@ -727,4 +714,20 @@ xen_swiotlb_get_sgtable(struct device *dev, struct sg_table *sgt, #endif return dma_common_get_sgtable(dev, sgt, cpu_addr, handle, size); } -EXPORT_SYMBOL_GPL(xen_swiotlb_get_sgtable); + +const struct dma_map_ops xen_swiotlb_dma_ops = { + .alloc = xen_swiotlb_alloc_coherent, + .free = xen_swiotlb_free_coherent, + .sync_single_for_cpu = xen_swiotlb_sync_single_for_cpu, + .sync_single_for_device = xen_swiotlb_sync_single_for_device, + .sync_sg_for_cpu = xen_swiotlb_sync_sg_for_cpu, + .sync_sg_for_device = xen_swiotlb_sync_sg_for_device, + .map_sg = xen_swiotlb_map_sg_attrs, + .unmap_sg = xen_swiotlb_unmap_sg_attrs, + .map_page = xen_swiotlb_map_page, + .unmap_page = xen_swiotlb_unmap_page, + .dma_supported = xen_swiotlb_dma_supported, + .set_dma_mask = xen_swiotlb_set_dma_mask, + .mmap = xen_swiotlb_dma_mmap, + .get_sgtable = xen_swiotlb_get_sgtable, +}; diff --git a/include/xen/swiotlb-xen.h b/include/xen/swiotlb-xen.h index 1f6d78f044b6..ed2de363da33 100644 --- a/include/xen/swiotlb-xen.h +++ b/include/xen/swiotlb-xen.h @@ -1,69 +1,9 @@ #ifndef __LINUX_SWIOTLB_XEN_H #define __LINUX_SWIOTLB_XEN_H -#include -#include #include extern int xen_swiotlb_init(int verbose, bool early); +extern const struct dma_map_ops xen_swiotlb_dma_ops; -extern void -*xen_swiotlb_alloc_coherent(struct device *hwdev, size_t size, - dma_addr_t *dma_handle, gfp_t flags, - unsigned long attrs); - -extern void -xen_swiotlb_free_coherent(struct device *hwdev, size_t size, - void *vaddr, dma_addr_t dma_handle, - unsigned long attrs); - -extern 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); - -extern void xen_swiotlb_unmap_page(struct device *hwdev, dma_addr_t dev_addr, - size_t size, enum dma_data_direction dir, - unsigned long attrs); -extern int -xen_swiotlb_map_sg_attrs(struct device *hwdev, struct scatterlist *sgl, - int nelems, enum dma_data_direction dir, - unsigned long attrs); - -extern void -xen_swiotlb_unmap_sg_attrs(struct device *hwdev, struct scatterlist *sgl, - int nelems, enum dma_data_direction dir, - unsigned long attrs); - -extern void -xen_swiotlb_sync_single_for_cpu(struct device *hwdev, dma_addr_t dev_addr, - size_t size, enum dma_data_direction dir); - -extern void -xen_swiotlb_sync_sg_for_cpu(struct device *hwdev, struct scatterlist *sg, - int nelems, enum dma_data_direction dir); - -extern void -xen_swiotlb_sync_single_for_device(struct device *hwdev, dma_addr_t dev_addr, - size_t size, enum dma_data_direction dir); - -extern void -xen_swiotlb_sync_sg_for_device(struct device *hwdev, struct scatterlist *sg, - int nelems, enum dma_data_direction dir); - -extern int -xen_swiotlb_dma_supported(struct device *hwdev, u64 mask); - -extern int -xen_swiotlb_set_dma_mask(struct device *dev, u64 dma_mask); - -extern int -xen_swiotlb_dma_mmap(struct device *dev, struct vm_area_struct *vma, - void *cpu_addr, dma_addr_t dma_addr, size_t size, - unsigned long attrs); - -extern int -xen_swiotlb_get_sgtable(struct device *dev, struct sg_table *sgt, - void *cpu_addr, dma_addr_t handle, size_t size, - unsigned long attrs); #endif /* __LINUX_SWIOTLB_XEN_H */ -- 2.11.0 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Christoph Hellwig Subject: [PATCH 07/44] xen-swiotlb: consolidate xen_swiotlb_dma_ops Date: Fri, 16 Jun 2017 20:10:22 +0200 Message-ID: <20170616181059.19206-8-hch@lst.de> References: <20170616181059.19206-1-hch@lst.de> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20170616181059.19206-1-hch@lst.de> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: x86@kernel.org, linux-arm-kernel@lists.infradead.org, xen-devel@lists.xenproject.org, linux-c6x-dev@linux-c6x.org, linux-hexagon@vger.kernel.org, linux-ia64@vger.kernel.org, linux-mips@linux-mips.org, openrisc@lists.librecores.org, linuxppc-dev@lists.ozlabs.org, linux-s390@vger.kernel.org, linux-sh@vger.kernel.org, sparclinux@vger.kernel.org, linux-xtensa@linux-xtensa.org, dmaengine@vger.kernel.org, linux-tegra@vger.kernel.org, dri-devel@lists.freedesktop.org, linux-samsung-soc@vger.kernel.org, iommu@lists.linux-foundation.org, netdev@vger.kernel.org Cc: linux-kernel@vger.kernel.org List-Id: linux-tegra@vger.kernel.org QVJNIGFuZCB4ODYgaGFkIGR1cGxpY2F0ZWQgdmVyc2lvbnMgb2YgdGhlIGRtYV9vcHMgc3RydWN0 dXJlLCB0aGUKb25seSBkaWZmZXJlbmNlIGlzIHRoYXQgeDg2IGhhc24ndCB3aXJlZCB1cCB0aGUg c2V0X2RtYV9tYXNrLAptbWFwLCBhbmQgZ2V0X3NndGFibGUgb3BzIHlldC4gIE9uIHg4NiBhbGwg b2YgdGhlbSBhcmUgaWRlbnRpY2FsCnRvIHRoZSBnZW5lcmljIHZlcnNpb24sIHNvIHRoZXkgYXJl bid0IG5lZWRlZCBidXQgaGFybWxlc3MuCgpBbGwgdGhlIHN5bWJvbHMgdXNlZCBvbmx5IGZvciB4 ZW5fc3dpb3RsYl9kbWFfb3BzIGNhbiBub3cgYmUgbWFya2VkCnN0YXRpYyBhcyB3ZWxsLgoKU2ln bmVkLW9mZi1ieTogQ2hyaXN0b3BoIEhlbGx3aWcgPGhjaEBsc3QuZGU+ClJldmlld2VkLWJ5OiBL b25yYWQgUnplc3p1dGVrIFdpbGsgPGtvbnJhZC53aWxrQG9yYWNsZS5jb20+Ci0tLQogYXJjaC9h cm0veGVuL21tLmMgICAgICAgICAgICAgIHwgMTcgLS0tLS0tLS0KIGFyY2gveDg2L3hlbi9wY2kt c3dpb3RsYi14ZW4uYyB8IDE0IC0tLS0tLS0KIGRyaXZlcnMveGVuL3N3aW90bGIteGVuLmMgICAg ICB8IDkzICsrKysrKysrKysrKysrKysrKysrKystLS0tLS0tLS0tLS0tLS0tLS0tLQogaW5jbHVk ZS94ZW4vc3dpb3RsYi14ZW4uaCAgICAgIHwgNjIgKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LQogNCBmaWxlcyBjaGFuZ2VkLCA0OSBpbnNlcnRpb25zKCspLCAxMzcgZGVsZXRpb25zKC0pCgpk aWZmIC0tZ2l0IGEvYXJjaC9hcm0veGVuL21tLmMgYi9hcmNoL2FybS94ZW4vbW0uYwppbmRleCBm MDMyNWQ5NmI5N2EuLjc4NWQyYTU2MmEyMyAxMDA2NDQKLS0tIGEvYXJjaC9hcm0veGVuL21tLmMK KysrIGIvYXJjaC9hcm0veGVuL21tLmMKQEAgLTE4NSwyMyArMTg1LDYgQEAgRVhQT1JUX1NZTUJP TF9HUEwoeGVuX2Rlc3Ryb3lfY29udGlndW91c19yZWdpb24pOwogY29uc3Qgc3RydWN0IGRtYV9t YXBfb3BzICp4ZW5fZG1hX29wczsKIEVYUE9SVF9TWU1CT0woeGVuX2RtYV9vcHMpOwogCi1zdGF0 aWMgY29uc3Qgc3RydWN0IGRtYV9tYXBfb3BzIHhlbl9zd2lvdGxiX2RtYV9vcHMgPSB7Ci0JLmFs bG9jID0geGVuX3N3aW90bGJfYWxsb2NfY29oZXJlbnQsCi0JLmZyZWUgPSB4ZW5fc3dpb3RsYl9m cmVlX2NvaGVyZW50LAotCS5zeW5jX3NpbmdsZV9mb3JfY3B1ID0geGVuX3N3aW90bGJfc3luY19z aW5nbGVfZm9yX2NwdSwKLQkuc3luY19zaW5nbGVfZm9yX2RldmljZSA9IHhlbl9zd2lvdGxiX3N5 bmNfc2luZ2xlX2Zvcl9kZXZpY2UsCi0JLnN5bmNfc2dfZm9yX2NwdSA9IHhlbl9zd2lvdGxiX3N5 bmNfc2dfZm9yX2NwdSwKLQkuc3luY19zZ19mb3JfZGV2aWNlID0geGVuX3N3aW90bGJfc3luY19z Z19mb3JfZGV2aWNlLAotCS5tYXBfc2cgPSB4ZW5fc3dpb3RsYl9tYXBfc2dfYXR0cnMsCi0JLnVu bWFwX3NnID0geGVuX3N3aW90bGJfdW5tYXBfc2dfYXR0cnMsCi0JLm1hcF9wYWdlID0geGVuX3N3 aW90bGJfbWFwX3BhZ2UsCi0JLnVubWFwX3BhZ2UgPSB4ZW5fc3dpb3RsYl91bm1hcF9wYWdlLAot CS5kbWFfc3VwcG9ydGVkID0geGVuX3N3aW90bGJfZG1hX3N1cHBvcnRlZCwKLQkuc2V0X2RtYV9t YXNrID0geGVuX3N3aW90bGJfc2V0X2RtYV9tYXNrLAotCS5tbWFwID0geGVuX3N3aW90bGJfZG1h X21tYXAsCi0JLmdldF9zZ3RhYmxlID0geGVuX3N3aW90bGJfZ2V0X3NndGFibGUsCi19OwotCiBp bnQgX19pbml0IHhlbl9tbV9pbml0KHZvaWQpCiB7CiAJc3RydWN0IGdudHRhYl9jYWNoZV9mbHVz aCBjZmx1c2g7CmRpZmYgLS1naXQgYS9hcmNoL3g4Ni94ZW4vcGNpLXN3aW90bGIteGVuLmMgYi9h cmNoL3g4Ni94ZW4vcGNpLXN3aW90bGIteGVuLmMKaW5kZXggNDJiMDhmOGZjMmNhLi4zN2M2MDU2 YTdiYmEgMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L3hlbi9wY2ktc3dpb3RsYi14ZW4uYworKysgYi9h cmNoL3g4Ni94ZW4vcGNpLXN3aW90bGIteGVuLmMKQEAgLTE4LDIwICsxOCw2IEBACiAKIGludCB4 ZW5fc3dpb3RsYiBfX3JlYWRfbW9zdGx5OwogCi1zdGF0aWMgY29uc3Qgc3RydWN0IGRtYV9tYXBf b3BzIHhlbl9zd2lvdGxiX2RtYV9vcHMgPSB7Ci0JLmFsbG9jID0geGVuX3N3aW90bGJfYWxsb2Nf Y29oZXJlbnQsCi0JLmZyZWUgPSB4ZW5fc3dpb3RsYl9mcmVlX2NvaGVyZW50LAotCS5zeW5jX3Np bmdsZV9mb3JfY3B1ID0geGVuX3N3aW90bGJfc3luY19zaW5nbGVfZm9yX2NwdSwKLQkuc3luY19z aW5nbGVfZm9yX2RldmljZSA9IHhlbl9zd2lvdGxiX3N5bmNfc2luZ2xlX2Zvcl9kZXZpY2UsCi0J LnN5bmNfc2dfZm9yX2NwdSA9IHhlbl9zd2lvdGxiX3N5bmNfc2dfZm9yX2NwdSwKLQkuc3luY19z Z19mb3JfZGV2aWNlID0geGVuX3N3aW90bGJfc3luY19zZ19mb3JfZGV2aWNlLAotCS5tYXBfc2cg PSB4ZW5fc3dpb3RsYl9tYXBfc2dfYXR0cnMsCi0JLnVubWFwX3NnID0geGVuX3N3aW90bGJfdW5t YXBfc2dfYXR0cnMsCi0JLm1hcF9wYWdlID0geGVuX3N3aW90bGJfbWFwX3BhZ2UsCi0JLnVubWFw X3BhZ2UgPSB4ZW5fc3dpb3RsYl91bm1hcF9wYWdlLAotCS5kbWFfc3VwcG9ydGVkID0geGVuX3N3 aW90bGJfZG1hX3N1cHBvcnRlZCwKLX07Ci0KIC8qCiAgKiBwY2lfeGVuX3N3aW90bGJfZGV0ZWN0 IC0gc2V0IHhlbl9zd2lvdGxiIHRvIDEgaWYgbmVjZXNzYXJ5CiAgKgpkaWZmIC0tZ2l0IGEvZHJp dmVycy94ZW4vc3dpb3RsYi14ZW4uYyBiL2RyaXZlcnMveGVuL3N3aW90bGIteGVuLmMKaW5kZXgg OGRhYjBkM2RjMTcyLi5hMGYwMDZkYWFiNDggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMveGVuL3N3aW90 bGIteGVuLmMKKysrIGIvZHJpdmVycy94ZW4vc3dpb3RsYi14ZW4uYwpAQCAtMjk1LDcgKzI5NSw4 IEBAIGludCBfX3JlZiB4ZW5fc3dpb3RsYl9pbml0KGludCB2ZXJib3NlLCBib29sIGVhcmx5KQog CQlmcmVlX3BhZ2VzKCh1bnNpZ25lZCBsb25nKXhlbl9pb190bGJfc3RhcnQsIG9yZGVyKTsKIAly ZXR1cm4gcmM7CiB9Ci12b2lkICoKKworc3RhdGljIHZvaWQgKgogeGVuX3N3aW90bGJfYWxsb2Nf Y29oZXJlbnQoc3RydWN0IGRldmljZSAqaHdkZXYsIHNpemVfdCBzaXplLAogCQkJICAgZG1hX2Fk ZHJfdCAqZG1hX2hhbmRsZSwgZ2ZwX3QgZmxhZ3MsCiAJCQkgICB1bnNpZ25lZCBsb25nIGF0dHJz KQpAQCAtMzQ2LDkgKzM0Nyw4IEBAIHhlbl9zd2lvdGxiX2FsbG9jX2NvaGVyZW50KHN0cnVjdCBk ZXZpY2UgKmh3ZGV2LCBzaXplX3Qgc2l6ZSwKIAltZW1zZXQocmV0LCAwLCBzaXplKTsKIAlyZXR1 cm4gcmV0OwogfQotRVhQT1JUX1NZTUJPTF9HUEwoeGVuX3N3aW90bGJfYWxsb2NfY29oZXJlbnQp OwogCi12b2lkCitzdGF0aWMgdm9pZAogeGVuX3N3aW90bGJfZnJlZV9jb2hlcmVudChzdHJ1Y3Qg ZGV2aWNlICpod2Rldiwgc2l6ZV90IHNpemUsIHZvaWQgKnZhZGRyLAogCQkJICBkbWFfYWRkcl90 IGRldl9hZGRyLCB1bnNpZ25lZCBsb25nIGF0dHJzKQogewpAQCAtMzY5LDggKzM2OSw2IEBAIHhl bl9zd2lvdGxiX2ZyZWVfY29oZXJlbnQoc3RydWN0IGRldmljZSAqaHdkZXYsIHNpemVfdCBzaXpl LCB2b2lkICp2YWRkciwKIAogCXhlbl9mcmVlX2NvaGVyZW50X3BhZ2VzKGh3ZGV2LCBzaXplLCB2 YWRkciwgKGRtYV9hZGRyX3QpcGh5cywgYXR0cnMpOwogfQotRVhQT1JUX1NZTUJPTF9HUEwoeGVu X3N3aW90bGJfZnJlZV9jb2hlcmVudCk7Ci0KIAogLyoKICAqIE1hcCBhIHNpbmdsZSBidWZmZXIg b2YgdGhlIGluZGljYXRlZCBzaXplIGZvciBETUEgaW4gc3RyZWFtaW5nIG1vZGUuICBUaGUKQEAg LTM3OSw3ICszNzcsNyBAQCBFWFBPUlRfU1lNQk9MX0dQTCh4ZW5fc3dpb3RsYl9mcmVlX2NvaGVy ZW50KTsKICAqIE9uY2UgdGhlIGRldmljZSBpcyBnaXZlbiB0aGUgZG1hIGFkZHJlc3MsIHRoZSBk ZXZpY2Ugb3ducyB0aGlzIG1lbW9yeSB1bnRpbAogICogZWl0aGVyIHhlbl9zd2lvdGxiX3VubWFw X3BhZ2Ugb3IgeGVuX3N3aW90bGJfZG1hX3N5bmNfc2luZ2xlIGlzIHBlcmZvcm1lZC4KICAqLwot ZG1hX2FkZHJfdCB4ZW5fc3dpb3RsYl9tYXBfcGFnZShzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVj dCBwYWdlICpwYWdlLAorc3RhdGljIGRtYV9hZGRyX3QgeGVuX3N3aW90bGJfbWFwX3BhZ2Uoc3Ry dWN0IGRldmljZSAqZGV2LCBzdHJ1Y3QgcGFnZSAqcGFnZSwKIAkJCQl1bnNpZ25lZCBsb25nIG9m ZnNldCwgc2l6ZV90IHNpemUsCiAJCQkJZW51bSBkbWFfZGF0YV9kaXJlY3Rpb24gZGlyLAogCQkJ CXVuc2lnbmVkIGxvbmcgYXR0cnMpCkBAIC00MjksNyArNDI3LDYgQEAgZG1hX2FkZHJfdCB4ZW5f c3dpb3RsYl9tYXBfcGFnZShzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBwYWdlICpwYWdlLAog CiAJcmV0dXJuIERNQV9FUlJPUl9DT0RFOwogfQotRVhQT1JUX1NZTUJPTF9HUEwoeGVuX3N3aW90 bGJfbWFwX3BhZ2UpOwogCiAvKgogICogVW5tYXAgYSBzaW5nbGUgc3RyZWFtaW5nIG1vZGUgRE1B IHRyYW5zbGF0aW9uLiAgVGhlIGRtYV9hZGRyIGFuZCBzaXplIG11c3QKQEAgLTQ2NywxMyArNDY0 LDEyIEBAIHN0YXRpYyB2b2lkIHhlbl91bm1hcF9zaW5nbGUoc3RydWN0IGRldmljZSAqaHdkZXYs IGRtYV9hZGRyX3QgZGV2X2FkZHIsCiAJZG1hX21hcmtfY2xlYW4ocGh5c190b192aXJ0KHBhZGRy KSwgc2l6ZSk7CiB9CiAKLXZvaWQgeGVuX3N3aW90bGJfdW5tYXBfcGFnZShzdHJ1Y3QgZGV2aWNl ICpod2RldiwgZG1hX2FkZHJfdCBkZXZfYWRkciwKK3N0YXRpYyB2b2lkIHhlbl9zd2lvdGxiX3Vu bWFwX3BhZ2Uoc3RydWN0IGRldmljZSAqaHdkZXYsIGRtYV9hZGRyX3QgZGV2X2FkZHIsCiAJCQkg ICAgc2l6ZV90IHNpemUsIGVudW0gZG1hX2RhdGFfZGlyZWN0aW9uIGRpciwKIAkJCSAgICB1bnNp Z25lZCBsb25nIGF0dHJzKQogewogCXhlbl91bm1hcF9zaW5nbGUoaHdkZXYsIGRldl9hZGRyLCBz aXplLCBkaXIsIGF0dHJzKTsKIH0KLUVYUE9SVF9TWU1CT0xfR1BMKHhlbl9zd2lvdGxiX3VubWFw X3BhZ2UpOwogCiAvKgogICogTWFrZSBwaHlzaWNhbCBtZW1vcnkgY29uc2lzdGVudCBmb3IgYSBz aW5nbGUgc3RyZWFtaW5nIG1vZGUgRE1BIHRyYW5zbGF0aW9uCkBAIC01MTYsNyArNTEyLDYgQEAg eGVuX3N3aW90bGJfc3luY19zaW5nbGVfZm9yX2NwdShzdHJ1Y3QgZGV2aWNlICpod2RldiwgZG1h X2FkZHJfdCBkZXZfYWRkciwKIHsKIAl4ZW5fc3dpb3RsYl9zeW5jX3NpbmdsZShod2RldiwgZGV2 X2FkZHIsIHNpemUsIGRpciwgU1lOQ19GT1JfQ1BVKTsKIH0KLUVYUE9SVF9TWU1CT0xfR1BMKHhl bl9zd2lvdGxiX3N5bmNfc2luZ2xlX2Zvcl9jcHUpOwogCiB2b2lkCiB4ZW5fc3dpb3RsYl9zeW5j X3NpbmdsZV9mb3JfZGV2aWNlKHN0cnVjdCBkZXZpY2UgKmh3ZGV2LCBkbWFfYWRkcl90IGRldl9h ZGRyLApAQCAtNTI0LDcgKzUxOSwyNSBAQCB4ZW5fc3dpb3RsYl9zeW5jX3NpbmdsZV9mb3JfZGV2 aWNlKHN0cnVjdCBkZXZpY2UgKmh3ZGV2LCBkbWFfYWRkcl90IGRldl9hZGRyLAogewogCXhlbl9z d2lvdGxiX3N5bmNfc2luZ2xlKGh3ZGV2LCBkZXZfYWRkciwgc2l6ZSwgZGlyLCBTWU5DX0ZPUl9E RVZJQ0UpOwogfQotRVhQT1JUX1NZTUJPTF9HUEwoeGVuX3N3aW90bGJfc3luY19zaW5nbGVfZm9y X2RldmljZSk7CisKKy8qCisgKiBVbm1hcCBhIHNldCBvZiBzdHJlYW1pbmcgbW9kZSBETUEgdHJh bnNsYXRpb25zLiAgQWdhaW4sIGNwdSByZWFkIHJ1bGVzCisgKiBjb25jZXJuaW5nIGNhbGxzIGhl cmUgYXJlIHRoZSBzYW1lIGFzIGZvciBzd2lvdGxiX3VubWFwX3BhZ2UoKSBhYm92ZS4KKyAqLwor c3RhdGljIHZvaWQKK3hlbl9zd2lvdGxiX3VubWFwX3NnX2F0dHJzKHN0cnVjdCBkZXZpY2UgKmh3 ZGV2LCBzdHJ1Y3Qgc2NhdHRlcmxpc3QgKnNnbCwKKwkJCSAgIGludCBuZWxlbXMsIGVudW0gZG1h X2RhdGFfZGlyZWN0aW9uIGRpciwKKwkJCSAgIHVuc2lnbmVkIGxvbmcgYXR0cnMpCit7CisJc3Ry dWN0IHNjYXR0ZXJsaXN0ICpzZzsKKwlpbnQgaTsKKworCUJVR19PTihkaXIgPT0gRE1BX05PTkUp OworCisJZm9yX2VhY2hfc2coc2dsLCBzZywgbmVsZW1zLCBpKQorCQl4ZW5fdW5tYXBfc2luZ2xl KGh3ZGV2LCBzZy0+ZG1hX2FkZHJlc3MsIHNnX2RtYV9sZW4oc2cpLCBkaXIsIGF0dHJzKTsKKwor fQogCiAvKgogICogTWFwIGEgc2V0IG9mIGJ1ZmZlcnMgZGVzY3JpYmVkIGJ5IHNjYXR0ZXJsaXN0 IGluIHN0cmVhbWluZyBtb2RlIGZvciBETUEuCkBAIC01NDIsNyArNTU1LDcgQEAgRVhQT1JUX1NZ TUJPTF9HUEwoeGVuX3N3aW90bGJfc3luY19zaW5nbGVfZm9yX2RldmljZSk7CiAgKiBEZXZpY2Ug b3duZXJzaGlwIGlzc3VlcyBhcyBtZW50aW9uZWQgYWJvdmUgZm9yIHhlbl9zd2lvdGxiX21hcF9w YWdlIGFyZSB0aGUKICAqIHNhbWUgaGVyZS4KICAqLwotaW50CitzdGF0aWMgaW50CiB4ZW5fc3dp b3RsYl9tYXBfc2dfYXR0cnMoc3RydWN0IGRldmljZSAqaHdkZXYsIHN0cnVjdCBzY2F0dGVybGlz dCAqc2dsLAogCQkJIGludCBuZWxlbXMsIGVudW0gZG1hX2RhdGFfZGlyZWN0aW9uIGRpciwKIAkJ CSB1bnNpZ25lZCBsb25nIGF0dHJzKQpAQCAtNTk5LDI3ICs2MTIsNiBAQCB4ZW5fc3dpb3RsYl9t YXBfc2dfYXR0cnMoc3RydWN0IGRldmljZSAqaHdkZXYsIHN0cnVjdCBzY2F0dGVybGlzdCAqc2ds LAogCX0KIAlyZXR1cm4gbmVsZW1zOwogfQotRVhQT1JUX1NZTUJPTF9HUEwoeGVuX3N3aW90bGJf bWFwX3NnX2F0dHJzKTsKLQotLyoKLSAqIFVubWFwIGEgc2V0IG9mIHN0cmVhbWluZyBtb2RlIERN QSB0cmFuc2xhdGlvbnMuICBBZ2FpbiwgY3B1IHJlYWQgcnVsZXMKLSAqIGNvbmNlcm5pbmcgY2Fs bHMgaGVyZSBhcmUgdGhlIHNhbWUgYXMgZm9yIHN3aW90bGJfdW5tYXBfcGFnZSgpIGFib3ZlLgot ICovCi12b2lkCi14ZW5fc3dpb3RsYl91bm1hcF9zZ19hdHRycyhzdHJ1Y3QgZGV2aWNlICpod2Rl diwgc3RydWN0IHNjYXR0ZXJsaXN0ICpzZ2wsCi0JCQkgICBpbnQgbmVsZW1zLCBlbnVtIGRtYV9k YXRhX2RpcmVjdGlvbiBkaXIsCi0JCQkgICB1bnNpZ25lZCBsb25nIGF0dHJzKQotewotCXN0cnVj dCBzY2F0dGVybGlzdCAqc2c7Ci0JaW50IGk7Ci0KLQlCVUdfT04oZGlyID09IERNQV9OT05FKTsK LQotCWZvcl9lYWNoX3NnKHNnbCwgc2csIG5lbGVtcywgaSkKLQkJeGVuX3VubWFwX3NpbmdsZSho d2Rldiwgc2ctPmRtYV9hZGRyZXNzLCBzZ19kbWFfbGVuKHNnKSwgZGlyLCBhdHRycyk7Ci0KLX0K LUVYUE9SVF9TWU1CT0xfR1BMKHhlbl9zd2lvdGxiX3VubWFwX3NnX2F0dHJzKTsKIAogLyoKICAq IE1ha2UgcGh5c2ljYWwgbWVtb3J5IGNvbnNpc3RlbnQgZm9yIGEgc2V0IG9mIHN0cmVhbWluZyBt b2RlIERNQSB0cmFuc2xhdGlvbnMKQEAgLTY0MSwyMSArNjMzLDE5IEBAIHhlbl9zd2lvdGxiX3N5 bmNfc2coc3RydWN0IGRldmljZSAqaHdkZXYsIHN0cnVjdCBzY2F0dGVybGlzdCAqc2dsLAogCQkJ CQlzZ19kbWFfbGVuKHNnKSwgZGlyLCB0YXJnZXQpOwogfQogCi12b2lkCitzdGF0aWMgdm9pZAog eGVuX3N3aW90bGJfc3luY19zZ19mb3JfY3B1KHN0cnVjdCBkZXZpY2UgKmh3ZGV2LCBzdHJ1Y3Qg c2NhdHRlcmxpc3QgKnNnLAogCQkJICAgIGludCBuZWxlbXMsIGVudW0gZG1hX2RhdGFfZGlyZWN0 aW9uIGRpcikKIHsKIAl4ZW5fc3dpb3RsYl9zeW5jX3NnKGh3ZGV2LCBzZywgbmVsZW1zLCBkaXIs IFNZTkNfRk9SX0NQVSk7CiB9Ci1FWFBPUlRfU1lNQk9MX0dQTCh4ZW5fc3dpb3RsYl9zeW5jX3Nn X2Zvcl9jcHUpOwogCi12b2lkCitzdGF0aWMgdm9pZAogeGVuX3N3aW90bGJfc3luY19zZ19mb3Jf ZGV2aWNlKHN0cnVjdCBkZXZpY2UgKmh3ZGV2LCBzdHJ1Y3Qgc2NhdHRlcmxpc3QgKnNnLAogCQkJ ICAgICAgIGludCBuZWxlbXMsIGVudW0gZG1hX2RhdGFfZGlyZWN0aW9uIGRpcikKIHsKIAl4ZW5f c3dpb3RsYl9zeW5jX3NnKGh3ZGV2LCBzZywgbmVsZW1zLCBkaXIsIFNZTkNfRk9SX0RFVklDRSk7 CiB9Ci1FWFBPUlRfU1lNQk9MX0dQTCh4ZW5fc3dpb3RsYl9zeW5jX3NnX2Zvcl9kZXZpY2UpOwog CiAvKgogICogUmV0dXJuIHdoZXRoZXIgdGhlIGdpdmVuIGRldmljZSBETUEgYWRkcmVzcyBtYXNr IGNhbiBiZSBzdXBwb3J0ZWQKQEAgLTY2MywxNCArNjUzLDEzIEBAIEVYUE9SVF9TWU1CT0xfR1BM KHhlbl9zd2lvdGxiX3N5bmNfc2dfZm9yX2RldmljZSk7CiAgKiBkdXJpbmcgYnVzIG1hc3Rlcmlu ZywgdGhlbiB5b3Ugd291bGQgcGFzcyAweDAwZmZmZmZmIGFzIHRoZSBtYXNrIHRvCiAgKiB0aGlz IGZ1bmN0aW9uLgogICovCi1pbnQKK3N0YXRpYyBpbnQKIHhlbl9zd2lvdGxiX2RtYV9zdXBwb3J0 ZWQoc3RydWN0IGRldmljZSAqaHdkZXYsIHU2NCBtYXNrKQogewogCXJldHVybiB4ZW5fdmlydF90 b19idXMoeGVuX2lvX3RsYl9lbmQgLSAxKSA8PSBtYXNrOwogfQotRVhQT1JUX1NZTUJPTF9HUEwo eGVuX3N3aW90bGJfZG1hX3N1cHBvcnRlZCk7CiAKLWludAorc3RhdGljIGludAogeGVuX3N3aW90 bGJfc2V0X2RtYV9tYXNrKHN0cnVjdCBkZXZpY2UgKmRldiwgdTY0IGRtYV9tYXNrKQogewogCWlm ICghZGV2LT5kbWFfbWFzayB8fCAheGVuX3N3aW90bGJfZG1hX3N1cHBvcnRlZChkZXYsIGRtYV9t YXNrKSkKQEAgLTY4MCwxNCArNjY5LDEzIEBAIHhlbl9zd2lvdGxiX3NldF9kbWFfbWFzayhzdHJ1 Y3QgZGV2aWNlICpkZXYsIHU2NCBkbWFfbWFzaykKIAogCXJldHVybiAwOwogfQotRVhQT1JUX1NZ TUJPTF9HUEwoeGVuX3N3aW90bGJfc2V0X2RtYV9tYXNrKTsKIAogLyoKICAqIENyZWF0ZSB1c2Vy c3BhY2UgbWFwcGluZyBmb3IgdGhlIERNQS1jb2hlcmVudCBtZW1vcnkuCiAgKiBUaGlzIGZ1bmN0 aW9uIHNob3VsZCBiZSBjYWxsZWQgd2l0aCB0aGUgcGFnZXMgZnJvbSB0aGUgY3VycmVudCBkb21h aW4gb25seSwKICAqIHBhc3NpbmcgcGFnZXMgbWFwcGVkIGZyb20gb3RoZXIgZG9tYWlucyB3b3Vs ZCBsZWFkIHRvIG1lbW9yeSBjb3JydXB0aW9uLgogICovCi1pbnQKK3N0YXRpYyBpbnQKIHhlbl9z d2lvdGxiX2RtYV9tbWFwKHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IHZtX2FyZWFfc3RydWN0 ICp2bWEsCiAJCSAgICAgdm9pZCAqY3B1X2FkZHIsIGRtYV9hZGRyX3QgZG1hX2FkZHIsIHNpemVf dCBzaXplLAogCQkgICAgIHVuc2lnbmVkIGxvbmcgYXR0cnMpCkBAIC02OTksMTMgKzY4NywxMiBA QCB4ZW5fc3dpb3RsYl9kbWFfbW1hcChzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCB2bV9hcmVh X3N0cnVjdCAqdm1hLAogI2VuZGlmCiAJcmV0dXJuIGRtYV9jb21tb25fbW1hcChkZXYsIHZtYSwg Y3B1X2FkZHIsIGRtYV9hZGRyLCBzaXplKTsKIH0KLUVYUE9SVF9TWU1CT0xfR1BMKHhlbl9zd2lv dGxiX2RtYV9tbWFwKTsKIAogLyoKICAqIFRoaXMgZnVuY3Rpb24gc2hvdWxkIGJlIGNhbGxlZCB3 aXRoIHRoZSBwYWdlcyBmcm9tIHRoZSBjdXJyZW50IGRvbWFpbiBvbmx5LAogICogcGFzc2luZyBw YWdlcyBtYXBwZWQgZnJvbSBvdGhlciBkb21haW5zIHdvdWxkIGxlYWQgdG8gbWVtb3J5IGNvcnJ1 cHRpb24uCiAgKi8KLWludAorc3RhdGljIGludAogeGVuX3N3aW90bGJfZ2V0X3NndGFibGUoc3Ry dWN0IGRldmljZSAqZGV2LCBzdHJ1Y3Qgc2dfdGFibGUgKnNndCwKIAkJCXZvaWQgKmNwdV9hZGRy LCBkbWFfYWRkcl90IGhhbmRsZSwgc2l6ZV90IHNpemUsCiAJCQl1bnNpZ25lZCBsb25nIGF0dHJz KQpAQCAtNzI3LDQgKzcxNCwyMCBAQCB4ZW5fc3dpb3RsYl9nZXRfc2d0YWJsZShzdHJ1Y3QgZGV2 aWNlICpkZXYsIHN0cnVjdCBzZ190YWJsZSAqc2d0LAogI2VuZGlmCiAJcmV0dXJuIGRtYV9jb21t b25fZ2V0X3NndGFibGUoZGV2LCBzZ3QsIGNwdV9hZGRyLCBoYW5kbGUsIHNpemUpOwogfQotRVhQ T1JUX1NZTUJPTF9HUEwoeGVuX3N3aW90bGJfZ2V0X3NndGFibGUpOworCitjb25zdCBzdHJ1Y3Qg ZG1hX21hcF9vcHMgeGVuX3N3aW90bGJfZG1hX29wcyA9IHsKKwkuYWxsb2MgPSB4ZW5fc3dpb3Rs Yl9hbGxvY19jb2hlcmVudCwKKwkuZnJlZSA9IHhlbl9zd2lvdGxiX2ZyZWVfY29oZXJlbnQsCisJ LnN5bmNfc2luZ2xlX2Zvcl9jcHUgPSB4ZW5fc3dpb3RsYl9zeW5jX3NpbmdsZV9mb3JfY3B1LAor CS5zeW5jX3NpbmdsZV9mb3JfZGV2aWNlID0geGVuX3N3aW90bGJfc3luY19zaW5nbGVfZm9yX2Rl dmljZSwKKwkuc3luY19zZ19mb3JfY3B1ID0geGVuX3N3aW90bGJfc3luY19zZ19mb3JfY3B1LAor CS5zeW5jX3NnX2Zvcl9kZXZpY2UgPSB4ZW5fc3dpb3RsYl9zeW5jX3NnX2Zvcl9kZXZpY2UsCisJ Lm1hcF9zZyA9IHhlbl9zd2lvdGxiX21hcF9zZ19hdHRycywKKwkudW5tYXBfc2cgPSB4ZW5fc3dp b3RsYl91bm1hcF9zZ19hdHRycywKKwkubWFwX3BhZ2UgPSB4ZW5fc3dpb3RsYl9tYXBfcGFnZSwK KwkudW5tYXBfcGFnZSA9IHhlbl9zd2lvdGxiX3VubWFwX3BhZ2UsCisJLmRtYV9zdXBwb3J0ZWQg PSB4ZW5fc3dpb3RsYl9kbWFfc3VwcG9ydGVkLAorCS5zZXRfZG1hX21hc2sgPSB4ZW5fc3dpb3Rs Yl9zZXRfZG1hX21hc2ssCisJLm1tYXAgPSB4ZW5fc3dpb3RsYl9kbWFfbW1hcCwKKwkuZ2V0X3Nn dGFibGUgPSB4ZW5fc3dpb3RsYl9nZXRfc2d0YWJsZSwKK307CmRpZmYgLS1naXQgYS9pbmNsdWRl L3hlbi9zd2lvdGxiLXhlbi5oIGIvaW5jbHVkZS94ZW4vc3dpb3RsYi14ZW4uaAppbmRleCAxZjZk NzhmMDQ0YjYuLmVkMmRlMzYzZGEzMyAxMDA2NDQKLS0tIGEvaW5jbHVkZS94ZW4vc3dpb3RsYi14 ZW4uaAorKysgYi9pbmNsdWRlL3hlbi9zd2lvdGxiLXhlbi5oCkBAIC0xLDY5ICsxLDkgQEAKICNp Zm5kZWYgX19MSU5VWF9TV0lPVExCX1hFTl9ICiAjZGVmaW5lIF9fTElOVVhfU1dJT1RMQl9YRU5f SAogCi0jaW5jbHVkZSA8bGludXgvZG1hLWRpcmVjdGlvbi5oPgotI2luY2x1ZGUgPGxpbnV4L3Nj YXR0ZXJsaXN0Lmg+CiAjaW5jbHVkZSA8bGludXgvc3dpb3RsYi5oPgogCiBleHRlcm4gaW50IHhl bl9zd2lvdGxiX2luaXQoaW50IHZlcmJvc2UsIGJvb2wgZWFybHkpOworZXh0ZXJuIGNvbnN0IHN0 cnVjdCBkbWFfbWFwX29wcyB4ZW5fc3dpb3RsYl9kbWFfb3BzOwogCi1leHRlcm4gdm9pZAotKnhl bl9zd2lvdGxiX2FsbG9jX2NvaGVyZW50KHN0cnVjdCBkZXZpY2UgKmh3ZGV2LCBzaXplX3Qgc2l6 ZSwKLQkJCSAgICBkbWFfYWRkcl90ICpkbWFfaGFuZGxlLCBnZnBfdCBmbGFncywKLQkJCSAgICB1 bnNpZ25lZCBsb25nIGF0dHJzKTsKLQotZXh0ZXJuIHZvaWQKLXhlbl9zd2lvdGxiX2ZyZWVfY29o ZXJlbnQoc3RydWN0IGRldmljZSAqaHdkZXYsIHNpemVfdCBzaXplLAotCQkJICB2b2lkICp2YWRk ciwgZG1hX2FkZHJfdCBkbWFfaGFuZGxlLAotCQkJICB1bnNpZ25lZCBsb25nIGF0dHJzKTsKLQot ZXh0ZXJuIGRtYV9hZGRyX3QgeGVuX3N3aW90bGJfbWFwX3BhZ2Uoc3RydWN0IGRldmljZSAqZGV2 LCBzdHJ1Y3QgcGFnZSAqcGFnZSwKLQkJCQkgICAgICAgdW5zaWduZWQgbG9uZyBvZmZzZXQsIHNp emVfdCBzaXplLAotCQkJCSAgICAgICBlbnVtIGRtYV9kYXRhX2RpcmVjdGlvbiBkaXIsCi0JCQkJ ICAgICAgIHVuc2lnbmVkIGxvbmcgYXR0cnMpOwotCi1leHRlcm4gdm9pZCB4ZW5fc3dpb3RsYl91 bm1hcF9wYWdlKHN0cnVjdCBkZXZpY2UgKmh3ZGV2LCBkbWFfYWRkcl90IGRldl9hZGRyLAotCQkJ CSAgIHNpemVfdCBzaXplLCBlbnVtIGRtYV9kYXRhX2RpcmVjdGlvbiBkaXIsCi0JCQkJICAgdW5z aWduZWQgbG9uZyBhdHRycyk7Ci1leHRlcm4gaW50Ci14ZW5fc3dpb3RsYl9tYXBfc2dfYXR0cnMo c3RydWN0IGRldmljZSAqaHdkZXYsIHN0cnVjdCBzY2F0dGVybGlzdCAqc2dsLAotCQkJIGludCBu ZWxlbXMsIGVudW0gZG1hX2RhdGFfZGlyZWN0aW9uIGRpciwKLQkJCSB1bnNpZ25lZCBsb25nIGF0 dHJzKTsKLQotZXh0ZXJuIHZvaWQKLXhlbl9zd2lvdGxiX3VubWFwX3NnX2F0dHJzKHN0cnVjdCBk ZXZpY2UgKmh3ZGV2LCBzdHJ1Y3Qgc2NhdHRlcmxpc3QgKnNnbCwKLQkJCSAgIGludCBuZWxlbXMs IGVudW0gZG1hX2RhdGFfZGlyZWN0aW9uIGRpciwKLQkJCSAgIHVuc2lnbmVkIGxvbmcgYXR0cnMp OwotCi1leHRlcm4gdm9pZAoteGVuX3N3aW90bGJfc3luY19zaW5nbGVfZm9yX2NwdShzdHJ1Y3Qg ZGV2aWNlICpod2RldiwgZG1hX2FkZHJfdCBkZXZfYWRkciwKLQkJCQlzaXplX3Qgc2l6ZSwgZW51 bSBkbWFfZGF0YV9kaXJlY3Rpb24gZGlyKTsKLQotZXh0ZXJuIHZvaWQKLXhlbl9zd2lvdGxiX3N5 bmNfc2dfZm9yX2NwdShzdHJ1Y3QgZGV2aWNlICpod2Rldiwgc3RydWN0IHNjYXR0ZXJsaXN0ICpz ZywKLQkJCSAgICBpbnQgbmVsZW1zLCBlbnVtIGRtYV9kYXRhX2RpcmVjdGlvbiBkaXIpOwotCi1l eHRlcm4gdm9pZAoteGVuX3N3aW90bGJfc3luY19zaW5nbGVfZm9yX2RldmljZShzdHJ1Y3QgZGV2 aWNlICpod2RldiwgZG1hX2FkZHJfdCBkZXZfYWRkciwKLQkJCQkgICBzaXplX3Qgc2l6ZSwgZW51 bSBkbWFfZGF0YV9kaXJlY3Rpb24gZGlyKTsKLQotZXh0ZXJuIHZvaWQKLXhlbl9zd2lvdGxiX3N5 bmNfc2dfZm9yX2RldmljZShzdHJ1Y3QgZGV2aWNlICpod2Rldiwgc3RydWN0IHNjYXR0ZXJsaXN0 ICpzZywKLQkJCSAgICAgICBpbnQgbmVsZW1zLCBlbnVtIGRtYV9kYXRhX2RpcmVjdGlvbiBkaXIp OwotCi1leHRlcm4gaW50Ci14ZW5fc3dpb3RsYl9kbWFfc3VwcG9ydGVkKHN0cnVjdCBkZXZpY2Ug Kmh3ZGV2LCB1NjQgbWFzayk7Ci0KLWV4dGVybiBpbnQKLXhlbl9zd2lvdGxiX3NldF9kbWFfbWFz ayhzdHJ1Y3QgZGV2aWNlICpkZXYsIHU2NCBkbWFfbWFzayk7Ci0KLWV4dGVybiBpbnQKLXhlbl9z d2lvdGxiX2RtYV9tbWFwKHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IHZtX2FyZWFfc3RydWN0 ICp2bWEsCi0JCSAgICAgdm9pZCAqY3B1X2FkZHIsIGRtYV9hZGRyX3QgZG1hX2FkZHIsIHNpemVf dCBzaXplLAotCQkgICAgIHVuc2lnbmVkIGxvbmcgYXR0cnMpOwotCi1leHRlcm4gaW50Ci14ZW5f c3dpb3RsYl9nZXRfc2d0YWJsZShzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBzZ190YWJsZSAq c2d0LAotCQkJdm9pZCAqY3B1X2FkZHIsIGRtYV9hZGRyX3QgaGFuZGxlLCBzaXplX3Qgc2l6ZSwK LQkJCXVuc2lnbmVkIGxvbmcgYXR0cnMpOwogI2VuZGlmIC8qIF9fTElOVVhfU1dJT1RMQl9YRU5f SCAqLwotLSAKMi4xMS4wCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fXwpkcmktZGV2ZWwgbWFpbGluZyBsaXN0CmRyaS1kZXZlbEBsaXN0cy5mcmVlZGVza3Rv cC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9kcmkt ZGV2ZWwK From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752895AbdFPS0p (ORCPT ); Fri, 16 Jun 2017 14:26:45 -0400 Received: from bombadil.infradead.org ([65.50.211.133]:44388 "EHLO bombadil.infradead.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752803AbdFPSLq (ORCPT ); Fri, 16 Jun 2017 14:11:46 -0400 From: Christoph Hellwig To: x86@kernel.org, linux-arm-kernel@lists.infradead.org, xen-devel@lists.xenproject.org, linux-c6x-dev@linux-c6x.org, linux-hexagon@vger.kernel.org, linux-ia64@vger.kernel.org, linux-mips@linux-mips.org, openrisc@lists.librecores.org, linuxppc-dev@lists.ozlabs.org, linux-s390@vger.kernel.org, linux-sh@vger.kernel.org, sparclinux@vger.kernel.org, linux-xtensa@linux-xtensa.org, dmaengine@vger.kernel.org, linux-tegra@vger.kernel.org, dri-devel@lists.freedesktop.org, linux-samsung-soc@vger.kernel.org, iommu@lists.linux-foundation.org, netdev@vger.kernel.org Cc: linux-kernel@vger.kernel.org Subject: [PATCH 07/44] xen-swiotlb: consolidate xen_swiotlb_dma_ops Date: Fri, 16 Jun 2017 20:10:22 +0200 Message-Id: <20170616181059.19206-8-hch@lst.de> X-Mailer: git-send-email 2.11.0 In-Reply-To: <20170616181059.19206-1-hch@lst.de> References: <20170616181059.19206-1-hch@lst.de> X-SRS-Rewrite: SMTP reverse-path rewritten from by bombadil.infradead.org. See http://www.infradead.org/rpr.html Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org ARM and x86 had duplicated versions of the dma_ops structure, the only difference is that x86 hasn't wired up the set_dma_mask, mmap, and get_sgtable ops yet. On x86 all of them are identical to the generic version, so they aren't needed but harmless. All the symbols used only for xen_swiotlb_dma_ops can now be marked static as well. Signed-off-by: Christoph Hellwig Reviewed-by: Konrad Rzeszutek Wilk --- arch/arm/xen/mm.c | 17 -------- arch/x86/xen/pci-swiotlb-xen.c | 14 ------- drivers/xen/swiotlb-xen.c | 93 ++++++++++++++++++++++-------------------- include/xen/swiotlb-xen.h | 62 +--------------------------- 4 files changed, 49 insertions(+), 137 deletions(-) diff --git a/arch/arm/xen/mm.c b/arch/arm/xen/mm.c index f0325d96b97a..785d2a562a23 100644 --- a/arch/arm/xen/mm.c +++ b/arch/arm/xen/mm.c @@ -185,23 +185,6 @@ EXPORT_SYMBOL_GPL(xen_destroy_contiguous_region); const struct dma_map_ops *xen_dma_ops; EXPORT_SYMBOL(xen_dma_ops); -static const struct dma_map_ops xen_swiotlb_dma_ops = { - .alloc = xen_swiotlb_alloc_coherent, - .free = xen_swiotlb_free_coherent, - .sync_single_for_cpu = xen_swiotlb_sync_single_for_cpu, - .sync_single_for_device = xen_swiotlb_sync_single_for_device, - .sync_sg_for_cpu = xen_swiotlb_sync_sg_for_cpu, - .sync_sg_for_device = xen_swiotlb_sync_sg_for_device, - .map_sg = xen_swiotlb_map_sg_attrs, - .unmap_sg = xen_swiotlb_unmap_sg_attrs, - .map_page = xen_swiotlb_map_page, - .unmap_page = xen_swiotlb_unmap_page, - .dma_supported = xen_swiotlb_dma_supported, - .set_dma_mask = xen_swiotlb_set_dma_mask, - .mmap = xen_swiotlb_dma_mmap, - .get_sgtable = xen_swiotlb_get_sgtable, -}; - int __init xen_mm_init(void) { struct gnttab_cache_flush cflush; diff --git a/arch/x86/xen/pci-swiotlb-xen.c b/arch/x86/xen/pci-swiotlb-xen.c index 42b08f8fc2ca..37c6056a7bba 100644 --- a/arch/x86/xen/pci-swiotlb-xen.c +++ b/arch/x86/xen/pci-swiotlb-xen.c @@ -18,20 +18,6 @@ int xen_swiotlb __read_mostly; -static const struct dma_map_ops xen_swiotlb_dma_ops = { - .alloc = xen_swiotlb_alloc_coherent, - .free = xen_swiotlb_free_coherent, - .sync_single_for_cpu = xen_swiotlb_sync_single_for_cpu, - .sync_single_for_device = xen_swiotlb_sync_single_for_device, - .sync_sg_for_cpu = xen_swiotlb_sync_sg_for_cpu, - .sync_sg_for_device = xen_swiotlb_sync_sg_for_device, - .map_sg = xen_swiotlb_map_sg_attrs, - .unmap_sg = xen_swiotlb_unmap_sg_attrs, - .map_page = xen_swiotlb_map_page, - .unmap_page = xen_swiotlb_unmap_page, - .dma_supported = xen_swiotlb_dma_supported, -}; - /* * pci_xen_swiotlb_detect - set xen_swiotlb to 1 if necessary * diff --git a/drivers/xen/swiotlb-xen.c b/drivers/xen/swiotlb-xen.c index 8dab0d3dc172..a0f006daab48 100644 --- a/drivers/xen/swiotlb-xen.c +++ b/drivers/xen/swiotlb-xen.c @@ -295,7 +295,8 @@ int __ref xen_swiotlb_init(int verbose, bool early) free_pages((unsigned long)xen_io_tlb_start, order); return rc; } -void * + +static void * xen_swiotlb_alloc_coherent(struct device *hwdev, size_t size, dma_addr_t *dma_handle, gfp_t flags, unsigned long attrs) @@ -346,9 +347,8 @@ xen_swiotlb_alloc_coherent(struct device *hwdev, size_t size, memset(ret, 0, size); return ret; } -EXPORT_SYMBOL_GPL(xen_swiotlb_alloc_coherent); -void +static void xen_swiotlb_free_coherent(struct device *hwdev, size_t size, void *vaddr, dma_addr_t dev_addr, unsigned long attrs) { @@ -369,8 +369,6 @@ xen_swiotlb_free_coherent(struct device *hwdev, size_t size, void *vaddr, xen_free_coherent_pages(hwdev, size, vaddr, (dma_addr_t)phys, attrs); } -EXPORT_SYMBOL_GPL(xen_swiotlb_free_coherent); - /* * Map a single buffer of the indicated size for DMA in streaming mode. The @@ -379,7 +377,7 @@ EXPORT_SYMBOL_GPL(xen_swiotlb_free_coherent); * 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. */ -dma_addr_t xen_swiotlb_map_page(struct device *dev, struct page *page, +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) @@ -429,7 +427,6 @@ dma_addr_t xen_swiotlb_map_page(struct device *dev, struct page *page, return DMA_ERROR_CODE; } -EXPORT_SYMBOL_GPL(xen_swiotlb_map_page); /* * Unmap a single streaming mode DMA translation. The dma_addr and size must @@ -467,13 +464,12 @@ static void xen_unmap_single(struct device *hwdev, dma_addr_t dev_addr, dma_mark_clean(phys_to_virt(paddr), size); } -void xen_swiotlb_unmap_page(struct device *hwdev, dma_addr_t dev_addr, +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) { xen_unmap_single(hwdev, dev_addr, size, dir, attrs); } -EXPORT_SYMBOL_GPL(xen_swiotlb_unmap_page); /* * Make physical memory consistent for a single streaming mode DMA translation @@ -516,7 +512,6 @@ xen_swiotlb_sync_single_for_cpu(struct device *hwdev, dma_addr_t dev_addr, { xen_swiotlb_sync_single(hwdev, dev_addr, size, dir, SYNC_FOR_CPU); } -EXPORT_SYMBOL_GPL(xen_swiotlb_sync_single_for_cpu); void xen_swiotlb_sync_single_for_device(struct device *hwdev, dma_addr_t dev_addr, @@ -524,7 +519,25 @@ xen_swiotlb_sync_single_for_device(struct device *hwdev, dma_addr_t dev_addr, { xen_swiotlb_sync_single(hwdev, dev_addr, size, dir, SYNC_FOR_DEVICE); } -EXPORT_SYMBOL_GPL(xen_swiotlb_sync_single_for_device); + +/* + * 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_attrs(struct device *hwdev, struct scatterlist *sgl, + int nelems, enum dma_data_direction dir, + unsigned long attrs) +{ + struct scatterlist *sg; + int i; + + BUG_ON(dir == DMA_NONE); + + for_each_sg(sgl, sg, nelems, i) + xen_unmap_single(hwdev, sg->dma_address, sg_dma_len(sg), dir, attrs); + +} /* * Map a set of buffers described by scatterlist in streaming mode for DMA. @@ -542,7 +555,7 @@ EXPORT_SYMBOL_GPL(xen_swiotlb_sync_single_for_device); * Device ownership issues as mentioned above for xen_swiotlb_map_page are the * same here. */ -int +static int xen_swiotlb_map_sg_attrs(struct device *hwdev, struct scatterlist *sgl, int nelems, enum dma_data_direction dir, unsigned long attrs) @@ -599,27 +612,6 @@ xen_swiotlb_map_sg_attrs(struct device *hwdev, struct scatterlist *sgl, } return nelems; } -EXPORT_SYMBOL_GPL(xen_swiotlb_map_sg_attrs); - -/* - * Unmap a set of streaming mode DMA translations. Again, cpu read rules - * concerning calls here are the same as for swiotlb_unmap_page() above. - */ -void -xen_swiotlb_unmap_sg_attrs(struct device *hwdev, struct scatterlist *sgl, - int nelems, enum dma_data_direction dir, - unsigned long attrs) -{ - struct scatterlist *sg; - int i; - - BUG_ON(dir == DMA_NONE); - - for_each_sg(sgl, sg, nelems, i) - xen_unmap_single(hwdev, sg->dma_address, sg_dma_len(sg), dir, attrs); - -} -EXPORT_SYMBOL_GPL(xen_swiotlb_unmap_sg_attrs); /* * Make physical memory consistent for a set of streaming mode DMA translations @@ -641,21 +633,19 @@ xen_swiotlb_sync_sg(struct device *hwdev, struct scatterlist *sgl, sg_dma_len(sg), dir, target); } -void +static void xen_swiotlb_sync_sg_for_cpu(struct device *hwdev, struct scatterlist *sg, int nelems, enum dma_data_direction dir) { xen_swiotlb_sync_sg(hwdev, sg, nelems, dir, SYNC_FOR_CPU); } -EXPORT_SYMBOL_GPL(xen_swiotlb_sync_sg_for_cpu); -void +static void xen_swiotlb_sync_sg_for_device(struct device *hwdev, struct scatterlist *sg, int nelems, enum dma_data_direction dir) { xen_swiotlb_sync_sg(hwdev, sg, nelems, dir, SYNC_FOR_DEVICE); } -EXPORT_SYMBOL_GPL(xen_swiotlb_sync_sg_for_device); /* * Return whether the given device DMA address mask can be supported @@ -663,14 +653,13 @@ EXPORT_SYMBOL_GPL(xen_swiotlb_sync_sg_for_device); * during bus mastering, then you would pass 0x00ffffff as the mask to * this function. */ -int +static int xen_swiotlb_dma_supported(struct device *hwdev, u64 mask) { return xen_virt_to_bus(xen_io_tlb_end - 1) <= mask; } -EXPORT_SYMBOL_GPL(xen_swiotlb_dma_supported); -int +static int xen_swiotlb_set_dma_mask(struct device *dev, u64 dma_mask) { if (!dev->dma_mask || !xen_swiotlb_dma_supported(dev, dma_mask)) @@ -680,14 +669,13 @@ xen_swiotlb_set_dma_mask(struct device *dev, u64 dma_mask) return 0; } -EXPORT_SYMBOL_GPL(xen_swiotlb_set_dma_mask); /* * Create userspace mapping for the DMA-coherent memory. * This function should be called with the pages from the current domain only, * passing pages mapped from other domains would lead to memory corruption. */ -int +static int xen_swiotlb_dma_mmap(struct device *dev, struct vm_area_struct *vma, void *cpu_addr, dma_addr_t dma_addr, size_t size, unsigned long attrs) @@ -699,13 +687,12 @@ xen_swiotlb_dma_mmap(struct device *dev, struct vm_area_struct *vma, #endif return dma_common_mmap(dev, vma, cpu_addr, dma_addr, size); } -EXPORT_SYMBOL_GPL(xen_swiotlb_dma_mmap); /* * This function should be called with the pages from the current domain only, * passing pages mapped from other domains would lead to memory corruption. */ -int +static int xen_swiotlb_get_sgtable(struct device *dev, struct sg_table *sgt, void *cpu_addr, dma_addr_t handle, size_t size, unsigned long attrs) @@ -727,4 +714,20 @@ xen_swiotlb_get_sgtable(struct device *dev, struct sg_table *sgt, #endif return dma_common_get_sgtable(dev, sgt, cpu_addr, handle, size); } -EXPORT_SYMBOL_GPL(xen_swiotlb_get_sgtable); + +const struct dma_map_ops xen_swiotlb_dma_ops = { + .alloc = xen_swiotlb_alloc_coherent, + .free = xen_swiotlb_free_coherent, + .sync_single_for_cpu = xen_swiotlb_sync_single_for_cpu, + .sync_single_for_device = xen_swiotlb_sync_single_for_device, + .sync_sg_for_cpu = xen_swiotlb_sync_sg_for_cpu, + .sync_sg_for_device = xen_swiotlb_sync_sg_for_device, + .map_sg = xen_swiotlb_map_sg_attrs, + .unmap_sg = xen_swiotlb_unmap_sg_attrs, + .map_page = xen_swiotlb_map_page, + .unmap_page = xen_swiotlb_unmap_page, + .dma_supported = xen_swiotlb_dma_supported, + .set_dma_mask = xen_swiotlb_set_dma_mask, + .mmap = xen_swiotlb_dma_mmap, + .get_sgtable = xen_swiotlb_get_sgtable, +}; diff --git a/include/xen/swiotlb-xen.h b/include/xen/swiotlb-xen.h index 1f6d78f044b6..ed2de363da33 100644 --- a/include/xen/swiotlb-xen.h +++ b/include/xen/swiotlb-xen.h @@ -1,69 +1,9 @@ #ifndef __LINUX_SWIOTLB_XEN_H #define __LINUX_SWIOTLB_XEN_H -#include -#include #include extern int xen_swiotlb_init(int verbose, bool early); +extern const struct dma_map_ops xen_swiotlb_dma_ops; -extern void -*xen_swiotlb_alloc_coherent(struct device *hwdev, size_t size, - dma_addr_t *dma_handle, gfp_t flags, - unsigned long attrs); - -extern void -xen_swiotlb_free_coherent(struct device *hwdev, size_t size, - void *vaddr, dma_addr_t dma_handle, - unsigned long attrs); - -extern 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); - -extern void xen_swiotlb_unmap_page(struct device *hwdev, dma_addr_t dev_addr, - size_t size, enum dma_data_direction dir, - unsigned long attrs); -extern int -xen_swiotlb_map_sg_attrs(struct device *hwdev, struct scatterlist *sgl, - int nelems, enum dma_data_direction dir, - unsigned long attrs); - -extern void -xen_swiotlb_unmap_sg_attrs(struct device *hwdev, struct scatterlist *sgl, - int nelems, enum dma_data_direction dir, - unsigned long attrs); - -extern void -xen_swiotlb_sync_single_for_cpu(struct device *hwdev, dma_addr_t dev_addr, - size_t size, enum dma_data_direction dir); - -extern void -xen_swiotlb_sync_sg_for_cpu(struct device *hwdev, struct scatterlist *sg, - int nelems, enum dma_data_direction dir); - -extern void -xen_swiotlb_sync_single_for_device(struct device *hwdev, dma_addr_t dev_addr, - size_t size, enum dma_data_direction dir); - -extern void -xen_swiotlb_sync_sg_for_device(struct device *hwdev, struct scatterlist *sg, - int nelems, enum dma_data_direction dir); - -extern int -xen_swiotlb_dma_supported(struct device *hwdev, u64 mask); - -extern int -xen_swiotlb_set_dma_mask(struct device *dev, u64 dma_mask); - -extern int -xen_swiotlb_dma_mmap(struct device *dev, struct vm_area_struct *vma, - void *cpu_addr, dma_addr_t dma_addr, size_t size, - unsigned long attrs); - -extern int -xen_swiotlb_get_sgtable(struct device *dev, struct sg_table *sgt, - void *cpu_addr, dma_addr_t handle, size_t size, - unsigned long attrs); #endif /* __LINUX_SWIOTLB_XEN_H */ -- 2.11.0 From mboxrd@z Thu Jan 1 00:00:00 1970 From: hch@lst.de (Christoph Hellwig) Date: Fri, 16 Jun 2017 20:10:22 +0200 Subject: [PATCH 07/44] xen-swiotlb: consolidate xen_swiotlb_dma_ops In-Reply-To: <20170616181059.19206-1-hch@lst.de> References: <20170616181059.19206-1-hch@lst.de> Message-ID: <20170616181059.19206-8-hch@lst.de> To: linux-arm-kernel@lists.infradead.org List-Id: linux-arm-kernel.lists.infradead.org ARM and x86 had duplicated versions of the dma_ops structure, the only difference is that x86 hasn't wired up the set_dma_mask, mmap, and get_sgtable ops yet. On x86 all of them are identical to the generic version, so they aren't needed but harmless. All the symbols used only for xen_swiotlb_dma_ops can now be marked static as well. Signed-off-by: Christoph Hellwig Reviewed-by: Konrad Rzeszutek Wilk --- arch/arm/xen/mm.c | 17 -------- arch/x86/xen/pci-swiotlb-xen.c | 14 ------- drivers/xen/swiotlb-xen.c | 93 ++++++++++++++++++++++-------------------- include/xen/swiotlb-xen.h | 62 +--------------------------- 4 files changed, 49 insertions(+), 137 deletions(-) diff --git a/arch/arm/xen/mm.c b/arch/arm/xen/mm.c index f0325d96b97a..785d2a562a23 100644 --- a/arch/arm/xen/mm.c +++ b/arch/arm/xen/mm.c @@ -185,23 +185,6 @@ EXPORT_SYMBOL_GPL(xen_destroy_contiguous_region); const struct dma_map_ops *xen_dma_ops; EXPORT_SYMBOL(xen_dma_ops); -static const struct dma_map_ops xen_swiotlb_dma_ops = { - .alloc = xen_swiotlb_alloc_coherent, - .free = xen_swiotlb_free_coherent, - .sync_single_for_cpu = xen_swiotlb_sync_single_for_cpu, - .sync_single_for_device = xen_swiotlb_sync_single_for_device, - .sync_sg_for_cpu = xen_swiotlb_sync_sg_for_cpu, - .sync_sg_for_device = xen_swiotlb_sync_sg_for_device, - .map_sg = xen_swiotlb_map_sg_attrs, - .unmap_sg = xen_swiotlb_unmap_sg_attrs, - .map_page = xen_swiotlb_map_page, - .unmap_page = xen_swiotlb_unmap_page, - .dma_supported = xen_swiotlb_dma_supported, - .set_dma_mask = xen_swiotlb_set_dma_mask, - .mmap = xen_swiotlb_dma_mmap, - .get_sgtable = xen_swiotlb_get_sgtable, -}; - int __init xen_mm_init(void) { struct gnttab_cache_flush cflush; diff --git a/arch/x86/xen/pci-swiotlb-xen.c b/arch/x86/xen/pci-swiotlb-xen.c index 42b08f8fc2ca..37c6056a7bba 100644 --- a/arch/x86/xen/pci-swiotlb-xen.c +++ b/arch/x86/xen/pci-swiotlb-xen.c @@ -18,20 +18,6 @@ int xen_swiotlb __read_mostly; -static const struct dma_map_ops xen_swiotlb_dma_ops = { - .alloc = xen_swiotlb_alloc_coherent, - .free = xen_swiotlb_free_coherent, - .sync_single_for_cpu = xen_swiotlb_sync_single_for_cpu, - .sync_single_for_device = xen_swiotlb_sync_single_for_device, - .sync_sg_for_cpu = xen_swiotlb_sync_sg_for_cpu, - .sync_sg_for_device = xen_swiotlb_sync_sg_for_device, - .map_sg = xen_swiotlb_map_sg_attrs, - .unmap_sg = xen_swiotlb_unmap_sg_attrs, - .map_page = xen_swiotlb_map_page, - .unmap_page = xen_swiotlb_unmap_page, - .dma_supported = xen_swiotlb_dma_supported, -}; - /* * pci_xen_swiotlb_detect - set xen_swiotlb to 1 if necessary * diff --git a/drivers/xen/swiotlb-xen.c b/drivers/xen/swiotlb-xen.c index 8dab0d3dc172..a0f006daab48 100644 --- a/drivers/xen/swiotlb-xen.c +++ b/drivers/xen/swiotlb-xen.c @@ -295,7 +295,8 @@ int __ref xen_swiotlb_init(int verbose, bool early) free_pages((unsigned long)xen_io_tlb_start, order); return rc; } -void * + +static void * xen_swiotlb_alloc_coherent(struct device *hwdev, size_t size, dma_addr_t *dma_handle, gfp_t flags, unsigned long attrs) @@ -346,9 +347,8 @@ xen_swiotlb_alloc_coherent(struct device *hwdev, size_t size, memset(ret, 0, size); return ret; } -EXPORT_SYMBOL_GPL(xen_swiotlb_alloc_coherent); -void +static void xen_swiotlb_free_coherent(struct device *hwdev, size_t size, void *vaddr, dma_addr_t dev_addr, unsigned long attrs) { @@ -369,8 +369,6 @@ xen_swiotlb_free_coherent(struct device *hwdev, size_t size, void *vaddr, xen_free_coherent_pages(hwdev, size, vaddr, (dma_addr_t)phys, attrs); } -EXPORT_SYMBOL_GPL(xen_swiotlb_free_coherent); - /* * Map a single buffer of the indicated size for DMA in streaming mode. The @@ -379,7 +377,7 @@ EXPORT_SYMBOL_GPL(xen_swiotlb_free_coherent); * 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. */ -dma_addr_t xen_swiotlb_map_page(struct device *dev, struct page *page, +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) @@ -429,7 +427,6 @@ dma_addr_t xen_swiotlb_map_page(struct device *dev, struct page *page, return DMA_ERROR_CODE; } -EXPORT_SYMBOL_GPL(xen_swiotlb_map_page); /* * Unmap a single streaming mode DMA translation. The dma_addr and size must @@ -467,13 +464,12 @@ static void xen_unmap_single(struct device *hwdev, dma_addr_t dev_addr, dma_mark_clean(phys_to_virt(paddr), size); } -void xen_swiotlb_unmap_page(struct device *hwdev, dma_addr_t dev_addr, +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) { xen_unmap_single(hwdev, dev_addr, size, dir, attrs); } -EXPORT_SYMBOL_GPL(xen_swiotlb_unmap_page); /* * Make physical memory consistent for a single streaming mode DMA translation @@ -516,7 +512,6 @@ xen_swiotlb_sync_single_for_cpu(struct device *hwdev, dma_addr_t dev_addr, { xen_swiotlb_sync_single(hwdev, dev_addr, size, dir, SYNC_FOR_CPU); } -EXPORT_SYMBOL_GPL(xen_swiotlb_sync_single_for_cpu); void xen_swiotlb_sync_single_for_device(struct device *hwdev, dma_addr_t dev_addr, @@ -524,7 +519,25 @@ xen_swiotlb_sync_single_for_device(struct device *hwdev, dma_addr_t dev_addr, { xen_swiotlb_sync_single(hwdev, dev_addr, size, dir, SYNC_FOR_DEVICE); } -EXPORT_SYMBOL_GPL(xen_swiotlb_sync_single_for_device); + +/* + * 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_attrs(struct device *hwdev, struct scatterlist *sgl, + int nelems, enum dma_data_direction dir, + unsigned long attrs) +{ + struct scatterlist *sg; + int i; + + BUG_ON(dir == DMA_NONE); + + for_each_sg(sgl, sg, nelems, i) + xen_unmap_single(hwdev, sg->dma_address, sg_dma_len(sg), dir, attrs); + +} /* * Map a set of buffers described by scatterlist in streaming mode for DMA. @@ -542,7 +555,7 @@ EXPORT_SYMBOL_GPL(xen_swiotlb_sync_single_for_device); * Device ownership issues as mentioned above for xen_swiotlb_map_page are the * same here. */ -int +static int xen_swiotlb_map_sg_attrs(struct device *hwdev, struct scatterlist *sgl, int nelems, enum dma_data_direction dir, unsigned long attrs) @@ -599,27 +612,6 @@ xen_swiotlb_map_sg_attrs(struct device *hwdev, struct scatterlist *sgl, } return nelems; } -EXPORT_SYMBOL_GPL(xen_swiotlb_map_sg_attrs); - -/* - * Unmap a set of streaming mode DMA translations. Again, cpu read rules - * concerning calls here are the same as for swiotlb_unmap_page() above. - */ -void -xen_swiotlb_unmap_sg_attrs(struct device *hwdev, struct scatterlist *sgl, - int nelems, enum dma_data_direction dir, - unsigned long attrs) -{ - struct scatterlist *sg; - int i; - - BUG_ON(dir == DMA_NONE); - - for_each_sg(sgl, sg, nelems, i) - xen_unmap_single(hwdev, sg->dma_address, sg_dma_len(sg), dir, attrs); - -} -EXPORT_SYMBOL_GPL(xen_swiotlb_unmap_sg_attrs); /* * Make physical memory consistent for a set of streaming mode DMA translations @@ -641,21 +633,19 @@ xen_swiotlb_sync_sg(struct device *hwdev, struct scatterlist *sgl, sg_dma_len(sg), dir, target); } -void +static void xen_swiotlb_sync_sg_for_cpu(struct device *hwdev, struct scatterlist *sg, int nelems, enum dma_data_direction dir) { xen_swiotlb_sync_sg(hwdev, sg, nelems, dir, SYNC_FOR_CPU); } -EXPORT_SYMBOL_GPL(xen_swiotlb_sync_sg_for_cpu); -void +static void xen_swiotlb_sync_sg_for_device(struct device *hwdev, struct scatterlist *sg, int nelems, enum dma_data_direction dir) { xen_swiotlb_sync_sg(hwdev, sg, nelems, dir, SYNC_FOR_DEVICE); } -EXPORT_SYMBOL_GPL(xen_swiotlb_sync_sg_for_device); /* * Return whether the given device DMA address mask can be supported @@ -663,14 +653,13 @@ EXPORT_SYMBOL_GPL(xen_swiotlb_sync_sg_for_device); * during bus mastering, then you would pass 0x00ffffff as the mask to * this function. */ -int +static int xen_swiotlb_dma_supported(struct device *hwdev, u64 mask) { return xen_virt_to_bus(xen_io_tlb_end - 1) <= mask; } -EXPORT_SYMBOL_GPL(xen_swiotlb_dma_supported); -int +static int xen_swiotlb_set_dma_mask(struct device *dev, u64 dma_mask) { if (!dev->dma_mask || !xen_swiotlb_dma_supported(dev, dma_mask)) @@ -680,14 +669,13 @@ xen_swiotlb_set_dma_mask(struct device *dev, u64 dma_mask) return 0; } -EXPORT_SYMBOL_GPL(xen_swiotlb_set_dma_mask); /* * Create userspace mapping for the DMA-coherent memory. * This function should be called with the pages from the current domain only, * passing pages mapped from other domains would lead to memory corruption. */ -int +static int xen_swiotlb_dma_mmap(struct device *dev, struct vm_area_struct *vma, void *cpu_addr, dma_addr_t dma_addr, size_t size, unsigned long attrs) @@ -699,13 +687,12 @@ xen_swiotlb_dma_mmap(struct device *dev, struct vm_area_struct *vma, #endif return dma_common_mmap(dev, vma, cpu_addr, dma_addr, size); } -EXPORT_SYMBOL_GPL(xen_swiotlb_dma_mmap); /* * This function should be called with the pages from the current domain only, * passing pages mapped from other domains would lead to memory corruption. */ -int +static int xen_swiotlb_get_sgtable(struct device *dev, struct sg_table *sgt, void *cpu_addr, dma_addr_t handle, size_t size, unsigned long attrs) @@ -727,4 +714,20 @@ xen_swiotlb_get_sgtable(struct device *dev, struct sg_table *sgt, #endif return dma_common_get_sgtable(dev, sgt, cpu_addr, handle, size); } -EXPORT_SYMBOL_GPL(xen_swiotlb_get_sgtable); + +const struct dma_map_ops xen_swiotlb_dma_ops = { + .alloc = xen_swiotlb_alloc_coherent, + .free = xen_swiotlb_free_coherent, + .sync_single_for_cpu = xen_swiotlb_sync_single_for_cpu, + .sync_single_for_device = xen_swiotlb_sync_single_for_device, + .sync_sg_for_cpu = xen_swiotlb_sync_sg_for_cpu, + .sync_sg_for_device = xen_swiotlb_sync_sg_for_device, + .map_sg = xen_swiotlb_map_sg_attrs, + .unmap_sg = xen_swiotlb_unmap_sg_attrs, + .map_page = xen_swiotlb_map_page, + .unmap_page = xen_swiotlb_unmap_page, + .dma_supported = xen_swiotlb_dma_supported, + .set_dma_mask = xen_swiotlb_set_dma_mask, + .mmap = xen_swiotlb_dma_mmap, + .get_sgtable = xen_swiotlb_get_sgtable, +}; diff --git a/include/xen/swiotlb-xen.h b/include/xen/swiotlb-xen.h index 1f6d78f044b6..ed2de363da33 100644 --- a/include/xen/swiotlb-xen.h +++ b/include/xen/swiotlb-xen.h @@ -1,69 +1,9 @@ #ifndef __LINUX_SWIOTLB_XEN_H #define __LINUX_SWIOTLB_XEN_H -#include -#include #include extern int xen_swiotlb_init(int verbose, bool early); +extern const struct dma_map_ops xen_swiotlb_dma_ops; -extern void -*xen_swiotlb_alloc_coherent(struct device *hwdev, size_t size, - dma_addr_t *dma_handle, gfp_t flags, - unsigned long attrs); - -extern void -xen_swiotlb_free_coherent(struct device *hwdev, size_t size, - void *vaddr, dma_addr_t dma_handle, - unsigned long attrs); - -extern 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); - -extern void xen_swiotlb_unmap_page(struct device *hwdev, dma_addr_t dev_addr, - size_t size, enum dma_data_direction dir, - unsigned long attrs); -extern int -xen_swiotlb_map_sg_attrs(struct device *hwdev, struct scatterlist *sgl, - int nelems, enum dma_data_direction dir, - unsigned long attrs); - -extern void -xen_swiotlb_unmap_sg_attrs(struct device *hwdev, struct scatterlist *sgl, - int nelems, enum dma_data_direction dir, - unsigned long attrs); - -extern void -xen_swiotlb_sync_single_for_cpu(struct device *hwdev, dma_addr_t dev_addr, - size_t size, enum dma_data_direction dir); - -extern void -xen_swiotlb_sync_sg_for_cpu(struct device *hwdev, struct scatterlist *sg, - int nelems, enum dma_data_direction dir); - -extern void -xen_swiotlb_sync_single_for_device(struct device *hwdev, dma_addr_t dev_addr, - size_t size, enum dma_data_direction dir); - -extern void -xen_swiotlb_sync_sg_for_device(struct device *hwdev, struct scatterlist *sg, - int nelems, enum dma_data_direction dir); - -extern int -xen_swiotlb_dma_supported(struct device *hwdev, u64 mask); - -extern int -xen_swiotlb_set_dma_mask(struct device *dev, u64 dma_mask); - -extern int -xen_swiotlb_dma_mmap(struct device *dev, struct vm_area_struct *vma, - void *cpu_addr, dma_addr_t dma_addr, size_t size, - unsigned long attrs); - -extern int -xen_swiotlb_get_sgtable(struct device *dev, struct sg_table *sgt, - void *cpu_addr, dma_addr_t handle, size_t size, - unsigned long attrs); #endif /* __LINUX_SWIOTLB_XEN_H */ -- 2.11.0