Change the parameters passed to iommu_dma_alloc_iova(): the dma_limit can
be easily extracted from the parameters of the passed struct device, so
replace it with a flags parameter, which can later hold more information
about the way the IOVA allocator should do it job. While touching the
parameter list, move struct device to the second position to better match
the convention of the DMA-mapping related functions.

Signed-off-by: Marek Szyprowski <m.szyprow...@samsung.com>
---
 drivers/iommu/dma-iommu.c | 23 +++++++++++++----------
 1 file changed, 13 insertions(+), 10 deletions(-)

diff --git a/drivers/iommu/dma-iommu.c b/drivers/iommu/dma-iommu.c
index 91dd8f46dae1..0ea87023306f 100644
--- a/drivers/iommu/dma-iommu.c
+++ b/drivers/iommu/dma-iommu.c
@@ -400,12 +400,16 @@ static int dma_info_to_prot(enum dma_data_direction dir, 
bool coherent,
        }
 }
 
+#define DMA_ALLOC_IOVA_COHERENT                BIT(0)
+
 static dma_addr_t iommu_dma_alloc_iova(struct iommu_domain *domain,
-               size_t size, u64 dma_limit, struct device *dev)
+               struct device *dev, size_t size, unsigned int flags)
 {
        struct iommu_dma_cookie *cookie = domain->iova_cookie;
        struct iova_domain *iovad = &cookie->iovad;
        unsigned long shift, iova_len, iova = IOVA_BAD_ADDR;
+       u64 dma_limit = (flags & DMA_ALLOC_IOVA_COHERENT) ?
+                       dev->coherent_dma_mask : dma_get_mask(dev);
 
        if (cookie->type == IOMMU_DMA_MSI_COOKIE) {
                cookie->msi_iova += size;
@@ -481,7 +485,7 @@ static void __iommu_dma_unmap(struct device *dev, 
dma_addr_t dma_addr,
 }
 
 static dma_addr_t __iommu_dma_map(struct device *dev, phys_addr_t phys,
-               size_t size, int prot, u64 dma_mask)
+               size_t size, int prot, unsigned int flags)
 {
        struct iommu_domain *domain = iommu_get_dma_domain(dev);
        struct iommu_dma_cookie *cookie = domain->iova_cookie;
@@ -494,7 +498,7 @@ static dma_addr_t __iommu_dma_map(struct device *dev, 
phys_addr_t phys,
 
        size = iova_align(iovad, size + iova_off);
 
-       iova = iommu_dma_alloc_iova(domain, size, dma_mask, dev);
+       iova = iommu_dma_alloc_iova(domain, dev, size, flags);
        if (iova == DMA_MAPPING_ERROR)
                return iova;
 
@@ -618,7 +622,7 @@ static void *iommu_dma_alloc_remap(struct device *dev, 
size_t size,
                return NULL;
 
        size = iova_align(iovad, size);
-       iova = iommu_dma_alloc_iova(domain, size, dev->coherent_dma_mask, dev);
+       iova = iommu_dma_alloc_iova(domain, dev, size, DMA_ALLOC_IOVA_COHERENT);
        if (iova == DMA_MAPPING_ERROR)
                goto out_free_pages;
 
@@ -733,7 +737,7 @@ static dma_addr_t iommu_dma_map_page(struct device *dev, 
struct page *page,
        int prot = dma_info_to_prot(dir, coherent, attrs);
        dma_addr_t dma_handle;
 
-       dma_handle = __iommu_dma_map(dev, phys, size, prot, dma_get_mask(dev));
+       dma_handle = __iommu_dma_map(dev, phys, size, prot, 0);
        if (!coherent && !(attrs & DMA_ATTR_SKIP_CPU_SYNC) &&
            dma_handle != DMA_MAPPING_ERROR)
                arch_sync_dma_for_device(phys, size, dir);
@@ -888,7 +892,7 @@ static int iommu_dma_map_sg(struct device *dev, struct 
scatterlist *sg,
                prev = s;
        }
 
-       iova = iommu_dma_alloc_iova(domain, iova_len, dma_get_mask(dev), dev);
+       iova = iommu_dma_alloc_iova(domain, dev, iova_len, 0);
        if (iova == DMA_MAPPING_ERROR)
                goto out_restore_sg;
 
@@ -936,8 +940,7 @@ static dma_addr_t iommu_dma_map_resource(struct device 
*dev, phys_addr_t phys,
                size_t size, enum dma_data_direction dir, unsigned long attrs)
 {
        return __iommu_dma_map(dev, phys, size,
-                       dma_info_to_prot(dir, false, attrs) | IOMMU_MMIO,
-                       dma_get_mask(dev));
+                       dma_info_to_prot(dir, false, attrs) | IOMMU_MMIO, 0);
 }
 
 static void iommu_dma_unmap_resource(struct device *dev, dma_addr_t handle,
@@ -1045,7 +1048,7 @@ static void *iommu_dma_alloc(struct device *dev, size_t 
size,
                return NULL;
 
        *handle = __iommu_dma_map(dev, page_to_phys(page), size, ioprot,
-                       dev->coherent_dma_mask);
+                                 DMA_ALLOC_IOVA_COHERENT);
        if (*handle == DMA_MAPPING_ERROR) {
                __iommu_dma_free(dev, size, cpu_addr);
                return NULL;
@@ -1182,7 +1185,7 @@ static struct iommu_dma_msi_page 
*iommu_dma_get_msi_page(struct device *dev,
        if (!msi_page)
                return NULL;
 
-       iova = iommu_dma_alloc_iova(domain, size, dma_get_mask(dev), dev);
+       iova = iommu_dma_alloc_iova(domain, dev, size, 0);
        if (iova == DMA_MAPPING_ERROR)
                goto out_free_page;
 
-- 
2.17.1

_______________________________________________
iommu mailing list
iommu@lists.linux-foundation.org
https://lists.linuxfoundation.org/mailman/listinfo/iommu

Reply via email to