iommu/arm-smmu-qcom: do not register driver in probe()

PATCH Applied Danilo Krummrich 9 participants 13 messages Jan 21 – Jan 22

Subsystems (5)

Arm Qualcomm mailing list Driver core IOMMU Arm SMMU drivers +1 more subsystems

lore

Share & tools

lore

Danilo Krummrich

author maintainer

2026-01-21 14:12 UTC #0 lore raw

PATCH 1/1 iommu/arm-smmu-qcom: do not register driver in probe()

Commit 0b4eeee2876f ("iommu/arm-smmu-qcom: Register the TBU driver in qcom_smmu_impl_init") intended to also probe the TBU driver when CONFIG_ARM_SMMU_QCOM_DEBUG is disabled, but also moved the corresponding platform_driver_register() call into qcom_smmu_impl_init() which is called from arm_smmu_device_probe().

However, it neither makes sense to register drivers from probe() callbacks of other drivers, nor does the driver core allow registering drivers with a device lock already being held.

The latter was revealed by commit dc23806a7c47 ("driver core: enforce device_lock for driver_match_device()") leading to a deadlock condition described in [1].

Additionally, it was noted by Robin that the current approach is potentially racy with async probe [2].

Hence, fix this by registering the qcom_smmu_tbu_driver from module_init(). Unfortunately, due to the vendoring of the driver, this requires an indirection through arm-smmu-impl.c.

Reported-by Mark Brown <[email protected]>

Closes https://lore.kernel.org/lkml/[email protected]/ open here

Link https://lore.kernel.org/lkml/[email protected]/ [1] open here

Link https://lore.kernel.org/lkml/[email protected]/ [2] open here

Fixes dc23806a7c47 ("driver core: enforce device_lock for driver_match_device()")

Fixes 0b4eeee2876f ("iommu/arm-smmu-qcom: Register the TBU driver in qcom_smmu_impl_init")

Signed-off-by Danilo Krummrich <[email protected]>

---
 drivers/iommu/arm/arm-smmu/arm-smmu-impl.c | 14 +++++++++++++
 drivers/iommu/arm/arm-smmu/arm-smmu-qcom.c | 14 +++++++++----
 drivers/iommu/arm/arm-smmu/arm-smmu.c      | 24 +++++++++++++++++++++-
 drivers/iommu/arm/arm-smmu/arm-smmu.h      |  5 +++++
 4 files changed, 52 insertions(+), 5 deletions(-)

drivers/iommu/arm/arm-smmu/arm-smmu-impl.c +14 -0

index db9b9a8e139c..4565a58bb213 100644
@@ -228,3 +228,17 @@ struct arm_smmu_device *arm_smmu_impl_init(struct arm_smmu_device *smmu)
 
 	return smmu;
 }
+
+int __init arm_smmu_impl_module_init(void)
+{
+	if (IS_ENABLED(CONFIG_ARM_SMMU_QCOM))
+		return qcom_smmu_module_init();
+
+	return 0;
+}
+
+void __exit arm_smmu_impl_module_exit(void)
+{
+	if (IS_ENABLED(CONFIG_ARM_SMMU_QCOM))
+		qcom_smmu_module_exit();
+}

drivers/iommu/arm/arm-smmu/arm-smmu-qcom.c +10 -4

index 573085349df3..22906d2c9a2d 100644
@@ -774,10 +774,6 @@ struct arm_smmu_device *qcom_smmu_impl_init(struct arm_smmu_device *smmu)
 {
 	const struct device_node *np = smmu->dev->of_node;
 	const struct of_device_id *match;
-	static u8 tbu_registered;
-
-	if (!tbu_registered++)
-		platform_driver_register(&qcom_smmu_tbu_driver);
 
 #ifdef CONFIG_ACPI
 	if (np == NULL) {

@@ -802,3 +798,13 @@ struct arm_smmu_device *qcom_smmu_impl_init(struct arm_smmu_device *smmu)
 
 	return smmu;
 }
+
+int __init qcom_smmu_module_init(void)
+{
+	return platform_driver_register(&qcom_smmu_tbu_driver);
+}
+
+void __exit qcom_smmu_module_exit(void)
+{
+	platform_driver_unregister(&qcom_smmu_tbu_driver);
+}

drivers/iommu/arm/arm-smmu/arm-smmu.c +23 -1

index 5e690cf85ec9..1e218fbea35a 100644
@@ -2365,7 +2365,29 @@ static struct platform_driver arm_smmu_driver = {
 	.remove = arm_smmu_device_remove,
 	.shutdown = arm_smmu_device_shutdown,
 };
-module_platform_driver(arm_smmu_driver);
+
+static int __init arm_smmu_init(void)
+{
+	int ret;
+
+	ret = platform_driver_register(&arm_smmu_driver);
+	if (ret)
+		return ret;
+
+	ret = arm_smmu_impl_module_init();
+	if (ret)
+		platform_driver_unregister(&arm_smmu_driver);
+
+	return ret;
+}
+module_init(arm_smmu_init);
+
+static void __exit arm_smmu_exit(void)
+{
+	arm_smmu_impl_module_exit();
+	platform_driver_unregister(&arm_smmu_driver);
+}
+module_exit(arm_smmu_exit);
 
 MODULE_DESCRIPTION("IOMMU API for ARM architected SMMU implementations");
 MODULE_AUTHOR("Will Deacon <[email protected]>");

drivers/iommu/arm/arm-smmu/arm-smmu.h +5 -0

index 2dbf3243b5ad..26d2e33cd328 100644
@@ -540,6 +540,11 @@ 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 __init arm_smmu_impl_module_init(void);
+void __exit arm_smmu_impl_module_exit(void);
+int __init qcom_smmu_module_init(void);
+void __exit qcom_smmu_module_exit(void);
+
 void arm_smmu_write_context_bank(struct arm_smmu_device *smmu, int idx);
 int arm_mmu500_reset(struct arm_smmu_device *smmu);

base-commit: dc23806a7c47ec5f1293aba407fb69519f976ee0

Signature · 1 line

2.52.0

Greg KH

maintainer Reviewed-by on v1 1/1

2026-01-21 14:46 UTC #1 lore raw

Quoted 21 lines · Danilo Krummrich

Commit 0b4eeee2876f ("iommu/arm-smmu-qcom: Register the TBU driver in qcom_smmu_impl_init") intended to also probe the TBU driver when CONFIG_ARM_SMMU_QCOM_DEBUG is disabled, but also moved the corresponding platform_driver_register() call into qcom_smmu_impl_init() which is called from arm_smmu_device_probe().
However, it neither makes sense to register drivers from probe() callbacks of other drivers, nor does the driver core allow registering drivers with a device lock already being held.
The latter was revealed by commit dc23806a7c47 ("driver core: enforce device_lock for driver_match_device()") leading to a deadlock condition described in [1].
Additionally, it was noted by Robin that the current approach is potentially racy with async probe [2].
Hence, fix this by registering the qcom_smmu_tbu_driver from module_init(). Unfortunately, due to the vendoring of the driver, this requires an indirection through arm-smmu-impl.c.

Quoted 7 lines

Reported-by Mark Brown <[email protected]>
Closes https://lore.kernel.org/lkml/[email protected]/ open here
Link https://lore.kernel.org/lkml/[email protected]/ [1] open here
Link https://lore.kernel.org/lkml/[email protected]/ [2] open here
Fixes dc23806a7c47 ("driver core: enforce device_lock for driver_match_device()")
Fixes 0b4eeee2876f ("iommu/arm-smmu-qcom: Register the TBU driver in qcom_smmu_impl_init")
Signed-off-by Danilo Krummrich <[email protected]>

Reviewed-by Greg Kroah-Hartman <[email protected]>

Robin Murphy

reviewer Acked-by on v1 1/1

2026-01-21 15:11 UTC #2 lore raw

In reply to Danilo Krummrich

Quoted 10 lines · Danilo Krummrich

Commit 0b4eeee2876f ("iommu/arm-smmu-qcom: Register the TBU driver in qcom_smmu_impl_init") intended to also probe the TBU driver when CONFIG_ARM_SMMU_QCOM_DEBUG is disabled, but also moved the corresponding platform_driver_register() call into qcom_smmu_impl_init() which is called from arm_smmu_device_probe().
However, it neither makes sense to register drivers from probe() callbacks of other drivers, nor does the driver core allow registering drivers with a device lock already being held.

Quoted 6 lines

The latter was revealed by commit dc23806a7c47 ("driver core: enforce device_lock for driver_match_device()") leading to a deadlock condition described in [1].
Additionally, it was noted by Robin that the current approach is potentially racy with async probe [2].

On third look, the current lack of unregister, when it can end up in a module which (theoretically) supports unloading, is also sketchy :)

Quoted 11 lines

Hence, fix this by registering the qcom_smmu_tbu_driver from module_init(). Unfortunately, due to the vendoring of the driver, this requires an indirection through arm-smmu-impl.c.
Reported-by Mark Brown <[email protected]>
Closes https://lore.kernel.org/lkml/[email protected]/ open here
Link https://lore.kernel.org/lkml/[email protected]/ [1] open here
Link https://lore.kernel.org/lkml/[email protected]/ [2] open here
Fixes dc23806a7c47 ("driver core: enforce device_lock for driver_match_device()")
Fixes 0b4eeee2876f ("iommu/arm-smmu-qcom: Register the TBU driver in qcom_smmu_impl_init")
Signed-off-by Danilo Krummrich <[email protected]>

Looks OK to me, thanks Danilo!

Acked-by Robin Murphy <[email protected]>

Bjorn Andersson

Tested-by Reviewed-by on v1 1/1

2026-01-21 15:54 UTC #3 lore raw

In reply to Danilo Krummrich

Quoted 21 lines · Danilo Krummrich

Commit 0b4eeee2876f ("iommu/arm-smmu-qcom: Register the TBU driver in qcom_smmu_impl_init") intended to also probe the TBU driver when CONFIG_ARM_SMMU_QCOM_DEBUG is disabled, but also moved the corresponding platform_driver_register() call into qcom_smmu_impl_init() which is called from arm_smmu_device_probe().
However, it neither makes sense to register drivers from probe() callbacks of other drivers, nor does the driver core allow registering drivers with a device lock already being held.
The latter was revealed by commit dc23806a7c47 ("driver core: enforce device_lock for driver_match_device()") leading to a deadlock condition described in [1].
Additionally, it was noted by Robin that the current approach is potentially racy with async probe [2].
Hence, fix this by registering the qcom_smmu_tbu_driver from module_init(). Unfortunately, due to the vendoring of the driver, this requires an indirection through arm-smmu-impl.c.

Quoted 7 lines

Reported-by Mark Brown <[email protected]>
Closes https://lore.kernel.org/lkml/[email protected]/ open here
Link https://lore.kernel.org/lkml/[email protected]/ [1] open here
Link https://lore.kernel.org/lkml/[email protected]/ [2] open here
Fixes dc23806a7c47 ("driver core: enforce device_lock for driver_match_device()")
Fixes 0b4eeee2876f ("iommu/arm-smmu-qcom: Register the TBU driver in qcom_smmu_impl_init")
Signed-off-by Danilo Krummrich <[email protected]>

Thank you Danilo.

Tested-by Bjorn Andersson <[email protected]>

Reviewed-by Bjorn Andersson <[email protected]>

Regards,
Bjorn

Quoted 115 lines

---
 drivers/iommu/arm/arm-smmu/arm-smmu-impl.c | 14 +++++++++++++
 drivers/iommu/arm/arm-smmu/arm-smmu-qcom.c | 14 +++++++++----
 drivers/iommu/arm/arm-smmu/arm-smmu.c      | 24 +++++++++++++++++++++-
 drivers/iommu/arm/arm-smmu/arm-smmu.h      |  5 +++++
 4 files changed, 52 insertions(+), 5 deletions(-)

drivers/iommu/arm/arm-smmu/arm-smmu-impl.c +14 -0

index db9b9a8e139c..4565a58bb213 100644
@@ -228,3 +228,17 @@ struct arm_smmu_device *arm_smmu_impl_init(struct arm_smmu_device *smmu)
 
 	return smmu;
 }
+
+int __init arm_smmu_impl_module_init(void)
+{
+	if (IS_ENABLED(CONFIG_ARM_SMMU_QCOM))
+		return qcom_smmu_module_init();
+
+	return 0;
+}
+
+void __exit arm_smmu_impl_module_exit(void)
+{
+	if (IS_ENABLED(CONFIG_ARM_SMMU_QCOM))
+		qcom_smmu_module_exit();
+}

drivers/iommu/arm/arm-smmu/arm-smmu-qcom.c +10 -4

index 573085349df3..22906d2c9a2d 100644
@@ -774,10 +774,6 @@ struct arm_smmu_device *qcom_smmu_impl_init(struct arm_smmu_device *smmu)
 {
 	const struct device_node *np = smmu->dev->of_node;
 	const struct of_device_id *match;
-	static u8 tbu_registered;
-
-	if (!tbu_registered++)
-		platform_driver_register(&qcom_smmu_tbu_driver);
 
 #ifdef CONFIG_ACPI
 	if (np == NULL) {

@@ -802,3 +798,13 @@ struct arm_smmu_device *qcom_smmu_impl_init(struct arm_smmu_device *smmu)
 
 	return smmu;
 }
+
+int __init qcom_smmu_module_init(void)
+{
+	return platform_driver_register(&qcom_smmu_tbu_driver);
+}
+
+void __exit qcom_smmu_module_exit(void)
+{
+	platform_driver_unregister(&qcom_smmu_tbu_driver);
+}

drivers/iommu/arm/arm-smmu/arm-smmu.c +23 -1

index 5e690cf85ec9..1e218fbea35a 100644
@@ -2365,7 +2365,29 @@ static struct platform_driver arm_smmu_driver = {
 	.remove = arm_smmu_device_remove,
 	.shutdown = arm_smmu_device_shutdown,
 };
-module_platform_driver(arm_smmu_driver);
+
+static int __init arm_smmu_init(void)
+{
+	int ret;
+
+	ret = platform_driver_register(&arm_smmu_driver);
+	if (ret)
+		return ret;
+
+	ret = arm_smmu_impl_module_init();
+	if (ret)
+		platform_driver_unregister(&arm_smmu_driver);
+
+	return ret;
+}
+module_init(arm_smmu_init);
+
+static void __exit arm_smmu_exit(void)
+{
+	arm_smmu_impl_module_exit();
+	platform_driver_unregister(&arm_smmu_driver);
+}
+module_exit(arm_smmu_exit);
 
 MODULE_DESCRIPTION("IOMMU API for ARM architected SMMU implementations");
 MODULE_AUTHOR("Will Deacon <[email protected]>");

drivers/iommu/arm/arm-smmu/arm-smmu.h +5 -0

index 2dbf3243b5ad..26d2e33cd328 100644
@@ -540,6 +540,11 @@ 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 __init arm_smmu_impl_module_init(void);
+void __exit arm_smmu_impl_module_exit(void);
+int __init qcom_smmu_module_init(void);
+void __exit qcom_smmu_module_exit(void);
+
 void arm_smmu_write_context_bank(struct arm_smmu_device *smmu, int idx);
 int arm_mmu500_reset(struct arm_smmu_device *smmu);

base-commit: dc23806a7c47ec5f1293aba407fb69519f976ee0

Signature · 1 line

2.52.0

Konrad Dybcio

Acked-by on v1 1/1

2026-01-21 16:02 UTC #4 lore raw

In reply to Danilo Krummrich

Quoted 21 lines · Danilo Krummrich

Commit 0b4eeee2876f ("iommu/arm-smmu-qcom: Register the TBU driver in qcom_smmu_impl_init") intended to also probe the TBU driver when CONFIG_ARM_SMMU_QCOM_DEBUG is disabled, but also moved the corresponding platform_driver_register() call into qcom_smmu_impl_init() which is called from arm_smmu_device_probe().
However, it neither makes sense to register drivers from probe() callbacks of other drivers, nor does the driver core allow registering drivers with a device lock already being held.
The latter was revealed by commit dc23806a7c47 ("driver core: enforce device_lock for driver_match_device()") leading to a deadlock condition described in [1].
Additionally, it was noted by Robin that the current approach is potentially racy with async probe [2].
Hence, fix this by registering the qcom_smmu_tbu_driver from module_init(). Unfortunately, due to the vendoring of the driver, this requires an indirection through arm-smmu-impl.c.

Quoted 8 lines

Reported-by Mark Brown <[email protected]>
Closes https://lore.kernel.org/lkml/[email protected]/ open here
Link https://lore.kernel.org/lkml/[email protected]/ [1] open here
Link https://lore.kernel.org/lkml/[email protected]/ [2] open here
Fixes dc23806a7c47 ("driver core: enforce device_lock for driver_match_device()")
Fixes 0b4eeee2876f ("iommu/arm-smmu-qcom: Register the TBU driver in qcom_smmu_impl_init")
Signed-off-by Danilo Krummrich <[email protected]>
---

Acked-by Konrad Dybcio <[email protected]>

Konrad

Mark Brown

Tested-by on v1 1/1

2026-01-21 16:05 UTC #5 lore raw

In reply to Danilo Krummrich

Quoted 5 lines · Danilo Krummrich

Commit 0b4eeee2876f ("iommu/arm-smmu-qcom: Register the TBU driver in qcom_smmu_impl_init") intended to also probe the TBU driver when CONFIG_ARM_SMMU_QCOM_DEBUG is disabled, but also moved the corresponding platform_driver_register() call into qcom_smmu_impl_init() which is called from arm_smmu_device_probe().

This fixes the boot lockup on Juno for me:

Tested-by Mark Brown <[email protected]>

Wang Jiayue

Tested-by Reviewed-by on v1 1/1

2026-01-22 03:04 UTC #6 lore raw

In reply to Danilo Krummrich

Quoted 22 lines · Danilo Krummrich

Commit 0b4eeee2876f ("iommu/arm-smmu-qcom: Register the TBU driver in qcom_smmu_impl_init") intended to also probe the TBU driver when CONFIG_ARM_SMMU_QCOM_DEBUG is disabled, but also moved the corresponding platform_driver_register() call into qcom_smmu_impl_init() which is called from arm_smmu_device_probe().
However, it neither makes sense to register drivers from probe() callbacks of other drivers, nor does the driver core allow registering drivers with a device lock already being held.
The latter was revealed by commit dc23806a7c47 ("driver core: enforce device_lock for driver_match_device()") leading to a deadlock condition described in [1].
Additionally, it was noted by Robin that the current approach is potentially racy with async probe [2].
Hence, fix this by registering the qcom_smmu_tbu_driver from module_init(). Unfortunately, due to the vendoring of the driver, this requires an indirection through arm-smmu-impl.c.

Quoted 6 lines

Reported-by Mark Brown <[email protected]>
Closes https://lore.kernel.org/lkml/[email protected]/ open here
Link https://lore.kernel.org/lkml/[email protected]/ [1] open here
Link https://lore.kernel.org/lkml/[email protected]/ [2] open here
Fixes dc23806a7c47 ("driver core: enforce device_lock for driver_match_device()")
Fixes 0b4eeee2876f ("iommu/arm-smmu-qcom: Register the TBU driver in qcom_smmu_impl_init")

Glad the backtrace helped identify the root cause.

I applied this patch to the qemu setup where I successfully reproduced the boot hang earlier, and the deadlock is resolved.

Tested-by Wang Jiayue <[email protected]>

Reviewed-by Wang Jiayue <[email protected]>

Quoted 115 lines

Signed-off-by Danilo Krummrich <[email protected]>

---
 drivers/iommu/arm/arm-smmu/arm-smmu-impl.c | 14 +++++++++++++
 drivers/iommu/arm/arm-smmu/arm-smmu-qcom.c | 14 +++++++++----
 drivers/iommu/arm/arm-smmu/arm-smmu.c      | 24 +++++++++++++++++++++-
 drivers/iommu/arm/arm-smmu/arm-smmu.h      |  5 +++++
 4 files changed, 52 insertions(+), 5 deletions(-)

drivers/iommu/arm/arm-smmu/arm-smmu-impl.c +14 -0

index db9b9a8e139c..4565a58bb213 100644
@@ -228,3 +228,17 @@ struct arm_smmu_device *arm_smmu_impl_init(struct arm_smmu_device *smmu)
 
        return smmu;
 }
+
+int __init arm_smmu_impl_module_init(void)
+{
+       if (IS_ENABLED(CONFIG_ARM_SMMU_QCOM))
+               return qcom_smmu_module_init();
+
+       return 0;
+}
+
+void __exit arm_smmu_impl_module_exit(void)
+{
+       if (IS_ENABLED(CONFIG_ARM_SMMU_QCOM))
+               qcom_smmu_module_exit();
+}

drivers/iommu/arm/arm-smmu/arm-smmu-qcom.c +10 -4

index 573085349df3..22906d2c9a2d 100644
@@ -774,10 +774,6 @@ struct arm_smmu_device *qcom_smmu_impl_init(struct arm_smmu_device *smmu)
 {
        const struct device_node *np = smmu->dev->of_node;
        const struct of_device_id *match;
-       static u8 tbu_registered;
-
-       if (!tbu_registered++)
-               platform_driver_register(&qcom_smmu_tbu_driver);
 
 #ifdef CONFIG_ACPI
        if (np == NULL) {

@@ -802,3 +798,13 @@ struct arm_smmu_device *qcom_smmu_impl_init(struct arm_smmu_device *smmu)
 
        return smmu;
 }
+
+int __init qcom_smmu_module_init(void)
+{
+       return platform_driver_register(&qcom_smmu_tbu_driver);
+}
+
+void __exit qcom_smmu_module_exit(void)
+{
+       platform_driver_unregister(&qcom_smmu_tbu_driver);
+}

drivers/iommu/arm/arm-smmu/arm-smmu.c +23 -1

index 5e690cf85ec9..1e218fbea35a 100644
@@ -2365,7 +2365,29 @@ static struct platform_driver arm_smmu_driver = {
        .remove = arm_smmu_device_remove,
        .shutdown = arm_smmu_device_shutdown,
 };
-module_platform_driver(arm_smmu_driver);
+
+static int __init arm_smmu_init(void)
+{
+       int ret;
+
+       ret = platform_driver_register(&arm_smmu_driver);
+       if (ret)
+               return ret;
+
+       ret = arm_smmu_impl_module_init();
+       if (ret)
+               platform_driver_unregister(&arm_smmu_driver);
+
+       return ret;
+}
+module_init(arm_smmu_init);
+
+static void __exit arm_smmu_exit(void)
+{
+       arm_smmu_impl_module_exit();
+       platform_driver_unregister(&arm_smmu_driver);
+}
+module_exit(arm_smmu_exit);
 
 MODULE_DESCRIPTION("IOMMU API for ARM architected SMMU implementations");
 MODULE_AUTHOR("Will Deacon <[email protected]>");

drivers/iommu/arm/arm-smmu/arm-smmu.h +5 -0

index 2dbf3243b5ad..26d2e33cd328 100644
@@ -540,6 +540,11 @@ 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 __init arm_smmu_impl_module_init(void);
+void __exit arm_smmu_impl_module_exit(void);
+int __init qcom_smmu_module_init(void);
+void __exit qcom_smmu_module_exit(void);
+
 void arm_smmu_write_context_bank(struct arm_smmu_device *smmu, int idx);
 int arm_mmu500_reset(struct arm_smmu_device *smmu);

base-commit: dc23806a7c47ec5f1293aba407fb69519f976ee0 --
2.52.0

Jörg Rödel

maintainer Acked-by Joerg Roedel on v1 1/1

2026-01-22 08:18 UTC #7 lore raw

In reply to Danilo Krummrich

Quoted 21 lines · Danilo Krummrich

Commit 0b4eeee2876f ("iommu/arm-smmu-qcom: Register the TBU driver in qcom_smmu_impl_init") intended to also probe the TBU driver when CONFIG_ARM_SMMU_QCOM_DEBUG is disabled, but also moved the corresponding platform_driver_register() call into qcom_smmu_impl_init() which is called from arm_smmu_device_probe().
However, it neither makes sense to register drivers from probe() callbacks of other drivers, nor does the driver core allow registering drivers with a device lock already being held.
The latter was revealed by commit dc23806a7c47 ("driver core: enforce device_lock for driver_match_device()") leading to a deadlock condition described in [1].
Additionally, it was noted by Robin that the current approach is potentially racy with async probe [2].
Hence, fix this by registering the qcom_smmu_tbu_driver from module_init(). Unfortunately, due to the vendoring of the driver, this requires an indirection through arm-smmu-impl.c.

Quoted 7 lines

Reported-by Mark Brown <[email protected]>
Closes https://lore.kernel.org/lkml/[email protected]/ open here
Link https://lore.kernel.org/lkml/[email protected]/ [1] open here
Link https://lore.kernel.org/lkml/[email protected]/ [2] open here
Fixes dc23806a7c47 ("driver core: enforce device_lock for driver_match_device()")
Fixes 0b4eeee2876f ("iommu/arm-smmu-qcom: Register the TBU driver in qcom_smmu_impl_init")
Signed-off-by Danilo Krummrich <[email protected]>

Acked-by Joerg Roedel <[email protected]>

This patch should go via the branch that contains

dc23806a7c47 ("driver core: enforce device_lock for driver_match_device()").

Otherwise we add a Fixes tag pointing to a commit which comes later in the git history.

-Joerg

Danilo Krummrich

author maintainer

2026-01-22 08:37 UTC #8 lore raw

Quoted 5 lines · Jörg Rödel

Acked-by Joerg Roedel <[email protected]>
This patch should go via the branch that contains
dc23806a7c47 ("driver core: enforce device_lock for driver_match_device()").

Yes, I will take it through the driver-core tree.

Thanks,
Danilo

Ioana Ciornei

Tested-by on v1 1/1

2026-01-22 09:21 UTC #9 lore raw

In reply to Danilo Krummrich

Quoted 21 lines · Danilo Krummrich

Commit 0b4eeee2876f ("iommu/arm-smmu-qcom: Register the TBU driver in qcom_smmu_impl_init") intended to also probe the TBU driver when CONFIG_ARM_SMMU_QCOM_DEBUG is disabled, but also moved the corresponding platform_driver_register() call into qcom_smmu_impl_init() which is called from arm_smmu_device_probe().
However, it neither makes sense to register drivers from probe() callbacks of other drivers, nor does the driver core allow registering drivers with a device lock already being held.
The latter was revealed by commit dc23806a7c47 ("driver core: enforce device_lock for driver_match_device()") leading to a deadlock condition described in [1].
Additionally, it was noted by Robin that the current approach is potentially racy with async probe [2].
Hence, fix this by registering the qcom_smmu_tbu_driver from module_init(). Unfortunately, due to the vendoring of the driver, this requires an indirection through arm-smmu-impl.c.

Quoted 7 lines

Reported-by Mark Brown <[email protected]>
Closes https://lore.kernel.org/lkml/[email protected]/ open here
Link https://lore.kernel.org/lkml/[email protected]/ [1] open here
Link https://lore.kernel.org/lkml/[email protected]/ [2] open here
Fixes dc23806a7c47 ("driver core: enforce device_lock for driver_match_device()")
Fixes 0b4eeee2876f ("iommu/arm-smmu-qcom: Register the TBU driver in qcom_smmu_impl_init")
Signed-off-by Danilo Krummrich <[email protected]>

The boot lockup was visible also on the NXP LX2160ARDB. This patch fixes it.

Tested-by Ioana Ciornei <[email protected]> #LX2160ARDB

Danilo Krummrich

author maintainer

2026-01-22 11:52 UTC #10 lore raw

Quoted 2 lines · Ioana Ciornei

The boot lockup was visible also on the NXP LX2160ARDB. This patch fixes it.

Interesting, this means that qcom_smmu_impl_init() must be called on this machine, is this expected?

Quoted 1 line

Tested-by Ioana Ciornei <[email protected]> #LX2160ARDB

Thanks for testing!

Robin Murphy

reviewer

2026-01-22 12:12 UTC #11 lore raw

Quoted 6 lines · Danilo Krummrich

Quoted 2 lines · Ioana Ciornei
The boot lockup was visible also on the NXP LX2160ARDB. This patch fixes it.
Interesting, this means that qcom_smmu_impl_init() must be called on this machine, is this expected?

Yup, same as on the Juno boards and probably others - an Arm SMMU is present, which means if ARM_SMMU_QCOM is enabled then arm_smmu_impl_init() is going to offer it to ask "hey, is this one of yours that you might want to do something with based on your extensive and complicated match list that we don't want to maintain in the common impl code?", wherein qcom_smmu_impl_init() *should* return without doing anything at all as it's not a match...

Cheers,
Robin.

Quoted 4 lines

Quoted 2 lines
Tested-by Ioana Ciornei <[email protected]> #LX2160ARDB
Thanks for testing!

Danilo Krummrich

author maintainer Applied

2026-01-22 14:41 UTC #12 lore raw

In reply to Danilo Krummrich

Quoted 21 lines · Danilo Krummrich

Commit 0b4eeee2876f ("iommu/arm-smmu-qcom: Register the TBU driver in qcom_smmu_impl_init") intended to also probe the TBU driver when CONFIG_ARM_SMMU_QCOM_DEBUG is disabled, but also moved the corresponding platform_driver_register() call into qcom_smmu_impl_init() which is called from arm_smmu_device_probe().
However, it neither makes sense to register drivers from probe() callbacks of other drivers, nor does the driver core allow registering drivers with a device lock already being held.
The latter was revealed by commit dc23806a7c47 ("driver core: enforce device_lock for driver_match_device()") leading to a deadlock condition described in [1].
Additionally, it was noted by Robin that the current approach is potentially racy with async probe [2].
Hence, fix this by registering the qcom_smmu_tbu_driver from module_init(). Unfortunately, due to the vendoring of the driver, this requires an indirection through arm-smmu-impl.c.

Quoted 7 lines

Reported-by Mark Brown <[email protected]>
Closes https://lore.kernel.org/lkml/[email protected]/ open here
Link https://lore.kernel.org/lkml/[email protected]/ [1] open here
Link https://lore.kernel.org/lkml/[email protected]/ [2] open here
Fixes dc23806a7c47 ("driver core: enforce device_lock for driver_match_device()")
Fixes 0b4eeee2876f ("iommu/arm-smmu-qcom: Register the TBU driver in qcom_smmu_impl_init")
Signed-off-by Danilo Krummrich <[email protected]>

Applied to driver-core-linus, thanks!