Commit 376dfd2a authored by Christoph Hellwig's avatar Christoph Hellwig Committed by Joerg Roedel
Browse files

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: default avatarChristoph Hellwig <hch@lst.de>
Acked-by: default avatarLi Yang <leoyang.li@nxp.com>
Link: https://lore.kernel.org/r/20210401155256.298656-7-hch@lst.de


Signed-off-by: default avatarJoerg Roedel <jroedel@suse.de>
parent ba58d121

drivers/iommu/fsl_pamu_domain.c

+14 −168
Original line number Diff line number Diff line
@@ -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,7 +289,7 @@ 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.
@@ -443,7 +298,6 @@ static int handle_attach_device(struct fsl_dma_domain *dma_domain, 
		if (ret)

			break;

	}

	}

	spin_unlock_irqrestore(&dma_domain->domain_lock, flags);



	return ret;
@@ -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,

drivers/iommu/fsl_pamu_domain.h

+0 −15
Original line number Diff line number Diff line
@@ -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;

drivers/iommu/iommu.c

+0 −11
Original line number Diff line number Diff line
@@ -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

drivers/soc/fsl/qbman/qman_portal.c

+0 −7
Original line number Diff line number Diff line
@@ -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__,

include/linux/iommu.h

+0 −17
Original line number Diff line number Diff line
@@ -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;