drivers/regulator/qcom-labibb-regulator.c

   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
 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
 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  */
 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  */
 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  */
 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
 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  */
 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  */
 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  */
 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
 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
 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
 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
 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
 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
 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");