net: qrtr: support suspend/hibernation

MHI devices may not be destroyed during suspend/hibernation, so need
to unprepare/prepare MHI channels throughout the transition, this is
done by adding suspend/resume callbacks.

The suspend callback is called in the late suspend stage, this means
MHI channels are still alive at suspend stage, and that makes it
possible for an MHI controller driver to communicate with others over
those channels at suspend stage. While the resume callback is called
in the early resume stage, for a similar reason.

Also note that we won't do unprepare/prepare when MHI device is in
suspend state because it's pointless if MHI is only meant to go through
a suspend/resume transition, instead of a complete power cycle.

Tested-on: WCN6855 hw2.0 PCI WLAN.HSP.1.1-03125-QCAHSPSWPL_V1_V2_SILICONZ_LITE-3.6510.30

Signed-off-by: Baochen Qiang <quic_bqiang@quicinc.com>
Reviewed-by: Manivannan Sadhasivam <manivannan.sadhasivam@linaro.org>
Reviewed-by: Jeff Johnson <quic_jjohnson@quicinc.com>
Signed-off-by: Kalle Valo <quic_kvalo@quicinc.com>
Link: https://msgid.link/20240305021320.3367-3-quic_bqiang@quicinc.com

diff --git a/net/qrtr/mhi.c b/net/qrtr/mhi.c
index 9ced13c0627a7f7e6cac0c8532eeb4155b6b4e93..69f53625a049ded5ca9a1d46d7c990c53881b88c 100644 (file)
--- a/net/qrtr/mhi.c
+++ b/net/qrtr/mhi.c
@@ -118,6 +118,51 @@ static const struct mhi_device_id qcom_mhi_qrtr_id_table[] = {
 };
 MODULE_DEVICE_TABLE(mhi, qcom_mhi_qrtr_id_table);
 
+static int __maybe_unused qcom_mhi_qrtr_pm_suspend_late(struct device *dev)
+{
+       struct mhi_device *mhi_dev = container_of(dev, struct mhi_device, dev);
+       enum mhi_state state;
+
+       state = mhi_get_mhi_state(mhi_dev->mhi_cntrl);
+       /*
+        * If the device is in suspend state, then no need for the
+        * client driver to unprepare the channels.
+        */
+       if (state == MHI_STATE_M3)
+               return 0;
+
+       mhi_unprepare_from_transfer(mhi_dev);
+
+       return 0;
+}
+
+static int __maybe_unused qcom_mhi_qrtr_pm_resume_early(struct device *dev)
+{
+       struct mhi_device *mhi_dev = container_of(dev, struct mhi_device, dev);
+       enum mhi_state state;
+       int rc;
+
+       state = mhi_get_mhi_state(mhi_dev->mhi_cntrl);
+       /*
+        * If the device is in suspend state, we won't unprepare channels
+        * in suspend callback, therefore no need to prepare channels when
+        * resume.
+        */
+       if (state == MHI_STATE_M3)
+               return 0;
+
+       rc = mhi_prepare_for_transfer_autoqueue(mhi_dev);
+       if (rc)
+               dev_err(dev, "failed to prepare for autoqueue transfer %d\n", rc);
+
+       return rc;
+}
+
+static const struct dev_pm_ops qcom_mhi_qrtr_pm_ops = {
+       SET_LATE_SYSTEM_SLEEP_PM_OPS(qcom_mhi_qrtr_pm_suspend_late,
+                                    qcom_mhi_qrtr_pm_resume_early)
+};
+
 static struct mhi_driver qcom_mhi_qrtr_driver = {
        .probe = qcom_mhi_qrtr_probe,
        .remove = qcom_mhi_qrtr_remove,
@@ -126,6 +171,7 @@ static struct mhi_driver qcom_mhi_qrtr_driver = {
        .id_table = qcom_mhi_qrtr_id_table,
        .driver = {
                .name = "qcom_mhi_qrtr",
+               .pm = &qcom_mhi_qrtr_pm_ops,
        },
 };