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