iommu/fsl_pamu: remove ->domain_window_enable

The only thing that fsl_pamu_window_enable does for the current caller
is to fill in the prot value in the only dma_window structure, and to
propagate a few values from the iommu_domain_geometry struture into the
dma_window.  Remove the dma_window entirely, hardcode the prot value and
otherwise use the iommu_domain_geometry structure instead.

Remove the now unused ->domain_window_enable iommu method.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Acked-by: Li Yang <leoyang.li@nxp.com>
Link: https://lore.kernel.org/r/20210401155256.298656-7-hch@lst.de
Signed-off-by: Joerg Roedel <jroedel@suse.de>

diff --git a/drivers/iommu/fsl_pamu_domain.c b/drivers/iommu/fsl_pamu_domain.c
index e6bdd38..689035e 100644 (file)
--- a/drivers/iommu/fsl_pamu_domain.c
+++ b/drivers/iommu/fsl_pamu_domain.c
@@ -54,34 +54,18 @@ static int __init iommu_init_mempool(void)
        return 0;
 }
 
-static phys_addr_t get_phys_addr(struct fsl_dma_domain *dma_domain, dma_addr_t iova)
-{
-       struct dma_window *win_ptr = &dma_domain->win_arr[0];
-       struct iommu_domain_geometry *geom;
-
-       geom = &dma_domain->iommu_domain.geometry;
-
-       if (win_ptr->valid)
-               return win_ptr->paddr + (iova & (win_ptr->size - 1));
-
-       return 0;
-}
-
 /* Map the DMA window corresponding to the LIODN */
 static int map_liodn(int liodn, struct fsl_dma_domain *dma_domain)
 {
        int ret;
-       struct dma_window *wnd = &dma_domain->win_arr[0];
-       phys_addr_t wnd_addr = dma_domain->iommu_domain.geometry.aperture_start;
+       struct iommu_domain_geometry *geom = &dma_domain->iommu_domain.geometry;
        unsigned long flags;
 
        spin_lock_irqsave(&iommu_lock, flags);
-       ret = pamu_config_ppaace(liodn, wnd_addr,
-                                wnd->size,
-                                ~(u32)0,
-                                wnd->paddr >> PAMU_PAGE_SHIFT,
-                                dma_domain->snoop_id, dma_domain->stash_id,
-                                wnd->prot);
+       ret = pamu_config_ppaace(liodn, geom->aperture_start,
+                                geom->aperture_end + 1, ~(u32)0,
+                                0, dma_domain->snoop_id, dma_domain->stash_id,
+                                PAACE_AP_PERMS_QUERY | PAACE_AP_PERMS_UPDATE);
        spin_unlock_irqrestore(&iommu_lock, flags);
        if (ret)
                pr_debug("PAACE configuration failed for liodn %d\n", liodn);
@@ -89,33 +73,6 @@ static int map_liodn(int liodn, struct fsl_dma_domain *dma_domain)
        return ret;
 }
 
-/* Update window/subwindow mapping for the LIODN */
-static int update_liodn(int liodn, struct fsl_dma_domain *dma_domain, u32 wnd_nr)
-{
-       int ret;
-       struct dma_window *wnd = &dma_domain->win_arr[wnd_nr];
-       phys_addr_t wnd_addr;
-       unsigned long flags;
-
-       spin_lock_irqsave(&iommu_lock, flags);
-
-       wnd_addr = dma_domain->iommu_domain.geometry.aperture_start;
-
-       ret = pamu_config_ppaace(liodn, wnd_addr,
-                                wnd->size,
-                                ~(u32)0,
-                                wnd->paddr >> PAMU_PAGE_SHIFT,
-                                dma_domain->snoop_id, dma_domain->stash_id,
-                                wnd->prot);
-       if (ret)
-               pr_debug("Window reconfiguration failed for liodn %d\n",
-                        liodn);
-
-       spin_unlock_irqrestore(&iommu_lock, flags);
-
-       return ret;
-}
-
 static int update_liodn_stash(int liodn, struct fsl_dma_domain *dma_domain,
                              u32 val)
 {
@@ -172,26 +129,6 @@ static int pamu_set_liodn(int liodn, struct device *dev,
        return ret;
 }
 
-static int check_size(u64 size, dma_addr_t iova)
-{
-       /*
-        * Size must be a power of two and at least be equal
-        * to PAMU page size.
-        */
-       if ((size & (size - 1)) || size < PAMU_PAGE_SIZE) {
-               pr_debug("Size too small or not a power of two\n");
-               return -EINVAL;
-       }
-
-       /* iova must be page size aligned */
-       if (iova & (size - 1)) {
-               pr_debug("Address is not aligned with window size\n");
-               return -EINVAL;
-       }
-
-       return 0;
-}
-
 static void remove_device_ref(struct device_domain_info *info)
 {
        unsigned long flags;
@@ -257,13 +194,10 @@ static void attach_device(struct fsl_dma_domain *dma_domain, int liodn, struct d
 static phys_addr_t fsl_pamu_iova_to_phys(struct iommu_domain *domain,
                                         dma_addr_t iova)
 {
-       struct fsl_dma_domain *dma_domain = to_fsl_dma_domain(domain);
-
        if (iova < domain->geometry.aperture_start ||
            iova > domain->geometry.aperture_end)
                return 0;
-
-       return get_phys_addr(dma_domain, iova);
+       return iova;
 }
 
 static bool fsl_pamu_capable(enum iommu_cap cap)
@@ -279,7 +213,6 @@ static void fsl_pamu_domain_free(struct iommu_domain *domain)
        detach_device(NULL, dma_domain);
 
        dma_domain->enabled = 0;
-       dma_domain->mapped = 0;
 
        kmem_cache_free(fsl_pamu_domain_cache, dma_domain);
 }
@@ -323,84 +256,6 @@ static int update_domain_stash(struct fsl_dma_domain *dma_domain, u32 val)
        return ret;
 }
 
-/* Update domain mappings for all LIODNs associated with the domain */
-static int update_domain_mapping(struct fsl_dma_domain *dma_domain, u32 wnd_nr)
-{
-       struct device_domain_info *info;
-       int ret = 0;
-
-       list_for_each_entry(info, &dma_domain->devices, link) {
-               ret = update_liodn(info->liodn, dma_domain, wnd_nr);
-               if (ret)
-                       break;
-       }
-       return ret;
-}
-
-
-static int fsl_pamu_window_enable(struct iommu_domain *domain, u32 wnd_nr,
-                                 phys_addr_t paddr, u64 size, int prot)
-{
-       struct fsl_dma_domain *dma_domain = to_fsl_dma_domain(domain);
-       struct dma_window *wnd;
-       int pamu_prot = 0;
-       int ret;
-       unsigned long flags;
-       u64 win_size;
-
-       if (prot & IOMMU_READ)
-               pamu_prot |= PAACE_AP_PERMS_QUERY;
-       if (prot & IOMMU_WRITE)
-               pamu_prot |= PAACE_AP_PERMS_UPDATE;
-
-       spin_lock_irqsave(&dma_domain->domain_lock, flags);
-       if (wnd_nr > 0) {
-               pr_debug("Invalid window index\n");
-               spin_unlock_irqrestore(&dma_domain->domain_lock, flags);
-               return -EINVAL;
-       }
-
-       win_size = (domain->geometry.aperture_end + 1) >> ilog2(1);
-       if (size > win_size) {
-               pr_debug("Invalid window size\n");
-               spin_unlock_irqrestore(&dma_domain->domain_lock, flags);
-               return -EINVAL;
-       }
-
-       if (dma_domain->enabled) {
-               pr_debug("Disable the window before updating the mapping\n");
-               spin_unlock_irqrestore(&dma_domain->domain_lock, flags);
-               return -EBUSY;
-       }
-
-       ret = check_size(size, domain->geometry.aperture_start);
-       if (ret) {
-               pr_debug("Aperture start not aligned to the size\n");
-               spin_unlock_irqrestore(&dma_domain->domain_lock, flags);
-               return -EINVAL;
-       }
-
-       wnd = &dma_domain->win_arr[wnd_nr];
-       if (!wnd->valid) {
-               wnd->paddr = paddr;
-               wnd->size = size;
-               wnd->prot = pamu_prot;
-
-               ret = update_domain_mapping(dma_domain, wnd_nr);
-               if (!ret) {
-                       wnd->valid = 1;
-                       dma_domain->mapped++;
-               }
-       } else {
-               pr_debug("Disable the window before updating the mapping\n");
-               ret = -EBUSY;
-       }
-
-       spin_unlock_irqrestore(&dma_domain->domain_lock, flags);
-
-       return ret;
-}
-
 /*
  * Attach the LIODN to the DMA domain and configure the geometry
  * and window mappings.
@@ -434,15 +289,14 @@ static int handle_attach_device(struct fsl_dma_domain *dma_domain,
                                     &domain->geometry);
                if (ret)
                        break;
-               if (dma_domain->mapped) {
-                       /*
-                        * Create window/subwindow mapping for
-                        * the LIODN.
-                        */
-                       ret = map_liodn(liodn[i], dma_domain);
-                       if (ret)
-                               break;
-               }
+
+               /*
+                * Create window/subwindow mapping for
+                * the LIODN.
+                */
+               ret = map_liodn(liodn[i], dma_domain);
+               if (ret)
+                       break;
        }
        spin_unlock_irqrestore(&dma_domain->domain_lock, flags);
 
@@ -552,13 +406,6 @@ static int configure_domain_dma_state(struct fsl_dma_domain *dma_domain, bool en
        int ret;
 
        spin_lock_irqsave(&dma_domain->domain_lock, flags);
-
-       if (enable && !dma_domain->mapped) {
-               pr_debug("Can't enable DMA domain without valid mapping\n");
-               spin_unlock_irqrestore(&dma_domain->domain_lock, flags);
-               return -ENODEV;
-       }
-
        dma_domain->enabled = enable;
        list_for_each_entry(info, &dma_domain->devices, link) {
                ret = (enable) ? pamu_enable_liodn(info->liodn) :
@@ -717,7 +564,6 @@ static const struct iommu_ops fsl_pamu_ops = {
        .domain_free    = fsl_pamu_domain_free,
        .attach_dev     = fsl_pamu_attach_device,
        .detach_dev     = fsl_pamu_detach_device,
-       .domain_window_enable = fsl_pamu_window_enable,
        .iova_to_phys   = fsl_pamu_iova_to_phys,
        .domain_set_attr = fsl_pamu_set_domain_attr,
        .probe_device   = fsl_pamu_probe_device,

diff --git a/drivers/iommu/fsl_pamu_domain.h b/drivers/iommu/fsl_pamu_domain.h
index d3523ee..13ee06e 100644 (file)
--- a/drivers/iommu/fsl_pamu_domain.h
+++ b/drivers/iommu/fsl_pamu_domain.h
@@ -9,24 +9,10 @@
 
 #include "fsl_pamu.h"
 
-struct dma_window {
-       phys_addr_t paddr;
-       u64 size;
-       int valid;
-       int prot;
-};
-
 struct fsl_dma_domain {
-       /*
-        * win_arr contains information of the configured
-        * windows for a domain.
-        */
-       struct dma_window               win_arr[1];
        /* list of devices associated with the domain */
        struct list_head                devices;
        /* dma_domain states:
-        * mapped - A particular mapping has been created
-        * within the configured geometry.
         * enabled - DMA has been enabled for the given
         * domain. This translates to setting of the
         * valid bit for the primary PAACE in the PAMU
@@ -35,7 +21,6 @@ struct fsl_dma_domain {
         * enabled for it.
         *
         */
-       int                             mapped;
        int                             enabled;
        /* stash_id obtained from the stash attribute details */
        u32                             stash_id;

diff --git a/drivers/iommu/iommu.c b/drivers/iommu/iommu.c
index e10cfa9..33bc0f8 100644 (file)
--- a/drivers/iommu/iommu.c
+++ b/drivers/iommu/iommu.c
@@ -2610,17 +2610,6 @@ size_t iommu_map_sg_atomic(struct iommu_domain *domain, unsigned long iova,
        return __iommu_map_sg(domain, iova, sg, nents, prot, GFP_ATOMIC);
 }
 
-int iommu_domain_window_enable(struct iommu_domain *domain, u32 wnd_nr,
-                              phys_addr_t paddr, u64 size, int prot)
-{
-       if (unlikely(domain->ops->domain_window_enable == NULL))
-               return -ENODEV;
-
-       return domain->ops->domain_window_enable(domain, wnd_nr, paddr, size,
-                                                prot);
-}
-EXPORT_SYMBOL_GPL(iommu_domain_window_enable);
-
 /**
  * report_iommu_fault() - report about an IOMMU fault to the IOMMU framework
  * @domain: the iommu domain where the fault has happened

diff --git a/drivers/soc/fsl/qbman/qman_portal.c b/drivers/soc/fsl/qbman/qman_portal.c
index 3d56ec4..9ee1663 100644 (file)
--- a/drivers/soc/fsl/qbman/qman_portal.c
+++ b/drivers/soc/fsl/qbman/qman_portal.c
@@ -65,13 +65,6 @@ static void portal_set_cpu(struct qm_portal_config *pcfg, int cpu)
                        __func__, ret);
                goto out_domain_free;
        }
-       ret = iommu_domain_window_enable(pcfg->iommu_domain, 0, 0, 1ULL << 36,
-                                        IOMMU_READ | IOMMU_WRITE);
-       if (ret < 0) {
-               dev_err(dev, "%s(): iommu_domain_window_enable() = %d",
-                       __func__, ret);
-               goto out_domain_free;
-       }
        ret = iommu_attach_device(pcfg->iommu_domain, dev);
        if (ret < 0) {
                dev_err(dev, "%s(): iommu_device_attach() = %d", __func__,

diff --git a/include/linux/iommu.h b/include/linux/iommu.h
index 761aa8b..69537e8 100644 (file)
--- a/include/linux/iommu.h
+++ b/include/linux/iommu.h
@@ -217,7 +217,6 @@ struct iommu_iotlb_gather {
  * @get_resv_regions: Request list of reserved regions for a device
  * @put_resv_regions: Free list of reserved regions for a device
  * @apply_resv_region: Temporary helper call-back for iova reserved ranges
- * @domain_window_enable: Configure and enable a particular window for a domain
  * @of_xlate: add OF master IDs to iommu grouping
  * @is_attach_deferred: Check if domain attach should be deferred from iommu
  *                      driver init to device driver init (default no)
@@ -275,10 +274,6 @@ struct iommu_ops {
                                  struct iommu_domain *domain,
                                  struct iommu_resv_region *region);
 
-       /* Window handling functions */
-       int (*domain_window_enable)(struct iommu_domain *domain, u32 wnd_nr,
-                                   phys_addr_t paddr, u64 size, int prot);
-
        int (*of_xlate)(struct device *dev, struct of_phandle_args *args);
        bool (*is_attach_deferred)(struct iommu_domain *domain, struct device *dev);
 
@@ -521,11 +516,6 @@ extern int iommu_domain_get_attr(struct iommu_domain *domain, enum iommu_attr,
 extern int iommu_domain_set_attr(struct iommu_domain *domain, enum iommu_attr,
                                 void *data);
 
-/* Window handling function prototypes */
-extern int iommu_domain_window_enable(struct iommu_domain *domain, u32 wnd_nr,
-                                     phys_addr_t offset, u64 size,
-                                     int prot);
-
 extern int report_iommu_fault(struct iommu_domain *domain, struct device *dev,
                              unsigned long iova, int flags);
 
@@ -749,13 +739,6 @@ static inline void iommu_iotlb_sync(struct iommu_domain *domain,
 {
 }
 
-static inline int iommu_domain_window_enable(struct iommu_domain *domain,
-                                            u32 wnd_nr, phys_addr_t paddr,
-                                            u64 size, int prot)
-{
-       return -ENODEV;
-}
-
 static inline phys_addr_t iommu_iova_to_phys(struct iommu_domain *domain, dma_addr_t iova)
 {
        return 0;