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"); 898