NVIDIA ARM SMMU Implementation
Subsystems (4)
v11 cover NVIDIA ARM SMMU Implementation
Changes in v11:
Addressed Rob comment on DT binding patch to set min/maxItems of reg property in else part. Rebased on top of https://git.kernel.org/pub/scm/linux/kernel/git/will/linux.git/log/?h=for-joerg/arm-smmu/updates.
Changes in v10:
Perform SMMU base ioremap before calling implementation init.
Check for Global faults across both ARM MMU-500s during global interrupt.
Check for context faults across all contexts of both ARM MMU-500s during context fault interrupt. Add new DT binding nvidia,smmu-500 for NVIDIA implementation.
https://lkml.org/lkml/2020/7/8/57
v9 - https://lkml.org/lkml/2020/6/30/1282
v8 - https://lkml.org/lkml/2020/6/29/2385
v7 - https://lkml.org/lkml/2020/6/28/347
v6 - https://lkml.org/lkml/2020/6/4/1018
v5 - https://lkml.org/lkml/2020/5/21/1114
v4 - https://lkml.org/lkml/2019/10/30/1054
v3 - https://lkml.org/lkml/2019/10/18/1601
v2 - https://lkml.org/lkml/2019/9/2/980
v1 - https://lkml.org/lkml/2019/8/29/1588
Krishna Reddy (5):
iommu/arm-smmu: move TLB timeout and spin count macros iommu/arm-smmu: ioremap smmu mmio region before implementation init iommu/arm-smmu: add NVIDIA implementation for ARM MMU-500 usage
dt-bindings: arm-smmu: add binding for Tegra194 SMMU iommu/arm-smmu: Add global/context fault implementation hooks
.../devicetree/bindings/iommu/arm,smmu.yaml | 25 +- MAINTAINERS | 2 + drivers/iommu/Makefile | 2 +- drivers/iommu/arm-smmu-impl.c | 3 + drivers/iommu/arm-smmu-nvidia.c | 278 ++++++++++++++++++ drivers/iommu/arm-smmu.c | 29 +- drivers/iommu/arm-smmu.h | 6 + 7 files changed, 334 insertions(+), 11 deletions(-) create mode 100644 drivers/iommu/arm-smmu-nvidia.c
base-commit: 49fbb25030265c660de732513f18275d88ff99d3
Signature · 1 line
2.26.2
PATCH v11 1/5 iommu/arm-smmu: move TLB timeout and spin count macros
Move TLB timeout and spin count macros to header file to allow using the same from vendor specific implementations.
--- drivers/iommu/arm-smmu.c | 3 --- drivers/iommu/arm-smmu.h | 2 ++ 2 files changed, 2 insertions(+), 3 deletions(-)
drivers/iommu/arm-smmu.c +0 -3
@@ -52,9 +52,6 @@*/ #define QCOM_DUMMY_VAL -1 -#define TLB_LOOP_TIMEOUT 1000000/* 1s! */ -#define TLB_SPIN_COUNT 10 -#define MSI_IOVA_BASE 0x8000000#define MSI_IOVA_LENGTH 0x100000
drivers/iommu/arm-smmu.h +2 -0
@@ -236,6 +236,8 @@ enum arm_smmu_cbar_type {/* Maximum number of context banks per SMMU */ #define ARM_SMMU_MAX_CBS 128 +#define TLB_LOOP_TIMEOUT 1000000/* 1s! */ +#define TLB_SPIN_COUNT 10/* Shared driver definitions */ enum arm_smmu_arch_version {
Signature · 1 line
2.26.2
PATCH v11 2/5 iommu/arm-smmu: ioremap smmu mmio region before implementation init
In reply to Krishna Reddyioremap smmu mmio region before calling into implementation init. This is necessary to allow mapped address available during vendor specific implementation init.
--- drivers/iommu/arm-smmu.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-)
drivers/iommu/arm-smmu.c +4 -4
@@ -2123,10 +2123,6 @@ static int arm_smmu_device_probe(struct platform_device *pdev)if (err)return err; - smmu =arm_smmu_impl_init (smmu); -if (IS_ERR (smmu)) -return PTR_ERR (smmu); - res =platform_get_resource (pdev,IORESOURCE_MEM ,0 ); ioaddr = res->start; smmu->base =devm_ioremap_resource (dev, res);
@@ -2138,6 +2134,10 @@ static int arm_smmu_device_probe(struct platform_device *pdev)*/ smmu->numpage =resource_size (res); + smmu =arm_smmu_impl_init (smmu); +if (IS_ERR (smmu)) +return PTR_ERR (smmu); + num_irqs =0 ;while ((res =platform_get_resource (pdev,IORESOURCE_IRQ , num_irqs))) { num_irqs++;
Signature · 1 line
2.26.2
PATCH v11 3/5 iommu/arm-smmu: add NVIDIA implementation for ARM MMU-500 usage
In reply to Krishna ReddyNVIDIA's Tegra194 SoC has three ARM MMU-500 instances. It uses two of the ARM MMU-500s together to interleave IOVA accesses across them and must be programmed identically. This implementation supports programming the two ARM MMU-500s that must be programmed identically.
The third ARM MMU-500 instance is supported by standard arm-smmu.c driver itself.
--- MAINTAINERS | 2 + drivers/iommu/Makefile | 2 +- drivers/iommu/arm-smmu-impl.c | 3 + drivers/iommu/arm-smmu-nvidia.c | 179 ++++++++++++++++++++++++++++++++ drivers/iommu/arm-smmu.c | 1 + drivers/iommu/arm-smmu.h | 1 + 6 files changed, 187 insertions(+), 1 deletion(-) create mode 100644 drivers/iommu/arm-smmu-nvidia.c
MAINTAINERS +2 -0
@@ -16810,8 +16810,10 @@ F: drivers/i2c/busses/i2c-tegra.c TEGRA IOMMU DRIVERS M: Thierry Reding <[email protected]> +R: Krishna Reddy <[email protected]> L: [email protected] S: Supported +F: drivers/iommu/arm-smmu-nvidia.c F: drivers/iommu/tegra* TEGRA KBC DRIVER
drivers/iommu/Makefile +1 -1
@@ -15,7 +15,7 @@ obj-$(CONFIG_AMD_IOMMU) += amd/iommu.o amd/init.o amd/quirks.o obj-$(CONFIG_AMD_IOMMU_DEBUGFS) += amd/debugfs.o obj-$(CONFIG_AMD_IOMMU_V2) += amd/iommu_v2.o obj-$(CONFIG_ARM_SMMU) += arm_smmu.o -arm_smmu-objs += arm-smmu.o arm-smmu-impl.o arm-smmu-qcom.o +arm_smmu-objs += arm-smmu.o arm-smmu-impl.o arm-smmu-nvidia.o arm-smmu-qcom.o obj-$(CONFIG_ARM_SMMU_V3) += arm-smmu-v3.o obj-$(CONFIG_DMAR_TABLE) += intel/dmar.o obj-$(CONFIG_INTEL_IOMMU) += intel/iommu.o intel/pasid.o
drivers/iommu/arm-smmu-impl.c +3 -0
@@ -213,6 +213,9 @@ struct arm_smmu_device *arm_smmu_impl_init(struct arm_smmu_device *smmu)if (of_property_read_bool (np,"calxeda,smmu-secure-config-access" )) smmu->impl = &calxeda_impl; +if (of_device_is_compatible (np,"nvidia,tegra194-smmu" )) +return nvidia_smmu_impl_init (smmu); + if (of_device_is_compatible(np, "qcom,sdm845-smmu-500") || of_device_is_compatible(np, "qcom,sc7180-smmu-500") || of_device_is_compatible(np, "qcom,sm8150-smmu-500") ||
drivers/iommu/arm-smmu-nvidia.c new file +179 -0
179 lines not on this page · raw message
drivers/iommu/arm-smmu.c +1 -0
@@ -1946,6 +1946,7 @@ static const struct of_device_id arm_smmu_of_match[] = { { .compatible = "arm,mmu-401", .data = &arm_mmu401 }, { .compatible = "arm,mmu-500", .data = &arm_mmu500 }, { .compatible = "cavium,smmu-v2", .data = &cavium_smmuv2 }, + { .compatible = "nvidia,smmu-500", .data = &arm_mmu500 }, { .compatible = "qcom,smmu-v2", .data = &qcom_smmuv2 }, { }, };
drivers/iommu/arm-smmu.h +1 -0
@@ -452,6 +452,7 @@ static inline void arm_smmu_writeq(struct arm_smmu_device *smmu, int page, arm_smmu_writeq((s), ARM_SMMU_CB((s), (n)), (o), (v))struct arm_smmu_device *arm_smmu_impl_init (struct arm_smmu_device *smmu); +struct arm_smmu_device *nvidia_smmu_impl_init (struct arm_smmu_device *smmu);struct arm_smmu_device *qcom_smmu_impl_init (struct arm_smmu_device *smmu);int arm_mmu500_reset (struct arm_smmu_device *smmu);
Signature · 1 line
2.26.2
PATCH v11 4/5 dt-bindings: arm-smmu: add binding for Tegra194 SMMU
In reply to Krishna ReddyAdd binding for NVIDIA's Tegra194 SoC SMMU.
--- .../devicetree/bindings/iommu/arm,smmu.yaml | 25 ++++++++++++++++++- 1 file changed, 24 insertions(+), 1 deletion(-)
Documentation/devicetree/bindings/iommu/arm,smmu.yaml +24 -1
@@ -44,6 +44,11 @@ properties: items: - const: marvell,ap806-smmu-500 - const: arm,mmu-500 + - description: NVIDIA SoCs that program two ARM MMU-500s identically + items: + - enum: + - nvidia,tegra194-smmu + - const: nvidia,smmu-500 - items: - const: arm,mmu-500 - const: arm,smmu-v2
@@ -61,7 +66,8 @@ properties: - cavium,smmu-v2 reg: - maxItems: 1 + minItems: 1 + maxItems: 2 '#global-interrupts': description: The number of global interrupts exposed by the device.
@@ -144,6 +150,23 @@ required: additionalProperties: false +allOf: + - if: + properties: + compatible: + contains: + enum: + - nvidia,tegra194-smmu + then: + properties: + reg: + minItems: 2 + maxItems: 2 + else: + properties: + reg: + maxItems: 1 + examples: - |+ /* SMMU with stream matching or stream indexing */
Signature · 1 line
2.26.2
PATCH v11 5/5 iommu/arm-smmu: Add global/context fault implementation hooks
In reply to Krishna ReddyAdd global/context fault hooks to allow vendor specific implementations override default fault interrupt handlers.
Update NVIDIA implementation to override the default global/context fault interrupt handlers and handle interrupts across the two ARM MMU-500s that are programmed identically.
--- drivers/iommu/arm-smmu-nvidia.c | 99 +++++++++++++++++++++++++++++++++ drivers/iommu/arm-smmu.c | 17 +++++- drivers/iommu/arm-smmu.h | 3 + 3 files changed, 117 insertions(+), 2 deletions(-)
drivers/iommu/arm-smmu-nvidia.c +99 -0
@@ -127,6 +127,103 @@ static int nvidia_smmu_reset(struct arm_smmu_device *smmu)return 0 ; } +static irqreturn_t nvidia_smmu_global_fault_inst (int irq, +struct arm_smmu_device *smmu, +int inst) +{ +u32 gfsr, gfsynr0, gfsynr1, gfsynr2; +void __iomem *gr0_base =nvidia_smmu_page (smmu, inst,0 ); + + gfsr =readl_relaxed (gr0_base + ARM_SMMU_GR0_sGFSR); +if (!gfsr) +return IRQ_NONE ; + + gfsynr0 =readl_relaxed (gr0_base + ARM_SMMU_GR0_sGFSYNR0); + gfsynr1 =readl_relaxed (gr0_base + ARM_SMMU_GR0_sGFSYNR1); + gfsynr2 =readl_relaxed (gr0_base + ARM_SMMU_GR0_sGFSYNR2); + +dev_err_ratelimited (smmu->dev, +"Unexpected global fault, this could be serious\n" ); +dev_err_ratelimited (smmu->dev, +"\tGFSR 0x%08x, GFSYNR0 0x%08x, GFSYNR1 0x%08x, GFSYNR2 0x%08x\n" , + gfsr, gfsynr0, gfsynr1, gfsynr2); + +writel_relaxed (gfsr, gr0_base + ARM_SMMU_GR0_sGFSR); +return IRQ_HANDLED ; +} + +static irqreturn_t nvidia_smmu_global_fault (int irq,void *dev) +{ +unsigned int inst; +irqreturn_t ret =IRQ_NONE ; +struct arm_smmu_device *smmu = dev; + +for (inst =0 ; inst <NUM_SMMU_INSTANCES ; inst++) { +irqreturn_t irq_ret; + + irq_ret =nvidia_smmu_global_fault_inst (irq, smmu, inst); +if (irq_ret ==IRQ_HANDLED ) + ret =IRQ_HANDLED ; + } + +return ret; +} + +static irqreturn_t nvidia_smmu_context_fault_bank (int irq, +struct arm_smmu_device *smmu, +int idx,int inst) +{ +u32 fsr, fsynr, cbfrsynra; +unsigned long iova; +void __iomem *gr1_base =nvidia_smmu_page (smmu, inst,1 ); +void __iomem *cb_base =nvidia_smmu_page (smmu, inst, smmu->numpage + idx); + + fsr =readl_relaxed (cb_base +ARM_SMMU_CB_FSR ); +if (!(fsr &ARM_SMMU_FSR_FAULT )) +return IRQ_NONE ; + + fsynr =readl_relaxed (cb_base +ARM_SMMU_CB_FSYNR0 ); + iova =readq_relaxed (cb_base +ARM_SMMU_CB_FAR ); + cbfrsynra =readl_relaxed (gr1_base +ARM_SMMU_GR1_CBFRSYNRA (idx)); + +dev_err_ratelimited (smmu->dev, +"Unhandled context fault: fsr=0x%x, iova=0x%08lx, fsynr=0x%x, cbfrsynra=0x%x, cb=%d\n" , + fsr, iova, fsynr, cbfrsynra, idx); + +writel_relaxed (fsr, cb_base +ARM_SMMU_CB_FSR ); +return IRQ_HANDLED ; +} + +static irqreturn_t nvidia_smmu_context_fault (int irq,void *dev) +{ +int idx; +unsigned int inst; +irqreturn_t ret =IRQ_NONE ; +struct arm_smmu_device *smmu; +struct iommu_domain *domain = dev; +struct arm_smmu_domain *smmu_domain; + + smmu_domain = container_of(domain, struct arm_smmu_domain, domain); + smmu = smmu_domain->smmu; + +for (inst =0 ; inst <NUM_SMMU_INSTANCES ; inst++) { +irqreturn_t irq_ret; + +/* +* Interrupt line is shared between all contexts. +* Check for faults across all contexts. +*/ +for (idx =0 ; idx < smmu->num_context_banks; idx++) { + irq_ret =nvidia_smmu_context_fault_bank (irq, smmu, + idx, inst); +if (irq_ret ==IRQ_HANDLED ) + ret =IRQ_HANDLED ; + } + } + +return ret; +} +static const struct arm_smmu_impl nvidia_smmu_impl = { .read_reg = nvidia_smmu_read_reg, .write_reg = nvidia_smmu_write_reg,
@@ -134,6 +231,8 @@ static const struct arm_smmu_impl nvidia_smmu_impl = { .write_reg64 = nvidia_smmu_write_reg64, .reset = nvidia_smmu_reset, .tlb_sync = nvidia_smmu_tlb_sync, + .global_fault = nvidia_smmu_global_fault, + .context_fault = nvidia_smmu_context_fault, };struct arm_smmu_device *nvidia_smmu_impl_init (struct arm_smmu_device *smmu)
drivers/iommu/arm-smmu.c +15 -2
@@ -670,6 +670,7 @@ static int arm_smmu_init_domain_context(struct iommu_domain *domain,enum io_pgtable_fmt fmt;struct arm_smmu_domain *smmu_domain =to_smmu_domain (domain);struct arm_smmu_cfg *cfg = &smmu_domain->cfg; +irqreturn_t (*context_fault)(int irq,void *dev);mutex_lock (&smmu_domain->init_mutex);if (smmu_domain->smmu)
@@ -832,7 +833,13 @@ static int arm_smmu_init_domain_context(struct iommu_domain *domain,* handler seeing a half-initialised domain state. */ irq = smmu->irqs[smmu->num_global_irqs + cfg->irptndx]; - ret =devm_request_irq (smmu->dev, irq, arm_smmu_context_fault, + +if (smmu->impl && smmu->impl->context_fault) + context_fault = smmu->impl->context_fault; +else + context_fault = arm_smmu_context_fault; + + ret =devm_request_irq (smmu->dev, irq, context_fault,IRQF_SHARED ,"arm-smmu-context-fault" , domain);if (ret <0 ) { dev_err(smmu->dev, "failed to request context IRQ %d (%u)\n",
@@ -2108,6 +2115,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; +irqreturn_t (*global_fault)(int irq,void *dev); smmu =devm_kzalloc (dev,sizeof (*smmu),GFP_KERNEL );if (!smmu) {
@@ -2194,9 +2202,14 @@ static int arm_smmu_device_probe(struct platform_device *pdev) smmu->num_context_irqs = smmu->num_context_banks; } +if (smmu->impl && smmu->impl->global_fault) + global_fault = smmu->impl->global_fault; +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], - arm_smmu_global_fault, + global_fault,IRQF_SHARED ,"arm-smmu global fault" , smmu);
drivers/iommu/arm-smmu.h +3 -0
@@ -18,6 +18,7 @@#include <linux/io-64-nonatomic-hi-lo.h> #include <linux/io-pgtable.h> #include <linux/iommu.h> +#include <linux/irqreturn.h> #include <linux/mutex.h> #include <linux/spinlock.h> #include <linux/types.h>
@@ -389,6 +390,8 @@ struct arm_smmu_impl {void (*tlb_sync)(struct arm_smmu_device *smmu,int page,int sync,int status);int (*def_domain_type)(struct device *dev); +irqreturn_t (*global_fault)(int irq,void *dev); +irqreturn_t (*context_fault)(int irq,void *dev); };static inline void __iomem *arm_smmu_page (struct arm_smmu_device *smmu,int n)
Signature · 1 line
2.26.2
Quoted 4 lines · Krishna Reddy
Changes in v11:
Addressed Rob comment on DT binding patch to set min/maxItems of reg property in else part. Rebased on top of https://git.kernel.org/pub/scm/linux/kernel/git/will/linux.git/log/?h=for-joerg/arm-smmu/updates.
Quoted 8 lines
Changes in v10:
Perform SMMU base ioremap before calling implementation init.
Check for Global faults across both ARM MMU-500s during global interrupt.
Check for context faults across all contexts of both ARM MMU-500s during context fault interrupt. Add new DT binding nvidia,smmu-500 for NVIDIA implementation.
https://lkml.org/lkml/2020/7/8/57[...]
Applied to will (for-joerg/arm-smmu/updates), thanks!
[1/5] iommu/arm-smmu: move TLB timeout and spin count macros
https://git.kernel.org/will/c/cd8479cf0de9 [2/5] iommu/arm-smmu: ioremap smmu mmio region before implementation init https://git.kernel.org/will/c/6c019f4e697e [3/5] iommu/arm-smmu: add NVIDIA implementation for ARM MMU-500 usage https://git.kernel.org/will/c/aab5a1c88276 [4/5] dt-bindings: arm-smmu: add binding for Tegra194 SMMU https://git.kernel.org/will/c/3d2deb0cdb69 [5/5] iommu/arm-smmu: Add global/context fault implementation hooks https://git.kernel.org/will/c/aa7ec73297df
Cheers,
Signature · 5 lines
Will https://fixes.arm64.dev https://next.arm64.dev https://will.arm64.dev