1 // SPDX-License-Identifier: GPL-2.0-only
2 // Copyright (c) 2020, The Linux Foundation. All rights reserved.
3 
4 #include <linux/module.h>
5 #include <linux/of_irq.h>
6 #include <linux/of.h>
7 #include <linux/of_device.h>
8 #include <linux/platform_device.h>
9 #include <linux/regmap.h>
10 #include <linux/regulator/driver.h>
11 #include <linux/regulator/of_regulator.h>
12 
13 #define REG_PERPH_TYPE                  0x04
14 
15 #define QCOM_LAB_TYPE			0x24
16 #define QCOM_IBB_TYPE			0x20
17 
18 #define PMI8998_LAB_REG_BASE		0xde00
19 #define PMI8998_IBB_REG_BASE		0xdc00
20 #define PMI8998_IBB_LAB_REG_OFFSET	0x200
21 
22 #define REG_LABIBB_STATUS1		0x08
23  #define LABIBB_STATUS1_SC_BIT		BIT(6)
24  #define LABIBB_STATUS1_VREG_OK_BIT	BIT(7)
25 
26 #define REG_LABIBB_INT_SET_TYPE		0x11
27 #define REG_LABIBB_INT_POLARITY_HIGH	0x12
28 #define REG_LABIBB_INT_POLARITY_LOW	0x13
29 #define REG_LABIBB_INT_LATCHED_CLR	0x14
30 #define REG_LABIBB_INT_EN_SET		0x15
31 #define REG_LABIBB_INT_EN_CLR		0x16
32  #define LABIBB_INT_VREG_OK		BIT(0)
33  #define LABIBB_INT_VREG_TYPE_LEVEL	0
34 
35 #define REG_LABIBB_VOLTAGE		0x41
36  #define LABIBB_VOLTAGE_OVERRIDE_EN	BIT(7)
37  #define LAB_VOLTAGE_SET_MASK		GENMASK(3, 0)
38  #define IBB_VOLTAGE_SET_MASK		GENMASK(5, 0)
39 
40 #define REG_LABIBB_ENABLE_CTL		0x46
41  #define LABIBB_CONTROL_ENABLE		BIT(7)
42 
43 #define REG_LABIBB_PD_CTL		0x47
44  #define LAB_PD_CTL_MASK		GENMASK(1, 0)
45  #define IBB_PD_CTL_MASK		(BIT(0) | BIT(7))
46  #define LAB_PD_CTL_STRONG_PULL		BIT(0)
47  #define IBB_PD_CTL_HALF_STRENGTH	BIT(0)
48  #define IBB_PD_CTL_EN			BIT(7)
49 
50 #define REG_LABIBB_CURRENT_LIMIT	0x4b
51  #define LAB_CURRENT_LIMIT_MASK		GENMASK(2, 0)
52  #define IBB_CURRENT_LIMIT_MASK		GENMASK(4, 0)
53  #define LAB_CURRENT_LIMIT_OVERRIDE_EN	BIT(3)
54  #define LABIBB_CURRENT_LIMIT_EN	BIT(7)
55 
56 #define REG_IBB_PWRUP_PWRDN_CTL_1	0x58
57  #define IBB_CTL_1_DISCHARGE_EN		BIT(2)
58 
59 #define REG_LABIBB_SOFT_START_CTL	0x5f
60 #define REG_LABIBB_SEC_ACCESS		0xd0
61  #define LABIBB_SEC_UNLOCK_CODE		0xa5
62 
63 #define LAB_ENABLE_CTL_MASK		BIT(7)
64 #define IBB_ENABLE_CTL_MASK		(BIT(7) | BIT(6))
65 
66 #define LABIBB_OFF_ON_DELAY		1000
67 #define LAB_ENABLE_TIME			(LABIBB_OFF_ON_DELAY * 2)
68 #define IBB_ENABLE_TIME			(LABIBB_OFF_ON_DELAY * 10)
69 #define LABIBB_POLL_ENABLED_TIME	1000
70 #define OCP_RECOVERY_INTERVAL_MS	500
71 #define SC_RECOVERY_INTERVAL_MS		250
72 #define LABIBB_MAX_OCP_COUNT		4
73 #define LABIBB_MAX_SC_COUNT		3
74 #define LABIBB_MAX_FATAL_COUNT		2
75 
76 struct labibb_current_limits {
77 	u32				uA_min;
78 	u32				uA_step;
79 	u8				ovr_val;
80 };
81 
82 struct labibb_regulator {
83 	struct regulator_desc		desc;
84 	struct device			*dev;
85 	struct regmap			*regmap;
86 	struct regulator_dev		*rdev;
87 	struct labibb_current_limits	uA_limits;
88 	struct delayed_work		ocp_recovery_work;
89 	struct delayed_work		sc_recovery_work;
90 	u16				base;
91 	u8				type;
92 	u8				dischg_sel;
93 	u8				soft_start_sel;
94 	int				sc_irq;
95 	int				sc_count;
96 	int				ocp_irq;
97 	int				ocp_irq_count;
98 	int				fatal_count;
99 };
100 
101 struct labibb_regulator_data {
102 	const char			*name;
103 	u8				type;
104 	u16				base;
105 	const struct regulator_desc	*desc;
106 };
107 
qcom_labibb_ocp_hw_enable(struct regulator_dev * rdev)108 static int qcom_labibb_ocp_hw_enable(struct regulator_dev *rdev)
109 {
110 	struct labibb_regulator *vreg = rdev_get_drvdata(rdev);
111 	int ret;
112 
113 	/* Clear irq latch status to avoid spurious event */
114 	ret = regmap_update_bits(rdev->regmap,
115 				 vreg->base + REG_LABIBB_INT_LATCHED_CLR,
116 				 LABIBB_INT_VREG_OK, 1);
117 	if (ret)
118 		return ret;
119 
120 	/* Enable OCP HW interrupt */
121 	return regmap_update_bits(rdev->regmap,
122 				  vreg->base + REG_LABIBB_INT_EN_SET,
123 				  LABIBB_INT_VREG_OK, 1);
124 }
125 
qcom_labibb_ocp_hw_disable(struct regulator_dev * rdev)126 static int qcom_labibb_ocp_hw_disable(struct regulator_dev *rdev)
127 {
128 	struct labibb_regulator *vreg = rdev_get_drvdata(rdev);
129 
130 	return regmap_update_bits(rdev->regmap,
131 				  vreg->base + REG_LABIBB_INT_EN_CLR,
132 				  LABIBB_INT_VREG_OK, 1);
133 }
134 
135 /**
136  * qcom_labibb_check_ocp_status - Check the Over-Current Protection status
137  * @vreg: Main driver structure
138  *
139  * This function checks the STATUS1 register for the VREG_OK bit: if it is
140  * set, then there is no Over-Current event.
141  *
142  * Returns: Zero if there is no over-current, 1 if in over-current or
143  *          negative number for error
144  */
qcom_labibb_check_ocp_status(struct labibb_regulator * vreg)145 static int qcom_labibb_check_ocp_status(struct labibb_regulator *vreg)
146 {
147 	u32 cur_status;
148 	int ret;
149 
150 	ret = regmap_read(vreg->rdev->regmap, vreg->base + REG_LABIBB_STATUS1,
151 			  &cur_status);
152 	if (ret)
153 		return ret;
154 
155 	return !(cur_status & LABIBB_STATUS1_VREG_OK_BIT);
156 }
157 
158 /**
159  * qcom_labibb_ocp_recovery_worker - Handle OCP event
160  * @work: OCP work structure
161  *
162  * This is the worker function to handle the Over Current Protection
163  * hardware event; This will check if the hardware is still
164  * signaling an over-current condition and will eventually stop
165  * the regulator if such condition is still signaled after
166  * LABIBB_MAX_OCP_COUNT times.
167  *
168  * If the driver that is consuming the regulator did not take action
169  * for the OCP condition, or the hardware did not stabilize, a cut
170  * of the LAB and IBB regulators will be forced (regulators will be
171  * disabled).
172  *
173  * As last, if the writes to shut down the LAB/IBB regulators fail
174  * for more than LABIBB_MAX_FATAL_COUNT, then a kernel panic will be
175  * triggered, as a last resort to protect the hardware from burning;
176  * this, however, is expected to never happen, but this is kept to
177  * try to further ensure that we protect the hardware at all costs.
178  */
qcom_labibb_ocp_recovery_worker(struct work_struct * work)179 static void qcom_labibb_ocp_recovery_worker(struct work_struct *work)
180 {
181 	struct labibb_regulator *vreg;
182 	const struct regulator_ops *ops;
183 	int ret;
184 
185 	vreg = container_of(work, struct labibb_regulator,
186 			    ocp_recovery_work.work);
187 	ops = vreg->rdev->desc->ops;
188 
189 	if (vreg->ocp_irq_count >= LABIBB_MAX_OCP_COUNT) {
190 		/*
191 		 * If we tried to disable the regulator multiple times but
192 		 * we kept failing, there's only one last hope to save our
193 		 * hardware from the death: raise a kernel bug, reboot and
194 		 * hope that the bootloader kindly saves us. This, though
195 		 * is done only as paranoid checking, because failing the
196 		 * regmap write to disable the vreg is almost impossible,
197 		 * since we got here after multiple regmap R/W.
198 		 */
199 		BUG_ON(vreg->fatal_count > LABIBB_MAX_FATAL_COUNT);
200 		dev_err(&vreg->rdev->dev, "LABIBB: CRITICAL: Disabling regulator\n");
201 
202 		/* Disable the regulator immediately to avoid damage */
203 		ret = ops->disable(vreg->rdev);
204 		if (ret) {
205 			vreg->fatal_count++;
206 			goto reschedule;
207 		}
208 		enable_irq(vreg->ocp_irq);
209 		vreg->fatal_count = 0;
210 		return;
211 	}
212 
213 	ret = qcom_labibb_check_ocp_status(vreg);
214 	if (ret != 0) {
215 		vreg->ocp_irq_count++;
216 		goto reschedule;
217 	}
218 
219 	ret = qcom_labibb_ocp_hw_enable(vreg->rdev);
220 	if (ret) {
221 		/* We cannot trust it without OCP enabled. */
222 		dev_err(vreg->dev, "Cannot enable OCP IRQ\n");
223 		vreg->ocp_irq_count++;
224 		goto reschedule;
225 	}
226 
227 	enable_irq(vreg->ocp_irq);
228 	/* Everything went fine: reset the OCP count! */
229 	vreg->ocp_irq_count = 0;
230 	return;
231 
232 reschedule:
233 	mod_delayed_work(system_wq, &vreg->ocp_recovery_work,
234 			 msecs_to_jiffies(OCP_RECOVERY_INTERVAL_MS));
235 }
236 
237 /**
238  * qcom_labibb_ocp_isr - Interrupt routine for OverCurrent Protection
239  * @irq:  Interrupt number
240  * @chip: Main driver structure
241  *
242  * Over Current Protection (OCP) will signal to the client driver
243  * that an over-current event has happened and then will schedule
244  * a recovery worker.
245  *
246  * Disabling and eventually re-enabling the regulator is expected
247  * to be done by the driver, as some hardware may be triggering an
248  * over-current condition only at first initialization or it may
249  * be expected only for a very brief amount of time, after which
250  * the attached hardware may be expected to stabilize its current
251  * draw.
252  *
253  * Returns: IRQ_HANDLED for success or IRQ_NONE for failure.
254  */
qcom_labibb_ocp_isr(int irq,void * chip)255 static irqreturn_t qcom_labibb_ocp_isr(int irq, void *chip)
256 {
257 	struct labibb_regulator *vreg = chip;
258 	const struct regulator_ops *ops = vreg->rdev->desc->ops;
259 	int ret;
260 
261 	/* If the regulator is not enabled, this is a fake event */
262 	if (!ops->is_enabled(vreg->rdev))
263 		return 0;
264 
265 	/* If we tried to recover for too many times it's not getting better */
266 	if (vreg->ocp_irq_count > LABIBB_MAX_OCP_COUNT)
267 		return IRQ_NONE;
268 
269 	/*
270 	 * If we (unlikely) can't read this register, to prevent hardware
271 	 * damage at all costs, we assume that the overcurrent event was
272 	 * real; Moreover, if the status register is not signaling OCP,
273 	 * it was a spurious event, so it's all ok.
274 	 */
275 	ret = qcom_labibb_check_ocp_status(vreg);
276 	if (ret == 0) {
277 		vreg->ocp_irq_count = 0;
278 		goto end;
279 	}
280 	vreg->ocp_irq_count++;
281 
282 	/*
283 	 * Disable the interrupt temporarily, or it will fire continuously;
284 	 * we will re-enable it in the recovery worker function.
285 	 */
286 	disable_irq_nosync(irq);
287 
288 	/* Warn the user for overcurrent */
289 	dev_warn(vreg->dev, "Over-Current interrupt fired!\n");
290 
291 	/* Disable the interrupt to avoid hogging */
292 	ret = qcom_labibb_ocp_hw_disable(vreg->rdev);
293 	if (ret)
294 		goto end;
295 
296 	/* Signal overcurrent event to drivers */
297 	regulator_notifier_call_chain(vreg->rdev,
298 				      REGULATOR_EVENT_OVER_CURRENT, NULL);
299 
300 end:
301 	/* Schedule the recovery work */
302 	schedule_delayed_work(&vreg->ocp_recovery_work,
303 			      msecs_to_jiffies(OCP_RECOVERY_INTERVAL_MS));
304 	if (ret)
305 		return IRQ_NONE;
306 
307 	return IRQ_HANDLED;
308 }
309 
qcom_labibb_set_ocp(struct regulator_dev * rdev)310 static int qcom_labibb_set_ocp(struct regulator_dev *rdev)
311 {
312 	struct labibb_regulator *vreg = rdev_get_drvdata(rdev);
313 	char *ocp_irq_name;
314 	u32 irq_flags = IRQF_ONESHOT;
315 	int irq_trig_low, ret;
316 
317 	/* If there is no OCP interrupt, there's nothing to set */
318 	if (vreg->ocp_irq <= 0)
319 		return -EINVAL;
320 
321 	ocp_irq_name = devm_kasprintf(vreg->dev, GFP_KERNEL, "%s-over-current",
322 				      vreg->desc.name);
323 	if (!ocp_irq_name)
324 		return -ENOMEM;
325 
326 	/* IRQ polarities - LAB: trigger-low, IBB: trigger-high */
327 	switch (vreg->type) {
328 	case QCOM_LAB_TYPE:
329 		irq_flags |= IRQF_TRIGGER_LOW;
330 		irq_trig_low = 1;
331 		break;
332 	case QCOM_IBB_TYPE:
333 		irq_flags |= IRQF_TRIGGER_HIGH;
334 		irq_trig_low = 0;
335 		break;
336 	default:
337 		return -EINVAL;
338 	}
339 
340 	/* Activate OCP HW level interrupt */
341 	ret = regmap_update_bits(rdev->regmap,
342 				 vreg->base + REG_LABIBB_INT_SET_TYPE,
343 				 LABIBB_INT_VREG_OK,
344 				 LABIBB_INT_VREG_TYPE_LEVEL);
345 	if (ret)
346 		return ret;
347 
348 	/* Set OCP interrupt polarity */
349 	ret = regmap_update_bits(rdev->regmap,
350 				 vreg->base + REG_LABIBB_INT_POLARITY_HIGH,
351 				 LABIBB_INT_VREG_OK, !irq_trig_low);
352 	if (ret)
353 		return ret;
354 	ret = regmap_update_bits(rdev->regmap,
355 				 vreg->base + REG_LABIBB_INT_POLARITY_LOW,
356 				 LABIBB_INT_VREG_OK, irq_trig_low);
357 	if (ret)
358 		return ret;
359 
360 	ret = qcom_labibb_ocp_hw_enable(rdev);
361 	if (ret)
362 		return ret;
363 
364 	return devm_request_threaded_irq(vreg->dev, vreg->ocp_irq, NULL,
365 					 qcom_labibb_ocp_isr, irq_flags,
366 					 ocp_irq_name, vreg);
367 }
368 
369 /**
370  * qcom_labibb_check_sc_status - Check the Short Circuit Protection status
371  * @vreg: Main driver structure
372  *
373  * This function checks the STATUS1 register on both LAB and IBB regulators
374  * for the ShortCircuit bit: if it is set on *any* of them, then we have
375  * experienced a short-circuit event.
376  *
377  * Returns: Zero if there is no short-circuit, 1 if in short-circuit or
378  *          negative number for error
379  */
qcom_labibb_check_sc_status(struct labibb_regulator * vreg)380 static int qcom_labibb_check_sc_status(struct labibb_regulator *vreg)
381 {
382 	u32 ibb_status, ibb_reg, lab_status, lab_reg;
383 	int ret;
384 
385 	/* We have to work on both regulators due to PBS... */
386 	lab_reg = ibb_reg = vreg->base + REG_LABIBB_STATUS1;
387 	if (vreg->type == QCOM_LAB_TYPE)
388 		ibb_reg -= PMI8998_IBB_LAB_REG_OFFSET;
389 	else
390 		lab_reg += PMI8998_IBB_LAB_REG_OFFSET;
391 
392 	ret = regmap_read(vreg->rdev->regmap, lab_reg, &lab_status);
393 	if (ret)
394 		return ret;
395 	ret = regmap_read(vreg->rdev->regmap, ibb_reg, &ibb_status);
396 	if (ret)
397 		return ret;
398 
399 	return !!(lab_status & LABIBB_STATUS1_SC_BIT) ||
400 	       !!(ibb_status & LABIBB_STATUS1_SC_BIT);
401 }
402 
403 /**
404  * qcom_labibb_sc_recovery_worker - Handle Short Circuit event
405  * @work: SC work structure
406  *
407  * This is the worker function to handle the Short Circuit Protection
408  * hardware event; This will check if the hardware is still
409  * signaling a short-circuit condition and will eventually never
410  * re-enable the regulator if such condition is still signaled after
411  * LABIBB_MAX_SC_COUNT times.
412  *
413  * If the driver that is consuming the regulator did not take action
414  * for the SC condition, or the hardware did not stabilize, this
415  * worker will stop rescheduling, leaving the regulators disabled
416  * as already done by the Portable Batch System (PBS).
417  *
418  * Returns: IRQ_HANDLED for success or IRQ_NONE for failure.
419  */
qcom_labibb_sc_recovery_worker(struct work_struct * work)420 static void qcom_labibb_sc_recovery_worker(struct work_struct *work)
421 {
422 	struct labibb_regulator *vreg;
423 	const struct regulator_ops *ops;
424 	u32 lab_reg, ibb_reg, lab_val, ibb_val, val;
425 	bool pbs_cut = false;
426 	int i, sc, ret;
427 
428 	vreg = container_of(work, struct labibb_regulator,
429 			    sc_recovery_work.work);
430 	ops = vreg->rdev->desc->ops;
431 
432 	/*
433 	 * If we tried to check the regulator status multiple times but we
434 	 * kept failing, then just bail out, as the Portable Batch System
435 	 * (PBS) will disable the vregs for us, preventing hardware damage.
436 	 */
437 	if (vreg->fatal_count > LABIBB_MAX_FATAL_COUNT)
438 		return;
439 
440 	/* Too many short-circuit events. Throw in the towel. */
441 	if (vreg->sc_count > LABIBB_MAX_SC_COUNT)
442 		return;
443 
444 	/*
445 	 * The Portable Batch System (PBS) automatically disables LAB
446 	 * and IBB when a short-circuit event is detected, so we have to
447 	 * check and work on both of them at the same time.
448 	 */
449 	lab_reg = ibb_reg = vreg->base + REG_LABIBB_ENABLE_CTL;
450 	if (vreg->type == QCOM_LAB_TYPE)
451 		ibb_reg -= PMI8998_IBB_LAB_REG_OFFSET;
452 	else
453 		lab_reg += PMI8998_IBB_LAB_REG_OFFSET;
454 
455 	sc = qcom_labibb_check_sc_status(vreg);
456 	if (sc)
457 		goto reschedule;
458 
459 	for (i = 0; i < LABIBB_MAX_SC_COUNT; i++) {
460 		ret = regmap_read(vreg->regmap, lab_reg, &lab_val);
461 		if (ret) {
462 			vreg->fatal_count++;
463 			goto reschedule;
464 		}
465 
466 		ret = regmap_read(vreg->regmap, ibb_reg, &ibb_val);
467 		if (ret) {
468 			vreg->fatal_count++;
469 			goto reschedule;
470 		}
471 		val = lab_val & ibb_val;
472 
473 		if (!(val & LABIBB_CONTROL_ENABLE)) {
474 			pbs_cut = true;
475 			break;
476 		}
477 		usleep_range(5000, 6000);
478 	}
479 	if (pbs_cut)
480 		goto reschedule;
481 
482 
483 	/*
484 	 * If we have reached this point, we either have successfully
485 	 * recovered from the SC condition or we had a spurious SC IRQ,
486 	 * which means that we can re-enable the regulators, if they
487 	 * have ever been disabled by the PBS.
488 	 */
489 	ret = ops->enable(vreg->rdev);
490 	if (ret)
491 		goto reschedule;
492 
493 	/* Everything went fine: reset the OCP count! */
494 	vreg->sc_count = 0;
495 	enable_irq(vreg->sc_irq);
496 	return;
497 
498 reschedule:
499 	/*
500 	 * Now that we have done basic handling of the short-circuit,
501 	 * reschedule this worker in the regular system workqueue, as
502 	 * taking action is not truly urgent anymore.
503 	 */
504 	vreg->sc_count++;
505 	mod_delayed_work(system_wq, &vreg->sc_recovery_work,
506 			 msecs_to_jiffies(SC_RECOVERY_INTERVAL_MS));
507 }
508 
509 /**
510  * qcom_labibb_sc_isr - Interrupt routine for Short Circuit Protection
511  * @irq:  Interrupt number
512  * @chip: Main driver structure
513  *
514  * Short Circuit Protection (SCP) will signal to the client driver
515  * that a regulation-out event has happened and then will schedule
516  * a recovery worker.
517  *
518  * The LAB and IBB regulators will be automatically disabled by the
519  * Portable Batch System (PBS) and they will be enabled again by
520  * the worker function if the hardware stops signaling the short
521  * circuit event.
522  *
523  * Returns: IRQ_HANDLED for success or IRQ_NONE for failure.
524  */
qcom_labibb_sc_isr(int irq,void * chip)525 static irqreturn_t qcom_labibb_sc_isr(int irq, void *chip)
526 {
527 	struct labibb_regulator *vreg = chip;
528 
529 	if (vreg->sc_count > LABIBB_MAX_SC_COUNT)
530 		return IRQ_NONE;
531 
532 	/* Warn the user for short circuit */
533 	dev_warn(vreg->dev, "Short-Circuit interrupt fired!\n");
534 
535 	/*
536 	 * Disable the interrupt temporarily, or it will fire continuously;
537 	 * we will re-enable it in the recovery worker function.
538 	 */
539 	disable_irq_nosync(irq);
540 
541 	/* Signal out of regulation event to drivers */
542 	regulator_notifier_call_chain(vreg->rdev,
543 				      REGULATOR_EVENT_REGULATION_OUT, NULL);
544 
545 	/* Schedule the short-circuit handling as high-priority work */
546 	mod_delayed_work(system_highpri_wq, &vreg->sc_recovery_work,
547 			 msecs_to_jiffies(SC_RECOVERY_INTERVAL_MS));
548 	return IRQ_HANDLED;
549 }
550 
551 
qcom_labibb_set_current_limit(struct regulator_dev * rdev,int min_uA,int max_uA)552 static int qcom_labibb_set_current_limit(struct regulator_dev *rdev,
553 					 int min_uA, int max_uA)
554 {
555 	struct labibb_regulator *vreg = rdev_get_drvdata(rdev);
556 	struct regulator_desc *desc = &vreg->desc;
557 	struct labibb_current_limits *lim = &vreg->uA_limits;
558 	u32 mask, val;
559 	int i, ret, sel = -1;
560 
561 	if (min_uA < lim->uA_min || max_uA < lim->uA_min)
562 		return -EINVAL;
563 
564 	for (i = 0; i < desc->n_current_limits; i++) {
565 		int uA_limit = (lim->uA_step * i) + lim->uA_min;
566 
567 		if (max_uA >= uA_limit && min_uA <= uA_limit)
568 			sel = i;
569 	}
570 	if (sel < 0)
571 		return -EINVAL;
572 
573 	/* Current limit setting needs secure access */
574 	ret = regmap_write(vreg->regmap, vreg->base + REG_LABIBB_SEC_ACCESS,
575 			   LABIBB_SEC_UNLOCK_CODE);
576 	if (ret)
577 		return ret;
578 
579 	mask = desc->csel_mask | lim->ovr_val;
580 	mask |= LABIBB_CURRENT_LIMIT_EN;
581 	val = (u32)sel | lim->ovr_val;
582 	val |= LABIBB_CURRENT_LIMIT_EN;
583 
584 	return regmap_update_bits(vreg->regmap, desc->csel_reg, mask, val);
585 }
586 
qcom_labibb_get_current_limit(struct regulator_dev * rdev)587 static int qcom_labibb_get_current_limit(struct regulator_dev *rdev)
588 {
589 	struct labibb_regulator *vreg = rdev_get_drvdata(rdev);
590 	struct regulator_desc *desc = &vreg->desc;
591 	struct labibb_current_limits *lim = &vreg->uA_limits;
592 	unsigned int cur_step;
593 	int ret;
594 
595 	ret = regmap_read(vreg->regmap, desc->csel_reg, &cur_step);
596 	if (ret)
597 		return ret;
598 	cur_step &= desc->csel_mask;
599 
600 	return (cur_step * lim->uA_step) + lim->uA_min;
601 }
602 
qcom_labibb_set_soft_start(struct regulator_dev * rdev)603 static int qcom_labibb_set_soft_start(struct regulator_dev *rdev)
604 {
605 	struct labibb_regulator *vreg = rdev_get_drvdata(rdev);
606 	u32 val = 0;
607 
608 	if (vreg->type == QCOM_IBB_TYPE)
609 		val = vreg->dischg_sel;
610 	else
611 		val = vreg->soft_start_sel;
612 
613 	return regmap_write(rdev->regmap, rdev->desc->soft_start_reg, val);
614 }
615 
qcom_labibb_get_table_sel(const int * table,int sz,u32 value)616 static int qcom_labibb_get_table_sel(const int *table, int sz, u32 value)
617 {
618 	int i;
619 
620 	for (i = 0; i < sz; i++)
621 		if (table[i] == value)
622 			return i;
623 	return -EINVAL;
624 }
625 
626 /* IBB discharge resistor values in KOhms */
627 static const int dischg_resistor_values[] = { 300, 64, 32, 16 };
628 
629 /* Soft start time in microseconds */
630 static const int soft_start_values[] = { 200, 400, 600, 800 };
631 
qcom_labibb_of_parse_cb(struct device_node * np,const struct regulator_desc * desc,struct regulator_config * config)632 static int qcom_labibb_of_parse_cb(struct device_node *np,
633 				   const struct regulator_desc *desc,
634 				   struct regulator_config *config)
635 {
636 	struct labibb_regulator *vreg = config->driver_data;
637 	u32 dischg_kohms, soft_start_time;
638 	int ret;
639 
640 	ret = of_property_read_u32(np, "qcom,discharge-resistor-kohms",
641 				       &dischg_kohms);
642 	if (ret)
643 		dischg_kohms = 300;
644 
645 	ret = qcom_labibb_get_table_sel(dischg_resistor_values,
646 					ARRAY_SIZE(dischg_resistor_values),
647 					dischg_kohms);
648 	if (ret < 0)
649 		return ret;
650 	vreg->dischg_sel = (u8)ret;
651 
652 	ret = of_property_read_u32(np, "qcom,soft-start-us",
653 				   &soft_start_time);
654 	if (ret)
655 		soft_start_time = 200;
656 
657 	ret = qcom_labibb_get_table_sel(soft_start_values,
658 					ARRAY_SIZE(soft_start_values),
659 					soft_start_time);
660 	if (ret < 0)
661 		return ret;
662 	vreg->soft_start_sel = (u8)ret;
663 
664 	return 0;
665 }
666 
667 static const struct regulator_ops qcom_labibb_ops = {
668 	.enable			= regulator_enable_regmap,
669 	.disable		= regulator_disable_regmap,
670 	.is_enabled		= regulator_is_enabled_regmap,
671 	.set_voltage_sel	= regulator_set_voltage_sel_regmap,
672 	.get_voltage_sel	= regulator_get_voltage_sel_regmap,
673 	.list_voltage		= regulator_list_voltage_linear,
674 	.map_voltage		= regulator_map_voltage_linear,
675 	.set_active_discharge	= regulator_set_active_discharge_regmap,
676 	.set_pull_down		= regulator_set_pull_down_regmap,
677 	.set_current_limit	= qcom_labibb_set_current_limit,
678 	.get_current_limit	= qcom_labibb_get_current_limit,
679 	.set_soft_start		= qcom_labibb_set_soft_start,
680 	.set_over_current_protection = qcom_labibb_set_ocp,
681 };
682 
683 static const struct regulator_desc pmi8998_lab_desc = {
684 	.enable_mask		= LAB_ENABLE_CTL_MASK,
685 	.enable_reg		= (PMI8998_LAB_REG_BASE + REG_LABIBB_ENABLE_CTL),
686 	.enable_val		= LABIBB_CONTROL_ENABLE,
687 	.enable_time		= LAB_ENABLE_TIME,
688 	.poll_enabled_time	= LABIBB_POLL_ENABLED_TIME,
689 	.soft_start_reg		= (PMI8998_LAB_REG_BASE + REG_LABIBB_SOFT_START_CTL),
690 	.pull_down_reg		= (PMI8998_LAB_REG_BASE + REG_LABIBB_PD_CTL),
691 	.pull_down_mask		= LAB_PD_CTL_MASK,
692 	.pull_down_val_on	= LAB_PD_CTL_STRONG_PULL,
693 	.vsel_reg		= (PMI8998_LAB_REG_BASE + REG_LABIBB_VOLTAGE),
694 	.vsel_mask		= LAB_VOLTAGE_SET_MASK,
695 	.apply_reg		= (PMI8998_LAB_REG_BASE + REG_LABIBB_VOLTAGE),
696 	.apply_bit		= LABIBB_VOLTAGE_OVERRIDE_EN,
697 	.csel_reg		= (PMI8998_LAB_REG_BASE + REG_LABIBB_CURRENT_LIMIT),
698 	.csel_mask		= LAB_CURRENT_LIMIT_MASK,
699 	.n_current_limits	= 8,
700 	.off_on_delay		= LABIBB_OFF_ON_DELAY,
701 	.owner			= THIS_MODULE,
702 	.type			= REGULATOR_VOLTAGE,
703 	.min_uV			= 4600000,
704 	.uV_step		= 100000,
705 	.n_voltages		= 16,
706 	.ops			= &qcom_labibb_ops,
707 	.of_parse_cb		= qcom_labibb_of_parse_cb,
708 };
709 
710 static const struct regulator_desc pmi8998_ibb_desc = {
711 	.enable_mask		= IBB_ENABLE_CTL_MASK,
712 	.enable_reg		= (PMI8998_IBB_REG_BASE + REG_LABIBB_ENABLE_CTL),
713 	.enable_val		= LABIBB_CONTROL_ENABLE,
714 	.enable_time		= IBB_ENABLE_TIME,
715 	.poll_enabled_time	= LABIBB_POLL_ENABLED_TIME,
716 	.soft_start_reg		= (PMI8998_IBB_REG_BASE + REG_LABIBB_SOFT_START_CTL),
717 	.active_discharge_off	= 0,
718 	.active_discharge_on	= IBB_CTL_1_DISCHARGE_EN,
719 	.active_discharge_mask	= IBB_CTL_1_DISCHARGE_EN,
720 	.active_discharge_reg	= (PMI8998_IBB_REG_BASE + REG_IBB_PWRUP_PWRDN_CTL_1),
721 	.pull_down_reg		= (PMI8998_IBB_REG_BASE + REG_LABIBB_PD_CTL),
722 	.pull_down_mask		= IBB_PD_CTL_MASK,
723 	.pull_down_val_on	= IBB_PD_CTL_HALF_STRENGTH | IBB_PD_CTL_EN,
724 	.vsel_reg		= (PMI8998_IBB_REG_BASE + REG_LABIBB_VOLTAGE),
725 	.vsel_mask		= IBB_VOLTAGE_SET_MASK,
726 	.apply_reg		= (PMI8998_IBB_REG_BASE + REG_LABIBB_VOLTAGE),
727 	.apply_bit		= LABIBB_VOLTAGE_OVERRIDE_EN,
728 	.csel_reg		= (PMI8998_IBB_REG_BASE + REG_LABIBB_CURRENT_LIMIT),
729 	.csel_mask		= IBB_CURRENT_LIMIT_MASK,
730 	.n_current_limits	= 32,
731 	.off_on_delay		= LABIBB_OFF_ON_DELAY,
732 	.owner			= THIS_MODULE,
733 	.type			= REGULATOR_VOLTAGE,
734 	.min_uV			= 1400000,
735 	.uV_step		= 100000,
736 	.n_voltages		= 64,
737 	.ops			= &qcom_labibb_ops,
738 	.of_parse_cb		= qcom_labibb_of_parse_cb,
739 };
740 
741 static const struct labibb_regulator_data pmi8998_labibb_data[] = {
742 	{"lab", QCOM_LAB_TYPE, PMI8998_LAB_REG_BASE, &pmi8998_lab_desc},
743 	{"ibb", QCOM_IBB_TYPE, PMI8998_IBB_REG_BASE, &pmi8998_ibb_desc},
744 	{ },
745 };
746 
747 static const struct of_device_id qcom_labibb_match[] = {
748 	{ .compatible = "qcom,pmi8998-lab-ibb", .data = &pmi8998_labibb_data},
749 	{ },
750 };
751 MODULE_DEVICE_TABLE(of, qcom_labibb_match);
752 
qcom_labibb_regulator_probe(struct platform_device * pdev)753 static int qcom_labibb_regulator_probe(struct platform_device *pdev)
754 {
755 	struct labibb_regulator *vreg;
756 	struct device *dev = &pdev->dev;
757 	struct regulator_config cfg = {};
758 	struct device_node *reg_node;
759 	const struct of_device_id *match;
760 	const struct labibb_regulator_data *reg_data;
761 	struct regmap *reg_regmap;
762 	unsigned int type;
763 	int ret;
764 
765 	reg_regmap = dev_get_regmap(pdev->dev.parent, NULL);
766 	if (!reg_regmap) {
767 		dev_err(&pdev->dev, "Couldn't get parent's regmap\n");
768 		return -ENODEV;
769 	}
770 
771 	match = of_match_device(qcom_labibb_match, &pdev->dev);
772 	if (!match)
773 		return -ENODEV;
774 
775 	for (reg_data = match->data; reg_data->name; reg_data++) {
776 		char *sc_irq_name;
777 		int irq = 0;
778 
779 		/* Validate if the type of regulator is indeed
780 		 * what's mentioned in DT.
781 		 */
782 		ret = regmap_read(reg_regmap, reg_data->base + REG_PERPH_TYPE,
783 				  &type);
784 		if (ret < 0) {
785 			dev_err(dev,
786 				"Peripheral type read failed ret=%d\n",
787 				ret);
788 			return -EINVAL;
789 		}
790 
791 		if (WARN_ON((type != QCOM_LAB_TYPE) && (type != QCOM_IBB_TYPE)) ||
792 		    WARN_ON(type != reg_data->type))
793 			return -EINVAL;
794 
795 		vreg  = devm_kzalloc(&pdev->dev, sizeof(*vreg),
796 					   GFP_KERNEL);
797 		if (!vreg)
798 			return -ENOMEM;
799 
800 		sc_irq_name = devm_kasprintf(dev, GFP_KERNEL,
801 					     "%s-short-circuit",
802 					     reg_data->name);
803 		if (!sc_irq_name)
804 			return -ENOMEM;
805 
806 		reg_node = of_get_child_by_name(pdev->dev.of_node,
807 						reg_data->name);
808 		if (!reg_node)
809 			return -EINVAL;
810 
811 		/* The Short Circuit interrupt is critical */
812 		irq = of_irq_get_byname(reg_node, "sc-err");
813 		if (irq <= 0) {
814 			if (irq == 0)
815 				irq = -EINVAL;
816 
817 			return dev_err_probe(vreg->dev, irq,
818 					     "Short-circuit irq not found.\n");
819 		}
820 		vreg->sc_irq = irq;
821 
822 		/* OverCurrent Protection IRQ is optional */
823 		irq = of_irq_get_byname(reg_node, "ocp");
824 		vreg->ocp_irq = irq;
825 		vreg->ocp_irq_count = 0;
826 		of_node_put(reg_node);
827 
828 		vreg->regmap = reg_regmap;
829 		vreg->dev = dev;
830 		vreg->base = reg_data->base;
831 		vreg->type = reg_data->type;
832 		INIT_DELAYED_WORK(&vreg->sc_recovery_work,
833 				  qcom_labibb_sc_recovery_worker);
834 
835 		if (vreg->ocp_irq > 0)
836 			INIT_DELAYED_WORK(&vreg->ocp_recovery_work,
837 					  qcom_labibb_ocp_recovery_worker);
838 
839 		switch (vreg->type) {
840 		case QCOM_LAB_TYPE:
841 			/* LAB Limits: 200-1600mA */
842 			vreg->uA_limits.uA_min  = 200000;
843 			vreg->uA_limits.uA_step = 200000;
844 			vreg->uA_limits.ovr_val = LAB_CURRENT_LIMIT_OVERRIDE_EN;
845 			break;
846 		case QCOM_IBB_TYPE:
847 			/* IBB Limits: 0-1550mA */
848 			vreg->uA_limits.uA_min  = 0;
849 			vreg->uA_limits.uA_step = 50000;
850 			vreg->uA_limits.ovr_val = 0; /* No override bit */
851 			break;
852 		default:
853 			return -EINVAL;
854 		}
855 
856 		memcpy(&vreg->desc, reg_data->desc, sizeof(vreg->desc));
857 		vreg->desc.of_match = reg_data->name;
858 		vreg->desc.name = reg_data->name;
859 
860 		cfg.dev = vreg->dev;
861 		cfg.driver_data = vreg;
862 		cfg.regmap = vreg->regmap;
863 
864 		vreg->rdev = devm_regulator_register(vreg->dev, &vreg->desc,
865 							&cfg);
866 
867 		if (IS_ERR(vreg->rdev)) {
868 			dev_err(dev, "qcom_labibb: error registering %s : %d\n",
869 					reg_data->name, ret);
870 			return PTR_ERR(vreg->rdev);
871 		}
872 
873 		ret = devm_request_threaded_irq(vreg->dev, vreg->sc_irq, NULL,
874 						qcom_labibb_sc_isr,
875 						IRQF_ONESHOT |
876 						IRQF_TRIGGER_RISING,
877 						sc_irq_name, vreg);
878 		if (ret)
879 			return ret;
880 	}
881 
882 	return 0;
883 }
884 
885 static struct platform_driver qcom_labibb_regulator_driver = {
886 	.driver	= {
887 		.name = "qcom-lab-ibb-regulator",
888 		.of_match_table	= qcom_labibb_match,
889 	},
890 	.probe = qcom_labibb_regulator_probe,
891 };
892 module_platform_driver(qcom_labibb_regulator_driver);
893 
894 MODULE_DESCRIPTION("Qualcomm labibb driver");
895 MODULE_AUTHOR("Nisha Kumari <nishakumari@codeaurora.org>");
896 MODULE_AUTHOR("Sumit Semwal <sumit.semwal@linaro.org>");
897 MODULE_LICENSE("GPL v2");
898