iommu/arm-smmu-v3: Tegra264 invalidation workaround
Subsystems (6)
v9 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 so each step is reviewable in isolation:
1/4 Refactor the existing CMDQ batch force-sync conditions into
arm_smmu_cmdq_batch_force_sync(). No functional change. Authored by Nicolin Chen.
2/4 Add the static key, command classifier, CMDQ submission wrapper,
and batch force-sync condition without enabling the workaround.
3/4 Report the erratum to user space through
IOMMU_HW_INFO_ARM_SMMUV3_ERRATA_REPEAT_TLBI_CFGI and submit user-provided invalidations through the raw CMDQ helper so the host does not apply the workaround a second time.
4/4 Enable the workaround for "nvidia,tegra264-smmu" and document
T264-SMMU-3 in silicon-errata.rst.
The series applies cleanly on linux-next/master (base-commit below).
Changes since v8:
- Split the iommufd changes into a separate patch, leaving the final patch to enable the workaround and document the erratum.
- Make arm_smmu_erratum_cmd_needs_repeating() file-local and remove its unused declaration from arm-smmu-v3.h.
- Restyle the SMMUv3 hw_info flag kdoc following enum iommufd_option.
Changes since v7:
- Rework the nesting/iommufd handling to report the erratum to user space and stop repeating user-issued invalidations in the host.
- Drop arm_vsmmu_can_batch_cmd() and its iommufd batching split. Expose __arm_smmu_cmdq_issue_cmdlist() and make arm_vsmmu_cache_invalidate() call it directly.
- Add the UAPI flag and report it from arm_smmu_hw_info() through a new arm_smmu_erratum_repeat_tlbi_cfgi() accessor.
- Carry Jason Gunthorpe's Reviewed-by on the first two patches and Nicolin Chen's Reviewed-by on the workaround infrastructure patch.
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 that a guest kernel enabling CMDQV on Tegra264 must also apply this workaround, since guest-level VCMDQs issue commands directly to the hardware.
Changes since v5:
- Move arm_smmu_erratum_cmd_needs_repeating() into arm-smmu-v3.c and 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 the misleading !n comment above arm_smmu_cmdq_issue_cmdlist(); keep the defensive !n guard.
- Remove the unused smmu parameter from the predicate.
Changes since v4:
- Drop ARM_SMMU_OPT_REPEAT_TLBI_CFGI: the option bit was set and read on the same "nvidia,tegra264-smmu" compatible as the static key.
- Reorder the series so compatible-string detection lands last, after all workaround infrastructure exists.
- Update the force-sync comment to reference the static key description.
Changes since v3:
- Drop the cmds->num == 0 early-return so the refactor is truly "no functional change".
- Rename ARM_SMMU_OPT_TLBI_TWICE to ARM_SMMU_OPT_REPEAT_TLBI_CFGI.
- Rename arm_smmu_cmd_needs_tlbi_twice() to arm_smmu_erratum_cmd_needs_repeating().
- Replace the explicit opcode switch with a range check.
- Introduce arm_smmu_erratum_repeat_tlbi_cfgi_key.
- Document the erratum in silicon-errata.rst.
- Guard the repeat path against an empty cmdlist.
Changes since v2:
- Split the changes into a reviewable and bisectable series.
- Share the command classifier with the iommufd path.
- Split iommufd batches at "needs repeating" transitions.
- Document why detection uses DT instead of IIDR/ACPI.
Changes since v1:
- Detect the erratum from the existing "nvidia,tegra264-smmu" compatible instead of adding a new property.
- Centralise doubling at the CMDQ submission layer and apply it only to CFGI/TLBI, not ATC_INV.
- Drop the binding/dtsi patches.
Ashish Mhetre (3):
iommu/arm-smmu-v3: Add CFGI/TLBI-repeat workaround iommu/arm-smmu-v3-iommufd: Report CFGI/TLBI-repeat erratum 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 | 7 +- drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c | 89 ++++++++++++++++--- drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.h | 5 ++ include/uapi/linux/iommufd.h | 13 ++- 5 files changed, 102 insertions(+), 14 deletions(-)
base-commit: 9eebf259d5352b87080d67758f483583d9e763d7
Signature · 1 line
2.50.1
PATCH v9 1/4 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
PATCH v9 2/4 iommu/arm-smmu-v3: Add CFGI/TLBI-repeat workaround
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 a file-local arm_smmu_erratum_cmd_needs_repeating() helper that gates on the static key first and then range-checks the opcode (CFGI_STE .. ATC_INV).
Rename the existing arm_smmu_cmdq_issue_cmdlist() to __arm_smmu_cmdq_issue_cmdlist() and add a thin wrapper of the original name that re-issues the same cmdlist a second time when the predicate fires. Register the new condition with arm_smmu_cmdq_batch_force_sync() too.
No callers enable the static key yet, so there is no functional change. A subsequent change will enable the key on affected instances.
--- drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c | 57 +++++++++++++++++++-- drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.h | 4 ++ 2 files changed, 57 insertions(+), 4 deletions(-)
drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c +53 -4
@@ -18,6 +18,7 @@#include <linux/interrupt.h> #include <linux/io-pgtable.h> #include <linux/iopoll.h> +#include <linux/jump_label.h> #include <linux/module.h> #include <linux/msi.h> #include <linux/of.h>
@@ -42,6 +43,14 @@ MODULE_PARM_DESC(disable_msipolling,static const struct iommu_ops arm_smmu_ops;static struct iommu_dirty_ops arm_smmu_dirty_ops; +/* +* Repeat every {CFGI,TLBI};CMD_SYNC command sequence so that the second +* issue executes only after the first issue's CMD_SYNC has completed. +* Does not apply to ATC_INV. The key is global and is enabled from DT +* probe on affected hardware (currently Tegra264 only). +*/ +static DEFINE_STATIC_KEY_FALSE (arm_smmu_erratum_repeat_tlbi_cfgi_key); +enum arm_smmu_msi_index {EVTQ_MSI_INDEX ,GERROR_MSI_INDEX ,
@@ -698,10 +707,10 @@ static void arm_smmu_cmdq_write_entries(struct arm_smmu_cmdq *cmdq,* insert their own list of commands then all of the commands from one * CPU will appear before any of the commands from the other CPU. */ -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) +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) {struct arm_smmu_cmd cmd_sync;u32 prod;
@@ -820,6 +829,38 @@ int arm_smmu_cmdq_issue_cmdlist(struct arm_smmu_device *smmu,return ret; } +static bool arm_smmu_erratum_cmd_needs_repeating (struct arm_smmu_cmd *cmd) +{ +u8 opcode; + +if (!static_branch_unlikely (&arm_smmu_erratum_repeat_tlbi_cfgi_key)) +return false; + + opcode =FIELD_GET (CMDQ_0_OP , cmd->data[0 ]); +return opcode >=CMDQ_OP_CFGI_STE && opcode <CMDQ_OP_ATC_INV ; +} + +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) +{ +int ret =__arm_smmu_cmdq_issue_cmdlist (smmu, cmdq, cmds, n, sync); + +/* +* A bare CMD_SYNC can be issued with n == 0 (e.g. an empty +* batch_submit()), in which case there is no cmds[0] to inspect +* and nothing to repeat. +*/ +if (!n || ret || !sync) +return ret; + +if (arm_smmu_erratum_cmd_needs_repeating (&cmds[0 ])) + ret =__arm_smmu_cmdq_issue_cmdlist (smmu, cmdq, cmds, n, sync); + +return ret; +} +static int arm_smmu_cmdq_issue_cmd_p (struct arm_smmu_device *smmu,struct arm_smmu_cmd *cmd,bool sync) {
@@ -860,6 +901,14 @@ static bool arm_smmu_cmdq_batch_force_sync(struct arm_smmu_device *smmu, (smmu->options & ARM_SMMU_OPT_CMDQ_FORCE_SYNC))return true; +/* +* See the description at arm_smmu_erratum_repeat_tlbi_cfgi_key. Batches +* never mix CFGI/TLBI with others, so checking cmds[0] alone is enough. +*/ +if (cmds->num ==CMDQ_BATCH_ENTRIES && +arm_smmu_erratum_cmd_needs_repeating (&cmds->cmds[0 ])) +return true; +return false; }
drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.h +4 -0
@@ -1208,6 +1208,10 @@ void arm_smmu_attach_commit(struct arm_smmu_attach_state *state);void arm_smmu_install_ste_for_dev (struct arm_smmu_master *master,const struct arm_smmu_ste *target); +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); int arm_smmu_cmdq_issue_cmdlist(struct arm_smmu_device *smmu, struct arm_smmu_cmdq *cmdq, struct arm_smmu_cmd *cmds, int n,
Signature · 1 line
2.50.1
PATCH v9 3/4 iommu/arm-smmu-v3-iommufd: Report CFGI/TLBI-repeat erratum
In reply to Ashish MhetreA guest with access to VCMDQ generates its own invalidation commands and must apply any invalidation errata before submitting them. If the host also repeats those commands, each affected invalidation is issued four times instead of twice.
Add IOMMU_HW_INFO_ARM_SMMUV3_ERRATA_REPEAT_TLBI_CFGI to report the CFGI/TLBI-repeat erratum to user space. This allows the VMM to expose the erratum to the guest or apply the workaround itself.
Use the raw __arm_smmu_cmdq_issue_cmdlist() helper for user-provided invalidations so the host does not apply the workaround a second time. Add arm_smmu_erratum_repeat_tlbi_cfgi() to query the static key when populating the SMMUv3 hardware information.
--- drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3-iommufd.c | 7 +++++-- drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c | 7 ++++++- drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.h | 1 + include/uapi/linux/iommufd.h | 13 ++++++++++++- 4 files changed, 24 insertions(+), 4 deletions(-)
drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3-iommufd.c +5 -2
@@ -33,6 +33,9 @@ void *arm_smmu_hw_info(struct device *dev, u32 *length, info->iidr =readl_relaxed (master->smmu->base +ARM_SMMU_IIDR ); info->aidr =readl_relaxed (master->smmu->base +ARM_SMMU_AIDR ); +if (arm_smmu_erratum_repeat_tlbi_cfgi ()) + info->flags |=IOMMU_HW_INFO_ARM_SMMUV3_ERRATA_REPEAT_TLBI_CFGI ; + *length =sizeof (*info); *type =IOMMU_HW_INFO_TYPE_ARM_SMMUV3 ;
@@ -400,8 +403,8 @@ int arm_vsmmu_cache_invalidate(struct iommufd_viommu *viommu,continue ;/* FIXME always uses the main cmdq rather than trying to group by type */ - ret =arm_smmu_cmdq_issue_cmdlist (smmu, &smmu->cmdq, &last->cmd, - cur - last, true); + ret =__arm_smmu_cmdq_issue_cmdlist (smmu, &smmu->cmdq, &last->cmd, + cur - last, true);if (ret) { cur--; goto out;
drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c +6 -1
@@ -829,11 +829,16 @@ int __arm_smmu_cmdq_issue_cmdlist(struct arm_smmu_device *smmu,return ret; } +bool arm_smmu_erratum_repeat_tlbi_cfgi (void ) +{ +return static_branch_unlikely (&arm_smmu_erratum_repeat_tlbi_cfgi_key); +} +static bool arm_smmu_erratum_cmd_needs_repeating (struct arm_smmu_cmd *cmd) {u8 opcode; -if (!static_branch_unlikely (&arm_smmu_erratum_repeat_tlbi_cfgi_key)) +if (!arm_smmu_erratum_repeat_tlbi_cfgi ())return false; opcode =FIELD_GET (CMDQ_0_OP , cmd->data[0 ]);
drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.h +1 -0
@@ -1216,6 +1216,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_repeat_tlbi_cfgi (void );#ifdef CONFIG_ARM_SMMU_V3_SVA bool arm_smmu_sva_supported (struct arm_smmu_device *smmu);
include/uapi/linux/iommufd.h +12 -1
@@ -602,11 +602,22 @@ struct iommu_hw_info_vtd {__aligned_u64 ecap_reg; }; +/** +* enum iommu_hw_info_arm_smmuv3_flags - Flags for ARM SMMUv3 hw_info +* @IOMMU_HW_INFO_ARM_SMMUV3_ERRATA_REPEAT_TLBI_CFGI: +* If set, user space must issue TLBI/CFGI+SYNC commands twice due to +* hardware erratum T264-SMMU-3. See the description at +* arm_smmu_erratum_repeat_tlbi_cfgi_key. +*/ +enum iommu_hw_info_arm_smmuv3_flags { +IOMMU_HW_INFO_ARM_SMMUV3_ERRATA_REPEAT_TLBI_CFGI =1 <<0 , +}; +/** * struct iommu_hw_info_arm_smmuv3 - ARM SMMUv3 hardware information * (IOMMU_HW_INFO_TYPE_ARM_SMMUV3) * -* @flags: Must be set to 0 +* @flags: Combination of enum iommu_hw_info_arm_smmuv3_flags * @__reserved: Must be 0 * @idr: Implemented features for ARM SMMU Non-secure programming interface * @iidr: Information about the implementation and implementer of ARM SMMU,
Signature · 1 line
2.50.1
Re: [PATCH v9 3/4] iommu/arm-smmu-v3-iommufd: Report CFGI/TLBI-repeat erratum
Quoted 14 lines · Ashish Mhetre
A guest with access to VCMDQ generates its own invalidation commands and must apply any invalidation errata before submitting them. If the host also repeats those commands, each affected invalidation is issued four times instead of twice.
Add
IOMMU_HW_INFO_ARM_SMMUV3_ERRATA_REPEAT_TLBI_CFGIto report the CFGI/TLBI-repeat erratum to user space. This allows the VMM to expose the erratum to the guest or apply the workaround itself.Use the raw
__arm_smmu_cmdq_issue_cmdlist()helper for user-provided invalidations so the host does not apply the workaround a second time. Addarm_smmu_erratum_repeat_tlbi_cfgi()to query the static key when populating the SMMUv3 hardware information.
Quoted 7 lines
Signed-off-by Ashish Mhetre <[email protected]>--- drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3-iommufd.c | 7 +++++-- drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c | 7 ++++++- drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.h | 1 + include/uapi/linux/iommufd.h | 13 ++++++++++++- 4 files changed, 24 insertions(+), 4 deletions(-)
Jason
Re: [PATCH v9 3/4] iommu/arm-smmu-v3-iommufd: Report CFGI/TLBI-repeat erratum
In reply to Ashish MhetreQuoted 9 lines · Ashish Mhetre
A guest with access to VCMDQ generates its own invalidation commands and must apply any invalidation errata before submitting them. If the host also repeats those commands, each affected invalidation is issued four times instead of twice.
Add
IOMMU_HW_INFO_ARM_SMMUV3_ERRATA_REPEAT_TLBI_CFGIto report the CFGI/TLBI-repeat erratum to user space. This allows the VMM to expose the erratum to the guest or apply the workaround itself.
Quoted 6 lines
Use the raw
__arm_smmu_cmdq_issue_cmdlist()helper for user-provided invalidations so the host does not apply the workaround a second time. Addarm_smmu_erratum_repeat_tlbi_cfgi()to query the static key when populating the SMMUv3 hardware information.Signed-off-by Ashish Mhetre <[email protected]>
PATCH v9 4/4 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.
--- 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
@@ -318,6 +318,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
@@ -5391,8 +5391,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 v9 4/4] iommu/arm-smmu-v3: Enable CFGI/TLBI-repeat workaround on Tegra264
Quoted 17 lines · Ashish Mhetre
Nvidia 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 behindarm_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()onarm_smmu_erratum_repeat_tlbi_cfgi_key. Document the erratum inDocumentation/arch/arm64/silicon-errata.rst.
Quoted 5 lines
Signed-off-by Ashish Mhetre <[email protected]>--- 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(-)
Jason
Re: [PATCH v9 4/4] iommu/arm-smmu-v3: Enable CFGI/TLBI-repeat workaround on Tegra264
In reply to Ashish MhetreQuoted 12 lines · Ashish Mhetre
Nvidia 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 behindarm_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.
Quoted 6 lines
Enable the workaround on instances matching the existing "nvidia,tegra264-smmu" compatible by calling
static_branch_enable()onarm_smmu_erratum_repeat_tlbi_cfgi_key. Document the erratum inDocumentation/arch/arm64/silicon-errata.rst.Signed-off-by Ashish Mhetre <[email protected]>
Quoted 8 lines · Ashish Mhetre
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'sCMD_SYNChas completed, giving the sequence:[...]
Applied to iommu (arm/smmu/updates), thanks!
But please check the comments from Sashiko if you get a chance:
https://sashiko.dev/#/patchset/[email protected]
[1/4] iommu/arm-smmu-v3: Factor out CMDQ batch force-sync conditions
https://git.kernel.org/iommu/c/097bf4a02f2d [2/4] iommu/arm-smmu-v3: Add CFGI/TLBI-repeat workaround https://git.kernel.org/iommu/c/95ed2da20283 [3/4] iommu/arm-smmu-v3-iommufd: Report CFGI/TLBI-repeat erratum https://git.kernel.org/iommu/c/d501d66815ee [4/4] iommu/arm-smmu-v3: Enable CFGI/TLBI-repeat workaround on Tegra264 https://git.kernel.org/iommu/c/06b15ddcfbc0
Cheers,
Signature · 5 lines
Will https://fixes.arm64.dev https://next.arm64.dev https://will.arm64.dev
Quoted 11 lines · Will Deacon
External email: Use caution opening links or attachments
Quoted 7 lines · Ashish Mhetre
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'sCMD_SYNChas completed, giving the sequence:
Quoted 5 lines
Quoted 1 line
[...]
Applied to iommu (arm/smmu/updates), thanks!
But please check the comments from Sashiko if you get a chance:
Both comments from Sashiko can be ignored.
Regarding comment on 2/4, it's false positive as at that point batches won't have mix commands.
Regarding comment on 3/4, the erratum is exposed via hw_info. So, it need to apply the WAR by checking the new flag else it's a bug in VMM.
Quoted 16 lines
[1/4] iommu/arm-smmu-v3: Factor out CMDQ batch force-sync conditions
https://git.kernel.org/iommu/c/097bf4a02f2d [2/4] iommu/arm-smmu-v3: Add CFGI/TLBI-repeat workaround https://git.kernel.org/iommu/c/95ed2da20283 [3/4] iommu/arm-smmu-v3-iommufd: Report CFGI/TLBI-repeat erratum https://git.kernel.org/iommu/c/d501d66815ee [4/4] iommu/arm-smmu-v3: Enable CFGI/TLBI-repeat workaround on Tegra264 https://git.kernel.org/iommu/c/06b15ddcfbc0Cheers,
--
Willhttps://fixes.arm64.dev
https://next.arm64.dev
https://will.arm64.dev