soc: qcom: ice: Fix race between qcom_ice_probe() and of_qcom_ice_get()

The current platform driver design causes probe ordering races with
consumers (UFS, eMMC) due to ICE's dependency on SCM firmware calls. If ICE
probe fails (missing ICE SCM or DT registers), devm_of_qcom_ice_get() loops
with -EPROBE_DEFER, leaving consumers non-functional even when ICE should
be gracefully disabled. devm_of_qcom_ice_get() doesn't know if the ICE
driver probe has failed due to above reasons or it is waiting for the SCM
driver.

Moreover, there is no devlink dependency between ICE and consumer drivers
as 'qcom,ice' is not considered as a DT 'supplier'. So the consumer drivers
have no idea of when the ICE driver is going to probe.

To address these issues, store the error pointer in a global xarray with
ice node phandle as a key during probe in addition to the valid ice pointer
and synchronize both qcom_ice_probe() and of_qcom_ice_get() using a mutex.

If the xarray entry is NULL, then it implies that the driver is not
probed yet, so return -EPROBE_DEFER. If it has any error pointer, return
that error pointer directly. Otherwise, add the devlink as usual and return
the valid pointer to the consumer.

Xarray is used instead of platform drvdata, since driver core frees the
drvdata during probe failure. So it cannot be used to pass the error
pointer to the consumers.

Note that this change only fixes the standalone ICE DT node bindings and
not the ones with 'ice' range embedded in the consumer nodes, where there
is no issue.

Fixes: 2afbf43a4aec ("soc: qcom: Make the Qualcomm UFS/SDCC ICE a dedicated driver")
Reported-by: Sumit Garg <sumit.garg@oss.qualcomm.com>
Tested-by: Sumit Garg <sumit.garg@oss.qualcomm.com> # OP-TEE as TZ
Acked-by: Sumit Garg <sumit.garg@oss.qualcomm.com>
Cc: stable@vger.kernel.org # 6.4
Signed-off-by: Manivannan Sadhasivam <manivannan.sadhasivam@oss.qualcomm.com>
Link: https://lore.kernel.org/r/20260518-qcom-ice-fix-v7-1-2a595382185b@oss.qualcomm.com
Signed-off-by: Bjorn Andersson <andersson@kernel.org>

diff --git a/drivers/soc/qcom/ice.c b/drivers/soc/qcom/ice.c
index b203bc685cadd21d6f96eb1799963a13db4b2b72..91991864b4a3c3e0d8c4a3dcb6168fa8cf693c38 100644 (file)
--- a/drivers/soc/qcom/ice.c
+++ b/drivers/soc/qcom/ice.c
@@ -16,6 +16,7 @@
 #include <linux/of.h>
 #include <linux/of_platform.h>
 #include <linux/platform_device.h>
+#include <linux/xarray.h>
 
 #include <linux/firmware/qcom/qcom_scm.h>
 
@@ -113,6 +114,9 @@ struct qcom_ice {
        u8 hwkm_version;
 };
 
+static DEFINE_XARRAY(ice_handles);
+static DEFINE_MUTEX(ice_mutex);
+
 static bool qcom_ice_check_supported(struct qcom_ice *ice)
 {
        u32 regval = qcom_ice_readl(ice, QCOM_ICE_REG_VERSION);
@@ -631,6 +635,8 @@ static struct qcom_ice *of_qcom_ice_get(struct device *dev)
                return qcom_ice_create(&pdev->dev, base);
        }
 
+       guard(mutex)(&ice_mutex);
+
        /*
         * If the consumer node does not provider an 'ice' reg range
         * (legacy DT binding), then it must at least provide a phandle
@@ -647,12 +653,13 @@ static struct qcom_ice *of_qcom_ice_get(struct device *dev)
                return ERR_PTR(-EPROBE_DEFER);
        }
 
-       ice = platform_get_drvdata(pdev);
-       if (!ice) {
-               dev_err(dev, "Cannot get ice instance from %s\n",
-                       dev_name(&pdev->dev));
+       ice = xa_load(&ice_handles, pdev->dev.of_node->phandle);
+       if (IS_ERR_OR_NULL(ice)) {
                platform_device_put(pdev);
-               return ERR_PTR(-EPROBE_DEFER);
+               if (!ice)
+                       return ERR_PTR(-EPROBE_DEFER);
+               else
+                       return ice;
        }
 
        link = device_link_add(dev, &pdev->dev, DL_FLAG_AUTOREMOVE_SUPPLIER);
@@ -716,24 +723,40 @@ EXPORT_SYMBOL_GPL(devm_of_qcom_ice_get);
 
 static int qcom_ice_probe(struct platform_device *pdev)
 {
+       unsigned long phandle = pdev->dev.of_node->phandle;
        struct qcom_ice *engine;
        void __iomem *base;
 
+       guard(mutex)(&ice_mutex);
+
        base = devm_platform_ioremap_resource(pdev, 0);
        if (IS_ERR(base)) {
                dev_warn(&pdev->dev, "ICE registers not found\n");
+               /* Store the error pointer for devm_of_qcom_ice_get() */
+               xa_store(&ice_handles, phandle, (__force void *)base, GFP_KERNEL);
                return PTR_ERR(base);
        }
 
        engine = qcom_ice_create(&pdev->dev, base);
-       if (IS_ERR(engine))
+       if (IS_ERR(engine)) {
+               /* Store the error pointer for devm_of_qcom_ice_get() */
+               xa_store(&ice_handles, phandle, engine, GFP_KERNEL);
                return PTR_ERR(engine);
+       }
 
-       platform_set_drvdata(pdev, engine);
+       xa_store(&ice_handles, phandle, engine, GFP_KERNEL);
 
        return 0;
 }
 
+static void qcom_ice_remove(struct platform_device *pdev)
+{
+       unsigned long phandle = pdev->dev.of_node->phandle;
+
+       guard(mutex)(&ice_mutex);
+       xa_store(&ice_handles, phandle, NULL, GFP_KERNEL);
+}
+
 static const struct of_device_id qcom_ice_of_match_table[] = {
        { .compatible = "qcom,inline-crypto-engine" },
        { },
@@ -742,6 +765,7 @@ MODULE_DEVICE_TABLE(of, qcom_ice_of_match_table);
 
 static struct platform_driver qcom_ice_driver = {
        .probe  = qcom_ice_probe,
+       .remove = qcom_ice_remove,
        .driver = {
                .name = "qcom-ice",
                .of_match_table = qcom_ice_of_match_table,