1 // SPDX-License-Identifier: GPL-2.0
2 //
3 // Copyright (C) 2021 ROHM Semiconductors
4 // regulator IRQ based event notification helpers
5 //
6 // Logic has been partially adapted from qcom-labibb driver.
7 //
8 // Author: Matti Vaittinen <matti.vaittinen@fi.rohmeurope.com>
9 
10 #include <linux/device.h>
11 #include <linux/err.h>
12 #include <linux/interrupt.h>
13 #include <linux/kernel.h>
14 #include <linux/reboot.h>
15 #include <linux/regmap.h>
16 #include <linux/slab.h>
17 #include <linux/spinlock.h>
18 #include <linux/regulator/driver.h>
19 
20 #include "internal.h"
21 
22 #define REGULATOR_FORCED_SAFETY_SHUTDOWN_WAIT_MS 10000
23 
24 struct regulator_irq {
25 	struct regulator_irq_data rdata;
26 	struct regulator_irq_desc desc;
27 	int irq;
28 	int retry_cnt;
29 	struct delayed_work isr_work;
30 };
31 
32 /*
33  * Should only be called from threaded handler to prevent potential deadlock
34  */
35 static void rdev_flag_err(struct regulator_dev *rdev, int err)
36 {
37 	spin_lock(&rdev->err_lock);
38 	rdev->cached_err |= err;
39 	spin_unlock(&rdev->err_lock);
40 }
41 
42 static void rdev_clear_err(struct regulator_dev *rdev, int err)
43 {
44 	spin_lock(&rdev->err_lock);
45 	rdev->cached_err &= ~err;
46 	spin_unlock(&rdev->err_lock);
47 }
48 
49 static void regulator_notifier_isr_work(struct work_struct *work)
50 {
51 	struct regulator_irq *h;
52 	struct regulator_irq_desc *d;
53 	struct regulator_irq_data *rid;
54 	int ret = 0;
55 	int tmo, i;
56 	int num_rdevs;
57 
58 	h = container_of(work, struct regulator_irq,
59 			    isr_work.work);
60 	d = &h->desc;
61 	rid = &h->rdata;
62 	num_rdevs = rid->num_states;
63 
64 reread:
65 	if (d->fatal_cnt && h->retry_cnt > d->fatal_cnt) {
66 		if (!d->die)
67 			return hw_protection_shutdown("Regulator HW failure? - no IC recovery",
68 						      REGULATOR_FORCED_SAFETY_SHUTDOWN_WAIT_MS);
69 		ret = d->die(rid);
70 		/*
71 		 * If the 'last resort' IC recovery failed we will have
72 		 * nothing else left to do...
73 		 */
74 		if (ret)
75 			return hw_protection_shutdown("Regulator HW failure. IC recovery failed",
76 						      REGULATOR_FORCED_SAFETY_SHUTDOWN_WAIT_MS);
77 
78 		/*
79 		 * If h->die() was implemented we assume recovery has been
80 		 * attempted (probably regulator was shut down) and we
81 		 * just enable IRQ and bail-out.
82 		 */
83 		goto enable_out;
84 	}
85 	if (d->renable) {
86 		ret = d->renable(rid);
87 
88 		if (ret == REGULATOR_FAILED_RETRY) {
89 			/* Driver could not get current status */
90 			h->retry_cnt++;
91 			if (!d->reread_ms)
92 				goto reread;
93 
94 			tmo = d->reread_ms;
95 			goto reschedule;
96 		}
97 
98 		if (ret) {
99 			/*
100 			 * IC status reading succeeded. update error info
101 			 * just in case the renable changed it.
102 			 */
103 			for (i = 0; i < num_rdevs; i++) {
104 				struct regulator_err_state *stat;
105 				struct regulator_dev *rdev;
106 
107 				stat = &rid->states[i];
108 				rdev = stat->rdev;
109 				rdev_clear_err(rdev, (~stat->errors) &
110 						      stat->possible_errs);
111 			}
112 			h->retry_cnt++;
113 			/*
114 			 * The IC indicated problem is still ON - no point in
115 			 * re-enabling the IRQ. Retry later.
116 			 */
117 			tmo = d->irq_off_ms;
118 			goto reschedule;
119 		}
120 	}
121 
122 	/*
123 	 * Either IC reported problem cleared or no status checker was provided.
124 	 * If problems are gone - good. If not - then the IRQ will fire again
125 	 * and we'll have a new nice loop. In any case we should clear error
126 	 * flags here and re-enable IRQs.
127 	 */
128 	for (i = 0; i < num_rdevs; i++) {
129 		struct regulator_err_state *stat;
130 		struct regulator_dev *rdev;
131 
132 		stat = &rid->states[i];
133 		rdev = stat->rdev;
134 		rdev_clear_err(rdev, stat->possible_errs);
135 	}
136 
137 	/*
138 	 * Things have been seemingly successful => zero retry-counter.
139 	 */
140 	h->retry_cnt = 0;
141 
142 enable_out:
143 	enable_irq(h->irq);
144 
145 	return;
146 
147 reschedule:
148 	if (!d->high_prio)
149 		mod_delayed_work(system_wq, &h->isr_work,
150 				 msecs_to_jiffies(tmo));
151 	else
152 		mod_delayed_work(system_highpri_wq, &h->isr_work,
153 				 msecs_to_jiffies(tmo));
154 }
155 
156 static irqreturn_t regulator_notifier_isr(int irq, void *data)
157 {
158 	struct regulator_irq *h = data;
159 	struct regulator_irq_desc *d;
160 	struct regulator_irq_data *rid;
161 	unsigned long rdev_map = 0;
162 	int num_rdevs;
163 	int ret, i;
164 
165 	d = &h->desc;
166 	rid = &h->rdata;
167 	num_rdevs = rid->num_states;
168 
169 	if (d->fatal_cnt)
170 		h->retry_cnt++;
171 
172 	/*
173 	 * we spare a few cycles by not clearing statuses prior to this call.
174 	 * The IC driver must initialize the status buffers for rdevs
175 	 * which it indicates having active events via rdev_map.
176 	 *
177 	 * Maybe we should just to be on a safer side(?)
178 	 */
179 	ret = d->map_event(irq, rid, &rdev_map);
180 
181 	/*
182 	 * If status reading fails (which is unlikely) we don't ack/disable
183 	 * IRQ but just increase fail count and retry when IRQ fires again.
184 	 * If retry_count exceeds the given safety limit we call IC specific die
185 	 * handler which can try disabling regulator(s).
186 	 *
187 	 * If no die handler is given we will just bug() as a last resort.
188 	 *
189 	 * We could try disabling all associated rdevs - but we might shoot
190 	 * ourselves in the head and leave the problematic regulator enabled. So
191 	 * if IC has no die-handler populated we just assume the regulator
192 	 * can't be disabled.
193 	 */
194 	if (unlikely(ret == REGULATOR_FAILED_RETRY))
195 		goto fail_out;
196 
197 	h->retry_cnt = 0;
198 	/*
199 	 * Let's not disable IRQ if there were no status bits for us. We'd
200 	 * better leave spurious IRQ handling to genirq
201 	 */
202 	if (ret || !rdev_map)
203 		return IRQ_NONE;
204 
205 	/*
206 	 * Some events are bogus if the regulator is disabled. Skip such events
207 	 * if all relevant regulators are disabled
208 	 */
209 	if (d->skip_off) {
210 		for_each_set_bit(i, &rdev_map, num_rdevs) {
211 			struct regulator_dev *rdev;
212 			const struct regulator_ops *ops;
213 
214 			rdev = rid->states[i].rdev;
215 			ops = rdev->desc->ops;
216 
217 			/*
218 			 * If any of the flagged regulators is enabled we do
219 			 * handle this
220 			 */
221 			if (ops->is_enabled(rdev))
222 				break;
223 		}
224 		if (i == num_rdevs)
225 			return IRQ_NONE;
226 	}
227 
228 	/* Disable IRQ if HW keeps line asserted */
229 	if (d->irq_off_ms)
230 		disable_irq_nosync(irq);
231 
232 	/*
233 	 * IRQ seems to be for us. Let's fire correct notifiers / store error
234 	 * flags
235 	 */
236 	for_each_set_bit(i, &rdev_map, num_rdevs) {
237 		struct regulator_err_state *stat;
238 		struct regulator_dev *rdev;
239 
240 		stat = &rid->states[i];
241 		rdev = stat->rdev;
242 
243 		rdev_dbg(rdev, "Sending regulator notification EVT 0x%lx\n",
244 			 stat->notifs);
245 
246 		regulator_notifier_call_chain(rdev, stat->notifs, NULL);
247 		rdev_flag_err(rdev, stat->errors);
248 	}
249 
250 	if (d->irq_off_ms) {
251 		if (!d->high_prio)
252 			schedule_delayed_work(&h->isr_work,
253 					      msecs_to_jiffies(d->irq_off_ms));
254 		else
255 			mod_delayed_work(system_highpri_wq,
256 					 &h->isr_work,
257 					 msecs_to_jiffies(d->irq_off_ms));
258 	}
259 
260 	return IRQ_HANDLED;
261 
262 fail_out:
263 	if (d->fatal_cnt && h->retry_cnt > d->fatal_cnt) {
264 		/* If we have no recovery, just try shut down straight away */
265 		if (!d->die) {
266 			hw_protection_shutdown("Regulator failure. Retry count exceeded",
267 					       REGULATOR_FORCED_SAFETY_SHUTDOWN_WAIT_MS);
268 		} else {
269 			ret = d->die(rid);
270 			/* If die() failed shut down as a last attempt to save the HW */
271 			if (ret)
272 				hw_protection_shutdown("Regulator failure. Recovery failed",
273 						       REGULATOR_FORCED_SAFETY_SHUTDOWN_WAIT_MS);
274 		}
275 	}
276 
277 	return IRQ_NONE;
278 }
279 
280 static int init_rdev_state(struct device *dev, struct regulator_irq *h,
281 			   struct regulator_dev **rdev, int common_err,
282 			   int *rdev_err, int rdev_amount)
283 {
284 	int i;
285 
286 	h->rdata.states = devm_kzalloc(dev, sizeof(*h->rdata.states) *
287 				       rdev_amount, GFP_KERNEL);
288 	if (!h->rdata.states)
289 		return -ENOMEM;
290 
291 	h->rdata.num_states = rdev_amount;
292 	h->rdata.data = h->desc.data;
293 
294 	for (i = 0; i < rdev_amount; i++) {
295 		h->rdata.states[i].possible_errs = common_err;
296 		if (rdev_err)
297 			h->rdata.states[i].possible_errs |= *rdev_err++;
298 		h->rdata.states[i].rdev = *rdev++;
299 	}
300 
301 	return 0;
302 }
303 
304 static void init_rdev_errors(struct regulator_irq *h)
305 {
306 	int i;
307 
308 	for (i = 0; i < h->rdata.num_states; i++)
309 		if (h->rdata.states[i].possible_errs)
310 			h->rdata.states[i].rdev->use_cached_err = true;
311 }
312 
313 /**
314  * regulator_irq_helper - register IRQ based regulator event/error notifier
315  *
316  * @dev:		device providing the IRQs
317  * @d:			IRQ helper descriptor.
318  * @irq:		IRQ used to inform events/errors to be notified.
319  * @irq_flags:		Extra IRQ flags to be OR'ed with the default
320  *			IRQF_ONESHOT when requesting the (threaded) irq.
321  * @common_errs:	Errors which can be flagged by this IRQ for all rdevs.
322  *			When IRQ is re-enabled these errors will be cleared
323  *			from all associated regulators
324  * @per_rdev_errs:	Optional error flag array describing errors specific
325  *			for only some of the regulators. These errors will be
326  *			or'ed with common errors. If this is given the array
327  *			should contain rdev_amount flags. Can be set to NULL
328  *			if there is no regulator specific error flags for this
329  *			IRQ.
330  * @rdev:		Array of pointers to regulators associated with this
331  *			IRQ.
332  * @rdev_amount:	Amount of regulators associated with this IRQ.
333  *
334  * Return: handle to irq_helper or an ERR_PTR() encoded error code.
335  */
336 void *regulator_irq_helper(struct device *dev,
337 			   const struct regulator_irq_desc *d, int irq,
338 			   int irq_flags, int common_errs, int *per_rdev_errs,
339 			   struct regulator_dev **rdev, int rdev_amount)
340 {
341 	struct regulator_irq *h;
342 	int ret;
343 
344 	if (!rdev_amount || !d || !d->map_event || !d->name)
345 		return ERR_PTR(-EINVAL);
346 
347 	h = devm_kzalloc(dev, sizeof(*h), GFP_KERNEL);
348 	if (!h)
349 		return ERR_PTR(-ENOMEM);
350 
351 	h->irq = irq;
352 	h->desc = *d;
353 
354 	ret = init_rdev_state(dev, h, rdev, common_errs, per_rdev_errs,
355 			      rdev_amount);
356 	if (ret)
357 		return ERR_PTR(ret);
358 
359 	init_rdev_errors(h);
360 
361 	if (h->desc.irq_off_ms)
362 		INIT_DELAYED_WORK(&h->isr_work, regulator_notifier_isr_work);
363 
364 	ret = request_threaded_irq(h->irq, NULL, regulator_notifier_isr,
365 				   IRQF_ONESHOT | irq_flags, h->desc.name, h);
366 	if (ret) {
367 		dev_err(dev, "Failed to request IRQ %d\n", irq);
368 
369 		return ERR_PTR(ret);
370 	}
371 
372 	return h;
373 }
374 EXPORT_SYMBOL_GPL(regulator_irq_helper);
375 
376 /**
377  * regulator_irq_helper_cancel - drop IRQ based regulator event/error notifier
378  *
379  * @handle:		Pointer to handle returned by a successful call to
380  *			regulator_irq_helper(). Will be NULLed upon return.
381  *
382  * The associated IRQ is released and work is cancelled when the function
383  * returns.
384  */
385 void regulator_irq_helper_cancel(void **handle)
386 {
387 	if (handle && *handle) {
388 		struct regulator_irq *h = *handle;
389 
390 		free_irq(h->irq, h);
391 		if (h->desc.irq_off_ms)
392 			cancel_delayed_work_sync(&h->isr_work);
393 
394 		h = NULL;
395 	}
396 }
397 EXPORT_SYMBOL_GPL(regulator_irq_helper_cancel);
398