soc: xilinx: Add cb event for subsystem restart

Add support to register subsystem restart events from firmware for Versal
and Versal NET platforms. This event is received when firmware requests
for subsystem restart. After receiving this event, the kernel needs to be
restarted.

Signed-off-by: Jay Buddhabhatti <[email protected]>
Link: https://lore.kernel.org/r/[email protected]
Signed-off-by: Michal Simek <[email protected]>

diff --git a/drivers/soc/xilinx/zynqmp_power.c b/drivers/soc/xilinx/zynqmp_power.c
index 965b1143936abe3d826bbd15207374099643bba5..fced6bedca43810a6dacf0f53043ea21cc7359e9 100644 (file)
--- a/drivers/soc/xilinx/zynqmp_power.c
+++ b/drivers/soc/xilinx/zynqmp_power.c
@@ -30,9 +30,27 @@ struct zynqmp_pm_work_struct {
        u32 args[CB_ARG_CNT];
 };
 
-static struct zynqmp_pm_work_struct *zynqmp_pm_init_suspend_work;
+/**
+ * struct zynqmp_pm_event_info - event related information
+ * @cb_fun:    Function pointer to store the callback function.
+ * @cb_type:   Type of callback from pm_api_cb_id,
+ *                     PM_NOTIFY_CB - for Error Events,
+ *                     PM_INIT_SUSPEND_CB - for suspend callback.
+ * @node_id:   Node-Id related to event.
+ * @event:     Event Mask for the Error Event.
+ * @wake:      Flag specifying whether the subsystem should be woken upon
+ *             event notification.
+ */
+struct zynqmp_pm_event_info {
+       event_cb_func_t cb_fun;
+       enum pm_api_cb_id cb_type;
+       u32 node_id;
+       u32 event;
+       bool wake;
+};
+
+static struct zynqmp_pm_work_struct *zynqmp_pm_init_suspend_work, *zynqmp_pm_init_restart_work;
 static struct mbox_chan *rx_chan;
-static bool event_registered;
 
 enum pm_suspend_mode {
        PM_SUSPEND_MODE_FIRST = 0,
@@ -54,6 +72,19 @@ static void zynqmp_pm_get_callback_data(u32 *buf)
        zynqmp_pm_invoke_fn(GET_CALLBACK_DATA, buf, 0);
 }
 
+static void subsystem_restart_event_callback(const u32 *payload, void *data)
+{
+       /* First element is callback API ID, others are callback arguments */
+       if (work_pending(&zynqmp_pm_init_restart_work->callback_work))
+               return;
+
+       /* Copy callback arguments into work's structure */
+       memcpy(zynqmp_pm_init_restart_work->args, &payload[0],
+              sizeof(zynqmp_pm_init_restart_work->args));
+
+       queue_work(system_unbound_wq, &zynqmp_pm_init_restart_work->callback_work);
+}
+
 static void suspend_event_callback(const u32 *payload, void *data)
 {
        /* First element is callback API ID, others are callback arguments */
@@ -119,6 +150,37 @@ static void ipi_receive_callback(struct mbox_client *cl, void *data)
        }
 }
 
+/**
+ * zynqmp_pm_subsystem_restart_work_fn - Initiate Subsystem restart
+ * @work:      Pointer to work_struct
+ *
+ * Bottom-half of PM callback IRQ handler.
+ */
+static void zynqmp_pm_subsystem_restart_work_fn(struct work_struct *work)
+{
+       int ret;
+       struct zynqmp_pm_work_struct *pm_work = container_of(work, struct zynqmp_pm_work_struct,
+                                                            callback_work);
+
+       /* First element is callback API ID, others are callback arguments */
+       if (pm_work->args[0] == PM_NOTIFY_CB) {
+               if (pm_work->args[2] == EVENT_SUBSYSTEM_RESTART) {
+                       ret = zynqmp_pm_system_shutdown(ZYNQMP_PM_SHUTDOWN_TYPE_SETSCOPE_ONLY,
+                                                       ZYNQMP_PM_SHUTDOWN_SUBTYPE_SUBSYSTEM);
+                       if (ret) {
+                               pr_err("unable to set shutdown scope\n");
+                               return;
+                       }
+
+                       kernel_restart(NULL);
+               } else {
+                       pr_err("%s Unsupported Event - %d\n", __func__, pm_work->args[2]);
+               }
+       } else {
+               pr_err("%s() Unsupported Callback %d\n", __func__, pm_work->args[0]);
+       }
+}
+
 /**
  * zynqmp_pm_init_suspend_work_fn - Initialize suspend
  * @work:      Pointer to work_struct
@@ -184,10 +246,46 @@ static ssize_t suspend_mode_store(struct device *dev,
 
 static DEVICE_ATTR_RW(suspend_mode);
 
+static void unregister_event(struct device *dev, void *res)
+{
+       struct zynqmp_pm_event_info *event_info = res;
+
+       xlnx_unregister_event(event_info->cb_type, event_info->node_id,
+                             event_info->event, event_info->cb_fun, NULL);
+}
+
+static int register_event(struct device *dev, const enum pm_api_cb_id cb_type, const u32 node_id,
+                         const u32 event, const bool wake, event_cb_func_t cb_fun)
+{
+       int ret;
+       struct zynqmp_pm_event_info *event_info;
+
+       event_info = devres_alloc(unregister_event, sizeof(struct zynqmp_pm_event_info),
+                                 GFP_KERNEL);
+       if (!event_info)
+               return -ENOMEM;
+
+       event_info->cb_type = cb_type;
+       event_info->node_id = node_id;
+       event_info->event = event;
+       event_info->wake = wake;
+       event_info->cb_fun = cb_fun;
+
+       ret = xlnx_register_event(event_info->cb_type, event_info->node_id,
+                                 event_info->event, event_info->wake, event_info->cb_fun, NULL);
+       if (ret) {
+               devres_free(event_info);
+               return ret;
+       }
+
+       devres_add(dev, event_info);
+       return 0;
+}
+
 static int zynqmp_pm_probe(struct platform_device *pdev)
 {
        int ret, irq;
-       u32 pm_api_version;
+       u32 pm_api_version, pm_family_code, pm_sub_family_code, node_id;
        struct mbox_client *client;
 
        zynqmp_pm_get_api_version(&pm_api_version);
@@ -203,21 +301,43 @@ static int zynqmp_pm_probe(struct platform_device *pdev)
         * is not available to use) or -ENODEV(Xilinx Event Manager not compiled),
         * then use ipi-mailbox or interrupt method.
         */
-       ret = xlnx_register_event(PM_INIT_SUSPEND_CB, 0, 0, false,
-                                 suspend_event_callback, NULL);
+       ret = register_event(&pdev->dev, PM_INIT_SUSPEND_CB, 0, 0, false,
+                            suspend_event_callback);
        if (!ret) {
                zynqmp_pm_init_suspend_work = devm_kzalloc(&pdev->dev,
                                                           sizeof(struct zynqmp_pm_work_struct),
                                                           GFP_KERNEL);
-               if (!zynqmp_pm_init_suspend_work) {
-                       xlnx_unregister_event(PM_INIT_SUSPEND_CB, 0, 0,
-                                             suspend_event_callback, NULL);
+               if (!zynqmp_pm_init_suspend_work)
                        return -ENOMEM;
-               }
-               event_registered = true;
 
                INIT_WORK(&zynqmp_pm_init_suspend_work->callback_work,
                          zynqmp_pm_init_suspend_work_fn);
+
+               ret = zynqmp_pm_get_family_info(&pm_family_code, &pm_sub_family_code);
+               if (ret < 0)
+                       return ret;
+
+               if (pm_sub_family_code == VERSALNET_SUB_FAMILY_CODE)
+                       node_id = PM_DEV_ACPU_0_0;
+               else
+                       node_id = PM_DEV_ACPU_0;
+
+               ret = register_event(&pdev->dev, PM_NOTIFY_CB, node_id, EVENT_SUBSYSTEM_RESTART,
+                                    false, subsystem_restart_event_callback);
+               if (ret) {
+                       dev_err(&pdev->dev, "Failed to Register with Xilinx Event manager %d\n",
+                               ret);
+                       return ret;
+               }
+
+               zynqmp_pm_init_restart_work = devm_kzalloc(&pdev->dev,
+                                                          sizeof(struct zynqmp_pm_work_struct),
+                                                          GFP_KERNEL);
+               if (!zynqmp_pm_init_restart_work)
+                       return -ENOMEM;
+
+               INIT_WORK(&zynqmp_pm_init_restart_work->callback_work,
+                         zynqmp_pm_subsystem_restart_work_fn);
        } else if (ret != -EACCES && ret != -ENODEV) {
                dev_err(&pdev->dev, "Failed to Register with Xilinx Event manager %d\n", ret);
                return ret;
@@ -264,15 +384,8 @@ static int zynqmp_pm_probe(struct platform_device *pdev)
        }
 
        ret = sysfs_create_file(&pdev->dev.kobj, &dev_attr_suspend_mode.attr);
-       if (ret) {
-               if (event_registered) {
-                       xlnx_unregister_event(PM_INIT_SUSPEND_CB, 0, 0, suspend_event_callback,
-                                             NULL);
-                       event_registered = false;
-               }
-               dev_err(&pdev->dev, "unable to create sysfs interface\n");
+       if (ret)
                return ret;
-       }
 
        return 0;
 }
@@ -280,8 +393,6 @@ static int zynqmp_pm_probe(struct platform_device *pdev)
 static void zynqmp_pm_remove(struct platform_device *pdev)
 {
        sysfs_remove_file(&pdev->dev.kobj, &dev_attr_suspend_mode.attr);
-       if (event_registered)
-               xlnx_unregister_event(PM_INIT_SUSPEND_CB, 0, 0, suspend_event_callback, NULL);
 
        if (!rx_chan)
                mbox_free_channel(rx_chan);

diff --git a/include/linux/firmware/xlnx-event-manager.h b/include/linux/firmware/xlnx-event-manager.h
index 82e8254b0f8069b30e5280b9679968a09f0df9f8..645dd34155e6eefc9652e84088c1aad2d16c4c28 100644 (file)
--- a/include/linux/firmware/xlnx-event-manager.h
+++ b/include/linux/firmware/xlnx-event-manager.h
@@ -1,4 +1,9 @@
 /* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Xilinx Event Management Driver
+ *
+ * Copyright (C) 2024, Advanced Micro Devices, Inc.
+ */
 
 #ifndef _FIRMWARE_XLNX_EVENT_MANAGER_H_
 #define _FIRMWARE_XLNX_EVENT_MANAGER_H_
@@ -7,6 +12,11 @@
 
 #define CB_MAX_PAYLOAD_SIZE    (4U) /*In payload maximum 32bytes */
 
+#define EVENT_SUBSYSTEM_RESTART                (4U)
+
+#define PM_DEV_ACPU_0_0                        (0x1810c0afU)
+#define PM_DEV_ACPU_0                  (0x1810c003U)
+
 /************************** Exported Function *****************************/
 
 typedef void (*event_cb_func_t)(const u32 *payload, void *data);