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
svc_watchdog_pm_notifier(struct notifier_block * notifier,unsigned long pm_event,void * unused)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
greybus_reset(struct work_struct * work)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
do_work(struct work_struct * work)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
gb_svc_watchdog_create(struct gb_svc * svc)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
gb_svc_watchdog_destroy(struct gb_svc * svc)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
gb_svc_watchdog_enabled(struct gb_svc * svc)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
gb_svc_watchdog_enable(struct gb_svc * svc)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
gb_svc_watchdog_disable(struct gb_svc * svc)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