iommu/arm-smmu-v3: Tegra264 invalidation workaround
Subsystems (5)
v7 cover iommu/arm-smmu-v3: Tegra264 invalidation workaround
Nvidia Tegra264 SMMUs are affected by an erratum where a TLB entry can survive an invalidation that races with concurrent traffic targeting the same entry. The hardware-recommended software workaround is to issue every CFGI/TLBI command (each followed by CMD_SYNC) twice. The second issue must execute only after the first issue's CMD_SYNC has completed, giving the sequence:
TLBI/CFGI ... CMD_SYNC TLBI/CFGI ... CMD_SYNC
ATC_INV is not affected and must not be doubled.
The erratum is not flagged by any SMMUv3 IDR/IIDR register, so it cannot be detected from hardware ID. Tegra264 is device-tree-only (no ACPI/IORT support), so detection is purely by compatible string.
This series is structured as a small refactor + infrastructure + enable sequence so that each step is reviewable in isolation:
1/3 Pure refactor (no functional change): lift the existing
force-sync conditions out of arm_smmu_cmdq_batch_add_cmd_p() into a new arm_smmu_cmdq_batch_force_sync() helper, so that adding another condition (in patch 2) is a one-line addition. Authored by Nicolin Chen.
2/3 Add the workaround infrastructure without enabling it. Defines
the file-local arm_smmu_erratum_repeat_tlbi_cfgi_key static key with an inline erratum description, the shared arm_smmu_erratum_cmd_needs_repeating() predicate, the arm_smmu_cmdq_issue_cmdlist() wrapper that can re-issue matching cmdlists, the batch-helper force-sync condition, and the iommufd batching split for mixed command classes.
3/3 Enable the workaround for the existing "nvidia,tegra264-smmu"
compatible and document the erratum in silicon-errata.rst.
The series applies cleanly on linux-next/master (base-commit below).
Changes since v6:
- Add #include <linux/jump_label.h> now that the static key is defined in arm-smmu-v3.c.
- Drop the unused smmu parameter from arm_vsmmu_can_batch_cmd().
- Expand the arm_smmu_cmdq_batch_force_sync() comment to note that batches never mix CFGI/TLBI with other commands, so checking cmds[0] alone is enough.
- Note in 3/3 that a guest kernel enabling CMDQV on Tegra264 must also apply this workaround, since guest-level VCMDQs issue commands directly to the hardware.
- Carry Reviewed-by: Nicolin Chen on 2/3 and 3/3.
Changes since v5:
- Move arm_smmu_erratum_cmd_needs_repeating() into arm-smmu-v3.c and leave a declaration-only stub in arm-smmu-v3.h. Make arm_smmu_erratum_repeat_tlbi_cfgi_key file-local static.
- Add an inline erratum/workaround description at the static key, referenced from arm_smmu_cmdq_batch_force_sync().
- Fix (rather than drop) the misleading !n comment above arm_smmu_cmdq_issue_cmdlist(); keep the defensive !n guard.
- Remove the unused smmu parameter from the predicate.
- Tweak 2/3 commit-message wording ("commit" vs "patch").
Changes since v4:
- Drop ARM_SMMU_OPT_REPEAT_TLBI_CFGI entirely: the option bit was set and read on the exact same "nvidia,tegra264-smmu" compatible as the static key, so it added no per-instance signal that the static key did not already carry. The predicate now gates purely on arm_smmu_erratum_repeat_tlbi_cfgi_key.
- Reorder the series so the compatible-string detection lands last, once all the infrastructure exists:
1/3 factor out force_sync helper (unchanged)
2/3 add static key + WAR functions (no functional change)
3/3 enable the key on nvidia,tegra264-smmu + silicon-errata Split the old v4 "Detect" and "Issue twice" patches accordingly.
- Update the /* See ARM_SMMU_OPT_REPEAT_TLBI_CFGI */ comment inside arm_smmu_cmdq_batch_force_sync() to reference the static key description instead.
Changes since v3:
- Drop the cmds->num == 0 early-return so the refactor is truly "no functional change".
- Rename ARM_SMMU_OPT_TLBI_TWICE -> ARM_SMMU_OPT_REPEAT_TLBI_CFGI and rephrase its kdoc to be hardware-agnostic.
- Rename arm_smmu_cmd_needs_tlbi_twice() -> arm_smmu_erratum_cmd_needs_repeating() and drop the kdoc above it.
- Replace the explicit opcode switch with a single range check opcode >= CMDQ_OP_CFGI_STE && opcode < CMDQ_OP_ATC_INV.
- Introduce arm_smmu_erratum_repeat_tlbi_cfgi_key static key:
the predicate gates on it first so unaffected kernels pay only a single static_branch_unlikely() check.
- Drop the verbose Tegra264-specific comments above arm_vsmmu_can_batch_cmd() and inside the batch helper.
- Document the erratum in Documentation/arch/arm64/silicon-errata.rst.
- Guard the repeat path in arm_smmu_cmdq_issue_cmdlist() with an n > 0 check so cmds[0] is never inspected on an empty cmdlist.
- Drop the carried Reviewed-by tags now that the patch shape has changed; re-review appreciated.
Changes since v2:
- Split into a 3-patch series (refactor / detect / apply) to keep each step small and bisectable.
- Move the classifier to arm-smmu-v3.h as static inline so the iommufd file can share it.
- Add arm_vsmmu_can_batch_cmd() to split iommufd batches at "needs repeating" transitions so the per-batch decision based on the first command stays correct under mixed user input.
- Spell out in the commit message why detection is via DT and not via IIDR/ACPI.
Changes since v1:
- Detect the erratum from the existing "nvidia,tegra264-smmu" compatible instead of adding a new property.
- Centralise the doubling at the CMDQ submission layer and only apply it to CFGI/TLBI (not ATC_INV).
- Drop the binding/dtsi patches accordingly.
Ashish Mhetre (2):
iommu/arm-smmu-v3: Introduce CFGI/TLBI-repeat workaround
infrastructure
iommu/arm-smmu-v3: Enable CFGI/TLBI-repeat workaround on Tegra264
Nicolin Chen (1):
iommu/arm-smmu-v3: Factor out CMDQ batch force-sync conditions
Documentation/arch/arm64/silicon-errata.rst | 2 + .../arm/arm-smmu-v3/arm-smmu-v3-iommufd.c | 14 +++- drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c | 84 ++++++++++++++++--- drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.h | 1 + 4 files changed, 89 insertions(+), 12 deletions(-)
base-commit: bee763d5f341b99cf472afeb508d4988f62a6ca1
Signature · 1 line
2.50.1
PATCH v7 1/3 iommu/arm-smmu-v3: Factor out CMDQ batch force-sync conditions
From: Nicolin Chen <[email protected]>
arm_smmu_cmdq_batch_add_cmd_p() carries two distinct reasons for flushing the current batch with a CMD_SYNC before appending the new command:
- The batch's pre-assigned cmdq does not support the new command.
- The Arm erratum 2812531 workaround (ARM_SMMU_OPT_CMDQ_FORCE_SYNC) forces a SYNC at one entry before the batch is full.
Lift those checks into a new arm_smmu_cmdq_batch_force_sync() helper so that adding another force-sync condition becomes a one-line addition. No functional change.
--- drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c | 23 +++++++++++++++------ 1 file changed, 17 insertions(+), 6 deletions(-)
drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c +17 -6
@@ -847,16 +847,27 @@ static void arm_smmu_cmdq_batch_init_cmd(struct arm_smmu_device *smmu, cmds->cmdq =arm_smmu_get_cmdq (smmu, cmd); } +static bool arm_smmu_cmdq_batch_force_sync (struct arm_smmu_device *smmu, +struct arm_smmu_cmdq_batch *cmds, +struct arm_smmu_cmd *cmd) +{ +/* The batch's pre-assigned cmdq doesn't support the new command */ +if (!arm_smmu_cmdq_supports_cmd (cmds->cmdq, cmd)) +return true; + +/* Arm erratum 2812531 */ +if (cmds->num ==CMDQ_BATCH_ENTRIES -1 && + (smmu->options &ARM_SMMU_OPT_CMDQ_FORCE_SYNC )) +return true; + +return false; +} +static void arm_smmu_cmdq_batch_add_cmd_p (struct arm_smmu_device *smmu,struct arm_smmu_cmdq_batch *cmds,struct arm_smmu_cmd *cmd) { -bool force_sync = (cmds->num ==CMDQ_BATCH_ENTRIES -1 ) && - (smmu->options &ARM_SMMU_OPT_CMDQ_FORCE_SYNC ); -bool unsupported_cmd; - - unsupported_cmd = !arm_smmu_cmdq_supports_cmd (cmds->cmdq, cmd); -if (force_sync || unsupported_cmd) { +if (arm_smmu_cmdq_batch_force_sync (smmu, cmds, cmd)) {arm_smmu_cmdq_issue_cmdlist (smmu, cmds->cmdq, cmds->cmds, cmds->num, true);arm_smmu_cmdq_batch_init_cmd (smmu, cmds, cmd);
Signature · 1 line
2.50.1
Re: [PATCH v7 1/3] iommu/arm-smmu-v3: Factor out CMDQ batch force-sync conditions
Quoted 14 lines · Ashish Mhetre
From: Nicolin Chen <[email protected]>
arm_smmu_cmdq_batch_add_cmd_p()carries two distinct reasons for flushing the current batch with aCMD_SYNCbefore appending the new command:- The batch's pre-assigned cmdq does not support the new command.
- The Arm erratum 2812531 workaround (ARM_SMMU_OPT_CMDQ_FORCE_SYNC) forces a SYNC at one entry before the batch is full.Lift those checks into a new
arm_smmu_cmdq_batch_force_sync()helper so that adding another force-sync condition becomes a one-line addition. No functional change.
Quoted 5 lines
Signed-off-by Nicolin Chen <[email protected]>Signed-off-by Ashish Mhetre <[email protected]>--- drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c | 23 +++++++++++++++------ 1 file changed, 17 insertions(+), 6 deletions(-)
Jason
PATCH v7 2/3 iommu/arm-smmu-v3: Introduce CFGI/TLBI-repeat workaround infrastructure
In reply to Ashish MhetreTegra264 SMMU instances need every CFGI/TLBI command sequence issued twice, with the second issue executing only after the first issue's CMD_SYNC has completed:
TLBI/CFGI ... CMD_SYNC TLBI/CFGI ... CMD_SYNC
ATC_INV is not affected and must never be doubled.
Add arm_smmu_erratum_repeat_tlbi_cfgi_key and an arm_smmu_erratum_cmd_needs_repeating() helper that gates on the static key first and then range-checks the opcode (CFGI_STE .. ATC_INV), so subsequent changes wiring the workaround into the CMDQ submission and iommufd batching paths can share a single predicate.
Rename the existing arm_smmu_cmdq_issue_cmdlist() to __arm_smmu_cmdq_issue_cmdlist() and add a thin wrapper that re-issues the same cmdlist a second time when the predicate fires. Register the new condition with arm_smmu_cmdq_batch_force_sync() and add arm_vsmmu_can_batch_cmd() so iommufd batches split at every "needs repeating" transition.
No callers enable the static key yet, so there is no functional change. A subsequent change will enable the key on affected instances.
--- .../arm/arm-smmu-v3/arm-smmu-v3-iommufd.c | 14 ++++- drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c | 57 +++++++++++++++++-- drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.h | 1 + 3 files changed, 67 insertions(+), 5 deletions(-)
drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3-iommufd.c +13 -1
@@ -350,6 +350,17 @@ static int arm_vsmmu_convert_user_cmd(struct arm_vsmmu *vsmmu,return 0 ; } +static bool arm_vsmmu_can_batch_cmd (struct arm_vsmmu_invalidation_cmd *last, +struct arm_vsmmu_invalidation_cmd *next) +{ +struct arm_smmu_cmd next_cmd = { + .data[0 ] =le64_to_cpu (next->ucmd.cmd[0 ]), + }; + +return arm_smmu_erratum_cmd_needs_repeating (&last->cmd) == +arm_smmu_erratum_cmd_needs_repeating (&next_cmd); +} +int arm_vsmmu_cache_invalidate (struct iommufd_viommu *viommu,struct iommu_user_data_array *array) {
@@ -382,7 +393,8 @@ int arm_vsmmu_cache_invalidate(struct iommufd_viommu *viommu,/* FIXME work in blocks of CMDQ_BATCH_ENTRIES and copy each block? */ cur++; -if (cur != end && (cur - last) !=CMDQ_BATCH_ENTRIES -1 ) +if (cur != end && (cur - last) !=CMDQ_BATCH_ENTRIES -1 && +arm_vsmmu_can_batch_cmd (last, cur))continue ;/* FIXME always uses the main cmdq rather than trying to group by type */
drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c +53 -4
87 lines not on this page · raw message
drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.h +1 -0
@@ -1211,6 +1211,7 @@ int arm_smmu_cmdq_issue_cmdlist(struct arm_smmu_device *smmu,struct arm_smmu_cmdq *cmdq, struct arm_smmu_cmd *cmds, int n, bool sync); +bool arm_smmu_erratum_cmd_needs_repeating (struct arm_smmu_cmd *cmd);#ifdef CONFIG_ARM_SMMU_V3_SVA bool arm_smmu_sva_supported (struct arm_smmu_device *smmu);
Signature · 1 line
2.50.1
Re: [PATCH v7 2/3] iommu/arm-smmu-v3: Introduce CFGI/TLBI-repeat workaround infrastructure
Quoted 24 lines · Ashish Mhetre
Tegra264 SMMU instances need every CFGI/TLBI command sequence issued twice, with the second issue executing only after the first issue's
CMD_SYNChas completed:TLBI/CFGI ...
CMD_SYNCTLBI/CFGI ...CMD_SYNC
ATC_INVis not affected and must never be doubled.Add
arm_smmu_erratum_repeat_tlbi_cfgi_keyand anarm_smmu_erratum_cmd_needs_repeating()helper that gates on the static key first and then range-checks the opcode (CFGI_STE..ATC_INV), so subsequent changes wiring the workaround into the CMDQ submission and iommufd batching paths can share a single predicate.Rename the existing
arm_smmu_cmdq_issue_cmdlist()to__arm_smmu_cmdq_issue_cmdlist()and add a thin wrapper that re-issues the same cmdlist a second time when the predicate fires. Register the new condition witharm_smmu_cmdq_batch_force_sync()and addarm_vsmmu_can_batch_cmd()so iommufd batches split at every "needs repeating" transition.No callers enable the static key yet, so there is no functional change. A subsequent change will enable the key on affected instances.
Quoted 8 lines
Suggested-by Nicolin Chen <[email protected]>Reviewed-by Nicolin Chen <[email protected]>Signed-off-by Ashish Mhetre <[email protected]>--- .../arm/arm-smmu-v3/arm-smmu-v3-iommufd.c | 14 ++++- drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c | 57 +++++++++++++++++-- drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.h | 1 + 3 files changed, 67 insertions(+), 5 deletions(-)
Because the VM has access to VCMDQ/etc it can issue commands directly (maybe not on this chip, but as a general comment), thus invalidation errata need to be made visible to the VM and we need to expect the VM will generate invalidations to properly deal with any errata.
Ie I'd expect the VM to see a "nvidia,tegra264-smmu" compatible string to activate the errata fix.
If so then we will already get duplicated invalidations here and then we will duplicate them again. That's not great.
On the other hand if you want to emulate a generic and actually functional SMMU device that has nothing like VCMDQ/etc then you must do something like this in this patch.
I was imagining a general direction that we would expose the errata information to the guest and the guest would have to deal with it.
Given this is the opposite I wonder if we want to do it. It does make sense for a chip that probably doesn't have vCMDQ and I don't think qemu can even create a DT description to trigger the errata anyhow.
But it starts to become confusing down the road if we decide other invalidation errata (like the CONT must be RIL thing) must be delt with by the guest.
So.. Maybe add a comment why this one is different, or maybe just disable FEAT_NESTING if there isn't a use case?
Otherwise the rest is fine
Jason
Re: [PATCH v7 2/3] iommu/arm-smmu-v3: Introduce CFGI/TLBI-repeat workaround infrastructure
Quoted 11 lines · Jason Gunthorpe
On Tue, Jul 14, 2026 at 10:42:01AM +0000, Ashish Mhetre wrote:
Because the VM has access to VCMDQ/etc it can issue commands directly (maybe not on this chip, but as a general comment), thus invalidation errata need to be made visible to the VM and we need to expect the VM will generate invalidations to properly deal with any errata.Ie I'd expect the VM to see a "nvidia,tegra264-smmu" compatible string to activate the errata fix.
If so then we will already get duplicated invalidations here and then we will duplicate them again. That's not great.
Oh, that's a good point.
Quoted 3 lines
On the other hand if you want to emulate a generic and actually functional SMMU device that has nothing like VCMDQ/etc then you must do something like this in this patch.
Tegra264 has virtualization use case. And It's built with VCMDQ, which should be the default case than the generic vSMMU case.
Quoted 6 lines
I was imagining a general direction that we would expose the errata information to the guest and the guest would have to deal with it.
Given this is the opposite I wonder if we want to do it. It does make sense for a chip that probably doesn't have vCMDQ and I don't think qemu can even create a DT description to trigger the errata anyhow.
I don't have the source code of the VMM used on Tegra264, but I believe the guest kernel can be the same copy of kernel as the host. So, its VMM is likely to use the "nvidia,tegra264-smmu" DT compatible string, to trigger the errata at the guest level.
Quoted 6 lines
But it starts to become confusing down the road if we decide other invalidation errata (like the CONT must be RIL thing) must be delt with by the guest.
So.. Maybe add a comment why this one is different, or maybe just disable
FEAT_NESTINGif there isn't a use case?
Given the use cases on Tegra264, instead of patching the iommufd path as this patch does, perhaps we should simply spit a WARN in arm_vsmmu_init():
if (static_branch_unlikely(&arm_smmu_erratum_repeat_tlbi_cfgi_key)) dev_warn(smmu->dev, "guest must WAR the repeat_tlbi_cfgi erratum\n");
?
Thanks
Nicolin
Re: [PATCH v7 2/3] iommu/arm-smmu-v3: Introduce CFGI/TLBI-repeat workaround infrastructure
Quoted 3 lines · Nicolin Chen
Given the use cases on Tegra264, instead of patching the iommufd path as this patch does, perhaps we should simply spit a WARN in
arm_vsmmu_init():
Nope, in this case you need to make the errata discoverable through the viommu info so the VMM can validate the right DT is used, or apply the WAR itself before submitting commands to the kernel.
Some kind of new flag in the viommu struct I guess
Jason
Re: [PATCH v7 2/3] iommu/arm-smmu-v3: Introduce CFGI/TLBI-repeat workaround infrastructure
Quoted 8 lines · Jason Gunthorpe
Quoted 3 lines · Nicolin Chen
Given the use cases on Tegra264, instead of patching the iommufd path as this patch does, perhaps we should simply spit a WARN in
arm_vsmmu_init():Nope, in this case you need to make the errata discoverable through the viommu info so the VMM can validate the right DT is used, or apply the WAR itself before submitting commands to the kernel.
OK.
Quoted 1 line
Some kind of new flag in the viommu struct I guess
struct iommu_hw_info_arm_smmuv3 has an unused "flags" field:
/**
* enum iommu_hw_info_smmuv3_flags - Flags for ARM SMMUv3 hw_info
* @IOMMU_HW_INFO_SMMUV3_ERRATA_REPEAT_TLBI_CFGI: If set, user space must issue
* TLBI/CFGI+SYNC commands twice
* due to a hardware erratum:
* <link-to-erratum>
*/
enum iommu_hw_info_smmuv3_flags {
IOMMU_HW_INFO_SMMUV3_ERRATA_REPEAT_TLBI_CFGI = 1 << 0,
};Thanks
Nicolin
Re: [PATCH v7 2/3] iommu/arm-smmu-v3: Introduce CFGI/TLBI-repeat workaround infrastructure
Quoted 24 lines · Nicolin Chen
Quoted 7 lines · Jason Gunthorpe
Quoted 3 lines · Nicolin Chen
Given the use cases on Tegra264, instead of patching the iommufd path as this patch does, perhaps we should simply spit a WARN in
arm_vsmmu_init():Nope, in this case you need to make the errata discoverable through the viommu info so the VMM can validate the right DT is used, or apply the WAR itself before submitting commands to the kernel.
OK.
Quoted 1 line
Some kind of new flag in the viommu struct I guess
struct
iommu_hw_info_arm_smmuv3has an unused "flags" field:/**
* enumiommu_hw_info_smmuv3_flags- Flags for ARM SMMUv3hw_info
* @IOMMU_HW_INFO_SMMUV3_ERRATA_REPEAT_TLBI_CFGI: If set, user space must issue* TLBI/CFGI+SYNC commands twice * due to a hardware erratum: * <link-to-erratum> */ enum iommu_hw_info_smmuv3_flags { IOMMU_HW_INFO_SMMUV3_ERRATA_REPEAT_TLBI_CFGI = 1 << 0, };
Quoted 2 lines
Thanks
Nicolin
Ack, I am sending v8 addressing this.
Thanks,
Ashish Mhetre
PATCH v7 3/3 iommu/arm-smmu-v3: Enable CFGI/TLBI-repeat workaround on Tegra264
In reply to Ashish MhetreNvidia Tegra264 SMMU is affected by an erratum where a TLB entry can survive an invalidation that races with concurrent traffic targeting the same entry. The hardware-recommended software workaround is to issue every CFGI/TLBI command (each followed by CMD_SYNC) twice, and that infrastructure is already in place behind arm_smmu_erratum_repeat_tlbi_cfgi_key.
Neither IDR nor IIDR flags this Tegra264-specific bug, so hardware detection is not possible. Tegra264 is device-tree-only (no ACPI/IORT support) and already has a dedicated "nvidia,tegra264-smmu" compatible, so DT-probe is the only viable detection path.
Enable the workaround on instances matching the existing "nvidia,tegra264-smmu" compatible by calling static_branch_enable() on arm_smmu_erratum_repeat_tlbi_cfgi_key. Document the erratum in Documentation/arch/arm64/silicon-errata.rst.
Note that since guest-level VCMDQs issue commands directly to the hardware, a guest kernel enabling the CMDQV feature on Tegra264 must apply this workaround as well.
--- Documentation/arch/arm64/silicon-errata.rst | 2 ++ drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c | 4 +++- 2 files changed, 5 insertions(+), 1 deletion(-)
Documentation/arch/arm64/silicon-errata.rst +2 -0
@@ -312,6 +312,8 @@ stable kernels. | | | T241-MPAM-4, | | | | | T241-MPAM-6 | | +----------------+-----------------+-----------------+-----------------------------+ +| NVIDIA | T264 SMMU | T264-SMMU-3 | N/A | ++----------------+-----------------+-----------------+-----------------------------+ +----------------+-----------------+-----------------+-----------------------------+ | Freescale/NXP | LS2080A/LS1043A | A-008585 | FSL_ERRATUM_A008585 | +----------------+-----------------+-----------------+-----------------------------+
drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c +3 -1
@@ -5357,8 +5357,10 @@ static int arm_smmu_device_dt_probe(struct platform_device *pdev,if (of_dma_is_coherent (dev->of_node)) smmu->features |=ARM_SMMU_FEAT_COHERENCY ; -if (of_device_is_compatible (dev->of_node,"nvidia,tegra264-smmu" )) +if (of_device_is_compatible (dev->of_node,"nvidia,tegra264-smmu" )) {tegra_cmdqv_dt_probe (dev->of_node, smmu); +static_branch_enable (&arm_smmu_erratum_repeat_tlbi_cfgi_key); + }return ret; }
Signature · 1 line
2.50.1
Re: [PATCH v7 3/3] iommu/arm-smmu-v3: Enable CFGI/TLBI-repeat workaround on Tegra264
drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c static int arm_smmu_device_dt_probe(struct platform_device *pdev, · line 5363
Quoted 11 lines · Ashish Mhetre
drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c +3
-1@@ -5357,8 +5357,10 @@ static int arm_smmu_device_dt_probe(struct platform_device *pdev,if (of_dma_is_coherent (dev->of_node)) smmu->features |=ARM_SMMU_FEAT_COHERENCY ; -if (of_device_is_compatible (dev->of_node,"nvidia,tegra264-smmu" )) +if (of_device_is_compatible (dev->of_node,"nvidia,tegra264-smmu" )) {tegra_cmdqv_dt_probe (dev->of_node, smmu); +static_branch_enable (&arm_smmu_erratum_repeat_tlbi_cfgi_key); + }
It is a bit of a big hammer to not have the per-instance FEAT but it probably doesn't matter
Jason