Commit e38432cb authored by Joerg Roedel's avatar Joerg Roedel
Browse files

Merge tag 'arm-smmu-updates' of... 

Merge tag 'arm-smmu-updates' of git://git.kernel.org/pub/scm/linux/kernel/git/will/linux into arm/smmu

Arm SMMU updates for 5.18

- Fix SMMUv3 soft lockup during continuous stream of events

- Fix error path for Qualcomm SMMU probe()

- Rework SMMU IRQ setup to prepare the ground for PMU support

- Minor cleanups and refactoring
parents 754e0b0e 97dfad19

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

+8 −19
Original line number Diff line number Diff line
@@ -1558,6 +1558,7 @@ static irqreturn_t arm_smmu_evtq_thread(int irq, void *dev) 
				dev_info(smmu->dev, "\t0x%016llx\n",

					 (unsigned long long)evt[i]);



			cond_resched();

		}



		/*
@@ -2911,32 +2912,20 @@ static int arm_smmu_init_one_queue(struct arm_smmu_device *smmu, 
	return 0;

}



static void arm_smmu_cmdq_free_bitmap(void *data)

{

	unsigned long *bitmap = data;

	bitmap_free(bitmap);

}



static int arm_smmu_cmdq_init(struct arm_smmu_device *smmu)

{

	int ret = 0;

	struct arm_smmu_cmdq *cmdq = &smmu->cmdq;

	unsigned int nents = 1 << cmdq->q.llq.max_n_shift;

	atomic_long_t *bitmap;



	atomic_set(&cmdq->owner_prod, 0);

	atomic_set(&cmdq->lock, 0);



	bitmap = (atomic_long_t *)bitmap_zalloc(nents, GFP_KERNEL);

	if (!bitmap) {

		dev_err(smmu->dev, "failed to allocate cmdq bitmap\n");

		ret = -ENOMEM;

	} else {

		cmdq->valid_map = bitmap;

		devm_add_action(smmu->dev, arm_smmu_cmdq_free_bitmap, bitmap);

	}

	cmdq->valid_map = (atomic_long_t *)devm_bitmap_zalloc(smmu->dev, nents,

							      GFP_KERNEL);

	if (!cmdq->valid_map)

		return -ENOMEM;



	return ret;

	return 0;

}



static int arm_smmu_init_queues(struct arm_smmu_device *smmu)
@@ -2981,10 +2970,10 @@ static int arm_smmu_init_l1_strtab(struct arm_smmu_device *smmu) 
{

	unsigned int i;

	struct arm_smmu_strtab_cfg *cfg = &smmu->strtab_cfg;

	size_t size = sizeof(*cfg->l1_desc) * cfg->num_l1_ents;

	void *strtab = smmu->strtab_cfg.strtab;



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

	cfg->l1_desc = devm_kcalloc(smmu->dev, cfg->num_l1_ents,

				    sizeof(*cfg->l1_desc), GFP_KERNEL);

	if (!cfg->l1_desc)

		return -ENOMEM;

drivers/iommu/arm/arm-smmu/arm-smmu.c

+44 −49
Original line number Diff line number Diff line
@@ -807,7 +807,7 @@ static int arm_smmu_init_domain_context(struct iommu_domain *domain, 
	 * Request context fault interrupt. Do this last to avoid the

	 * handler seeing a half-initialised domain state.

	 */

	irq = smmu->irqs[smmu->num_global_irqs + cfg->irptndx];

	irq = smmu->irqs[cfg->irptndx];



	if (smmu->impl && smmu->impl->context_fault)

		context_fault = smmu->impl->context_fault;
@@ -858,7 +858,7 @@ static void arm_smmu_destroy_domain_context(struct iommu_domain *domain) 
	arm_smmu_write_context_bank(smmu, cfg->cbndx);



	if (cfg->irptndx != ARM_SMMU_INVALID_IRPTNDX) {

		irq = smmu->irqs[smmu->num_global_irqs + cfg->irptndx];

		irq = smmu->irqs[cfg->irptndx];

		devm_free_irq(smmu->dev, irq, domain);

	}
@@ -1951,8 +1951,8 @@ static int acpi_smmu_get_data(u32 model, struct arm_smmu_device *smmu) 
	return ret;

}



static int arm_smmu_device_acpi_probe(struct platform_device *pdev,

				      struct arm_smmu_device *smmu)

static int arm_smmu_device_acpi_probe(struct arm_smmu_device *smmu,

				      u32 *global_irqs, u32 *pmu_irqs)

{

	struct device *dev = smmu->dev;

	struct acpi_iort_node *node =
@@ -1968,7 +1968,8 @@ static int arm_smmu_device_acpi_probe(struct platform_device *pdev, 
		return ret;



	/* Ignore the configuration access interrupt */

	smmu->num_global_irqs = 1;

	*global_irqs = 1;

	*pmu_irqs = 0;



	if (iort_smmu->flags & ACPI_IORT_SMMU_COHERENT_WALK)

		smmu->features |= ARM_SMMU_FEAT_COHERENT_WALK;
@@ -1976,25 +1977,24 @@ static int arm_smmu_device_acpi_probe(struct platform_device *pdev, 
	return 0;

}

#else

static inline int arm_smmu_device_acpi_probe(struct platform_device *pdev,

					     struct arm_smmu_device *smmu)

static inline int arm_smmu_device_acpi_probe(struct arm_smmu_device *smmu,

					     u32 *global_irqs, u32 *pmu_irqs)

{

	return -ENODEV;

}

#endif



static int arm_smmu_device_dt_probe(struct platform_device *pdev,

				    struct arm_smmu_device *smmu)

static int arm_smmu_device_dt_probe(struct arm_smmu_device *smmu,

				    u32 *global_irqs, u32 *pmu_irqs)

{

	const struct arm_smmu_match_data *data;

	struct device *dev = &pdev->dev;

	struct device *dev = smmu->dev;

	bool legacy_binding;



	if (of_property_read_u32(dev->of_node, "#global-interrupts",

				 &smmu->num_global_irqs)) {

		dev_err(dev, "missing #global-interrupts property\n");

		return -ENODEV;

	}

	if (of_property_read_u32(dev->of_node, "#global-interrupts", global_irqs))

		return dev_err_probe(dev, -ENODEV,

				     "missing #global-interrupts property\n");

	*pmu_irqs = 0;



	data = of_device_get_match_data(dev);

	smmu->version = data->version;
@@ -2073,6 +2073,7 @@ static int arm_smmu_device_probe(struct platform_device *pdev) 
	struct arm_smmu_device *smmu;

	struct device *dev = &pdev->dev;

	int num_irqs, i, err;

	u32 global_irqs, pmu_irqs;

	irqreturn_t (*global_fault)(int irq, void *dev);



	smmu = devm_kzalloc(dev, sizeof(*smmu), GFP_KERNEL);
@@ -2083,10 +2084,9 @@ static int arm_smmu_device_probe(struct platform_device *pdev) 
	smmu->dev = dev;



	if (dev->of_node)

		err = arm_smmu_device_dt_probe(pdev, smmu);

		err = arm_smmu_device_dt_probe(smmu, &global_irqs, &pmu_irqs);

	else

		err = arm_smmu_device_acpi_probe(pdev, smmu);



		err = arm_smmu_device_acpi_probe(smmu, &global_irqs, &pmu_irqs);

	if (err)

		return err;
@@ -2105,31 +2105,25 @@ static int arm_smmu_device_probe(struct platform_device *pdev) 
	if (IS_ERR(smmu))

		return PTR_ERR(smmu);



	num_irqs = 0;

	while ((res = platform_get_resource(pdev, IORESOURCE_IRQ, num_irqs))) {

		num_irqs++;

		if (num_irqs > smmu->num_global_irqs)

			smmu->num_context_irqs++;

	}

	num_irqs = platform_irq_count(pdev);



	if (!smmu->num_context_irqs) {

		dev_err(dev, "found %d interrupts but expected at least %d\n",

			num_irqs, smmu->num_global_irqs + 1);

		return -ENODEV;

	}

	smmu->num_context_irqs = num_irqs - global_irqs - pmu_irqs;

	if (smmu->num_context_irqs <= 0)

		return dev_err_probe(dev, -ENODEV,

				"found %d interrupts but expected at least %d\n",

				num_irqs, global_irqs + pmu_irqs + 1);



	smmu->irqs = devm_kcalloc(dev, num_irqs, sizeof(*smmu->irqs),

				  GFP_KERNEL);

	if (!smmu->irqs) {

		dev_err(dev, "failed to allocate %d irqs\n", num_irqs);

		return -ENOMEM;

	}

	smmu->irqs = devm_kcalloc(dev, smmu->num_context_irqs,

				  sizeof(*smmu->irqs), GFP_KERNEL);

	if (!smmu->irqs)

		return dev_err_probe(dev, -ENOMEM, "failed to allocate %d irqs\n",

				     smmu->num_context_irqs);



	for (i = 0; i < num_irqs; ++i) {

		int irq = platform_get_irq(pdev, i);

	for (i = 0; i < smmu->num_context_irqs; i++) {

		int irq = platform_get_irq(pdev, global_irqs + pmu_irqs + i);



		if (irq < 0)

			return -ENODEV;

			return irq;

		smmu->irqs[i] = irq;

	}
@@ -2165,17 +2159,18 @@ static int arm_smmu_device_probe(struct platform_device *pdev) 
	else

		global_fault = arm_smmu_global_fault;



	for (i = 0; i < smmu->num_global_irqs; ++i) {

		err = devm_request_irq(smmu->dev, smmu->irqs[i],

				       global_fault,

				       IRQF_SHARED,

				       "arm-smmu global fault",

				       smmu);

		if (err) {

			dev_err(dev, "failed to request global IRQ %d (%u)\n",

				i, smmu->irqs[i]);

			return err;

		}

	for (i = 0; i < global_irqs; i++) {

		int irq = platform_get_irq(pdev, i);



		if (irq < 0)

			return irq;



		err = devm_request_irq(dev, irq, global_fault, IRQF_SHARED,

				       "arm-smmu global fault", smmu);

		if (err)

			return dev_err_probe(dev, err,

					"failed to request global IRQ %d (%u)\n",

					i, irq);

	}



	err = iommu_device_sysfs_add(&smmu->iommu, smmu->dev, NULL,

drivers/iommu/arm/arm-smmu/arm-smmu.h

+2 −3
Original line number Diff line number Diff line
@@ -318,11 +318,10 @@ struct arm_smmu_device { 
	unsigned long			pa_size;

	unsigned long			pgsize_bitmap;



	u32				num_global_irqs;

	u32				num_context_irqs;

	int				num_context_irqs;

	int				num_clks;

	unsigned int			*irqs;

	struct clk_bulk_data		*clks;

	int				num_clks;



	spinlock_t			global_sync_lock;

drivers/iommu/arm/arm-smmu/qcom_iommu.c

+7 −3
Original line number Diff line number Diff line
@@ -827,20 +827,20 @@ static int qcom_iommu_device_probe(struct platform_device *pdev) 
	ret = devm_of_platform_populate(dev);

	if (ret) {

		dev_err(dev, "Failed to populate iommu contexts\n");

		return ret;

		goto err_pm_disable;

	}



	ret = iommu_device_sysfs_add(&qcom_iommu->iommu, dev, NULL,

				     dev_name(dev));

	if (ret) {

		dev_err(dev, "Failed to register iommu in sysfs\n");

		return ret;

		goto err_pm_disable;

	}



	ret = iommu_device_register(&qcom_iommu->iommu, &qcom_iommu_ops, dev);

	if (ret) {

		dev_err(dev, "Failed to register iommu\n");

		return ret;

		goto err_pm_disable;

	}



	bus_set_iommu(&platform_bus_type, &qcom_iommu_ops);
@@ -852,6 +852,10 @@ static int qcom_iommu_device_probe(struct platform_device *pdev) 
	}



	return 0;



err_pm_disable:

	pm_runtime_disable(dev);

	return ret;

}



static int qcom_iommu_device_remove(struct platform_device *pdev)

drivers/perf/arm_smmuv3_pmu.c

+3 −1
Original line number Diff line number Diff line
@@ -654,6 +654,7 @@ static int smmu_pmu_offline_cpu(unsigned int cpu, struct hlist_node *node) 
static irqreturn_t smmu_pmu_handle_irq(int irq_num, void *data)

{

	struct smmu_pmu *smmu_pmu = data;

	DECLARE_BITMAP(ovs, BITS_PER_TYPE(u64));

	u64 ovsr;

	unsigned int idx;
@@ -663,7 +664,8 @@ static irqreturn_t smmu_pmu_handle_irq(int irq_num, void *data) 


	writeq(ovsr, smmu_pmu->reloc_base + SMMU_PMCG_OVSCLR0);



	for_each_set_bit(idx, (unsigned long *)&ovsr, smmu_pmu->num_counters) {

	bitmap_from_u64(ovs, ovsr);

	for_each_set_bit(idx, ovs, smmu_pmu->num_counters) {

		struct perf_event *event = smmu_pmu->events[idx];

		struct hw_perf_event *hwc;