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 } 198