1 /* 2 * Regulator driver for DA9055 PMIC 3 * 4 * Copyright(c) 2012 Dialog Semiconductor Ltd. 5 * 6 * Author: David Dajun Chen <dchen@diasemi.com> 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; either version 2 of the License, or 11 * (at your option) any later version. 12 * 13 */ 14 15 #include <linux/module.h> 16 #include <linux/init.h> 17 #include <linux/err.h> 18 #include <linux/gpio.h> 19 #include <linux/platform_device.h> 20 #include <linux/regulator/driver.h> 21 #include <linux/regulator/machine.h> 22 23 #include <linux/mfd/da9055/core.h> 24 #include <linux/mfd/da9055/reg.h> 25 #include <linux/mfd/da9055/pdata.h> 26 27 #define DA9055_MIN_UA 0 28 #define DA9055_MAX_UA 3 29 30 #define DA9055_LDO_MODE_SYNC 0 31 #define DA9055_LDO_MODE_SLEEP 1 32 33 #define DA9055_BUCK_MODE_SLEEP 1 34 #define DA9055_BUCK_MODE_SYNC 2 35 #define DA9055_BUCK_MODE_AUTO 3 36 37 /* DA9055 REGULATOR IDs */ 38 #define DA9055_ID_BUCK1 0 39 #define DA9055_ID_BUCK2 1 40 #define DA9055_ID_LDO1 2 41 #define DA9055_ID_LDO2 3 42 #define DA9055_ID_LDO3 4 43 #define DA9055_ID_LDO4 5 44 #define DA9055_ID_LDO5 6 45 #define DA9055_ID_LDO6 7 46 47 /* DA9055 BUCK current limit */ 48 static const int da9055_current_limits[] = { 500000, 600000, 700000, 800000 }; 49 50 struct da9055_conf_reg { 51 int reg; 52 int sel_mask; 53 int en_mask; 54 }; 55 56 struct da9055_volt_reg { 57 int reg_a; 58 int reg_b; 59 int sl_shift; 60 int v_mask; 61 }; 62 63 struct da9055_mode_reg { 64 int reg; 65 int mask; 66 int shift; 67 }; 68 69 struct da9055_regulator_info { 70 struct regulator_desc reg_desc; 71 struct da9055_conf_reg conf; 72 struct da9055_volt_reg volt; 73 struct da9055_mode_reg mode; 74 }; 75 76 struct da9055_regulator { 77 struct da9055 *da9055; 78 struct da9055_regulator_info *info; 79 struct regulator_dev *rdev; 80 enum gpio_select reg_rselect; 81 }; 82 83 static unsigned int da9055_buck_get_mode(struct regulator_dev *rdev) 84 { 85 struct da9055_regulator *regulator = rdev_get_drvdata(rdev); 86 struct da9055_regulator_info *info = regulator->info; 87 int ret, mode = 0; 88 89 ret = da9055_reg_read(regulator->da9055, info->mode.reg); 90 if (ret < 0) 91 return ret; 92 93 switch ((ret & info->mode.mask) >> info->mode.shift) { 94 case DA9055_BUCK_MODE_SYNC: 95 mode = REGULATOR_MODE_FAST; 96 break; 97 case DA9055_BUCK_MODE_AUTO: 98 mode = REGULATOR_MODE_NORMAL; 99 break; 100 case DA9055_BUCK_MODE_SLEEP: 101 mode = REGULATOR_MODE_STANDBY; 102 break; 103 } 104 105 return mode; 106 } 107 108 static int da9055_buck_set_mode(struct regulator_dev *rdev, 109 unsigned int mode) 110 { 111 struct da9055_regulator *regulator = rdev_get_drvdata(rdev); 112 struct da9055_regulator_info *info = regulator->info; 113 int val = 0; 114 115 switch (mode) { 116 case REGULATOR_MODE_FAST: 117 val = DA9055_BUCK_MODE_SYNC << info->mode.shift; 118 break; 119 case REGULATOR_MODE_NORMAL: 120 val = DA9055_BUCK_MODE_AUTO << info->mode.shift; 121 break; 122 case REGULATOR_MODE_STANDBY: 123 val = DA9055_BUCK_MODE_SLEEP << info->mode.shift; 124 break; 125 } 126 127 return da9055_reg_update(regulator->da9055, info->mode.reg, 128 info->mode.mask, val); 129 } 130 131 static unsigned int da9055_ldo_get_mode(struct regulator_dev *rdev) 132 { 133 struct da9055_regulator *regulator = rdev_get_drvdata(rdev); 134 struct da9055_regulator_info *info = regulator->info; 135 int ret; 136 137 ret = da9055_reg_read(regulator->da9055, info->volt.reg_b); 138 if (ret < 0) 139 return ret; 140 141 if (ret >> info->volt.sl_shift) 142 return REGULATOR_MODE_STANDBY; 143 else 144 return REGULATOR_MODE_NORMAL; 145 } 146 147 static int da9055_ldo_set_mode(struct regulator_dev *rdev, unsigned int mode) 148 { 149 struct da9055_regulator *regulator = rdev_get_drvdata(rdev); 150 struct da9055_regulator_info *info = regulator->info; 151 struct da9055_volt_reg volt = info->volt; 152 int val = 0; 153 154 switch (mode) { 155 case REGULATOR_MODE_NORMAL: 156 case REGULATOR_MODE_FAST: 157 val = DA9055_LDO_MODE_SYNC; 158 break; 159 case REGULATOR_MODE_STANDBY: 160 val = DA9055_LDO_MODE_SLEEP; 161 break; 162 } 163 164 return da9055_reg_update(regulator->da9055, volt.reg_b, 165 1 << volt.sl_shift, 166 val << volt.sl_shift); 167 } 168 169 static int da9055_buck_get_current_limit(struct regulator_dev *rdev) 170 { 171 struct da9055_regulator *regulator = rdev_get_drvdata(rdev); 172 struct da9055_regulator_info *info = regulator->info; 173 int ret; 174 175 ret = da9055_reg_read(regulator->da9055, DA9055_REG_BUCK_LIM); 176 if (ret < 0) 177 return ret; 178 179 ret &= info->mode.mask; 180 return da9055_current_limits[ret >> info->mode.shift]; 181 } 182 183 static int da9055_buck_set_current_limit(struct regulator_dev *rdev, int min_uA, 184 int max_uA) 185 { 186 struct da9055_regulator *regulator = rdev_get_drvdata(rdev); 187 struct da9055_regulator_info *info = regulator->info; 188 int i; 189 190 for (i = ARRAY_SIZE(da9055_current_limits) - 1; i >= 0; i--) { 191 if ((min_uA <= da9055_current_limits[i]) && 192 (da9055_current_limits[i] <= max_uA)) 193 return da9055_reg_update(regulator->da9055, 194 DA9055_REG_BUCK_LIM, 195 info->mode.mask, 196 i << info->mode.shift); 197 } 198 199 return -EINVAL; 200 } 201 202 static int da9055_regulator_get_voltage_sel(struct regulator_dev *rdev) 203 { 204 struct da9055_regulator *regulator = rdev_get_drvdata(rdev); 205 struct da9055_regulator_info *info = regulator->info; 206 struct da9055_volt_reg volt = info->volt; 207 int ret, sel; 208 209 /* 210 * There are two voltage register set A & B for voltage ramping but 211 * either one of then can be active therefore we first determine 212 * the active register set. 213 */ 214 ret = da9055_reg_read(regulator->da9055, info->conf.reg); 215 if (ret < 0) 216 return ret; 217 218 ret &= info->conf.sel_mask; 219 220 /* Get the voltage for the active register set A/B */ 221 if (ret == DA9055_REGUALTOR_SET_A) 222 ret = da9055_reg_read(regulator->da9055, volt.reg_a); 223 else 224 ret = da9055_reg_read(regulator->da9055, volt.reg_b); 225 226 if (ret < 0) 227 return ret; 228 229 sel = (ret & volt.v_mask); 230 return sel; 231 } 232 233 static int da9055_regulator_set_voltage_sel(struct regulator_dev *rdev, 234 unsigned int selector) 235 { 236 struct da9055_regulator *regulator = rdev_get_drvdata(rdev); 237 struct da9055_regulator_info *info = regulator->info; 238 int ret; 239 240 /* 241 * Regulator register set A/B is not selected through GPIO therefore 242 * we use default register set A for voltage ramping. 243 */ 244 if (regulator->reg_rselect == NO_GPIO) { 245 /* Select register set A */ 246 ret = da9055_reg_update(regulator->da9055, info->conf.reg, 247 info->conf.sel_mask, DA9055_SEL_REG_A); 248 if (ret < 0) 249 return ret; 250 251 /* Set the voltage */ 252 return da9055_reg_update(regulator->da9055, info->volt.reg_a, 253 info->volt.v_mask, selector); 254 } 255 256 /* 257 * Here regulator register set A/B is selected through GPIO. 258 * Therefore we first determine the selected register set A/B and 259 * then set the desired voltage for that register set A/B. 260 */ 261 ret = da9055_reg_read(regulator->da9055, info->conf.reg); 262 if (ret < 0) 263 return ret; 264 265 ret &= info->conf.sel_mask; 266 267 /* Set the voltage */ 268 if (ret == DA9055_REGUALTOR_SET_A) 269 return da9055_reg_update(regulator->da9055, info->volt.reg_a, 270 info->volt.v_mask, selector); 271 else 272 return da9055_reg_update(regulator->da9055, info->volt.reg_b, 273 info->volt.v_mask, selector); 274 } 275 276 static int da9055_regulator_set_suspend_voltage(struct regulator_dev *rdev, 277 int uV) 278 { 279 struct da9055_regulator *regulator = rdev_get_drvdata(rdev); 280 struct da9055_regulator_info *info = regulator->info; 281 int ret; 282 283 /* Select register set B for suspend voltage ramping. */ 284 if (regulator->reg_rselect == NO_GPIO) { 285 ret = da9055_reg_update(regulator->da9055, info->conf.reg, 286 info->conf.sel_mask, DA9055_SEL_REG_B); 287 if (ret < 0) 288 return ret; 289 } 290 291 ret = regulator_map_voltage_linear(rdev, uV, uV); 292 if (ret < 0) 293 return ret; 294 295 return da9055_reg_update(regulator->da9055, info->volt.reg_b, 296 info->volt.v_mask, ret); 297 } 298 299 static int da9055_suspend_enable(struct regulator_dev *rdev) 300 { 301 struct da9055_regulator *regulator = rdev_get_drvdata(rdev); 302 struct da9055_regulator_info *info = regulator->info; 303 304 /* Select register set B for voltage ramping. */ 305 if (regulator->reg_rselect == NO_GPIO) 306 return da9055_reg_update(regulator->da9055, info->conf.reg, 307 info->conf.sel_mask, DA9055_SEL_REG_B); 308 else 309 return 0; 310 } 311 312 static int da9055_suspend_disable(struct regulator_dev *rdev) 313 { 314 struct da9055_regulator *regulator = rdev_get_drvdata(rdev); 315 struct da9055_regulator_info *info = regulator->info; 316 317 /* Diselect register set B. */ 318 if (regulator->reg_rselect == NO_GPIO) 319 return da9055_reg_update(regulator->da9055, info->conf.reg, 320 info->conf.sel_mask, DA9055_SEL_REG_A); 321 else 322 return 0; 323 } 324 325 static struct regulator_ops da9055_buck_ops = { 326 .get_mode = da9055_buck_get_mode, 327 .set_mode = da9055_buck_set_mode, 328 329 .get_current_limit = da9055_buck_get_current_limit, 330 .set_current_limit = da9055_buck_set_current_limit, 331 332 .get_voltage_sel = da9055_regulator_get_voltage_sel, 333 .set_voltage_sel = da9055_regulator_set_voltage_sel, 334 .list_voltage = regulator_list_voltage_linear, 335 .map_voltage = regulator_map_voltage_linear, 336 .is_enabled = regulator_is_enabled_regmap, 337 .enable = regulator_enable_regmap, 338 .disable = regulator_disable_regmap, 339 340 .set_suspend_voltage = da9055_regulator_set_suspend_voltage, 341 .set_suspend_enable = da9055_suspend_enable, 342 .set_suspend_disable = da9055_suspend_disable, 343 .set_suspend_mode = da9055_buck_set_mode, 344 }; 345 346 static struct regulator_ops da9055_ldo_ops = { 347 .get_mode = da9055_ldo_get_mode, 348 .set_mode = da9055_ldo_set_mode, 349 350 .get_voltage_sel = da9055_regulator_get_voltage_sel, 351 .set_voltage_sel = da9055_regulator_set_voltage_sel, 352 .list_voltage = regulator_list_voltage_linear, 353 .map_voltage = regulator_map_voltage_linear, 354 .is_enabled = regulator_is_enabled_regmap, 355 .enable = regulator_enable_regmap, 356 .disable = regulator_disable_regmap, 357 358 .set_suspend_voltage = da9055_regulator_set_suspend_voltage, 359 .set_suspend_enable = da9055_suspend_enable, 360 .set_suspend_disable = da9055_suspend_disable, 361 .set_suspend_mode = da9055_ldo_set_mode, 362 363 }; 364 365 #define DA9055_LDO(_id, step, min, max, vbits, voffset) \ 366 {\ 367 .reg_desc = {\ 368 .name = #_id,\ 369 .ops = &da9055_ldo_ops,\ 370 .type = REGULATOR_VOLTAGE,\ 371 .id = DA9055_ID_##_id,\ 372 .n_voltages = (max - min) / step + 1 + (voffset), \ 373 .enable_reg = DA9055_REG_BCORE_CONT + DA9055_ID_##_id, \ 374 .enable_mask = 1, \ 375 .min_uV = (min) * 1000,\ 376 .uV_step = (step) * 1000,\ 377 .linear_min_sel = (voffset),\ 378 .owner = THIS_MODULE,\ 379 },\ 380 .conf = {\ 381 .reg = DA9055_REG_BCORE_CONT + DA9055_ID_##_id, \ 382 .sel_mask = (1 << 4),\ 383 .en_mask = 1,\ 384 },\ 385 .volt = {\ 386 .reg_a = DA9055_REG_VBCORE_A + DA9055_ID_##_id, \ 387 .reg_b = DA9055_REG_VBCORE_B + DA9055_ID_##_id, \ 388 .sl_shift = 7,\ 389 .v_mask = (1 << (vbits)) - 1,\ 390 },\ 391 } 392 393 #define DA9055_BUCK(_id, step, min, max, vbits, voffset, mbits, sbits) \ 394 {\ 395 .reg_desc = {\ 396 .name = #_id,\ 397 .ops = &da9055_buck_ops,\ 398 .type = REGULATOR_VOLTAGE,\ 399 .id = DA9055_ID_##_id,\ 400 .n_voltages = (max - min) / step + 1 + (voffset), \ 401 .enable_reg = DA9055_REG_BCORE_CONT + DA9055_ID_##_id, \ 402 .enable_mask = 1,\ 403 .min_uV = (min) * 1000,\ 404 .uV_step = (step) * 1000,\ 405 .linear_min_sel = (voffset),\ 406 .owner = THIS_MODULE,\ 407 },\ 408 .conf = {\ 409 .reg = DA9055_REG_BCORE_CONT + DA9055_ID_##_id, \ 410 .sel_mask = (1 << 4),\ 411 .en_mask = 1,\ 412 },\ 413 .volt = {\ 414 .reg_a = DA9055_REG_VBCORE_A + DA9055_ID_##_id, \ 415 .reg_b = DA9055_REG_VBCORE_B + DA9055_ID_##_id, \ 416 .sl_shift = 7,\ 417 .v_mask = (1 << (vbits)) - 1,\ 418 },\ 419 .mode = {\ 420 .reg = DA9055_REG_BCORE_MODE,\ 421 .mask = (mbits),\ 422 .shift = (sbits),\ 423 },\ 424 } 425 426 static struct da9055_regulator_info da9055_regulator_info[] = { 427 DA9055_BUCK(BUCK1, 25, 725, 2075, 6, 9, 0xc, 2), 428 DA9055_BUCK(BUCK2, 25, 925, 2500, 6, 0, 3, 0), 429 DA9055_LDO(LDO1, 50, 900, 3300, 6, 2), 430 DA9055_LDO(LDO2, 50, 900, 3300, 6, 3), 431 DA9055_LDO(LDO3, 50, 900, 3300, 6, 2), 432 DA9055_LDO(LDO4, 50, 900, 3300, 6, 2), 433 DA9055_LDO(LDO5, 50, 900, 2750, 6, 2), 434 DA9055_LDO(LDO6, 20, 900, 3300, 7, 0), 435 }; 436 437 /* 438 * Configures regulator to be controlled either through GPIO 1 or 2. 439 * GPIO can control regulator state and/or select the regulator register 440 * set A/B for voltage ramping. 441 */ 442 static int da9055_gpio_init(struct da9055_regulator *regulator, 443 struct regulator_config *config, 444 struct da9055_pdata *pdata, int id) 445 { 446 struct da9055_regulator_info *info = regulator->info; 447 int ret = 0; 448 449 if (pdata->gpio_ren && pdata->gpio_ren[id]) { 450 char name[18]; 451 int gpio_mux = pdata->gpio_ren[id]; 452 453 config->ena_gpio = pdata->ena_gpio[id]; 454 config->ena_gpio_flags = GPIOF_OUT_INIT_HIGH; 455 config->ena_gpio_invert = 1; 456 457 /* 458 * GPI pin is muxed with regulator to control the 459 * regulator state. 460 */ 461 sprintf(name, "DA9055 GPI %d", gpio_mux); 462 ret = devm_gpio_request_one(config->dev, gpio_mux, GPIOF_DIR_IN, 463 name); 464 if (ret < 0) 465 goto err; 466 467 /* 468 * Let the regulator know that its state is controlled 469 * through GPI. 470 */ 471 ret = da9055_reg_update(regulator->da9055, info->conf.reg, 472 DA9055_E_GPI_MASK, 473 pdata->reg_ren[id] 474 << DA9055_E_GPI_SHIFT); 475 if (ret < 0) 476 goto err; 477 } 478 479 if (pdata->gpio_rsel && pdata->gpio_rsel[id]) { 480 char name[18]; 481 int gpio_mux = pdata->gpio_rsel[id]; 482 483 regulator->reg_rselect = pdata->reg_rsel[id]; 484 485 /* 486 * GPI pin is muxed with regulator to select the 487 * regulator register set A/B for voltage ramping. 488 */ 489 sprintf(name, "DA9055 GPI %d", gpio_mux); 490 ret = devm_gpio_request_one(config->dev, gpio_mux, GPIOF_DIR_IN, 491 name); 492 if (ret < 0) 493 goto err; 494 495 /* 496 * Let the regulator know that its register set A/B 497 * will be selected through GPI for voltage ramping. 498 */ 499 ret = da9055_reg_update(regulator->da9055, info->conf.reg, 500 DA9055_V_GPI_MASK, 501 pdata->reg_rsel[id] 502 << DA9055_V_GPI_SHIFT); 503 } 504 505 err: 506 return ret; 507 } 508 509 static irqreturn_t da9055_ldo5_6_oc_irq(int irq, void *data) 510 { 511 struct da9055_regulator *regulator = data; 512 513 regulator_notifier_call_chain(regulator->rdev, 514 REGULATOR_EVENT_OVER_CURRENT, NULL); 515 516 return IRQ_HANDLED; 517 } 518 519 static inline struct da9055_regulator_info *find_regulator_info(int id) 520 { 521 struct da9055_regulator_info *info; 522 int i; 523 524 for (i = 0; i < ARRAY_SIZE(da9055_regulator_info); i++) { 525 info = &da9055_regulator_info[i]; 526 if (info->reg_desc.id == id) 527 return info; 528 } 529 530 return NULL; 531 } 532 533 static int da9055_regulator_probe(struct platform_device *pdev) 534 { 535 struct regulator_config config = { }; 536 struct da9055_regulator *regulator; 537 struct da9055 *da9055 = dev_get_drvdata(pdev->dev.parent); 538 struct da9055_pdata *pdata = da9055->dev->platform_data; 539 int ret, irq; 540 541 if (pdata == NULL || pdata->regulators[pdev->id] == NULL) 542 return -ENODEV; 543 544 regulator = devm_kzalloc(&pdev->dev, sizeof(struct da9055_regulator), 545 GFP_KERNEL); 546 if (!regulator) 547 return -ENOMEM; 548 549 regulator->info = find_regulator_info(pdev->id); 550 if (regulator->info == NULL) { 551 dev_err(&pdev->dev, "invalid regulator ID specified\n"); 552 return -EINVAL; 553 } 554 555 regulator->da9055 = da9055; 556 config.dev = &pdev->dev; 557 config.driver_data = regulator; 558 config.regmap = da9055->regmap; 559 560 if (pdata && pdata->regulators) 561 config.init_data = pdata->regulators[pdev->id]; 562 563 ret = da9055_gpio_init(regulator, &config, pdata, pdev->id); 564 if (ret < 0) 565 return ret; 566 567 regulator->rdev = regulator_register(®ulator->info->reg_desc, 568 &config); 569 if (IS_ERR(regulator->rdev)) { 570 dev_err(&pdev->dev, "Failed to register regulator %s\n", 571 regulator->info->reg_desc.name); 572 ret = PTR_ERR(regulator->rdev); 573 return ret; 574 } 575 576 /* Only LDO 5 and 6 has got the over current interrupt */ 577 if (pdev->id == DA9055_ID_LDO5 || pdev->id == DA9055_ID_LDO6) { 578 irq = platform_get_irq_byname(pdev, "REGULATOR"); 579 irq = regmap_irq_get_virq(da9055->irq_data, irq); 580 ret = devm_request_threaded_irq(&pdev->dev, irq, NULL, 581 da9055_ldo5_6_oc_irq, 582 IRQF_TRIGGER_HIGH | 583 IRQF_ONESHOT | 584 IRQF_PROBE_SHARED, 585 pdev->name, regulator); 586 if (ret != 0) { 587 if (ret != -EBUSY) { 588 dev_err(&pdev->dev, 589 "Failed to request Regulator IRQ %d: %d\n", 590 irq, ret); 591 goto err_regulator; 592 } 593 } 594 } 595 596 platform_set_drvdata(pdev, regulator); 597 598 return 0; 599 600 err_regulator: 601 regulator_unregister(regulator->rdev); 602 return ret; 603 } 604 605 static int da9055_regulator_remove(struct platform_device *pdev) 606 { 607 struct da9055_regulator *regulator = platform_get_drvdata(pdev); 608 609 regulator_unregister(regulator->rdev); 610 611 return 0; 612 } 613 614 static struct platform_driver da9055_regulator_driver = { 615 .probe = da9055_regulator_probe, 616 .remove = da9055_regulator_remove, 617 .driver = { 618 .name = "da9055-regulator", 619 .owner = THIS_MODULE, 620 }, 621 }; 622 623 static int __init da9055_regulator_init(void) 624 { 625 return platform_driver_register(&da9055_regulator_driver); 626 } 627 subsys_initcall(da9055_regulator_init); 628 629 static void __exit da9055_regulator_exit(void) 630 { 631 platform_driver_unregister(&da9055_regulator_driver); 632 } 633 module_exit(da9055_regulator_exit); 634 635 MODULE_AUTHOR("David Dajun Chen <dchen@diasemi.com>"); 636 MODULE_DESCRIPTION("Power Regulator driver for Dialog DA9055 PMIC"); 637 MODULE_LICENSE("GPL"); 638 MODULE_ALIAS("platform:da9055-regulator"); 639