1 // SPDX-License-Identifier: GPL-2.0-only
2 // Copyright (c) 2020, The Linux Foundation. All rights reserved.
4 #include <linux/module.h>
5 #include <linux/of_irq.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>
13 #define REG_PERPH_TYPE 0x04
15 #define QCOM_LAB_TYPE 0x24
16 #define QCOM_IBB_TYPE 0x20
18 #define PMI8998_LAB_REG_BASE 0xde00
19 #define PMI8998_IBB_REG_BASE 0xdc00
20 #define PMI8998_IBB_LAB_REG_OFFSET 0x200
22 #define REG_LABIBB_STATUS1 0x08
23 #define LABIBB_STATUS1_SC_BIT BIT(6)
24 #define LABIBB_STATUS1_VREG_OK_BIT BIT(7)
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
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)
40 #define REG_LABIBB_ENABLE_CTL 0x46
41 #define LABIBB_CONTROL_ENABLE BIT(7)
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)
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)
56 #define REG_IBB_PWRUP_PWRDN_CTL_1 0x58
57 #define IBB_CTL_1_DISCHARGE_EN BIT(2)
59 #define REG_LABIBB_SOFT_START_CTL 0x5f
60 #define REG_LABIBB_SEC_ACCESS 0xd0
61 #define LABIBB_SEC_UNLOCK_CODE 0xa5
63 #define LAB_ENABLE_CTL_MASK BIT(7)
64 #define IBB_ENABLE_CTL_MASK (BIT(7) | BIT(6))
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
76 struct labibb_current_limits {
82 struct labibb_regulator {
83 struct regulator_desc desc;
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;
101 struct labibb_regulator_data {
105 const struct regulator_desc *desc;
108 static int qcom_labibb_ocp_hw_enable(struct regulator_dev *rdev)
110 struct labibb_regulator *vreg = rdev_get_drvdata(rdev);
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);
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);
126 static int qcom_labibb_ocp_hw_disable(struct regulator_dev *rdev)
128 struct labibb_regulator *vreg = rdev_get_drvdata(rdev);
130 return regmap_update_bits(rdev->regmap,
131 vreg->base + REG_LABIBB_INT_EN_CLR,
132 LABIBB_INT_VREG_OK, 1);
136 * qcom_labibb_check_ocp_status - Check the Over-Current Protection status
137 * @vreg: Main driver structure
139 * This function checks the STATUS1 register for the VREG_OK bit: if it is
140 * set, then there is no Over-Current event.
142 * Returns: Zero if there is no over-current, 1 if in over-current or
143 * negative number for error
145 static int qcom_labibb_check_ocp_status(struct labibb_regulator *vreg)
150 ret = regmap_read(vreg->rdev->regmap, vreg->base + REG_LABIBB_STATUS1,
155 return !(cur_status & LABIBB_STATUS1_VREG_OK_BIT);
159 * qcom_labibb_ocp_recovery_worker - Handle OCP event
160 * @work: OCP work structure
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.
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
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.
179 static void qcom_labibb_ocp_recovery_worker(struct work_struct *work)
181 struct labibb_regulator *vreg;
182 const struct regulator_ops *ops;
185 vreg = container_of(work, struct labibb_regulator,
186 ocp_recovery_work.work);
187 ops = vreg->rdev->desc->ops;
189 if (vreg->ocp_irq_count >= LABIBB_MAX_OCP_COUNT) {
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.
199 BUG_ON(vreg->fatal_count > LABIBB_MAX_FATAL_COUNT);
200 dev_err(&vreg->rdev->dev, "LABIBB: CRITICAL: Disabling regulator\n");
202 /* Disable the regulator immediately to avoid damage */
203 ret = ops->disable(vreg->rdev);
208 enable_irq(vreg->ocp_irq);
209 vreg->fatal_count = 0;
213 ret = qcom_labibb_check_ocp_status(vreg);
215 vreg->ocp_irq_count++;
219 ret = qcom_labibb_ocp_hw_enable(vreg->rdev);
221 /* We cannot trust it without OCP enabled. */
222 dev_err(vreg->dev, "Cannot enable OCP IRQ\n");
223 vreg->ocp_irq_count++;
227 enable_irq(vreg->ocp_irq);
228 /* Everything went fine: reset the OCP count! */
229 vreg->ocp_irq_count = 0;
233 mod_delayed_work(system_wq, &vreg->ocp_recovery_work,
234 msecs_to_jiffies(OCP_RECOVERY_INTERVAL_MS));
238 * qcom_labibb_ocp_isr - Interrupt routine for OverCurrent Protection
239 * @irq: Interrupt number
240 * @chip: Main driver structure
242 * Over Current Protection (OCP) will signal to the client driver
243 * that an over-current event has happened and then will schedule
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
253 * Returns: IRQ_HANDLED for success or IRQ_NONE for failure.
255 static irqreturn_t qcom_labibb_ocp_isr(int irq, void *chip)
257 struct labibb_regulator *vreg = chip;
258 const struct regulator_ops *ops = vreg->rdev->desc->ops;
261 /* If the regulator is not enabled, this is a fake event */
262 if (!ops->is_enabled(vreg->rdev))
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)
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.
275 ret = qcom_labibb_check_ocp_status(vreg);
277 vreg->ocp_irq_count = 0;
280 vreg->ocp_irq_count++;
283 * Disable the interrupt temporarily, or it will fire continuously;
284 * we will re-enable it in the recovery worker function.
286 disable_irq_nosync(irq);
288 /* Warn the user for overcurrent */
289 dev_warn(vreg->dev, "Over-Current interrupt fired!\n");
291 /* Disable the interrupt to avoid hogging */
292 ret = qcom_labibb_ocp_hw_disable(vreg->rdev);
296 /* Signal overcurrent event to drivers */
297 regulator_notifier_call_chain(vreg->rdev,
298 REGULATOR_EVENT_OVER_CURRENT, NULL);
301 /* Schedule the recovery work */
302 schedule_delayed_work(&vreg->ocp_recovery_work,
303 msecs_to_jiffies(OCP_RECOVERY_INTERVAL_MS));
310 static int qcom_labibb_set_ocp(struct regulator_dev *rdev)
312 struct labibb_regulator *vreg = rdev_get_drvdata(rdev);
314 u32 irq_flags = IRQF_ONESHOT;
315 int irq_trig_low, ret;
317 /* If there is no OCP interrupt, there's nothing to set */
318 if (vreg->ocp_irq <= 0)
321 ocp_irq_name = devm_kasprintf(vreg->dev, GFP_KERNEL, "%s-over-current",
326 /* IRQ polarities - LAB: trigger-low, IBB: trigger-high */
327 switch (vreg->type) {
329 irq_flags |= IRQF_TRIGGER_LOW;
333 irq_flags |= IRQF_TRIGGER_HIGH;
340 /* Activate OCP HW level interrupt */
341 ret = regmap_update_bits(rdev->regmap,
342 vreg->base + REG_LABIBB_INT_SET_TYPE,
344 LABIBB_INT_VREG_TYPE_LEVEL);
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);
354 ret = regmap_update_bits(rdev->regmap,
355 vreg->base + REG_LABIBB_INT_POLARITY_LOW,
356 LABIBB_INT_VREG_OK, irq_trig_low);
360 ret = qcom_labibb_ocp_hw_enable(rdev);
364 return devm_request_threaded_irq(vreg->dev, vreg->ocp_irq, NULL,
365 qcom_labibb_ocp_isr, irq_flags,
370 * qcom_labibb_check_sc_status - Check the Short Circuit Protection status
371 * @vreg: Main driver structure
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.
377 * Returns: Zero if there is no short-circuit, 1 if in short-circuit or
378 * negative number for error
380 static int qcom_labibb_check_sc_status(struct labibb_regulator *vreg)
382 u32 ibb_status, ibb_reg, lab_status, lab_reg;
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;
390 lab_reg += PMI8998_IBB_LAB_REG_OFFSET;
392 ret = regmap_read(vreg->rdev->regmap, lab_reg, &lab_status);
395 ret = regmap_read(vreg->rdev->regmap, ibb_reg, &ibb_status);
399 return !!(lab_status & LABIBB_STATUS1_SC_BIT) ||
400 !!(ibb_status & LABIBB_STATUS1_SC_BIT);
404 * qcom_labibb_sc_recovery_worker - Handle Short Circuit event
405 * @work: SC work structure
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.
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).
418 * Returns: IRQ_HANDLED for success or IRQ_NONE for failure.
420 static void qcom_labibb_sc_recovery_worker(struct work_struct *work)
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;
428 vreg = container_of(work, struct labibb_regulator,
429 sc_recovery_work.work);
430 ops = vreg->rdev->desc->ops;
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.
437 if (vreg->fatal_count > LABIBB_MAX_FATAL_COUNT)
440 /* Too many short-circuit events. Throw in the towel. */
441 if (vreg->sc_count > LABIBB_MAX_SC_COUNT)
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.
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;
453 lab_reg += PMI8998_IBB_LAB_REG_OFFSET;
455 sc = qcom_labibb_check_sc_status(vreg);
459 for (i = 0; i < LABIBB_MAX_SC_COUNT; i++) {
460 ret = regmap_read(vreg->regmap, lab_reg, &lab_val);
466 ret = regmap_read(vreg->regmap, ibb_reg, &ibb_val);
471 val = lab_val & ibb_val;
473 if (!(val & LABIBB_CONTROL_ENABLE)) {
477 usleep_range(5000, 6000);
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.
489 ret = ops->enable(vreg->rdev);
493 /* Everything went fine: reset the OCP count! */
495 enable_irq(vreg->sc_irq);
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.
505 mod_delayed_work(system_wq, &vreg->sc_recovery_work,
506 msecs_to_jiffies(SC_RECOVERY_INTERVAL_MS));
510 * qcom_labibb_sc_isr - Interrupt routine for Short Circuit Protection
511 * @irq: Interrupt number
512 * @chip: Main driver structure
514 * Short Circuit Protection (SCP) will signal to the client driver
515 * that a regulation-out event has happened and then will schedule
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
523 * Returns: IRQ_HANDLED for success or IRQ_NONE for failure.
525 static irqreturn_t qcom_labibb_sc_isr(int irq, void *chip)
527 struct labibb_regulator *vreg = chip;
529 if (vreg->sc_count > LABIBB_MAX_SC_COUNT)
532 /* Warn the user for short circuit */
533 dev_warn(vreg->dev, "Short-Circuit interrupt fired!\n");
536 * Disable the interrupt temporarily, or it will fire continuously;
537 * we will re-enable it in the recovery worker function.
539 disable_irq_nosync(irq);
541 /* Signal out of regulation event to drivers */
542 regulator_notifier_call_chain(vreg->rdev,
543 REGULATOR_EVENT_REGULATION_OUT, NULL);
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));
552 static int qcom_labibb_set_current_limit(struct regulator_dev *rdev,
553 int min_uA, int max_uA)
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;
559 int i, ret, sel = -1;
561 if (min_uA < lim->uA_min || max_uA < lim->uA_min)
564 for (i = 0; i < desc->n_current_limits; i++) {
565 int uA_limit = (lim->uA_step * i) + lim->uA_min;
567 if (max_uA >= uA_limit && min_uA <= uA_limit)
573 /* Current limit setting needs secure access */
574 ret = regmap_write(vreg->regmap, vreg->base + REG_LABIBB_SEC_ACCESS,
575 LABIBB_SEC_UNLOCK_CODE);
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;
584 return regmap_update_bits(vreg->regmap, desc->csel_reg, mask, val);
587 static int qcom_labibb_get_current_limit(struct regulator_dev *rdev)
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;
595 ret = regmap_read(vreg->regmap, desc->csel_reg, &cur_step);
598 cur_step &= desc->csel_mask;
600 return (cur_step * lim->uA_step) + lim->uA_min;
603 static int qcom_labibb_set_soft_start(struct regulator_dev *rdev)
605 struct labibb_regulator *vreg = rdev_get_drvdata(rdev);
608 if (vreg->type == QCOM_IBB_TYPE)
609 val = vreg->dischg_sel;
611 val = vreg->soft_start_sel;
613 return regmap_write(rdev->regmap, rdev->desc->soft_start_reg, val);
616 static int qcom_labibb_get_table_sel(const int *table, int sz, u32 value)
620 for (i = 0; i < sz; i++)
621 if (table[i] == value)
626 /* IBB discharge resistor values in KOhms */
627 static const int dischg_resistor_values[] = { 300, 64, 32, 16 };
629 /* Soft start time in microseconds */
630 static const int soft_start_values[] = { 200, 400, 600, 800 };
632 static int qcom_labibb_of_parse_cb(struct device_node *np,
633 const struct regulator_desc *desc,
634 struct regulator_config *config)
636 struct labibb_regulator *vreg = config->driver_data;
637 u32 dischg_kohms, soft_start_time;
640 ret = of_property_read_u32(np, "qcom,discharge-resistor-kohms",
645 ret = qcom_labibb_get_table_sel(dischg_resistor_values,
646 ARRAY_SIZE(dischg_resistor_values),
650 vreg->dischg_sel = (u8)ret;
652 ret = of_property_read_u32(np, "qcom,soft-start-us",
655 soft_start_time = 200;
657 ret = qcom_labibb_get_table_sel(soft_start_values,
658 ARRAY_SIZE(soft_start_values),
662 vreg->soft_start_sel = (u8)ret;
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,
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,
706 .ops = &qcom_labibb_ops,
707 .of_parse_cb = qcom_labibb_of_parse_cb,
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,
737 .ops = &qcom_labibb_ops,
738 .of_parse_cb = qcom_labibb_of_parse_cb,
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},
747 static const struct of_device_id qcom_labibb_match[] = {
748 { .compatible = "qcom,pmi8998-lab-ibb", .data = &pmi8998_labibb_data},
751 MODULE_DEVICE_TABLE(of, qcom_labibb_match);
753 static int qcom_labibb_regulator_probe(struct platform_device *pdev)
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;
765 reg_regmap = dev_get_regmap(pdev->dev.parent, NULL);
767 dev_err(&pdev->dev, "Couldn't get parent's regmap\n");
771 match = of_match_device(qcom_labibb_match, &pdev->dev);
775 for (reg_data = match->data; reg_data->name; reg_data++) {
779 /* Validate if the type of regulator is indeed
780 * what's mentioned in DT.
782 ret = regmap_read(reg_regmap, reg_data->base + REG_PERPH_TYPE,
786 "Peripheral type read failed ret=%d\n",
791 if (WARN_ON((type != QCOM_LAB_TYPE) && (type != QCOM_IBB_TYPE)) ||
792 WARN_ON(type != reg_data->type))
795 vreg = devm_kzalloc(&pdev->dev, sizeof(*vreg),
800 sc_irq_name = devm_kasprintf(dev, GFP_KERNEL,
806 reg_node = of_get_child_by_name(pdev->dev.of_node,
811 /* The Short Circuit interrupt is critical */
812 irq = of_irq_get_byname(reg_node, "sc-err");
817 return dev_err_probe(vreg->dev, irq,
818 "Short-circuit irq not found.\n");
822 /* OverCurrent Protection IRQ is optional */
823 irq = of_irq_get_byname(reg_node, "ocp");
825 vreg->ocp_irq_count = 0;
826 of_node_put(reg_node);
828 vreg->regmap = reg_regmap;
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);
835 if (vreg->ocp_irq > 0)
836 INIT_DELAYED_WORK(&vreg->ocp_recovery_work,
837 qcom_labibb_ocp_recovery_worker);
839 switch (vreg->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;
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 */
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;
861 cfg.driver_data = vreg;
862 cfg.regmap = vreg->regmap;
864 vreg->rdev = devm_regulator_register(vreg->dev, &vreg->desc,
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);
873 ret = devm_request_threaded_irq(vreg->dev, vreg->sc_irq, NULL,
885 static struct platform_driver qcom_labibb_regulator_driver = {
887 .name = "qcom-lab-ibb-regulator",
888 .of_match_table = qcom_labibb_match,
890 .probe = qcom_labibb_regulator_probe,
892 module_platform_driver(qcom_labibb_regulator_driver);
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");