Commit fc2c8d0a authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'iommu-fixes-v5.12-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/joro/iommu 

Pull iommu fixes from Joerg Roedel:

 - Fix a sleeping-while-atomic issue in the AMD IOMMU code

 - Disable lazy IOTLB flush for untrusted devices in the Intel VT-d
   driver

 - Fix status code definitions for Intel VT-d

 - Fix IO Page Fault issue in Tegra IOMMU driver

* tag 'iommu-fixes-v5.12-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/joro/iommu:
  iommu/vt-d: Fix status code for Allocate/Free PASID command
  iommu: Don't use lazy flush for untrusted device
  iommu/tegra-smmu: Fix mc errors on tegra124-nyan
  iommu/amd: Fix sleeping in atomic in increase_address_space()
parents f09b04cc 444d66a2

drivers/iommu/amd/io_pgtable.c

+6 −4
Original line number Diff line number Diff line
@@ -182,6 +182,10 @@ static bool increase_address_space(struct protection_domain *domain, 
	bool ret = true;

	u64 *pte;



	pte = (void *)get_zeroed_page(gfp);

	if (!pte)

		return false;



	spin_lock_irqsave(&domain->lock, flags);



	if (address <= PM_LEVEL_SIZE(domain->iop.mode))
@@ -191,10 +195,6 @@ static bool increase_address_space(struct protection_domain *domain, 
	if (WARN_ON_ONCE(domain->iop.mode == PAGE_MODE_6_LEVEL))

		goto out;



	pte = (void *)get_zeroed_page(gfp);

	if (!pte)

		goto out;



	*pte = PM_LEVEL_PDE(domain->iop.mode, iommu_virt_to_phys(domain->iop.root));



	domain->iop.root  = pte;
@@ -208,10 +208,12 @@ static bool increase_address_space(struct protection_domain *domain, 
	 */

	amd_iommu_domain_set_pgtable(domain, pte, domain->iop.mode);



	pte = NULL;

	ret = true;



out:

	spin_unlock_irqrestore(&domain->lock, flags);

	free_page((unsigned long)pte);



	return ret;

}

drivers/iommu/dma-iommu.c

+8 −7
Original line number Diff line number Diff line
@@ -311,6 +311,11 @@ static void iommu_dma_flush_iotlb_all(struct iova_domain *iovad) 
	domain->ops->flush_iotlb_all(domain);

}



static bool dev_is_untrusted(struct device *dev)

{

	return dev_is_pci(dev) && to_pci_dev(dev)->untrusted;

}



/**

 * iommu_dma_init_domain - Initialise a DMA mapping domain

 * @domain: IOMMU domain previously prepared by iommu_get_dma_cookie()
@@ -365,8 +370,9 @@ static int iommu_dma_init_domain(struct iommu_domain *domain, dma_addr_t base, 


	init_iova_domain(iovad, 1UL << order, base_pfn);



	if (!cookie->fq_domain && !iommu_domain_get_attr(domain,

			DOMAIN_ATTR_DMA_USE_FLUSH_QUEUE, &attr) && attr) {

	if (!cookie->fq_domain && (!dev || !dev_is_untrusted(dev)) &&

	    !iommu_domain_get_attr(domain, DOMAIN_ATTR_DMA_USE_FLUSH_QUEUE, &attr) &&

	    attr) {

		if (init_iova_flush_queue(iovad, iommu_dma_flush_iotlb_all,

					  iommu_dma_entry_dtor))

			pr_warn("iova flush queue initialization failed\n");
@@ -508,11 +514,6 @@ static void __iommu_dma_unmap_swiotlb(struct device *dev, dma_addr_t dma_addr, 
				iova_align(iovad, size), dir, attrs);

}



static bool dev_is_untrusted(struct device *dev)

{

	return dev_is_pci(dev) && to_pci_dev(dev)->untrusted;

}



static dma_addr_t __iommu_dma_map(struct device *dev, phys_addr_t phys,

		size_t size, int prot, u64 dma_mask)

{

drivers/iommu/intel/pasid.h

+2 −2
Original line number Diff line number Diff line
@@ -30,8 +30,8 @@ 
#define VCMD_VRSP_IP			0x1

#define VCMD_VRSP_SC(e)			(((e) >> 1) & 0x3)

#define VCMD_VRSP_SC_SUCCESS		0

#define VCMD_VRSP_SC_NO_PASID_AVAIL	1

#define VCMD_VRSP_SC_INVALID_PASID	1

#define VCMD_VRSP_SC_NO_PASID_AVAIL	2

#define VCMD_VRSP_SC_INVALID_PASID	2

#define VCMD_VRSP_RESULT_PASID(e)	(((e) >> 8) & 0xfffff)

#define VCMD_CMD_OPERAND(e)		((e) << 8)

/*

drivers/iommu/tegra-smmu.c

+71 −1
Original line number Diff line number Diff line
@@ -798,10 +798,70 @@ static phys_addr_t tegra_smmu_iova_to_phys(struct iommu_domain *domain, 
	return SMMU_PFN_PHYS(pfn) + SMMU_OFFSET_IN_PAGE(iova);

}



static struct tegra_smmu *tegra_smmu_find(struct device_node *np)

{

	struct platform_device *pdev;

	struct tegra_mc *mc;



	pdev = of_find_device_by_node(np);

	if (!pdev)

		return NULL;



	mc = platform_get_drvdata(pdev);

	if (!mc)

		return NULL;



	return mc->smmu;

}



static int tegra_smmu_configure(struct tegra_smmu *smmu, struct device *dev,

				struct of_phandle_args *args)

{

	const struct iommu_ops *ops = smmu->iommu.ops;

	int err;



	err = iommu_fwspec_init(dev, &dev->of_node->fwnode, ops);

	if (err < 0) {

		dev_err(dev, "failed to initialize fwspec: %d\n", err);

		return err;

	}



	err = ops->of_xlate(dev, args);

	if (err < 0) {

		dev_err(dev, "failed to parse SW group ID: %d\n", err);

		iommu_fwspec_free(dev);

		return err;

	}



	return 0;

}



static struct iommu_device *tegra_smmu_probe_device(struct device *dev)

{

	struct tegra_smmu *smmu = dev_iommu_priv_get(dev);

	struct device_node *np = dev->of_node;

	struct tegra_smmu *smmu = NULL;

	struct of_phandle_args args;

	unsigned int index = 0;

	int err;



	while (of_parse_phandle_with_args(np, "iommus", "#iommu-cells", index,

					  &args) == 0) {

		smmu = tegra_smmu_find(args.np);

		if (smmu) {

			err = tegra_smmu_configure(smmu, dev, &args);

			of_node_put(args.np);



			if (err < 0)

				return ERR_PTR(err);



			break;

		}



		of_node_put(args.np);

		index++;

	}



	smmu = dev_iommu_priv_get(dev);

	if (!smmu)

		return ERR_PTR(-ENODEV);
@@ -1028,6 +1088,16 @@ struct tegra_smmu *tegra_smmu_probe(struct device *dev, 
	if (!smmu)

		return ERR_PTR(-ENOMEM);



	/*

	 * This is a bit of a hack. Ideally we'd want to simply return this

	 * value. However the IOMMU registration process will attempt to add

	 * all devices to the IOMMU when bus_set_iommu() is called. In order

	 * not to rely on global variables to track the IOMMU instance, we

	 * set it here so that it can be looked up from the .probe_device()

	 * callback via the IOMMU device's .drvdata field.

	 */

	mc->smmu = smmu;



	size = BITS_TO_LONGS(soc->num_asids) * sizeof(long);



	smmu->asids = devm_kzalloc(dev, size, GFP_KERNEL);