Skip to contentSkip to conversation

Add device tree support for NVIDIA Tegra CMDQV

PATCH Superseded Ashish Mhetre 4 participants 11 messages Nov 25, 2025 – Dec 1, 2025

Subsystems (5)

v2 of 8 Superseded Latest is v8 →

lore
Share & tools
lore
#0 lore raw

v2 cover Add device tree support for NVIDIA Tegra CMDQV

This series adds device tree support for the CMDQ-Virtualization (CMDQV) hardware on NVIDIA Tegra264 SoCs.

CMDQV is a hardware block that works alongside the ARM SMMUv3 to assist in virtualizing the command queue. It was previously only supported through ACPI on Tegra241. This series extends the existing driver to support device tree based initialization, which is required for Tegra264 platforms.

The series is structured as follows:

Patch 1: Extends the tegra241-cmdqv driver to support device tree probing
alongside the existing ACPI support. The SMMU driver now parses the nvidia,cmdqv phandle to associate each SMMU with its corresponding CMDQV instance.

Patch 2: Adds device tree binding documentation for nvidia,tegra264-cmdqv
and extends the arm,smmu-v3 binding with an optional nvidia,cmdqv property.

Patch 3: Adds CMDQV device nodes to the Tegra264 device tree and enables
them on the tegra264-p3834 platform.

The implementation follows the existing ACPI probe path to minimize code divergence and maintain consistency with Tegra241 support.

Changes from V1:
- Updated dependency for CONFIG_TEGRA241_CMDQV on OF || ACPI
- Changed maintainer to Nicolin Chen
- Removed interrupt-names property
- Added nvidia,tegra264-smmu to compatible enum for arm-smmu-v3
- Added allOf constraint to restrict nvidia,cmdqv property to nvidia,tegra264-smmu only
- Updated SMMU nodes in device tree to use nvidia,tegra264-smmu compatible string

Ashish Mhetre (3):
iommu/arm-smmu-v3: Add device-tree support for CMDQV driver
dt-bindings: iommu: Add NVIDIA Tegra CMDQV support
arm64: dts: nvidia: Add nodes for CMDQV

 .../bindings/iommu/arm,smmu-v3.yaml           | 30 +++++++++-
 .../bindings/iommu/nvidia,tegra264-cmdqv.yaml | 42 ++++++++++++++
 .../arm64/boot/dts/nvidia/tegra264-p3834.dtsi |  8 +++
 arch/arm64/boot/dts/nvidia/tegra264.dtsi      | 55 +++++++++++++++++--
 drivers/iommu/arm/Kconfig                     |  2 +-
 drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c   | 32 +++++++++++
 .../iommu/arm/arm-smmu-v3/tegra241-cmdqv.c    | 43 ++++++++++++++-
 7 files changed, 203 insertions(+), 9 deletions(-)
 create mode 100644 Documentation/devicetree/bindings/iommu/nvidia,tegra264-cmdqv.yaml
Signature · 1 line
2.25.1
#1 lore raw

PATCH v2 1/3 iommu/arm-smmu-v3: Add device-tree support for CMDQV driver

Add device tree support to the CMDQV driver to enable usage on Tegra264 SoCs. The implementation parses the nvidia,cmdqv phandle from the SMMU device tree node to associate each SMMU with its corresponding CMDQV instance.

Update the dependency from Kconfig as the driver now supports both ACPI and device tree initialization through conditional compilation.

Add nvidia,tegra264-smmu to the arm-smmu-v3 device tree match table to enable device tree based probing on Nvidia Tegra264 platforms and restrict CMDQV usage to other vendors.

---
 drivers/iommu/arm/Kconfig                     |  2 +-
 drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c   | 32 ++++++++++++++
 .../iommu/arm/arm-smmu-v3/tegra241-cmdqv.c    | 43 ++++++++++++++++++-
 3 files changed, 75 insertions(+), 2 deletions(-)
drivers/iommu/arm/Kconfig +1 -1
index ef42bbe07dbe..168ada9c3d68 100644
@@ -121,7 +121,7 @@ config ARM_SMMU_V3_KUNIT_TEST
 
 config TEGRA241_CMDQV
 	bool "NVIDIA Tegra241 CMDQ-V extension support for ARM SMMUv3"
-	depends on ACPI
+	depends on OF || ACPI
 	help
 	  Support for NVIDIA CMDQ-Virtualization extension for ARM SMMUv3. The
 	  CMDQ-V extension is similar to v3.3 ECMDQ for multi command queues
drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c +32 -0
index a33fbd12a0dd..2eec7cd4f3de 100644
@@ -4530,6 +4530,34 @@ static int arm_smmu_device_hw_probe(struct arm_smmu_device *smmu)
 	return 0;
 }
 
+#ifdef CONFIG_TEGRA241_CMDQV
+static void tegra_cmdqv_dt_probe(struct device_node *smmu_node,
+				 struct arm_smmu_device *smmu)
+{
+	struct platform_device *pdev;
+	struct device_node *np;
+
+	np = of_parse_phandle(smmu_node, "nvidia,cmdqv", 0);
+	if (!np)
+		return;
+
+	pdev = of_find_device_by_node(np);
+	of_node_put(np);
+	if (!pdev)
+		return;
+
+	smmu->impl_dev = &pdev->dev;
+	smmu->options |= ARM_SMMU_OPT_TEGRA241_CMDQV;
+	dev_info(smmu->dev, "found companion CMDQV device: %s\n",
+		 dev_name(smmu->impl_dev));
+}
+#else
+static void tegra_cmdqv_dt_probe(struct device_node *smmu_node,
+				 struct arm_smmu_device *smmu)
+{
+}
+#endif
+
 #ifdef CONFIG_ACPI
 #ifdef CONFIG_TEGRA241_CMDQV
 static void acpi_smmu_dsdt_probe_tegra241_cmdqv(struct acpi_iort_node *node,
@@ -4634,6 +4662,9 @@ 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"))
+		tegra_cmdqv_dt_probe(dev->of_node, smmu);
+
 	return ret;
 }
 
@@ -4867,6 +4898,7 @@ static void arm_smmu_device_shutdown(struct platform_device *pdev)
 
 static const struct of_device_id arm_smmu_of_match[] = {
 	{ .compatible = "arm,smmu-v3", },
+	{ .compatible = "nvidia,tegra264-smmu", },
 	{ },
 };
 MODULE_DEVICE_TABLE(of, arm_smmu_of_match);
drivers/iommu/arm/arm-smmu-v3/tegra241-cmdqv.c +42 -1

69 lines not on this page · raw message

Signature · 1 line
2.25.1
reviewer
#2 lore raw

Re: [PATCH V2 1/3] iommu/arm-smmu-v3: Add device-tree support for CMDQV driver

Quoted 25 lines · Ashish Mhetre

Add device tree support to the CMDQV driver to enable usage on Tegra264 SoCs. The implementation parses the nvidia,cmdqv phandle from the SMMU device tree node to associate each SMMU with its corresponding CMDQV instance.

Update the dependency from Kconfig as the driver now supports both ACPI and device tree initialization through conditional compilation.

Add nvidia,tegra264-smmu to the arm-smmu-v3 device tree match table to enable device tree based probing on Nvidia Tegra264 platforms and restrict CMDQV usage to other vendors.

---
  drivers/iommu/arm/Kconfig                     |  2 +-
  drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c   | 32 ++++++++++++++
  .../iommu/arm/arm-smmu-v3/tegra241-cmdqv.c    | 43 ++++++++++++++++++-
  3 files changed, 75 insertions(+), 2 deletions(-)
drivers/iommu/arm/Kconfig +0 -0
index ef42bbe07dbe..168ada9c3d68 100644

drivers/iommu/arm/Kconfig config ARM_SMMU_V3_KUNIT_TEST · line 124

Quoted 5 lines
drivers/iommu/arm/Kconfig +1 -1
@@ -121,7 +121,7 @@ config ARM_SMMU_V3_KUNIT_TEST
 
  config TEGRA241_CMDQV
  	bool "NVIDIA Tegra241 CMDQ-V extension support for ARM SMMUv3"
-	depends on ACPI
+	depends on OF || ACPI

This now does nothing, since ARM_SMMU_V3 depends on ARM64 which already implies at least OF anyway.

Quoted 17 lines
drivers/iommu/arm/Kconfig +0 -0
  	help
  	  Support for NVIDIA CMDQ-Virtualization extension for ARM SMMUv3. The
  	  CMDQ-V extension is similar to v3.3 ECMDQ for multi command queues
drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c +6 -0
index a33fbd12a0dd..2eec7cd4f3de 100644
@@ -4530,6 +4530,34 @@ static int arm_smmu_device_hw_probe(struct arm_smmu_device *smmu)
  	return 0;
  }
 
+#ifdef CONFIG_TEGRA241_CMDQV
+static void tegra_cmdqv_dt_probe(struct device_node *smmu_node,
+				 struct arm_smmu_device *smmu)
+{
+	struct platform_device *pdev;
+	struct device_node *np;

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c static int arm_smmu_device_hw_probe(struct arm_smmu_device *smmu) · line 4548

Quoted 10 lines
drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c +10 -0
+
+	np = of_parse_phandle(smmu_node, "nvidia,cmdqv", 0);
+	if (!np)
+		return;
+
+	pdev = of_find_device_by_node(np);
+	of_node_put(np);
+	if (!pdev)
+		return;
+

You need to drop the reference on the platform device too.

Quoted 26 lines
drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c +15 -0
+	smmu->impl_dev = &pdev->dev;
+	smmu->options |= ARM_SMMU_OPT_TEGRA241_CMDQV;
+	dev_info(smmu->dev, "found companion CMDQV device: %s\n",
+		 dev_name(smmu->impl_dev));
+}
+#else
+static void tegra_cmdqv_dt_probe(struct device_node *smmu_node,
+				 struct arm_smmu_device *smmu)
+{
+}
+#endif
+
  #ifdef CONFIG_ACPI
  #ifdef CONFIG_TEGRA241_CMDQV
  static void acpi_smmu_dsdt_probe_tegra241_cmdqv(struct acpi_iort_node *node,
@@ -4634,6 +4662,9 @@ 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"))
+		tegra_cmdqv_dt_probe(dev->of_node, smmu);
+
  	return ret;
  }
 

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c static void arm_smmu_device_shutdown(struct platform_device *pdev) · line 4901

Quoted 4 lines
drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c +1 -0
@@ -4867,6 +4898,7 @@ static void arm_smmu_device_shutdown(struct platform_device *pdev)
 
  static const struct of_device_id arm_smmu_of_match[] = {
  	{ .compatible = "arm,smmu-v3", },
+	{ .compatible = "nvidia,tegra264-smmu", },

Since you're not using match data, this is pointless, as anything with this compatible must still also match the generic compatible anyway.

Thanks,
Robin.

Quoted 80 lines
drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c +0 -0
  	{ },
  };
  MODULE_DEVICE_TABLE(of, arm_smmu_of_match);
drivers/iommu/arm/arm-smmu-v3/tegra241-cmdqv.c +42 -1
index 378104cd395e..2608bf6518b4 100644
@@ -11,6 +11,8 @@
  #include <linux/iommufd.h>
  #include <linux/iopoll.h>
  #include <uapi/linux/iommufd.h>
+#include <linux/of_platform.h>
+#include <linux/platform_device.h>
 
  #include <acpi/acpixf.h>
 
@@ -917,6 +919,26 @@ tegra241_cmdqv_find_acpi_resource(struct device *dev, int *irq)
  	return res;
  }
 
+static struct resource *
+tegra241_cmdqv_find_dt_resource(struct device *dev, int *irq)
+{
+	struct platform_device *pdev = to_platform_device(dev);
+	struct resource *res;
+
+	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+	if (!res) {
+		dev_err(dev, "no memory resource found for CMDQV\n");
+		return NULL;
+	}
+
+	if (irq)
+		*irq = platform_get_irq_optional(pdev, 0);
+	if (!irq || *irq <= 0)
+		dev_warn(dev, "no interrupt. errors will not be reported\n");
+
+	return res;
+}
+
  static int tegra241_cmdqv_init_structures(struct arm_smmu_device *smmu)
  {
  	struct tegra241_cmdqv *cmdqv =
@@ -1048,11 +1070,14 @@ struct arm_smmu_device *tegra241_cmdqv_probe(struct arm_smmu_device *smmu)
 
  	if (!smmu->dev->of_node)
  		res = tegra241_cmdqv_find_acpi_resource(smmu->impl_dev, &irq);
+	else
+		res = tegra241_cmdqv_find_dt_resource(smmu->impl_dev, &irq);
  	if (!res)
  		goto out_fallback;
 
  	new_smmu = __tegra241_cmdqv_probe(smmu, res, irq);
-	kfree(res);
+	if (!smmu->dev->of_node)
+		kfree(res);
 
  	if (new_smmu)
  		return new_smmu;
@@ -1346,4 +1371,20 @@ tegra241_cmdqv_init_vintf_user(struct arm_vsmmu *vsmmu,
  	return ret;
  }
 
+static const struct of_device_id tegra241_cmdqv_of_match[] = {
+	{ .compatible = "nvidia,tegra264-cmdqv" },
+	{ /* sentinel */ }
+};
+MODULE_DEVICE_TABLE(of, tegra241_cmdqv_of_match);
+
+static struct platform_driver tegra241_cmdqv_driver = {
+	.driver = {
+		.name = "tegra241-cmdqv",
+		.of_match_table = tegra241_cmdqv_of_match,
+	},
+};
+module_platform_driver(tegra241_cmdqv_driver);
+
+MODULE_DESCRIPTION("NVIDIA Tegra241 Command Queue Virtualization Driver");
+MODULE_LICENSE("GPL");
  MODULE_IMPORT_NS("IOMMUFD");
#3 lore raw

Re: [PATCH V2 1/3] iommu/arm-smmu-v3: Add device-tree support for CMDQV driver

Quoted 30 lines · Robin Murphy

External email: Use caution opening links or attachments

Quoted 26 lines · Ashish Mhetre

Add device tree support to the CMDQV driver to enable usage on Tegra264 SoCs. The implementation parses the nvidia,cmdqv phandle from the SMMU device tree node to associate each SMMU with its corresponding CMDQV instance.

Update the dependency from Kconfig as the driver now supports both ACPI and device tree initialization through conditional compilation.

Add nvidia,tegra264-smmu to the arm-smmu-v3 device tree match table to enable device tree based probing on Nvidia Tegra264 platforms and restrict CMDQV usage to other vendors.

---
  drivers/iommu/arm/Kconfig                     |  2 +- drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c   | 32 ++++++++++++++ .../iommu/arm/arm-smmu-v3/tegra241-cmdqv.c    | 43 ++++++++++++++++++-

  3 files changed, 75 insertions(+), 2 deletions(-)
drivers/iommu/arm/Kconfig +0 -0
index ef42bbe07dbe..168ada9c3d68 100644
@@ -121,7 +121,7 @@ config ARM_SMMU_V3_KUNIT_TEST
 
Quoted 8 lines
Quoted 4 lines

  config TEGRA241_CMDQV
      bool "NVIDIA Tegra241 CMDQ-V extension support for ARM SMMUv3" -     depends on ACPI
+     depends on OF || ACPI

This now does nothing, since ARM_SMMU_V3 depends on ARM64 which already implies at least OF anyway.

Acknowledged, I will remove the dependency.

Quoted 22 lines
Quoted 22 lines

      help
        Support for NVIDIA CMDQ-Virtualization extension for ARM SMMUv3. The CMDQ-V extension is similar to v3.3 ECMDQ for multi command queues

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c +10 -0
index a33fbd12a0dd..2eec7cd4f3de 100644
@@ -4530,6 +4530,34 @@ static int arm_smmu_device_hw_probe(struct 
 arm_smmu_device *smmu)
       return 0;
   }
 
+#ifdef CONFIG_TEGRA241_CMDQV
+static void tegra_cmdqv_dt_probe(struct device_node *smmu_node,
+                              struct arm_smmu_device *smmu)
+{
+     struct platform_device *pdev;
+     struct device_node *np;
+
+     np = of_parse_phandle(smmu_node, "nvidia,cmdqv", 0);
+     if (!np)
+             return;
Quoted 9 lines

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c static int arm_smmu_device_hw_probe(struct arm_smmu_device *smmu) · line 4548

Quoted 6 lines
drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c +6 -0
+
+     pdev = of_find_device_by_node(np);
+     of_node_put(np);
+     if (!pdev)
+             return;
+

You need to drop the reference on the platform device too.

Yes, I will fix this in next revision.

Quoted 29 lines
Quoted 29 lines
drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c +12 -0
+     smmu->impl_dev = &pdev->dev;
+     smmu->options |= ARM_SMMU_OPT_TEGRA241_CMDQV;
+     dev_info(smmu->dev, "found companion CMDQV device: %s\n",
+              dev_name(smmu->impl_dev));
+}
+#else
+static void tegra_cmdqv_dt_probe(struct device_node *smmu_node,
+                              struct arm_smmu_device *smmu)
+{
+}
+#endif
+
   #ifdef CONFIG_ACPI
   #ifdef CONFIG_TEGRA241_CMDQV

  static void acpi_smmu_dsdt_probe_tegra241_cmdqv(struct acpi_iort_node *node,

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c +3 -0
@@ -4634,6 +4662,9 @@ 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"))
+             tegra_cmdqv_dt_probe(dev->of_node, smmu);
+
       return ret;
   }
@@ -4867,6 +4898,7 @@ static void arm_smmu_device_shutdown(struct 
 platform_device *pdev)
 
Quoted 7 lines

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c static void arm_smmu_device_shutdown(struct platform_device *pdev) · line 4901

Quoted 3 lines
drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c +1 -0
   static const struct of_device_id arm_smmu_of_match[] = {
       { .compatible = "arm,smmu-v3", },
+     { .compatible = "nvidia,tegra264-smmu", },

Since you're not using match data, this is pointless, as anything with this compatible must still also match the generic compatible anyway.

Sure, I'll remove "nvidia,tegra264-smmu" in next version.

Quoted 89 lines

Thanks,
Robin.

Quoted 86 lines
drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c +0 -0
       { },
   };

  MODULE_DEVICE_TABLE(of, arm_smmu_of_match);

drivers/iommu/arm/arm-smmu-v3/tegra241-cmdqv.c +22 -0
index 378104cd395e..2608bf6518b4 100644
@@ -11,6 +11,8 @@
   #include <linux/iommufd.h>
   #include <linux/iopoll.h>
   #include <uapi/linux/iommufd.h>
+#include <linux/of_platform.h>
+#include <linux/platform_device.h>
 
   #include <acpi/acpixf.h>
 
@@ -917,6 +919,26 @@ tegra241_cmdqv_find_acpi_resource(struct device 
 *dev, int *irq)
       return res;
   }
 
+static struct resource *
+tegra241_cmdqv_find_dt_resource(struct device *dev, int *irq)
+{
+     struct platform_device *pdev = to_platform_device(dev);
+     struct resource *res;
+
+     res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+     if (!res) {
+             dev_err(dev, "no memory resource found for CMDQV\n");
+             return NULL;
+     }
+
+     if (irq)
+             *irq = platform_get_irq_optional(pdev, 0);
+     if (!irq || *irq <= 0)
+             dev_warn(dev, "no interrupt. errors will not be 
 reported\n");
+
+     return res;
+}
+
   static int tegra241_cmdqv_init_structures(struct arm_smmu_device *smmu)

  {
      struct tegra241_cmdqv *cmdqv =

drivers/iommu/arm/arm-smmu-v3/tegra241-cmdqv.c +4 -1
@@ -1048,11 +1070,14 @@ struct arm_smmu_device 
 *tegra241_cmdqv_probe(struct arm_smmu_device *smmu)
 
       if (!smmu->dev->of_node)
               res = tegra241_cmdqv_find_acpi_resource(smmu->impl_dev, &irq);
+     else
+             res = tegra241_cmdqv_find_dt_resource(smmu->impl_dev, 
 &irq);
       if (!res)
               goto out_fallback;
 
       new_smmu = __tegra241_cmdqv_probe(smmu, res, irq);
-     kfree(res);
+     if (!smmu->dev->of_node)
+             kfree(res);
 

      if (new_smmu)
              return new_smmu;

drivers/iommu/arm/arm-smmu-v3/tegra241-cmdqv.c +15 -0
@@ -1346,4 +1371,20 @@ tegra241_cmdqv_init_vintf_user(struct 
 arm_vsmmu *vsmmu,
       return ret;
   }
 
+static const struct of_device_id tegra241_cmdqv_of_match[] = {
+     { .compatible = "nvidia,tegra264-cmdqv" },
+     { /* sentinel */ }
+};
+MODULE_DEVICE_TABLE(of, tegra241_cmdqv_of_match);
+
+static struct platform_driver tegra241_cmdqv_driver = {
+     .driver = {
+             .name = "tegra241-cmdqv",
+             .of_match_table = tegra241_cmdqv_of_match,
+     },
+};
+module_platform_driver(tegra241_cmdqv_driver);
+
+MODULE_DESCRIPTION("NVIDIA Tegra241 Command Queue Virtualization 

Driver");
+MODULE_LICENSE("GPL");
  MODULE_IMPORT_NS("IOMMUFD");

#4 lore raw

PATCH v2 2/3 dt-bindings: iommu: Add NVIDIA Tegra CMDQV support

In reply to Ashish Mhetre

The Command Queue Virtualization (CMDQV) hardware is part of the SMMUv3 implementation on NVIDIA Tegra SoCs. It assists in virtualizing the command queue for the SMMU.

Add a new device tree binding document for nvidia,tegra264-cmdqv.

Also update the arm,smmu-v3 binding to include an optional nvidia,cmdqv property. This property is a phandle to the CMDQV device node, allowing the SMMU driver to associate with its corresponding CMDQV instance. Restrict this property usage to Nvidia Tegra264 only.

---
 .../bindings/iommu/arm,smmu-v3.yaml           | 30 ++++++++++++-
 .../bindings/iommu/nvidia,tegra264-cmdqv.yaml | 42 +++++++++++++++++++
 2 files changed, 70 insertions(+), 2 deletions(-)
 create mode 100644 Documentation/devicetree/bindings/iommu/nvidia,tegra264-cmdqv.yaml
Documentation/devicetree/bindings/iommu/arm,smmu-v3.yaml +28 -2
index 75fcf4cb52d9..1c03482e4c61 100644
@@ -20,7 +20,12 @@ properties:
   $nodename:
     pattern: "^iommu@[0-9a-f]*"
   compatible:
-    const: arm,smmu-v3
+    oneOf:
+      - const: arm,smmu-v3
+      - items:
+          - enum:
+              - nvidia,tegra264-smmu
+          - const: arm,smmu-v3
 
   reg:
     maxItems: 1
@@ -58,6 +63,15 @@ properties:
 
   msi-parent: true
 
+  nvidia,cmdqv:
+    description: |
+      A phandle to its pairing CMDQV extension for an implementation on NVIDIA
+      Tegra SoC.
+
+      If this property is absent, CMDQ-Virtualization won't be used and SMMU
+      will only use its own CMDQ.
+    $ref: /schemas/types.yaml#/definitions/phandle
+
   hisilicon,broken-prefetch-cmd:
     type: boolean
     description: Avoid sending CMD_PREFETCH_* commands to the SMMU.
@@ -69,6 +83,17 @@ properties:
       register access with page 0 offsets. Set for Cavium ThunderX2 silicon that
       doesn't support SMMU page1 register space.
 
+allOf:
+  - if:
+      not:
+        properties:
+          compatible:
+            contains:
+              const: nvidia,tegra264-smmu
+    then:
+      properties:
+        nvidia,cmdqv: false
+
 required:
   - compatible
   - reg
@@ -82,7 +107,7 @@ examples:
     #include <dt-bindings/interrupt-controller/irq.h>
 
     iommu@2b400000 {
-            compatible = "arm,smmu-v3";
+            compatible = "nvidia,tegra264-smmu", "arm,smmu-v3";
             reg = <0x2b400000 0x20000>;
             interrupts = <GIC_SPI 74 IRQ_TYPE_EDGE_RISING>,
                          <GIC_SPI 75 IRQ_TYPE_EDGE_RISING>,
@@ -92,4 +117,5 @@ examples:
             dma-coherent;
             #iommu-cells = <1>;
             msi-parent = <&its 0xff0000>;
+            nvidia,cmdqv = <&cmdqv>;
     };
Documentation/devicetree/bindings/iommu/nvidia,tegra264-cmdqv.yaml new file +42 -0

42 lines not on this page · raw message

Signature · 1 line
2.25.1
#5 lore raw

PATCH v2 3/3 arm64: dts: nvidia: Add nodes for CMDQV

In reply to Ashish Mhetre

The Command Queue Virtualization (CMDQV) hardware is part of the SMMUv3 implementation on NVIDIA Tegra SoCs. It assists in virtualizing the command queue for the SMMU.

Update SMMU compatible strings to use nvidia,tegra264-smmu to enable CMDQV support. Add device tree nodes for the CMDQV hardware and enable them on the tegra264-p3834 platform where SMMUs are enabled. Each SMMU instance is paired with its corresponding CMDQV instance via the nvidia,cmdqv property.

---
 .../arm64/boot/dts/nvidia/tegra264-p3834.dtsi |  8 +++
 arch/arm64/boot/dts/nvidia/tegra264.dtsi      | 55 +++++++++++++++++--
 2 files changed, 58 insertions(+), 5 deletions(-)
arch/arm64/boot/dts/nvidia/tegra264-p3834.dtsi +8 -0
index 06795c82427a..375d122b92fa 100644
@@ -26,5 +26,13 @@ iommu@5000000 {
 		iommu@6000000 {
 			status = "okay";
 		};
+
+		cmdqv@5200000 {
+			status = "okay";
+		};
+
+		cmdqv@6200000 {
+			status = "okay";
+		};
 	};
 };
arch/arm64/boot/dts/nvidia/tegra264.dtsi +50 -5

109 lines not on this page · raw message

Signature · 1 line
2.25.1
maintainer
#6 lore raw

Re: [PATCH V2 3/3] arm64: dts: nvidia: Add nodes for CMDQV

Quoted 21 lines · Ashish Mhetre

The Command Queue Virtualization (CMDQV) hardware is part of the SMMUv3 implementation on NVIDIA Tegra SoCs. It assists in virtualizing the command queue for the SMMU.

Update SMMU compatible strings to use nvidia,tegra264-smmu to enable CMDQV support. Add device tree nodes for the CMDQV hardware and enable them on the tegra264-p3834 platform where SMMUs are enabled. Each SMMU instance is paired with its corresponding CMDQV instance via the nvidia,cmdqv property.

---
  .../arm64/boot/dts/nvidia/tegra264-p3834.dtsi |  8 +++
  arch/arm64/boot/dts/nvidia/tegra264.dtsi      | 55 +++++++++++++++++--
  2 files changed, 58 insertions(+), 5 deletions(-)
arch/arm64/boot/dts/nvidia/tegra264-p3834.dtsi +0 -0
index 06795c82427a..375d122b92fa 100644

arch/arm64/boot/dts/nvidia/tegra264-p3834.dtsi iommu@5000000 { · line 32

Quoted 7 lines
arch/arm64/boot/dts/nvidia/tegra264-p3834.dtsi +4 -0
@@ -26,5 +26,13 @@ iommu@5000000 {
  		iommu@6000000 {
  			status = "okay";
  		};
+
+		cmdqv@5200000 {
+			status = "okay";
+		};

This needs to be ordered in the file according to its address.

Quoted 33 lines
arch/arm64/boot/dts/nvidia/tegra264-p3834.dtsi +4 -0
+
+		cmdqv@6200000 {
+			status = "okay";
+		};
  	};
  };
arch/arm64/boot/dts/nvidia/tegra264.dtsi +3 -2
index f137565da804..d8287b95221e 100644
@@ -3361,7 +3361,7 @@ bus@8100000000 {
  			 <0x02 0x00000000 0xd0 0x00000000 0x08 0x80000000>; /* ECAM, prefetchable memory, I/O */
 
  		smmu1: iommu@5000000 {
-			compatible = "arm,smmu-v3";
+			compatible = "nvidia,tegra264-smmu", "arm,smmu-v3";
  			reg = <0x00 0x5000000 0x0 0x200000>;
  			interrupts = <GIC_SPI 12 IRQ_TYPE_EDGE_RISING>,
  				     <GIC_SPI 13 IRQ_TYPE_EDGE_RISING>;
@@ -3370,10 +3370,11 @@ smmu1: iommu@5000000 {
 
  			#iommu-cells = <1>;
  			dma-coherent;
+			nvidia,cmdqv = <&cmdqv1>;
  		};
 
  		smmu2: iommu@6000000 {
-			compatible = "arm,smmu-v3";
+			compatible = "nvidia,tegra264-smmu", "arm,smmu-v3";
  			reg = <0x00 0x6000000 0x0 0x200000>;
  			interrupts = <GIC_SPI 1 IRQ_TYPE_EDGE_RISING>,
  				     <GIC_SPI 2 IRQ_TYPE_EDGE_RISING>;

arch/arm64/boot/dts/nvidia/tegra264.dtsi smmu2: iommu@6000000 { · line 3389

Quoted 7 lines
arch/arm64/boot/dts/nvidia/tegra264.dtsi +4 -0
@@ -3382,6 +3383,23 @@ smmu2: iommu@6000000 {
 
  			#iommu-cells = <1>;
  			dma-coherent;
+			nvidia,cmdqv = <&cmdqv2>;
+		};
+
+		cmdqv1: cmdqv@5200000 {

Same here. Please order according to the address.

Quoted 39 lines
arch/arm64/boot/dts/nvidia/tegra264.dtsi +16 -2
+			compatible = "nvidia,tegra264-cmdqv";
+			status = "disabled";
+
+			reg = <0x00 0x5200000 0x0 0x830000>;
+			interrupts = <GIC_SPI 19 IRQ_TYPE_LEVEL_HIGH>;
+		};
+
+		cmdqv2: cmdqv@6200000 {
+			compatible = "nvidia,tegra264-cmdqv";
+			status = "disabled";
+
+			reg = <0x00 0x6200000 0x0 0x830000>;
+			interrupts = <GIC_SPI 8 IRQ_TYPE_LEVEL_HIGH>;
  		};
 
  		mc: memory-controller@8020000 {
@@ -3437,7 +3455,7 @@ emc: external-memory-controller@8800000 {
  		};
 
  		smmu0: iommu@a000000 {
-			compatible = "arm,smmu-v3";
+			compatible = "nvidia,tegra264-smmu", "arm,smmu-v3";
  			reg = <0x00 0xa000000 0x0 0x200000>;
  			interrupts = <GIC_SPI 21 IRQ_TYPE_EDGE_RISING>,
  				     <GIC_SPI 22 IRQ_TYPE_EDGE_RISING>;
@@ -3446,10 +3464,11 @@ smmu0: iommu@a000000 {
 
  			#iommu-cells = <1>;
  			dma-coherent;
+			nvidia,cmdqv = <&cmdqv0>;
  		};
 
  		smmu4: iommu@b000000 {
-			compatible = "arm,smmu-v3";
+			compatible = "nvidia,tegra264-smmu", "arm,smmu-v3";
  			reg = <0x00 0xb000000 0x0 0x200000>;
  			interrupts = <GIC_SPI 30 IRQ_TYPE_EDGE_RISING>,
  				     <GIC_SPI 31 IRQ_TYPE_EDGE_RISING>;

arch/arm64/boot/dts/nvidia/tegra264.dtsi smmu4: iommu@b000000 { · line 3483

Quoted 7 lines
arch/arm64/boot/dts/nvidia/tegra264.dtsi +4 -0
@@ -3458,6 +3477,23 @@ smmu4: iommu@b000000 {
 
  			#iommu-cells = <1>;
  			dma-coherent;
+			nvidia,cmdqv = <&cmdqv4>;
+		};
+
+		cmdqv0: cmdqv@a200000 {

And here.

Quoted 41 lines
arch/arm64/boot/dts/nvidia/tegra264.dtsi +23 -1
+			compatible = "nvidia,tegra264-cmdqv";
+			status = "disabled";
+
+			reg = <0x00 0xa200000 0x0 0x830000>;
+			interrupts = <GIC_SPI 28 IRQ_TYPE_LEVEL_HIGH>;
+		};
+
+		cmdqv4: cmdqv@b200000 {
+			compatible = "nvidia,tegra264-cmdqv";
+			status = "disabled";
+
+			reg = <0x00 0xb200000 0x0 0x830000>;
+			interrupts = <GIC_SPI 37 IRQ_TYPE_LEVEL_HIGH>;
  		};
 
  		i2c14: i2c@c410000 {
@@ -3690,7 +3726,7 @@ bus@8800000000 {
  		ranges = <0x00 0x00000000 0x88 0x00000000 0x01 0x00000000>;
 
  		smmu3: iommu@6000000 {
-			compatible = "arm,smmu-v3";
+			compatible = "nvidia,tegra264-smmu", "arm,smmu-v3";
  			reg = <0x00 0x6000000 0x0 0x200000>;
  			interrupts = <GIC_SPI 225 IRQ_TYPE_EDGE_RISING>,
  				     <GIC_SPI 226 IRQ_TYPE_EDGE_RISING>;
@@ -3699,6 +3735,15 @@ smmu3: iommu@6000000 {
 
  			#iommu-cells = <1>;
  			dma-coherent;
+			nvidia,cmdqv = <&cmdqv3>;
+		};
+
+		cmdqv3: cmdqv@6200000 {
+			compatible = "nvidia,tegra264-cmdqv";
+			status = "disabled";
+
+			reg = <0x00 0x6200000 0x0 0x830000>;
+			interrupts = <GIC_SPI 232 IRQ_TYPE_LEVEL_HIGH>;
  		};
 
  		hda@90b0000 {
Signature · 1 line
nvpublic
#7 lore raw

Re: [PATCH V2 3/3] arm64: dts: nvidia: Add nodes for CMDQV

Quoted 19 lines · Jon Hunter
Quoted 16 lines · Ashish Mhetre

The Command Queue Virtualization (CMDQV) hardware is part of the SMMUv3 implementation on NVIDIA Tegra SoCs. It assists in virtualizing the command queue for the SMMU.

Update SMMU compatible strings to use nvidia,tegra264-smmu to enable CMDQV support. Add device tree nodes for the CMDQV hardware and enable them on the tegra264-p3834 platform where SMMUs are enabled. Each SMMU instance is paired with its corresponding CMDQV instance via the nvidia,cmdqv property.

---
  .../arm64/boot/dts/nvidia/tegra264-p3834.dtsi |  8 +++ arch/arm64/boot/dts/nvidia/tegra264.dtsi      | 55 +++++++++++++++++--

  2 files changed, 58 insertions(+), 5 deletions(-)
Quoted 14 lines

arch/arm64/boot/dts/nvidia/tegra264-p3834.dtsi iommu@5000000 { · line 32

Quoted 12 lines
arch/arm64/boot/dts/nvidia/tegra264-p3834.dtsi +4 -0
index 06795c82427a..375d122b92fa 100644
@@ -26,5 +26,13 @@ iommu@5000000 {
           iommu@6000000 {
               status = "okay";
           };
+
+        cmdqv@5200000 {
+            status = "okay";
+        };

This needs to be ordered in the file according to its address.

Hi Jon, Thanks for the review.
cmdqv nodes follow same ordering as its corresponding iommu nodes. I have added them immediately after corresponding iommu nodes. Can you please check and see if it's fine? Same applies to your similar comments below as well.

Quoted 122 lines
Quoted 31 lines
arch/arm64/boot/dts/nvidia/tegra264-p3834.dtsi +4 -0
+
+        cmdqv@6200000 {
+            status = "okay";
+        };
       };
   };
arch/arm64/boot/dts/nvidia/tegra264.dtsi +0 -0
index f137565da804..d8287b95221e 100644
@@ -3361,7 +3361,7 @@ bus@8100000000 {

               <0x02 0x00000000 0xd0 0x00000000 0x08 0x80000000>; /* ECAM, prefetchable memory, I/O */
            smmu1: iommu@5000000 {
-            compatible = "arm,smmu-v3";
+            compatible = "nvidia,tegra264-smmu", "arm,smmu-v3";
              reg = <0x00 0x5000000 0x0 0x200000>;
              interrupts = <GIC_SPI 12 IRQ_TYPE_EDGE_RISING>,
                       <GIC_SPI 13 IRQ_TYPE_EDGE_RISING>;

arch/arm64/boot/dts/nvidia/tegra264.dtsi +2 -1
@@ -3370,10 +3370,11 @@ smmu1: iommu@5000000 {
                 #iommu-cells = <1>;
               dma-coherent;
+            nvidia,cmdqv = <&cmdqv1>;
           };
             smmu2: iommu@6000000 {
-            compatible = "arm,smmu-v3";
+            compatible = "nvidia,tegra264-smmu", "arm,smmu-v3";
               reg = <0x00 0x6000000 0x0 0x200000>;
               interrupts = <GIC_SPI 1 IRQ_TYPE_EDGE_RISING>,
                        <GIC_SPI 2 IRQ_TYPE_EDGE_RISING>;

arch/arm64/boot/dts/nvidia/tegra264.dtsi smmu2: iommu@6000000 { · line 3388

Quoted 6 lines
arch/arm64/boot/dts/nvidia/tegra264.dtsi +4 -0
@@ -3382,6 +3383,23 @@ smmu2: iommu@6000000 {
                 #iommu-cells = <1>;
               dma-coherent;
+            nvidia,cmdqv = <&cmdqv2>;
+        };
+
+        cmdqv1: cmdqv@5200000 {

Same here. Please order according to the address.

Quoted 35 lines
arch/arm64/boot/dts/nvidia/tegra264.dtsi +16 -2
+            compatible = "nvidia,tegra264-cmdqv";
+            status = "disabled";
+
+            reg = <0x00 0x5200000 0x0 0x830000>;
+            interrupts = <GIC_SPI 19 IRQ_TYPE_LEVEL_HIGH>;
+        };
+
+        cmdqv2: cmdqv@6200000 {
+            compatible = "nvidia,tegra264-cmdqv";
+            status = "disabled";
+
+            reg = <0x00 0x6200000 0x0 0x830000>;
+            interrupts = <GIC_SPI 8 IRQ_TYPE_LEVEL_HIGH>;
           };
             mc: memory-controller@8020000 {
@@ -3437,7 +3455,7 @@ emc: external-memory-controller@8800000 {
           };
             smmu0: iommu@a000000 {
-            compatible = "arm,smmu-v3";
+            compatible = "nvidia,tegra264-smmu", "arm,smmu-v3";
               reg = <0x00 0xa000000 0x0 0x200000>;
               interrupts = <GIC_SPI 21 IRQ_TYPE_EDGE_RISING>,
                        <GIC_SPI 22 IRQ_TYPE_EDGE_RISING>;
@@ -3446,10 +3464,11 @@ smmu0: iommu@a000000 {
                 #iommu-cells = <1>;
               dma-coherent;
+            nvidia,cmdqv = <&cmdqv0>;
           };
             smmu4: iommu@b000000 {
-            compatible = "arm,smmu-v3";
+            compatible = "nvidia,tegra264-smmu", "arm,smmu-v3";
               reg = <0x00 0xb000000 0x0 0x200000>;
               interrupts = <GIC_SPI 30 IRQ_TYPE_EDGE_RISING>,
                        <GIC_SPI 31 IRQ_TYPE_EDGE_RISING>;

arch/arm64/boot/dts/nvidia/tegra264.dtsi smmu4: iommu@b000000 { · line 3482

Quoted 6 lines
arch/arm64/boot/dts/nvidia/tegra264.dtsi +4 -0
@@ -3458,6 +3477,23 @@ smmu4: iommu@b000000 {
                 #iommu-cells = <1>;
               dma-coherent;
+            nvidia,cmdqv = <&cmdqv4>;
+        };
+
+        cmdqv0: cmdqv@a200000 {

And here.

Quoted 37 lines
arch/arm64/boot/dts/nvidia/tegra264.dtsi +23 -1
+            compatible = "nvidia,tegra264-cmdqv";
+            status = "disabled";
+
+            reg = <0x00 0xa200000 0x0 0x830000>;
+            interrupts = <GIC_SPI 28 IRQ_TYPE_LEVEL_HIGH>;
+        };
+
+        cmdqv4: cmdqv@b200000 {
+            compatible = "nvidia,tegra264-cmdqv";
+            status = "disabled";
+
+            reg = <0x00 0xb200000 0x0 0x830000>;
+            interrupts = <GIC_SPI 37 IRQ_TYPE_LEVEL_HIGH>;
           };
             i2c14: i2c@c410000 {
@@ -3690,7 +3726,7 @@ bus@8800000000 {
           ranges = <0x00 0x00000000 0x88 0x00000000 0x01 0x00000000>;
             smmu3: iommu@6000000 {
-            compatible = "arm,smmu-v3";
+            compatible = "nvidia,tegra264-smmu", "arm,smmu-v3";
               reg = <0x00 0x6000000 0x0 0x200000>;
               interrupts = <GIC_SPI 225 IRQ_TYPE_EDGE_RISING>,
                        <GIC_SPI 226 IRQ_TYPE_EDGE_RISING>;
@@ -3699,6 +3735,15 @@ smmu3: iommu@6000000 {
                 #iommu-cells = <1>;
               dma-coherent;
+            nvidia,cmdqv = <&cmdqv3>;
+        };
+
+        cmdqv3: cmdqv@6200000 {
+            compatible = "nvidia,tegra264-cmdqv";
+            status = "disabled";
+
+            reg = <0x00 0x6200000 0x0 0x830000>;
+            interrupts = <GIC_SPI 232 IRQ_TYPE_LEVEL_HIGH>;
           };
             hda@90b0000 {
#8 lore raw

Re: [PATCH V2 3/3] arm64: dts: nvidia: Add nodes for CMDQV

Quoted 37 lines · Ashish Mhetre
Quoted 19 lines · Jon Hunter
Quoted 16 lines · Ashish Mhetre

The Command Queue Virtualization (CMDQV) hardware is part of the SMMUv3 implementation on NVIDIA Tegra SoCs. It assists in virtualizing the command queue for the SMMU.

Update SMMU compatible strings to use nvidia,tegra264-smmu to enable CMDQV support. Add device tree nodes for the CMDQV hardware and enable them on the tegra264-p3834 platform where SMMUs are enabled. Each SMMU instance is paired with its corresponding CMDQV instance via the nvidia,cmdqv property.

---
  .../arm64/boot/dts/nvidia/tegra264-p3834.dtsi |  8 +++ arch/arm64/boot/dts/nvidia/tegra264.dtsi      | 55 +++++++++++++++++--

  2 files changed, 58 insertions(+), 5 deletions(-)
Quoted 15 lines

arch/arm64/boot/dts/nvidia/tegra264-p3834.dtsi iommu@5000000 { · line 32

Quoted 13 lines
arch/arm64/boot/dts/nvidia/tegra264-p3834.dtsi +4 -0
index 06795c82427a..375d122b92fa 100644
@@ -26,5 +26,13 @@ iommu@5000000 {
           iommu@6000000 {
               status = "okay";
           };
+
+        cmdqv@5200000 {
+            status = "okay";
+        };

This needs to be ordered in the file according to its address.

Quoted 3 lines

Hi Jon, Thanks for the review.
cmdqv nodes follow same ordering as its corresponding iommu nodes. I have added them immediately after corresponding iommu nodes.

No, you didn't. It seems like you sorted by type and then address. But we always sort by address first. Type doesn't matter.

This node belongs above the iommu@6000000 node and after iommu@5000000. The same ordering should be respected in the DTS include.

Thierry

#9 lore raw

Re: [PATCH V2 3/3] arm64: dts: nvidia: Add nodes for CMDQV

Quoted 37 lines · Thierry Reding
Quoted 33 lines · Ashish Mhetre
Quoted 18 lines · Jon Hunter
Quoted 16 lines · Ashish Mhetre

The Command Queue Virtualization (CMDQV) hardware is part of the SMMUv3 implementation on NVIDIA Tegra SoCs. It assists in virtualizing the command queue for the SMMU.

Update SMMU compatible strings to use nvidia,tegra264-smmu to enable CMDQV support. Add device tree nodes for the CMDQV hardware and enable them on the tegra264-p3834 platform where SMMUs are enabled. Each SMMU instance is paired with its corresponding CMDQV instance via the nvidia,cmdqv property.

---
   .../arm64/boot/dts/nvidia/tegra264-p3834.dtsi |  8 +++
   arch/arm64/boot/dts/nvidia/tegra264.dtsi      | 55 +++++++++++++++++--
   2 files changed, 58 insertions(+), 5 deletions(-)
Quoted 14 lines

arch/arm64/boot/dts/nvidia/tegra264-p3834.dtsi iommu@5000000 { · line 32

Quoted 13 lines
arch/arm64/boot/dts/nvidia/tegra264-p3834.dtsi +4 -0
index 06795c82427a..375d122b92fa 100644
@@ -26,5 +26,13 @@ iommu@5000000 {
           iommu@6000000 {
               status = "okay";
           };
+
+        cmdqv@5200000 {
+            status = "okay";
+        };

This needs to be ordered in the file according to its address.

Quoted 3 lines

Hi Jon, Thanks for the review.
cmdqv nodes follow same ordering as its corresponding iommu nodes. I have added them immediately after corresponding iommu nodes.

Quoted 7 lines

No, you didn't. It seems like you sorted by type and then address. But we always sort by address first. Type doesn't matter.

This node belongs above the iommu@6000000 node and after iommu@5000000. The same ordering should be respected in the DTS include.

Thierry

Oh, I got it. Thanks for clarification. I'll make these changes in v3.

reviewer
#10 lore raw

Re: [PATCH V2 3/3] arm64: dts: nvidia: Add nodes for CMDQV

In reply to Ashish Mhetre
Quoted 36 lines · Ashish Mhetre
Quoted 19 lines · Jon Hunter
Quoted 16 lines · Ashish Mhetre

The Command Queue Virtualization (CMDQV) hardware is part of the SMMUv3 implementation on NVIDIA Tegra SoCs. It assists in virtualizing the command queue for the SMMU.

Update SMMU compatible strings to use nvidia,tegra264-smmu to enable CMDQV support. Add device tree nodes for the CMDQV hardware and enable them on the tegra264-p3834 platform where SMMUs are enabled. Each SMMU instance is paired with its corresponding CMDQV instance via the nvidia,cmdqv property.

---
  .../arm64/boot/dts/nvidia/tegra264-p3834.dtsi |  8 +++ arch/arm64/boot/dts/nvidia/tegra264.dtsi      | 55 +++++++++++++++++--

  2 files changed, 58 insertions(+), 5 deletions(-)
Quoted 14 lines

arch/arm64/boot/dts/nvidia/tegra264-p3834.dtsi iommu@5000000 { · line 32

Quoted 12 lines
arch/arm64/boot/dts/nvidia/tegra264-p3834.dtsi +4 -0
index 06795c82427a..375d122b92fa 100644
@@ -26,5 +26,13 @@ iommu@5000000 {
           iommu@6000000 {
               status = "okay";
           };
+
+        cmdqv@5200000 {
+            status = "okay";
+        };

This needs to be ordered in the file according to its address.

Quoted 5 lines

Hi Jon, Thanks for the review.
cmdqv nodes follow same ordering as its corresponding iommu nodes. I have added them immediately after corresponding iommu nodes. Can you please check and see if it's fine? Same applies to your similar comments below as well.

It's fairly standard practice to order DT nodes by unit address where applicable (and alphabetically by node name otherwise). The platform maintainers aren't necessarily familiar with the intended usage of every individual node when they have to resolve merge conflicts etc., so maintaining a straightforward consistent pattern is generally easier for everyone.

Thanks,
Robin.