firmware: ti_sci: Partial-IO support

Add support for Partial-IO poweroff. In Partial-IO pins of a few
hardware units can generate system wakeups while DDR memory is not
powered resulting in a fresh boot of the system. These hardware units in
the SoC are always powered so that some logic can detect pin activity.

If the system supports Partial-IO as described in the fw capabilities, a
sys_off handler is added. This sys_off handler decides if the poweroff
is executed by entering normal poweroff or Partial-IO instead. The
decision is made by checking if wakeup is enabled on all devices that
may wake up the SoC from Partial-IO.

The possible wakeup devices are found by checking which devices
reference a "Partial-IO" system state in the list of wakeup-source
system states. Only devices that are actually enabled by the user will
be considered as an active wakeup source. If none of the wakeup sources
is enabled the system will do a normal poweroff. If at least one wakeup
source is enabled it will instead send a TI_SCI_MSG_PREPARE_SLEEP
message from the sys_off handler. Sending this message will result in an
immediate shutdown of the system. No execution is expected after this
point. The code will wait for 5s and do an emergency_restart afterwards
if Partial-IO wasn't entered at that point.

A short documentation about Partial-IO can be found in section 6.2.4.5
of the TRM at
  https://www.ti.com/lit/pdf/spruiv7

Signed-off-by: Markus Schneider-Pargmann (TI.com) <msp@baylibre.com>
Reviewed-by: Dhruva Gole <d-gole@ti.com>
Reviewed-by: Kendall Willis <k-willis@ti.com>
Reviewed-by: Sebin Francis <sebin.francis@ti.com>
Link: https://patch.msgid.link/20251103-topic-am62-partialio-v6-12-b4-v10-2-0557e858d747@baylibre.com
Signed-off-by: Nishanth Menon <nm@ti.com>

diff --git a/drivers/firmware/ti_sci.c b/drivers/firmware/ti_sci.c
index c49294ca3c940ed98a5d1a6e1e67d99ab56b8ec6..e027a2bd8f265892412a642be146f4dd806fbd4e 100644 (file)
--- a/drivers/firmware/ti_sci.c
+++ b/drivers/firmware/ti_sci.c
@@ -1673,6 +1673,9 @@ fail:
 static int ti_sci_cmd_prepare_sleep(const struct ti_sci_handle *handle, u8 mode,
                                    u32 ctx_lo, u32 ctx_hi, u32 debug_flags)
 {
+       u32 msg_flags = mode == TISCI_MSG_VALUE_SLEEP_MODE_PARTIAL_IO ?
+                       TI_SCI_FLAG_REQ_GENERIC_NORESPONSE :
+                       TI_SCI_FLAG_REQ_ACK_ON_PROCESSED;
        struct ti_sci_info *info;
        struct ti_sci_msg_req_prepare_sleep *req;
        struct ti_sci_msg_hdr *resp;
@@ -1689,7 +1692,7 @@ static int ti_sci_cmd_prepare_sleep(const struct ti_sci_handle *handle, u8 mode,
        dev = info->dev;
 
        xfer = ti_sci_get_one_xfer(info, TI_SCI_MSG_PREPARE_SLEEP,
-                                  TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
+                                  msg_flags,
                                   sizeof(*req), sizeof(*resp));
        if (IS_ERR(xfer)) {
                ret = PTR_ERR(xfer);
@@ -1709,11 +1712,12 @@ static int ti_sci_cmd_prepare_sleep(const struct ti_sci_handle *handle, u8 mode,
                goto fail;
        }
 
-       resp = (struct ti_sci_msg_hdr *)xfer->xfer_buf;
-
-       if (!ti_sci_is_response_ack(resp)) {
-               dev_err(dev, "Failed to prepare sleep\n");
-               ret = -ENODEV;
+       if (msg_flags == TI_SCI_FLAG_REQ_ACK_ON_PROCESSED) {
+               resp = (struct ti_sci_msg_hdr *)xfer->xfer_buf;
+               if (!ti_sci_is_response_ack(resp)) {
+                       dev_err(dev, "Failed to prepare sleep\n");
+                       ret = -ENODEV;
+               }
        }
 
 fail:
@@ -3667,6 +3671,78 @@ devm_ti_sci_get_resource(const struct ti_sci_handle *handle, struct device *dev,
 }
 EXPORT_SYMBOL_GPL(devm_ti_sci_get_resource);
 
+/*
+ * Iterate all device nodes that have a wakeup-source property and check if one
+ * of the possible phandles points to a Partial-IO system state. If it
+ * does resolve the device node to an actual device and check if wakeup is
+ * enabled.
+ */
+static bool ti_sci_partial_io_wakeup_enabled(struct ti_sci_info *info)
+{
+       struct device_node *wakeup_node = NULL;
+
+       for_each_node_with_property(wakeup_node, "wakeup-source") {
+               struct of_phandle_iterator it;
+               int err;
+
+               of_for_each_phandle(&it, err, wakeup_node, "wakeup-source", NULL, 0) {
+                       struct platform_device *pdev;
+                       bool may_wakeup;
+
+                       /*
+                        * Continue if idle-state-name is not off-wake. Return
+                        * value is the index of the string which should be 0 if
+                        * off-wake is present.
+                        */
+                       if (of_property_match_string(it.node, "idle-state-name", "off-wake"))
+                               continue;
+
+                       pdev = of_find_device_by_node(wakeup_node);
+                       if (!pdev)
+                               continue;
+
+                       may_wakeup = device_may_wakeup(&pdev->dev);
+                       put_device(&pdev->dev);
+
+                       if (may_wakeup) {
+                               dev_dbg(info->dev, "%pOF identified as wakeup source for Partial-IO\n",
+                                       wakeup_node);
+                               of_node_put(it.node);
+                               of_node_put(wakeup_node);
+                               return true;
+                       }
+               }
+       }
+
+       return false;
+}
+
+static int ti_sci_sys_off_handler(struct sys_off_data *data)
+{
+       struct ti_sci_info *info = data->cb_data;
+       const struct ti_sci_handle *handle = &info->handle;
+       bool enter_partial_io = ti_sci_partial_io_wakeup_enabled(info);
+       int ret;
+
+       if (!enter_partial_io)
+               return NOTIFY_DONE;
+
+       dev_info(info->dev, "Entering Partial-IO because a powered wakeup-enabled device was found.\n");
+
+       ret = ti_sci_cmd_prepare_sleep(handle, TISCI_MSG_VALUE_SLEEP_MODE_PARTIAL_IO, 0, 0, 0);
+       if (ret) {
+               dev_err(info->dev,
+                       "Failed to enter Partial-IO %pe, trying to do an emergency restart\n",
+                       ERR_PTR(ret));
+               emergency_restart();
+       }
+
+       mdelay(5000);
+       emergency_restart();
+
+       return NOTIFY_DONE;
+}
+
 static int tisci_reboot_handler(struct sys_off_data *data)
 {
        struct ti_sci_info *info = data->cb_data;
@@ -3949,6 +4025,19 @@ static int ti_sci_probe(struct platform_device *pdev)
                goto out;
        }
 
+       if (info->fw_caps & MSG_FLAG_CAPS_LPM_PARTIAL_IO) {
+               ret = devm_register_sys_off_handler(dev,
+                                                   SYS_OFF_MODE_POWER_OFF,
+                                                   SYS_OFF_PRIO_FIRMWARE,
+                                                   ti_sci_sys_off_handler,
+                                                   info);
+               if (ret) {
+                       dev_err(dev, "Failed to register sys_off_handler %pe\n",
+                               ERR_PTR(ret));
+                       goto out;
+               }
+       }
+
        dev_info(dev, "ABI: %d.%d (firmware rev 0x%04x '%s')\n",
                 info->handle.version.abi_major, info->handle.version.abi_minor,
                 info->handle.version.firmware_revision,
@@ -3958,7 +4047,13 @@ static int ti_sci_probe(struct platform_device *pdev)
        list_add_tail(&info->node, &ti_sci_list);
        mutex_unlock(&ti_sci_list_mutex);
 
-       return of_platform_populate(dev->of_node, NULL, NULL, dev);
+       ret = of_platform_populate(dev->of_node, NULL, NULL, dev);
+       if (ret) {
+               dev_err(dev, "platform_populate failed %pe\n", ERR_PTR(ret));
+               goto out;
+       }
+       return 0;
+
 out:
        if (!IS_ERR(info->chan_tx))
                mbox_free_channel(info->chan_tx);

diff --git a/drivers/firmware/ti_sci.h b/drivers/firmware/ti_sci.h
index 7559cde17b6ccfeeb1bc357fce5c5767c3f75c54..91f234550c4388238e7d629dd2300ce78648a6fd 100644 (file)
--- a/drivers/firmware/ti_sci.h
+++ b/drivers/firmware/ti_sci.h
@@ -597,6 +597,11 @@ struct ti_sci_msg_resp_get_clock_freq {
 struct ti_sci_msg_req_prepare_sleep {
        struct ti_sci_msg_hdr   hdr;
 
+/*
+ * When sending prepare_sleep with MODE_PARTIAL_IO no response will be sent,
+ * no further steps are required.
+ */
+#define TISCI_MSG_VALUE_SLEEP_MODE_PARTIAL_IO                          0x03
 #define TISCI_MSG_VALUE_SLEEP_MODE_DM_MANAGED                          0xfd
        u8                      mode;
        u32                     ctx_lo;