drivers/greybus/svc_watchdog.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * SVC Greybus "watchdog" driver.
   4  *
   5  * Copyright 2016 Google Inc.
   6  */
   7
   8 #include <linux/delay.h>
   9 #include <linux/suspend.h>
  10 #include <linux/workqueue.h>
  11 #include <linux/greybus.h>
  12
  13 #define SVC_WATCHDOG_PERIOD     (2 * HZ)
  14
  15 struct gb_svc_watchdog {
  16         struct delayed_work     work;
  17         struct gb_svc           *svc;
  18         bool                    enabled;
  19         struct notifier_block pm_notifier;
  20 };
  21
  22 static struct delayed_work reset_work;
  23
  24 static int svc_watchdog_pm_notifier(struct notifier_block *notifier,
  25                                     unsigned long pm_event, void *unused)
  26 {
  27         struct gb_svc_watchdog *watchdog =
  28                 container_of(notifier, struct gb_svc_watchdog, pm_notifier);
  29
  30         switch (pm_event) {
  31         case PM_SUSPEND_PREPARE:
  32                 gb_svc_watchdog_disable(watchdog->svc);
  33                 break;
  34         case PM_POST_SUSPEND:
  35                 gb_svc_watchdog_enable(watchdog->svc);
  36                 break;
  37         default:
  38                 break;
  39         }
  40
  41         return NOTIFY_DONE;
  42 }
  43
  44 static void greybus_reset(struct work_struct *work)
  45 {
  46         static char const start_path[] = "/system/bin/start";
  47         static char *envp[] = {
  48                 "HOME=/",
  49                 "PATH=/sbin:/vendor/bin:/system/sbin:/system/bin:/system/xbin",
  50                 NULL,
  51         };
  52         static char *argv[] = {
  53                 (char *)start_path,
  54                 "unipro_reset",
  55                 NULL,
  56         };
  57
  58         pr_err("svc_watchdog: calling \"%s %s\" to reset greybus network!\n",
  59                argv[0], argv[1]);
  60         call_usermodehelper(start_path, argv, envp, UMH_WAIT_EXEC);
  61 }
  62
  63 static void do_work(struct work_struct *work)
  64 {
  65         struct gb_svc_watchdog *watchdog;
  66         struct gb_svc *svc;
  67         int retval;
  68
  69         watchdog = container_of(work, struct gb_svc_watchdog, work.work);
  70         svc = watchdog->svc;
  71
  72         dev_dbg(&svc->dev, "%s: ping.\n", __func__);
  73         retval = gb_svc_ping(svc);
  74         if (retval) {
  75                 /*
  76                  * Something went really wrong, let's warn userspace and then
  77                  * pull the plug and reset the whole greybus network.
  78                  * We need to do this outside of this workqueue as we will be
  79                  * tearing down the svc device itself.  So queue up
  80                  * yet-another-callback to do that.
  81                  */
  82                 dev_err(&svc->dev,
  83                         "SVC ping has returned %d, something is wrong!!!\n",
  84                         retval);
  85
  86                 if (svc->action == GB_SVC_WATCHDOG_BITE_PANIC_KERNEL) {
  87                         panic("SVC is not responding\n");
  88                 } else if (svc->action == GB_SVC_WATCHDOG_BITE_RESET_UNIPRO) {
  89                         dev_err(&svc->dev, "Resetting the greybus network, watch out!!!\n");
  90
  91                         INIT_DELAYED_WORK(&reset_work, greybus_reset);
  92                         schedule_delayed_work(&reset_work, HZ / 2);
  93
  94                         /*
  95                          * Disable ourselves, we don't want to trip again unless
  96                          * userspace wants us to.
  97                          */
  98                         watchdog->enabled = false;
  99                 }
 100         }
 101
 102         /* resubmit our work to happen again, if we are still "alive" */
 103         if (watchdog->enabled)
 104                 schedule_delayed_work(&watchdog->work, SVC_WATCHDOG_PERIOD);
 105 }
 106
 107 int gb_svc_watchdog_create(struct gb_svc *svc)
 108 {
 109         struct gb_svc_watchdog *watchdog;
 110         int retval;
 111
 112         if (svc->watchdog)
 113                 return 0;
 114
 115         watchdog = kmalloc(sizeof(*watchdog), GFP_KERNEL);
 116         if (!watchdog)
 117                 return -ENOMEM;
 118
 119         watchdog->enabled = false;
 120         watchdog->svc = svc;
 121         INIT_DELAYED_WORK(&watchdog->work, do_work);
 122         svc->watchdog = watchdog;
 123
 124         watchdog->pm_notifier.notifier_call = svc_watchdog_pm_notifier;
 125         retval = register_pm_notifier(&watchdog->pm_notifier);
 126         if (retval) {
 127                 dev_err(&svc->dev, "error registering pm notifier(%d)\n",
 128                         retval);
 129                 goto svc_watchdog_create_err;
 130         }
 131
 132         retval = gb_svc_watchdog_enable(svc);
 133         if (retval) {
 134                 dev_err(&svc->dev, "error enabling watchdog (%d)\n", retval);
 135                 unregister_pm_notifier(&watchdog->pm_notifier);
 136                 goto svc_watchdog_create_err;
 137         }
 138         return retval;
 139
 140 svc_watchdog_create_err:
 141         svc->watchdog = NULL;
 142         kfree(watchdog);
 143
 144         return retval;
 145 }
 146
 147 void gb_svc_watchdog_destroy(struct gb_svc *svc)
 148 {
 149         struct gb_svc_watchdog *watchdog = svc->watchdog;
 150
 151         if (!watchdog)
 152                 return;
 153
 154         unregister_pm_notifier(&watchdog->pm_notifier);
 155         gb_svc_watchdog_disable(svc);
 156         svc->watchdog = NULL;
 157         kfree(watchdog);
 158 }
 159
 160 bool gb_svc_watchdog_enabled(struct gb_svc *svc)
 161 {
 162         if (!svc || !svc->watchdog)
 163                 return false;
 164         return svc->watchdog->enabled;
 165 }
 166
 167 int gb_svc_watchdog_enable(struct gb_svc *svc)
 168 {
 169         struct gb_svc_watchdog *watchdog;
 170
 171         if (!svc->watchdog)
 172                 return -ENODEV;
 173
 174         watchdog = svc->watchdog;
 175         if (watchdog->enabled)
 176                 return 0;
 177
 178         watchdog->enabled = true;
 179         schedule_delayed_work(&watchdog->work, SVC_WATCHDOG_PERIOD);
 180         return 0;
 181 }
 182
 183 int gb_svc_watchdog_disable(struct gb_svc *svc)
 184 {
 185         struct gb_svc_watchdog *watchdog;
 186
 187         if (!svc->watchdog)
 188                 return -ENODEV;
 189
 190         watchdog = svc->watchdog;
 191         if (!watchdog->enabled)
 192                 return 0;
 193
 194         watchdog->enabled = false;
 195         cancel_delayed_work_sync(&watchdog->work);
 196         return 0;
 197 }