1 /* 2 * Driver for Regulator part of Palmas PMIC Chips 3 * 4 * Copyright 2011-2013 Texas Instruments Inc. 5 * 6 * Author: Graeme Gregory <gg@slimlogic.co.uk> 7 * Author: Ian Lartey <ian@slimlogic.co.uk> 8 * 9 * This program is free software; you can redistribute it and/or modify it 10 * under the terms of the GNU General Public License as published by the 11 * Free Software Foundation; either version 2 of the License, or (at your 12 * option) any later version. 13 * 14 */ 15 16 #include <linux/kernel.h> 17 #include <linux/module.h> 18 #include <linux/init.h> 19 #include <linux/err.h> 20 #include <linux/platform_device.h> 21 #include <linux/regulator/driver.h> 22 #include <linux/regulator/machine.h> 23 #include <linux/slab.h> 24 #include <linux/regmap.h> 25 #include <linux/mfd/palmas.h> 26 #include <linux/of.h> 27 #include <linux/of_platform.h> 28 #include <linux/regulator/of_regulator.h> 29 30 struct regs_info { 31 char *name; 32 char *sname; 33 u8 vsel_addr; 34 u8 ctrl_addr; 35 u8 tstep_addr; 36 int sleep_id; 37 }; 38 39 static const struct regulator_linear_range smps_low_ranges[] = { 40 REGULATOR_LINEAR_RANGE(0, 0x0, 0x0, 0), 41 REGULATOR_LINEAR_RANGE(500000, 0x1, 0x6, 0), 42 REGULATOR_LINEAR_RANGE(510000, 0x7, 0x79, 10000), 43 REGULATOR_LINEAR_RANGE(1650000, 0x7A, 0x7f, 0), 44 }; 45 46 static const struct regulator_linear_range smps_high_ranges[] = { 47 REGULATOR_LINEAR_RANGE(0, 0x0, 0x0, 0), 48 REGULATOR_LINEAR_RANGE(1000000, 0x1, 0x6, 0), 49 REGULATOR_LINEAR_RANGE(1020000, 0x7, 0x79, 20000), 50 REGULATOR_LINEAR_RANGE(3300000, 0x7A, 0x7f, 0), 51 }; 52 53 static const struct regs_info palmas_regs_info[] = { 54 { 55 .name = "SMPS12", 56 .sname = "smps1-in", 57 .vsel_addr = PALMAS_SMPS12_VOLTAGE, 58 .ctrl_addr = PALMAS_SMPS12_CTRL, 59 .tstep_addr = PALMAS_SMPS12_TSTEP, 60 .sleep_id = PALMAS_EXTERNAL_REQSTR_ID_SMPS12, 61 }, 62 { 63 .name = "SMPS123", 64 .sname = "smps1-in", 65 .vsel_addr = PALMAS_SMPS12_VOLTAGE, 66 .ctrl_addr = PALMAS_SMPS12_CTRL, 67 .tstep_addr = PALMAS_SMPS12_TSTEP, 68 .sleep_id = PALMAS_EXTERNAL_REQSTR_ID_SMPS12, 69 }, 70 { 71 .name = "SMPS3", 72 .sname = "smps3-in", 73 .vsel_addr = PALMAS_SMPS3_VOLTAGE, 74 .ctrl_addr = PALMAS_SMPS3_CTRL, 75 .sleep_id = PALMAS_EXTERNAL_REQSTR_ID_SMPS3, 76 }, 77 { 78 .name = "SMPS45", 79 .sname = "smps4-in", 80 .vsel_addr = PALMAS_SMPS45_VOLTAGE, 81 .ctrl_addr = PALMAS_SMPS45_CTRL, 82 .tstep_addr = PALMAS_SMPS45_TSTEP, 83 .sleep_id = PALMAS_EXTERNAL_REQSTR_ID_SMPS45, 84 }, 85 { 86 .name = "SMPS457", 87 .sname = "smps4-in", 88 .vsel_addr = PALMAS_SMPS45_VOLTAGE, 89 .ctrl_addr = PALMAS_SMPS45_CTRL, 90 .tstep_addr = PALMAS_SMPS45_TSTEP, 91 .sleep_id = PALMAS_EXTERNAL_REQSTR_ID_SMPS45, 92 }, 93 { 94 .name = "SMPS6", 95 .sname = "smps6-in", 96 .vsel_addr = PALMAS_SMPS6_VOLTAGE, 97 .ctrl_addr = PALMAS_SMPS6_CTRL, 98 .tstep_addr = PALMAS_SMPS6_TSTEP, 99 .sleep_id = PALMAS_EXTERNAL_REQSTR_ID_SMPS6, 100 }, 101 { 102 .name = "SMPS7", 103 .sname = "smps7-in", 104 .vsel_addr = PALMAS_SMPS7_VOLTAGE, 105 .ctrl_addr = PALMAS_SMPS7_CTRL, 106 .sleep_id = PALMAS_EXTERNAL_REQSTR_ID_SMPS7, 107 }, 108 { 109 .name = "SMPS8", 110 .sname = "smps8-in", 111 .vsel_addr = PALMAS_SMPS8_VOLTAGE, 112 .ctrl_addr = PALMAS_SMPS8_CTRL, 113 .tstep_addr = PALMAS_SMPS8_TSTEP, 114 .sleep_id = PALMAS_EXTERNAL_REQSTR_ID_SMPS8, 115 }, 116 { 117 .name = "SMPS9", 118 .sname = "smps9-in", 119 .vsel_addr = PALMAS_SMPS9_VOLTAGE, 120 .ctrl_addr = PALMAS_SMPS9_CTRL, 121 .sleep_id = PALMAS_EXTERNAL_REQSTR_ID_SMPS9, 122 }, 123 { 124 .name = "SMPS10_OUT2", 125 .sname = "smps10-in", 126 .ctrl_addr = PALMAS_SMPS10_CTRL, 127 .sleep_id = PALMAS_EXTERNAL_REQSTR_ID_SMPS10, 128 }, 129 { 130 .name = "SMPS10_OUT1", 131 .sname = "smps10-out2", 132 .ctrl_addr = PALMAS_SMPS10_CTRL, 133 .sleep_id = PALMAS_EXTERNAL_REQSTR_ID_SMPS10, 134 }, 135 { 136 .name = "LDO1", 137 .sname = "ldo1-in", 138 .vsel_addr = PALMAS_LDO1_VOLTAGE, 139 .ctrl_addr = PALMAS_LDO1_CTRL, 140 .sleep_id = PALMAS_EXTERNAL_REQSTR_ID_LDO1, 141 }, 142 { 143 .name = "LDO2", 144 .sname = "ldo2-in", 145 .vsel_addr = PALMAS_LDO2_VOLTAGE, 146 .ctrl_addr = PALMAS_LDO2_CTRL, 147 .sleep_id = PALMAS_EXTERNAL_REQSTR_ID_LDO2, 148 }, 149 { 150 .name = "LDO3", 151 .sname = "ldo3-in", 152 .vsel_addr = PALMAS_LDO3_VOLTAGE, 153 .ctrl_addr = PALMAS_LDO3_CTRL, 154 .sleep_id = PALMAS_EXTERNAL_REQSTR_ID_LDO3, 155 }, 156 { 157 .name = "LDO4", 158 .sname = "ldo4-in", 159 .vsel_addr = PALMAS_LDO4_VOLTAGE, 160 .ctrl_addr = PALMAS_LDO4_CTRL, 161 .sleep_id = PALMAS_EXTERNAL_REQSTR_ID_LDO4, 162 }, 163 { 164 .name = "LDO5", 165 .sname = "ldo5-in", 166 .vsel_addr = PALMAS_LDO5_VOLTAGE, 167 .ctrl_addr = PALMAS_LDO5_CTRL, 168 .sleep_id = PALMAS_EXTERNAL_REQSTR_ID_LDO5, 169 }, 170 { 171 .name = "LDO6", 172 .sname = "ldo6-in", 173 .vsel_addr = PALMAS_LDO6_VOLTAGE, 174 .ctrl_addr = PALMAS_LDO6_CTRL, 175 .sleep_id = PALMAS_EXTERNAL_REQSTR_ID_LDO6, 176 }, 177 { 178 .name = "LDO7", 179 .sname = "ldo7-in", 180 .vsel_addr = PALMAS_LDO7_VOLTAGE, 181 .ctrl_addr = PALMAS_LDO7_CTRL, 182 .sleep_id = PALMAS_EXTERNAL_REQSTR_ID_LDO7, 183 }, 184 { 185 .name = "LDO8", 186 .sname = "ldo8-in", 187 .vsel_addr = PALMAS_LDO8_VOLTAGE, 188 .ctrl_addr = PALMAS_LDO8_CTRL, 189 .sleep_id = PALMAS_EXTERNAL_REQSTR_ID_LDO8, 190 }, 191 { 192 .name = "LDO9", 193 .sname = "ldo9-in", 194 .vsel_addr = PALMAS_LDO9_VOLTAGE, 195 .ctrl_addr = PALMAS_LDO9_CTRL, 196 .sleep_id = PALMAS_EXTERNAL_REQSTR_ID_LDO9, 197 }, 198 { 199 .name = "LDOLN", 200 .sname = "ldoln-in", 201 .vsel_addr = PALMAS_LDOLN_VOLTAGE, 202 .ctrl_addr = PALMAS_LDOLN_CTRL, 203 .sleep_id = PALMAS_EXTERNAL_REQSTR_ID_LDOLN, 204 }, 205 { 206 .name = "LDOUSB", 207 .sname = "ldousb-in", 208 .vsel_addr = PALMAS_LDOUSB_VOLTAGE, 209 .ctrl_addr = PALMAS_LDOUSB_CTRL, 210 .sleep_id = PALMAS_EXTERNAL_REQSTR_ID_LDOUSB, 211 }, 212 { 213 .name = "REGEN1", 214 .ctrl_addr = PALMAS_REGEN1_CTRL, 215 .sleep_id = PALMAS_EXTERNAL_REQSTR_ID_REGEN1, 216 }, 217 { 218 .name = "REGEN2", 219 .ctrl_addr = PALMAS_REGEN2_CTRL, 220 .sleep_id = PALMAS_EXTERNAL_REQSTR_ID_REGEN2, 221 }, 222 { 223 .name = "REGEN3", 224 .ctrl_addr = PALMAS_REGEN3_CTRL, 225 .sleep_id = PALMAS_EXTERNAL_REQSTR_ID_REGEN3, 226 }, 227 { 228 .name = "SYSEN1", 229 .ctrl_addr = PALMAS_SYSEN1_CTRL, 230 .sleep_id = PALMAS_EXTERNAL_REQSTR_ID_SYSEN1, 231 }, 232 { 233 .name = "SYSEN2", 234 .ctrl_addr = PALMAS_SYSEN2_CTRL, 235 .sleep_id = PALMAS_EXTERNAL_REQSTR_ID_SYSEN2, 236 }, 237 }; 238 239 static unsigned int palmas_smps_ramp_delay[4] = {0, 10000, 5000, 2500}; 240 241 #define SMPS_CTRL_MODE_OFF 0x00 242 #define SMPS_CTRL_MODE_ON 0x01 243 #define SMPS_CTRL_MODE_ECO 0x02 244 #define SMPS_CTRL_MODE_PWM 0x03 245 246 #define PALMAS_SMPS_NUM_VOLTAGES 122 247 #define PALMAS_SMPS10_NUM_VOLTAGES 2 248 #define PALMAS_LDO_NUM_VOLTAGES 50 249 250 #define SMPS10_VSEL (1<<3) 251 #define SMPS10_BOOST_EN (1<<2) 252 #define SMPS10_BYPASS_EN (1<<1) 253 #define SMPS10_SWITCH_EN (1<<0) 254 255 #define REGULATOR_SLAVE 0 256 257 static int palmas_smps_read(struct palmas *palmas, unsigned int reg, 258 unsigned int *dest) 259 { 260 unsigned int addr; 261 262 addr = PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE, reg); 263 264 return regmap_read(palmas->regmap[REGULATOR_SLAVE], addr, dest); 265 } 266 267 static int palmas_smps_write(struct palmas *palmas, unsigned int reg, 268 unsigned int value) 269 { 270 unsigned int addr; 271 272 addr = PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE, reg); 273 274 return regmap_write(palmas->regmap[REGULATOR_SLAVE], addr, value); 275 } 276 277 static int palmas_ldo_read(struct palmas *palmas, unsigned int reg, 278 unsigned int *dest) 279 { 280 unsigned int addr; 281 282 addr = PALMAS_BASE_TO_REG(PALMAS_LDO_BASE, reg); 283 284 return regmap_read(palmas->regmap[REGULATOR_SLAVE], addr, dest); 285 } 286 287 static int palmas_ldo_write(struct palmas *palmas, unsigned int reg, 288 unsigned int value) 289 { 290 unsigned int addr; 291 292 addr = PALMAS_BASE_TO_REG(PALMAS_LDO_BASE, reg); 293 294 return regmap_write(palmas->regmap[REGULATOR_SLAVE], addr, value); 295 } 296 297 static int palmas_set_mode_smps(struct regulator_dev *dev, unsigned int mode) 298 { 299 struct palmas_pmic *pmic = rdev_get_drvdata(dev); 300 int id = rdev_get_id(dev); 301 unsigned int reg; 302 bool rail_enable = true; 303 304 palmas_smps_read(pmic->palmas, palmas_regs_info[id].ctrl_addr, ®); 305 reg &= ~PALMAS_SMPS12_CTRL_MODE_ACTIVE_MASK; 306 307 if (reg == SMPS_CTRL_MODE_OFF) 308 rail_enable = false; 309 310 switch (mode) { 311 case REGULATOR_MODE_NORMAL: 312 reg |= SMPS_CTRL_MODE_ON; 313 break; 314 case REGULATOR_MODE_IDLE: 315 reg |= SMPS_CTRL_MODE_ECO; 316 break; 317 case REGULATOR_MODE_FAST: 318 reg |= SMPS_CTRL_MODE_PWM; 319 break; 320 default: 321 return -EINVAL; 322 } 323 324 pmic->current_reg_mode[id] = reg & PALMAS_SMPS12_CTRL_MODE_ACTIVE_MASK; 325 if (rail_enable) 326 palmas_smps_write(pmic->palmas, 327 palmas_regs_info[id].ctrl_addr, reg); 328 329 /* Switch the enable value to ensure this is used for enable */ 330 pmic->desc[id].enable_val = pmic->current_reg_mode[id]; 331 332 return 0; 333 } 334 335 static unsigned int palmas_get_mode_smps(struct regulator_dev *dev) 336 { 337 struct palmas_pmic *pmic = rdev_get_drvdata(dev); 338 int id = rdev_get_id(dev); 339 unsigned int reg; 340 341 reg = pmic->current_reg_mode[id] & PALMAS_SMPS12_CTRL_MODE_ACTIVE_MASK; 342 343 switch (reg) { 344 case SMPS_CTRL_MODE_ON: 345 return REGULATOR_MODE_NORMAL; 346 case SMPS_CTRL_MODE_ECO: 347 return REGULATOR_MODE_IDLE; 348 case SMPS_CTRL_MODE_PWM: 349 return REGULATOR_MODE_FAST; 350 } 351 352 return 0; 353 } 354 355 static int palmas_smps_set_ramp_delay(struct regulator_dev *rdev, 356 int ramp_delay) 357 { 358 struct palmas_pmic *pmic = rdev_get_drvdata(rdev); 359 int id = rdev_get_id(rdev); 360 unsigned int reg = 0; 361 unsigned int addr = palmas_regs_info[id].tstep_addr; 362 int ret; 363 364 /* SMPS3 and SMPS7 do not have tstep_addr setting */ 365 switch (id) { 366 case PALMAS_REG_SMPS3: 367 case PALMAS_REG_SMPS7: 368 return 0; 369 } 370 371 if (ramp_delay <= 0) 372 reg = 0; 373 else if (ramp_delay <= 2500) 374 reg = 3; 375 else if (ramp_delay <= 5000) 376 reg = 2; 377 else 378 reg = 1; 379 380 ret = palmas_smps_write(pmic->palmas, addr, reg); 381 if (ret < 0) { 382 dev_err(pmic->palmas->dev, "TSTEP write failed: %d\n", ret); 383 return ret; 384 } 385 386 pmic->ramp_delay[id] = palmas_smps_ramp_delay[reg]; 387 return ret; 388 } 389 390 static struct regulator_ops palmas_ops_smps = { 391 .is_enabled = regulator_is_enabled_regmap, 392 .enable = regulator_enable_regmap, 393 .disable = regulator_disable_regmap, 394 .set_mode = palmas_set_mode_smps, 395 .get_mode = palmas_get_mode_smps, 396 .get_voltage_sel = regulator_get_voltage_sel_regmap, 397 .set_voltage_sel = regulator_set_voltage_sel_regmap, 398 .list_voltage = regulator_list_voltage_linear_range, 399 .map_voltage = regulator_map_voltage_linear_range, 400 .set_voltage_time_sel = regulator_set_voltage_time_sel, 401 .set_ramp_delay = palmas_smps_set_ramp_delay, 402 }; 403 404 static struct regulator_ops palmas_ops_ext_control_smps = { 405 .set_mode = palmas_set_mode_smps, 406 .get_mode = palmas_get_mode_smps, 407 .get_voltage_sel = regulator_get_voltage_sel_regmap, 408 .set_voltage_sel = regulator_set_voltage_sel_regmap, 409 .list_voltage = regulator_list_voltage_linear_range, 410 .map_voltage = regulator_map_voltage_linear_range, 411 .set_voltage_time_sel = regulator_set_voltage_time_sel, 412 .set_ramp_delay = palmas_smps_set_ramp_delay, 413 }; 414 415 static struct regulator_ops palmas_ops_smps10 = { 416 .is_enabled = regulator_is_enabled_regmap, 417 .enable = regulator_enable_regmap, 418 .disable = regulator_disable_regmap, 419 .get_voltage_sel = regulator_get_voltage_sel_regmap, 420 .set_voltage_sel = regulator_set_voltage_sel_regmap, 421 .list_voltage = regulator_list_voltage_linear, 422 .map_voltage = regulator_map_voltage_linear, 423 .set_bypass = regulator_set_bypass_regmap, 424 .get_bypass = regulator_get_bypass_regmap, 425 }; 426 427 static int palmas_is_enabled_ldo(struct regulator_dev *dev) 428 { 429 struct palmas_pmic *pmic = rdev_get_drvdata(dev); 430 int id = rdev_get_id(dev); 431 unsigned int reg; 432 433 palmas_ldo_read(pmic->palmas, palmas_regs_info[id].ctrl_addr, ®); 434 435 reg &= PALMAS_LDO1_CTRL_STATUS; 436 437 return !!(reg); 438 } 439 440 static struct regulator_ops palmas_ops_ldo = { 441 .is_enabled = palmas_is_enabled_ldo, 442 .enable = regulator_enable_regmap, 443 .disable = regulator_disable_regmap, 444 .get_voltage_sel = regulator_get_voltage_sel_regmap, 445 .set_voltage_sel = regulator_set_voltage_sel_regmap, 446 .list_voltage = regulator_list_voltage_linear, 447 .map_voltage = regulator_map_voltage_linear, 448 }; 449 450 static struct regulator_ops palmas_ops_ext_control_ldo = { 451 .get_voltage_sel = regulator_get_voltage_sel_regmap, 452 .set_voltage_sel = regulator_set_voltage_sel_regmap, 453 .list_voltage = regulator_list_voltage_linear, 454 .map_voltage = regulator_map_voltage_linear, 455 }; 456 457 static struct regulator_ops palmas_ops_extreg = { 458 .is_enabled = regulator_is_enabled_regmap, 459 .enable = regulator_enable_regmap, 460 .disable = regulator_disable_regmap, 461 }; 462 463 static struct regulator_ops palmas_ops_ext_control_extreg = { 464 }; 465 466 static int palmas_regulator_config_external(struct palmas *palmas, int id, 467 struct palmas_reg_init *reg_init) 468 { 469 int sleep_id = palmas_regs_info[id].sleep_id; 470 int ret; 471 472 ret = palmas_ext_control_req_config(palmas, sleep_id, 473 reg_init->roof_floor, true); 474 if (ret < 0) 475 dev_err(palmas->dev, 476 "Ext control config for regulator %d failed %d\n", 477 id, ret); 478 return ret; 479 } 480 481 /* 482 * setup the hardware based sleep configuration of the SMPS/LDO regulators 483 * from the platform data. This is different to the software based control 484 * supported by the regulator framework as it is controlled by toggling 485 * pins on the PMIC such as PREQ, SYSEN, ... 486 */ 487 static int palmas_smps_init(struct palmas *palmas, int id, 488 struct palmas_reg_init *reg_init) 489 { 490 unsigned int reg; 491 unsigned int addr; 492 int ret; 493 494 addr = palmas_regs_info[id].ctrl_addr; 495 496 ret = palmas_smps_read(palmas, addr, ®); 497 if (ret) 498 return ret; 499 500 switch (id) { 501 case PALMAS_REG_SMPS10_OUT1: 502 case PALMAS_REG_SMPS10_OUT2: 503 reg &= ~PALMAS_SMPS10_CTRL_MODE_SLEEP_MASK; 504 if (reg_init->mode_sleep) 505 reg |= reg_init->mode_sleep << 506 PALMAS_SMPS10_CTRL_MODE_SLEEP_SHIFT; 507 break; 508 default: 509 if (reg_init->warm_reset) 510 reg |= PALMAS_SMPS12_CTRL_WR_S; 511 else 512 reg &= ~PALMAS_SMPS12_CTRL_WR_S; 513 514 if (reg_init->roof_floor) 515 reg |= PALMAS_SMPS12_CTRL_ROOF_FLOOR_EN; 516 else 517 reg &= ~PALMAS_SMPS12_CTRL_ROOF_FLOOR_EN; 518 519 reg &= ~PALMAS_SMPS12_CTRL_MODE_SLEEP_MASK; 520 if (reg_init->mode_sleep) 521 reg |= reg_init->mode_sleep << 522 PALMAS_SMPS12_CTRL_MODE_SLEEP_SHIFT; 523 } 524 525 ret = palmas_smps_write(palmas, addr, reg); 526 if (ret) 527 return ret; 528 529 if (palmas_regs_info[id].vsel_addr && reg_init->vsel) { 530 addr = palmas_regs_info[id].vsel_addr; 531 532 reg = reg_init->vsel; 533 534 ret = palmas_smps_write(palmas, addr, reg); 535 if (ret) 536 return ret; 537 } 538 539 if (reg_init->roof_floor && (id != PALMAS_REG_SMPS10_OUT1) && 540 (id != PALMAS_REG_SMPS10_OUT2)) { 541 /* Enable externally controlled regulator */ 542 addr = palmas_regs_info[id].ctrl_addr; 543 ret = palmas_smps_read(palmas, addr, ®); 544 if (ret < 0) 545 return ret; 546 547 if (!(reg & PALMAS_SMPS12_CTRL_MODE_ACTIVE_MASK)) { 548 reg |= SMPS_CTRL_MODE_ON; 549 ret = palmas_smps_write(palmas, addr, reg); 550 if (ret < 0) 551 return ret; 552 } 553 return palmas_regulator_config_external(palmas, id, reg_init); 554 } 555 return 0; 556 } 557 558 static int palmas_ldo_init(struct palmas *palmas, int id, 559 struct palmas_reg_init *reg_init) 560 { 561 unsigned int reg; 562 unsigned int addr; 563 int ret; 564 565 addr = palmas_regs_info[id].ctrl_addr; 566 567 ret = palmas_ldo_read(palmas, addr, ®); 568 if (ret) 569 return ret; 570 571 if (reg_init->warm_reset) 572 reg |= PALMAS_LDO1_CTRL_WR_S; 573 else 574 reg &= ~PALMAS_LDO1_CTRL_WR_S; 575 576 if (reg_init->mode_sleep) 577 reg |= PALMAS_LDO1_CTRL_MODE_SLEEP; 578 else 579 reg &= ~PALMAS_LDO1_CTRL_MODE_SLEEP; 580 581 ret = palmas_ldo_write(palmas, addr, reg); 582 if (ret) 583 return ret; 584 585 if (reg_init->roof_floor) { 586 /* Enable externally controlled regulator */ 587 addr = palmas_regs_info[id].ctrl_addr; 588 ret = palmas_update_bits(palmas, PALMAS_LDO_BASE, 589 addr, PALMAS_LDO1_CTRL_MODE_ACTIVE, 590 PALMAS_LDO1_CTRL_MODE_ACTIVE); 591 if (ret < 0) { 592 dev_err(palmas->dev, 593 "LDO Register 0x%02x update failed %d\n", 594 addr, ret); 595 return ret; 596 } 597 return palmas_regulator_config_external(palmas, id, reg_init); 598 } 599 return 0; 600 } 601 602 static int palmas_extreg_init(struct palmas *palmas, int id, 603 struct palmas_reg_init *reg_init) 604 { 605 unsigned int addr; 606 int ret; 607 unsigned int val = 0; 608 609 addr = palmas_regs_info[id].ctrl_addr; 610 611 if (reg_init->mode_sleep) 612 val = PALMAS_REGEN1_CTRL_MODE_SLEEP; 613 614 ret = palmas_update_bits(palmas, PALMAS_RESOURCE_BASE, 615 addr, PALMAS_REGEN1_CTRL_MODE_SLEEP, val); 616 if (ret < 0) { 617 dev_err(palmas->dev, "Resource reg 0x%02x update failed %d\n", 618 addr, ret); 619 return ret; 620 } 621 622 if (reg_init->roof_floor) { 623 /* Enable externally controlled regulator */ 624 addr = palmas_regs_info[id].ctrl_addr; 625 ret = palmas_update_bits(palmas, PALMAS_RESOURCE_BASE, 626 addr, PALMAS_REGEN1_CTRL_MODE_ACTIVE, 627 PALMAS_REGEN1_CTRL_MODE_ACTIVE); 628 if (ret < 0) { 629 dev_err(palmas->dev, 630 "Resource Register 0x%02x update failed %d\n", 631 addr, ret); 632 return ret; 633 } 634 return palmas_regulator_config_external(palmas, id, reg_init); 635 } 636 return 0; 637 } 638 639 static void palmas_enable_ldo8_track(struct palmas *palmas) 640 { 641 unsigned int reg; 642 unsigned int addr; 643 int ret; 644 645 addr = palmas_regs_info[PALMAS_REG_LDO8].ctrl_addr; 646 647 ret = palmas_ldo_read(palmas, addr, ®); 648 if (ret) { 649 dev_err(palmas->dev, "Error in reading ldo8 control reg\n"); 650 return; 651 } 652 653 reg |= PALMAS_LDO8_CTRL_LDO_TRACKING_EN; 654 ret = palmas_ldo_write(palmas, addr, reg); 655 if (ret < 0) { 656 dev_err(palmas->dev, "Error in enabling tracking mode\n"); 657 return; 658 } 659 /* 660 * When SMPS45 is set to off and LDO8 tracking is enabled, the LDO8 661 * output is defined by the LDO8_VOLTAGE.VSEL register divided by two, 662 * and can be set from 0.45 to 1.65 V. 663 */ 664 addr = palmas_regs_info[PALMAS_REG_LDO8].vsel_addr; 665 ret = palmas_ldo_read(palmas, addr, ®); 666 if (ret) { 667 dev_err(palmas->dev, "Error in reading ldo8 voltage reg\n"); 668 return; 669 } 670 671 reg = (reg << 1) & PALMAS_LDO8_VOLTAGE_VSEL_MASK; 672 ret = palmas_ldo_write(palmas, addr, reg); 673 if (ret < 0) 674 dev_err(palmas->dev, "Error in setting ldo8 voltage reg\n"); 675 676 return; 677 } 678 679 static struct of_regulator_match palmas_matches[] = { 680 { .name = "smps12", }, 681 { .name = "smps123", }, 682 { .name = "smps3", }, 683 { .name = "smps45", }, 684 { .name = "smps457", }, 685 { .name = "smps6", }, 686 { .name = "smps7", }, 687 { .name = "smps8", }, 688 { .name = "smps9", }, 689 { .name = "smps10_out2", }, 690 { .name = "smps10_out1", }, 691 { .name = "ldo1", }, 692 { .name = "ldo2", }, 693 { .name = "ldo3", }, 694 { .name = "ldo4", }, 695 { .name = "ldo5", }, 696 { .name = "ldo6", }, 697 { .name = "ldo7", }, 698 { .name = "ldo8", }, 699 { .name = "ldo9", }, 700 { .name = "ldoln", }, 701 { .name = "ldousb", }, 702 { .name = "regen1", }, 703 { .name = "regen2", }, 704 { .name = "regen3", }, 705 { .name = "sysen1", }, 706 { .name = "sysen2", }, 707 }; 708 709 static void palmas_dt_to_pdata(struct device *dev, 710 struct device_node *node, 711 struct palmas_pmic_platform_data *pdata) 712 { 713 struct device_node *regulators; 714 u32 prop; 715 int idx, ret; 716 717 node = of_node_get(node); 718 regulators = of_get_child_by_name(node, "regulators"); 719 if (!regulators) { 720 dev_info(dev, "regulator node not found\n"); 721 return; 722 } 723 724 ret = of_regulator_match(dev, regulators, palmas_matches, 725 PALMAS_NUM_REGS); 726 of_node_put(regulators); 727 if (ret < 0) { 728 dev_err(dev, "Error parsing regulator init data: %d\n", ret); 729 return; 730 } 731 732 for (idx = 0; idx < PALMAS_NUM_REGS; idx++) { 733 if (!palmas_matches[idx].init_data || 734 !palmas_matches[idx].of_node) 735 continue; 736 737 pdata->reg_data[idx] = palmas_matches[idx].init_data; 738 739 pdata->reg_init[idx] = devm_kzalloc(dev, 740 sizeof(struct palmas_reg_init), GFP_KERNEL); 741 742 pdata->reg_init[idx]->warm_reset = 743 of_property_read_bool(palmas_matches[idx].of_node, 744 "ti,warm-reset"); 745 746 ret = of_property_read_u32(palmas_matches[idx].of_node, 747 "ti,roof-floor", &prop); 748 /* EINVAL: Property not found */ 749 if (ret != -EINVAL) { 750 int econtrol; 751 752 /* use default value, when no value is specified */ 753 econtrol = PALMAS_EXT_CONTROL_NSLEEP; 754 if (!ret) { 755 switch (prop) { 756 case 1: 757 econtrol = PALMAS_EXT_CONTROL_ENABLE1; 758 break; 759 case 2: 760 econtrol = PALMAS_EXT_CONTROL_ENABLE2; 761 break; 762 case 3: 763 econtrol = PALMAS_EXT_CONTROL_NSLEEP; 764 break; 765 default: 766 WARN_ON(1); 767 dev_warn(dev, 768 "%s: Invalid roof-floor option: %u\n", 769 palmas_matches[idx].name, prop); 770 break; 771 } 772 } 773 pdata->reg_init[idx]->roof_floor = econtrol; 774 } 775 776 ret = of_property_read_u32(palmas_matches[idx].of_node, 777 "ti,mode-sleep", &prop); 778 if (!ret) 779 pdata->reg_init[idx]->mode_sleep = prop; 780 781 ret = of_property_read_bool(palmas_matches[idx].of_node, 782 "ti,smps-range"); 783 if (ret) 784 pdata->reg_init[idx]->vsel = 785 PALMAS_SMPS12_VOLTAGE_RANGE; 786 787 if (idx == PALMAS_REG_LDO8) 788 pdata->enable_ldo8_tracking = of_property_read_bool( 789 palmas_matches[idx].of_node, 790 "ti,enable-ldo8-tracking"); 791 } 792 793 pdata->ldo6_vibrator = of_property_read_bool(node, "ti,ldo6-vibrator"); 794 } 795 796 797 static int palmas_regulators_probe(struct platform_device *pdev) 798 { 799 struct palmas *palmas = dev_get_drvdata(pdev->dev.parent); 800 struct palmas_pmic_platform_data *pdata = dev_get_platdata(&pdev->dev); 801 struct device_node *node = pdev->dev.of_node; 802 struct regulator_dev *rdev; 803 struct regulator_config config = { }; 804 struct palmas_pmic *pmic; 805 struct palmas_reg_init *reg_init; 806 int id = 0, ret; 807 unsigned int addr, reg; 808 809 if (node && !pdata) { 810 pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL); 811 812 if (!pdata) 813 return -ENOMEM; 814 815 palmas_dt_to_pdata(&pdev->dev, node, pdata); 816 } 817 818 pmic = devm_kzalloc(&pdev->dev, sizeof(*pmic), GFP_KERNEL); 819 if (!pmic) 820 return -ENOMEM; 821 822 pmic->dev = &pdev->dev; 823 pmic->palmas = palmas; 824 palmas->pmic = pmic; 825 platform_set_drvdata(pdev, pmic); 826 827 ret = palmas_smps_read(palmas, PALMAS_SMPS_CTRL, ®); 828 if (ret) 829 return ret; 830 831 if (reg & PALMAS_SMPS_CTRL_SMPS12_SMPS123_EN) 832 pmic->smps123 = 1; 833 834 if (reg & PALMAS_SMPS_CTRL_SMPS45_SMPS457_EN) 835 pmic->smps457 = 1; 836 837 config.regmap = palmas->regmap[REGULATOR_SLAVE]; 838 config.dev = &pdev->dev; 839 config.driver_data = pmic; 840 841 for (id = 0; id < PALMAS_REG_LDO1; id++) { 842 bool ramp_delay_support = false; 843 844 /* 845 * Miss out regulators which are not available due 846 * to slaving configurations. 847 */ 848 switch (id) { 849 case PALMAS_REG_SMPS12: 850 case PALMAS_REG_SMPS3: 851 if (pmic->smps123) 852 continue; 853 if (id == PALMAS_REG_SMPS12) 854 ramp_delay_support = true; 855 break; 856 case PALMAS_REG_SMPS123: 857 if (!pmic->smps123) 858 continue; 859 ramp_delay_support = true; 860 break; 861 case PALMAS_REG_SMPS45: 862 case PALMAS_REG_SMPS7: 863 if (pmic->smps457) 864 continue; 865 if (id == PALMAS_REG_SMPS45) 866 ramp_delay_support = true; 867 break; 868 case PALMAS_REG_SMPS457: 869 if (!pmic->smps457) 870 continue; 871 ramp_delay_support = true; 872 break; 873 case PALMAS_REG_SMPS10_OUT1: 874 case PALMAS_REG_SMPS10_OUT2: 875 if (!PALMAS_PMIC_HAS(palmas, SMPS10_BOOST)) 876 continue; 877 } 878 879 if ((id == PALMAS_REG_SMPS6) || (id == PALMAS_REG_SMPS8)) 880 ramp_delay_support = true; 881 882 if (ramp_delay_support) { 883 addr = palmas_regs_info[id].tstep_addr; 884 ret = palmas_smps_read(pmic->palmas, addr, ®); 885 if (ret < 0) { 886 dev_err(&pdev->dev, 887 "reading TSTEP reg failed: %d\n", ret); 888 return ret; 889 } 890 pmic->desc[id].ramp_delay = 891 palmas_smps_ramp_delay[reg & 0x3]; 892 pmic->ramp_delay[id] = pmic->desc[id].ramp_delay; 893 } 894 895 /* Initialise sleep/init values from platform data */ 896 if (pdata && pdata->reg_init[id]) { 897 reg_init = pdata->reg_init[id]; 898 ret = palmas_smps_init(palmas, id, reg_init); 899 if (ret) 900 return ret; 901 } else { 902 reg_init = NULL; 903 } 904 905 /* Register the regulators */ 906 pmic->desc[id].name = palmas_regs_info[id].name; 907 pmic->desc[id].id = id; 908 909 switch (id) { 910 case PALMAS_REG_SMPS10_OUT1: 911 case PALMAS_REG_SMPS10_OUT2: 912 pmic->desc[id].n_voltages = PALMAS_SMPS10_NUM_VOLTAGES; 913 pmic->desc[id].ops = &palmas_ops_smps10; 914 pmic->desc[id].vsel_reg = 915 PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE, 916 PALMAS_SMPS10_CTRL); 917 pmic->desc[id].vsel_mask = SMPS10_VSEL; 918 pmic->desc[id].enable_reg = 919 PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE, 920 PALMAS_SMPS10_CTRL); 921 if (id == PALMAS_REG_SMPS10_OUT1) 922 pmic->desc[id].enable_mask = SMPS10_SWITCH_EN; 923 else 924 pmic->desc[id].enable_mask = SMPS10_BOOST_EN; 925 pmic->desc[id].bypass_reg = 926 PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE, 927 PALMAS_SMPS10_CTRL); 928 pmic->desc[id].bypass_mask = SMPS10_BYPASS_EN; 929 pmic->desc[id].min_uV = 3750000; 930 pmic->desc[id].uV_step = 1250000; 931 break; 932 default: 933 /* 934 * Read and store the RANGE bit for later use 935 * This must be done before regulator is probed, 936 * otherwise we error in probe with unsupportable 937 * ranges. Read the current smps mode for later use. 938 */ 939 addr = palmas_regs_info[id].vsel_addr; 940 pmic->desc[id].n_linear_ranges = 3; 941 942 ret = palmas_smps_read(pmic->palmas, addr, ®); 943 if (ret) 944 return ret; 945 if (reg & PALMAS_SMPS12_VOLTAGE_RANGE) 946 pmic->range[id] = 1; 947 if (pmic->range[id]) 948 pmic->desc[id].linear_ranges = smps_high_ranges; 949 else 950 pmic->desc[id].linear_ranges = smps_low_ranges; 951 952 if (reg_init && reg_init->roof_floor) 953 pmic->desc[id].ops = 954 &palmas_ops_ext_control_smps; 955 else 956 pmic->desc[id].ops = &palmas_ops_smps; 957 pmic->desc[id].n_voltages = PALMAS_SMPS_NUM_VOLTAGES; 958 pmic->desc[id].vsel_reg = 959 PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE, 960 palmas_regs_info[id].vsel_addr); 961 pmic->desc[id].vsel_mask = 962 PALMAS_SMPS12_VOLTAGE_VSEL_MASK; 963 964 /* Read the smps mode for later use. */ 965 addr = palmas_regs_info[id].ctrl_addr; 966 ret = palmas_smps_read(pmic->palmas, addr, ®); 967 if (ret) 968 return ret; 969 pmic->current_reg_mode[id] = reg & 970 PALMAS_SMPS12_CTRL_MODE_ACTIVE_MASK; 971 972 pmic->desc[id].enable_reg = 973 PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE, 974 palmas_regs_info[id].ctrl_addr); 975 pmic->desc[id].enable_mask = 976 PALMAS_SMPS12_CTRL_MODE_ACTIVE_MASK; 977 /* set_mode overrides this value */ 978 pmic->desc[id].enable_val = SMPS_CTRL_MODE_ON; 979 } 980 981 pmic->desc[id].type = REGULATOR_VOLTAGE; 982 pmic->desc[id].owner = THIS_MODULE; 983 984 if (pdata) 985 config.init_data = pdata->reg_data[id]; 986 else 987 config.init_data = NULL; 988 989 pmic->desc[id].supply_name = palmas_regs_info[id].sname; 990 config.of_node = palmas_matches[id].of_node; 991 992 rdev = devm_regulator_register(&pdev->dev, &pmic->desc[id], 993 &config); 994 if (IS_ERR(rdev)) { 995 dev_err(&pdev->dev, 996 "failed to register %s regulator\n", 997 pdev->name); 998 return PTR_ERR(rdev); 999 } 1000 1001 /* Save regulator for cleanup */ 1002 pmic->rdev[id] = rdev; 1003 } 1004 1005 /* Start this loop from the id left from previous loop */ 1006 for (; id < PALMAS_NUM_REGS; id++) { 1007 if (pdata && pdata->reg_init[id]) 1008 reg_init = pdata->reg_init[id]; 1009 else 1010 reg_init = NULL; 1011 1012 /* Miss out regulators which are not available due 1013 * to alternate functions. 1014 */ 1015 1016 /* Register the regulators */ 1017 pmic->desc[id].name = palmas_regs_info[id].name; 1018 pmic->desc[id].id = id; 1019 pmic->desc[id].type = REGULATOR_VOLTAGE; 1020 pmic->desc[id].owner = THIS_MODULE; 1021 1022 if (id < PALMAS_REG_REGEN1) { 1023 pmic->desc[id].n_voltages = PALMAS_LDO_NUM_VOLTAGES; 1024 if (reg_init && reg_init->roof_floor) 1025 pmic->desc[id].ops = 1026 &palmas_ops_ext_control_ldo; 1027 else 1028 pmic->desc[id].ops = &palmas_ops_ldo; 1029 pmic->desc[id].min_uV = 900000; 1030 pmic->desc[id].uV_step = 50000; 1031 pmic->desc[id].linear_min_sel = 1; 1032 pmic->desc[id].enable_time = 500; 1033 pmic->desc[id].vsel_reg = 1034 PALMAS_BASE_TO_REG(PALMAS_LDO_BASE, 1035 palmas_regs_info[id].vsel_addr); 1036 pmic->desc[id].vsel_mask = 1037 PALMAS_LDO1_VOLTAGE_VSEL_MASK; 1038 pmic->desc[id].enable_reg = 1039 PALMAS_BASE_TO_REG(PALMAS_LDO_BASE, 1040 palmas_regs_info[id].ctrl_addr); 1041 pmic->desc[id].enable_mask = 1042 PALMAS_LDO1_CTRL_MODE_ACTIVE; 1043 1044 /* Check if LDO8 is in tracking mode or not */ 1045 if (pdata && (id == PALMAS_REG_LDO8) && 1046 pdata->enable_ldo8_tracking) { 1047 palmas_enable_ldo8_track(palmas); 1048 pmic->desc[id].min_uV = 450000; 1049 pmic->desc[id].uV_step = 25000; 1050 } 1051 1052 /* LOD6 in vibrator mode will have enable time 2000us */ 1053 if (pdata && pdata->ldo6_vibrator && 1054 (id == PALMAS_REG_LDO6)) 1055 pmic->desc[id].enable_time = 2000; 1056 } else { 1057 pmic->desc[id].n_voltages = 1; 1058 if (reg_init && reg_init->roof_floor) 1059 pmic->desc[id].ops = 1060 &palmas_ops_ext_control_extreg; 1061 else 1062 pmic->desc[id].ops = &palmas_ops_extreg; 1063 pmic->desc[id].enable_reg = 1064 PALMAS_BASE_TO_REG(PALMAS_RESOURCE_BASE, 1065 palmas_regs_info[id].ctrl_addr); 1066 pmic->desc[id].enable_mask = 1067 PALMAS_REGEN1_CTRL_MODE_ACTIVE; 1068 } 1069 1070 if (pdata) 1071 config.init_data = pdata->reg_data[id]; 1072 else 1073 config.init_data = NULL; 1074 1075 pmic->desc[id].supply_name = palmas_regs_info[id].sname; 1076 config.of_node = palmas_matches[id].of_node; 1077 1078 rdev = devm_regulator_register(&pdev->dev, &pmic->desc[id], 1079 &config); 1080 if (IS_ERR(rdev)) { 1081 dev_err(&pdev->dev, 1082 "failed to register %s regulator\n", 1083 pdev->name); 1084 return PTR_ERR(rdev); 1085 } 1086 1087 /* Save regulator for cleanup */ 1088 pmic->rdev[id] = rdev; 1089 1090 /* Initialise sleep/init values from platform data */ 1091 if (pdata) { 1092 reg_init = pdata->reg_init[id]; 1093 if (reg_init) { 1094 if (id < PALMAS_REG_REGEN1) 1095 ret = palmas_ldo_init(palmas, 1096 id, reg_init); 1097 else 1098 ret = palmas_extreg_init(palmas, 1099 id, reg_init); 1100 if (ret) 1101 return ret; 1102 } 1103 } 1104 } 1105 1106 1107 return 0; 1108 } 1109 1110 static const struct of_device_id of_palmas_match_tbl[] = { 1111 { .compatible = "ti,palmas-pmic", }, 1112 { .compatible = "ti,twl6035-pmic", }, 1113 { .compatible = "ti,twl6036-pmic", }, 1114 { .compatible = "ti,twl6037-pmic", }, 1115 { .compatible = "ti,tps65913-pmic", }, 1116 { .compatible = "ti,tps65914-pmic", }, 1117 { .compatible = "ti,tps80036-pmic", }, 1118 { .compatible = "ti,tps659038-pmic", }, 1119 { /* end */ } 1120 }; 1121 1122 static struct platform_driver palmas_driver = { 1123 .driver = { 1124 .name = "palmas-pmic", 1125 .of_match_table = of_palmas_match_tbl, 1126 .owner = THIS_MODULE, 1127 }, 1128 .probe = palmas_regulators_probe, 1129 }; 1130 1131 static int __init palmas_init(void) 1132 { 1133 return platform_driver_register(&palmas_driver); 1134 } 1135 subsys_initcall(palmas_init); 1136 1137 static void __exit palmas_exit(void) 1138 { 1139 platform_driver_unregister(&palmas_driver); 1140 } 1141 module_exit(palmas_exit); 1142 1143 MODULE_AUTHOR("Graeme Gregory <gg@slimlogic.co.uk>"); 1144 MODULE_DESCRIPTION("Palmas voltage regulator driver"); 1145 MODULE_LICENSE("GPL"); 1146 MODULE_ALIAS("platform:palmas-pmic"); 1147 MODULE_DEVICE_TABLE(of, of_palmas_match_tbl); 1148