1279 lines · c
1// SPDX-License-Identifier: GPL-2.0-or-later2/*3 * tps65910.c -- TI tps659104 *5 * Copyright 2010 Texas Instruments Inc.6 *7 * Author: Graeme Gregory <gg@slimlogic.co.uk>8 * Author: Jorge Eduardo Candelaria <jedu@slimlogic.co.uk>9 */10 11#include <linux/kernel.h>12#include <linux/module.h>13#include <linux/init.h>14#include <linux/err.h>15#include <linux/of.h>16#include <linux/platform_device.h>17#include <linux/regulator/driver.h>18#include <linux/regulator/machine.h>19#include <linux/slab.h>20#include <linux/mfd/tps65910.h>21#include <linux/regulator/of_regulator.h>22 23#define TPS65910_SUPPLY_STATE_ENABLED 0x124#define EXT_SLEEP_CONTROL (TPS65910_SLEEP_CONTROL_EXT_INPUT_EN1 | \25 TPS65910_SLEEP_CONTROL_EXT_INPUT_EN2 | \26 TPS65910_SLEEP_CONTROL_EXT_INPUT_EN3 | \27 TPS65911_SLEEP_CONTROL_EXT_INPUT_SLEEP)28 29/* supported VIO voltages in microvolts */30static const unsigned int VIO_VSEL_table[] = {31 1500000, 1800000, 2500000, 3300000,32};33 34/* VSEL tables for TPS65910 specific LDOs and dcdc's */35 36/* supported VRTC voltages in microvolts */37static const unsigned int VRTC_VSEL_table[] = {38 1800000,39};40 41/* supported VDD3 voltages in microvolts */42static const unsigned int VDD3_VSEL_table[] = {43 5000000,44};45 46/* supported VDIG1 voltages in microvolts */47static const unsigned int VDIG1_VSEL_table[] = {48 1200000, 1500000, 1800000, 2700000,49};50 51/* supported VDIG2 voltages in microvolts */52static const unsigned int VDIG2_VSEL_table[] = {53 1000000, 1100000, 1200000, 1800000,54};55 56/* supported VPLL voltages in microvolts */57static const unsigned int VPLL_VSEL_table[] = {58 1000000, 1100000, 1800000, 2500000,59};60 61/* supported VDAC voltages in microvolts */62static const unsigned int VDAC_VSEL_table[] = {63 1800000, 2600000, 2800000, 2850000,64};65 66/* supported VAUX1 voltages in microvolts */67static const unsigned int VAUX1_VSEL_table[] = {68 1800000, 2500000, 2800000, 2850000,69};70 71/* supported VAUX2 voltages in microvolts */72static const unsigned int VAUX2_VSEL_table[] = {73 1800000, 2800000, 2900000, 3300000,74};75 76/* supported VAUX33 voltages in microvolts */77static const unsigned int VAUX33_VSEL_table[] = {78 1800000, 2000000, 2800000, 3300000,79};80 81/* supported VMMC voltages in microvolts */82static const unsigned int VMMC_VSEL_table[] = {83 1800000, 2800000, 3000000, 3300000,84};85 86/* supported BBCH voltages in microvolts */87static const unsigned int VBB_VSEL_table[] = {88 3000000, 2520000, 3150000, 5000000,89};90 91struct tps_info {92 const char *name;93 const char *vin_name;94 u8 n_voltages;95 const unsigned int *voltage_table;96 int enable_time_us;97};98 99static struct tps_info tps65910_regs[] = {100 {101 .name = "vrtc",102 .vin_name = "vcc7",103 .n_voltages = ARRAY_SIZE(VRTC_VSEL_table),104 .voltage_table = VRTC_VSEL_table,105 .enable_time_us = 2200,106 },107 {108 .name = "vio",109 .vin_name = "vccio",110 .n_voltages = ARRAY_SIZE(VIO_VSEL_table),111 .voltage_table = VIO_VSEL_table,112 .enable_time_us = 350,113 },114 {115 .name = "vdd1",116 .vin_name = "vcc1",117 .enable_time_us = 350,118 },119 {120 .name = "vdd2",121 .vin_name = "vcc2",122 .enable_time_us = 350,123 },124 {125 .name = "vdd3",126 .n_voltages = ARRAY_SIZE(VDD3_VSEL_table),127 .voltage_table = VDD3_VSEL_table,128 .enable_time_us = 200,129 },130 {131 .name = "vdig1",132 .vin_name = "vcc6",133 .n_voltages = ARRAY_SIZE(VDIG1_VSEL_table),134 .voltage_table = VDIG1_VSEL_table,135 .enable_time_us = 100,136 },137 {138 .name = "vdig2",139 .vin_name = "vcc6",140 .n_voltages = ARRAY_SIZE(VDIG2_VSEL_table),141 .voltage_table = VDIG2_VSEL_table,142 .enable_time_us = 100,143 },144 {145 .name = "vpll",146 .vin_name = "vcc5",147 .n_voltages = ARRAY_SIZE(VPLL_VSEL_table),148 .voltage_table = VPLL_VSEL_table,149 .enable_time_us = 100,150 },151 {152 .name = "vdac",153 .vin_name = "vcc5",154 .n_voltages = ARRAY_SIZE(VDAC_VSEL_table),155 .voltage_table = VDAC_VSEL_table,156 .enable_time_us = 100,157 },158 {159 .name = "vaux1",160 .vin_name = "vcc4",161 .n_voltages = ARRAY_SIZE(VAUX1_VSEL_table),162 .voltage_table = VAUX1_VSEL_table,163 .enable_time_us = 100,164 },165 {166 .name = "vaux2",167 .vin_name = "vcc4",168 .n_voltages = ARRAY_SIZE(VAUX2_VSEL_table),169 .voltage_table = VAUX2_VSEL_table,170 .enable_time_us = 100,171 },172 {173 .name = "vaux33",174 .vin_name = "vcc3",175 .n_voltages = ARRAY_SIZE(VAUX33_VSEL_table),176 .voltage_table = VAUX33_VSEL_table,177 .enable_time_us = 100,178 },179 {180 .name = "vmmc",181 .vin_name = "vcc3",182 .n_voltages = ARRAY_SIZE(VMMC_VSEL_table),183 .voltage_table = VMMC_VSEL_table,184 .enable_time_us = 100,185 },186 {187 .name = "vbb",188 .vin_name = "vcc7",189 .n_voltages = ARRAY_SIZE(VBB_VSEL_table),190 .voltage_table = VBB_VSEL_table,191 },192};193 194static struct tps_info tps65911_regs[] = {195 {196 .name = "vrtc",197 .vin_name = "vcc7",198 .enable_time_us = 2200,199 },200 {201 .name = "vio",202 .vin_name = "vccio",203 .n_voltages = ARRAY_SIZE(VIO_VSEL_table),204 .voltage_table = VIO_VSEL_table,205 .enable_time_us = 350,206 },207 {208 .name = "vdd1",209 .vin_name = "vcc1",210 .n_voltages = 0x4C,211 .enable_time_us = 350,212 },213 {214 .name = "vdd2",215 .vin_name = "vcc2",216 .n_voltages = 0x4C,217 .enable_time_us = 350,218 },219 {220 .name = "vddctrl",221 .n_voltages = 0x44,222 .enable_time_us = 900,223 },224 {225 .name = "ldo1",226 .vin_name = "vcc6",227 .n_voltages = 0x33,228 .enable_time_us = 420,229 },230 {231 .name = "ldo2",232 .vin_name = "vcc6",233 .n_voltages = 0x33,234 .enable_time_us = 420,235 },236 {237 .name = "ldo3",238 .vin_name = "vcc5",239 .n_voltages = 0x1A,240 .enable_time_us = 230,241 },242 {243 .name = "ldo4",244 .vin_name = "vcc5",245 .n_voltages = 0x33,246 .enable_time_us = 230,247 },248 {249 .name = "ldo5",250 .vin_name = "vcc4",251 .n_voltages = 0x1A,252 .enable_time_us = 230,253 },254 {255 .name = "ldo6",256 .vin_name = "vcc3",257 .n_voltages = 0x1A,258 .enable_time_us = 230,259 },260 {261 .name = "ldo7",262 .vin_name = "vcc3",263 .n_voltages = 0x1A,264 .enable_time_us = 230,265 },266 {267 .name = "ldo8",268 .vin_name = "vcc3",269 .n_voltages = 0x1A,270 .enable_time_us = 230,271 },272};273 274#define EXT_CONTROL_REG_BITS(id, regs_offs, bits) (((regs_offs) << 8) | (bits))275static unsigned int tps65910_ext_sleep_control[] = {276 0,277 EXT_CONTROL_REG_BITS(VIO, 1, 0),278 EXT_CONTROL_REG_BITS(VDD1, 1, 1),279 EXT_CONTROL_REG_BITS(VDD2, 1, 2),280 EXT_CONTROL_REG_BITS(VDD3, 1, 3),281 EXT_CONTROL_REG_BITS(VDIG1, 0, 1),282 EXT_CONTROL_REG_BITS(VDIG2, 0, 2),283 EXT_CONTROL_REG_BITS(VPLL, 0, 6),284 EXT_CONTROL_REG_BITS(VDAC, 0, 7),285 EXT_CONTROL_REG_BITS(VAUX1, 0, 3),286 EXT_CONTROL_REG_BITS(VAUX2, 0, 4),287 EXT_CONTROL_REG_BITS(VAUX33, 0, 5),288 EXT_CONTROL_REG_BITS(VMMC, 0, 0),289};290 291static unsigned int tps65911_ext_sleep_control[] = {292 0,293 EXT_CONTROL_REG_BITS(VIO, 1, 0),294 EXT_CONTROL_REG_BITS(VDD1, 1, 1),295 EXT_CONTROL_REG_BITS(VDD2, 1, 2),296 EXT_CONTROL_REG_BITS(VDDCTRL, 1, 3),297 EXT_CONTROL_REG_BITS(LDO1, 0, 1),298 EXT_CONTROL_REG_BITS(LDO2, 0, 2),299 EXT_CONTROL_REG_BITS(LDO3, 0, 7),300 EXT_CONTROL_REG_BITS(LDO4, 0, 6),301 EXT_CONTROL_REG_BITS(LDO5, 0, 3),302 EXT_CONTROL_REG_BITS(LDO6, 0, 0),303 EXT_CONTROL_REG_BITS(LDO7, 0, 5),304 EXT_CONTROL_REG_BITS(LDO8, 0, 4),305};306 307struct tps65910_reg {308 struct regulator_desc *desc;309 struct tps65910 *mfd;310 struct regulator_dev **rdev;311 struct tps_info **info;312 int num_regulators;313 int mode;314 int (*get_ctrl_reg)(int);315 unsigned int *ext_sleep_control;316 unsigned int board_ext_control[TPS65910_NUM_REGS];317};318 319static int tps65910_get_ctrl_register(int id)320{321 switch (id) {322 case TPS65910_REG_VRTC:323 return TPS65910_VRTC;324 case TPS65910_REG_VIO:325 return TPS65910_VIO;326 case TPS65910_REG_VDD1:327 return TPS65910_VDD1;328 case TPS65910_REG_VDD2:329 return TPS65910_VDD2;330 case TPS65910_REG_VDD3:331 return TPS65910_VDD3;332 case TPS65910_REG_VDIG1:333 return TPS65910_VDIG1;334 case TPS65910_REG_VDIG2:335 return TPS65910_VDIG2;336 case TPS65910_REG_VPLL:337 return TPS65910_VPLL;338 case TPS65910_REG_VDAC:339 return TPS65910_VDAC;340 case TPS65910_REG_VAUX1:341 return TPS65910_VAUX1;342 case TPS65910_REG_VAUX2:343 return TPS65910_VAUX2;344 case TPS65910_REG_VAUX33:345 return TPS65910_VAUX33;346 case TPS65910_REG_VMMC:347 return TPS65910_VMMC;348 case TPS65910_REG_VBB:349 return TPS65910_BBCH;350 default:351 return -EINVAL;352 }353}354 355static int tps65911_get_ctrl_register(int id)356{357 switch (id) {358 case TPS65910_REG_VRTC:359 return TPS65910_VRTC;360 case TPS65910_REG_VIO:361 return TPS65910_VIO;362 case TPS65910_REG_VDD1:363 return TPS65910_VDD1;364 case TPS65910_REG_VDD2:365 return TPS65910_VDD2;366 case TPS65911_REG_VDDCTRL:367 return TPS65911_VDDCTRL;368 case TPS65911_REG_LDO1:369 return TPS65911_LDO1;370 case TPS65911_REG_LDO2:371 return TPS65911_LDO2;372 case TPS65911_REG_LDO3:373 return TPS65911_LDO3;374 case TPS65911_REG_LDO4:375 return TPS65911_LDO4;376 case TPS65911_REG_LDO5:377 return TPS65911_LDO5;378 case TPS65911_REG_LDO6:379 return TPS65911_LDO6;380 case TPS65911_REG_LDO7:381 return TPS65911_LDO7;382 case TPS65911_REG_LDO8:383 return TPS65911_LDO8;384 default:385 return -EINVAL;386 }387}388 389static int tps65910_set_mode(struct regulator_dev *dev, unsigned int mode)390{391 struct tps65910_reg *pmic = rdev_get_drvdata(dev);392 struct regmap *regmap = rdev_get_regmap(dev);393 int reg, id = rdev_get_id(dev);394 395 reg = pmic->get_ctrl_reg(id);396 if (reg < 0)397 return reg;398 399 switch (mode) {400 case REGULATOR_MODE_NORMAL:401 return regmap_update_bits(regmap, reg,402 LDO_ST_MODE_BIT | LDO_ST_ON_BIT,403 LDO_ST_ON_BIT);404 case REGULATOR_MODE_IDLE:405 return regmap_set_bits(regmap, reg,406 LDO_ST_ON_BIT | LDO_ST_MODE_BIT);407 case REGULATOR_MODE_STANDBY:408 return regmap_clear_bits(regmap, reg, LDO_ST_ON_BIT);409 }410 411 return -EINVAL;412}413 414static unsigned int tps65910_get_mode(struct regulator_dev *dev)415{416 struct tps65910_reg *pmic = rdev_get_drvdata(dev);417 struct regmap *regmap = rdev_get_regmap(dev);418 int ret, reg, value, id = rdev_get_id(dev);419 420 reg = pmic->get_ctrl_reg(id);421 if (reg < 0)422 return reg;423 424 ret = regmap_read(regmap, reg, &value);425 if (ret < 0)426 return ret;427 428 if (!(value & LDO_ST_ON_BIT))429 return REGULATOR_MODE_STANDBY;430 else if (value & LDO_ST_MODE_BIT)431 return REGULATOR_MODE_IDLE;432 else433 return REGULATOR_MODE_NORMAL;434}435 436static int tps65910_get_voltage_dcdc_sel(struct regulator_dev *dev)437{438 struct regmap *regmap = rdev_get_regmap(dev);439 int ret, id = rdev_get_id(dev);440 int opvsel = 0, srvsel = 0, vselmax = 0, mult = 0, sr = 0;441 442 switch (id) {443 case TPS65910_REG_VDD1:444 ret = regmap_read(regmap, TPS65910_VDD1_OP, &opvsel);445 if (ret < 0)446 return ret;447 ret = regmap_read(regmap, TPS65910_VDD1, &mult);448 if (ret < 0)449 return ret;450 mult = (mult & VDD1_VGAIN_SEL_MASK) >> VDD1_VGAIN_SEL_SHIFT;451 ret = regmap_read(regmap, TPS65910_VDD1_SR, &srvsel);452 if (ret < 0)453 return ret;454 sr = opvsel & VDD1_OP_CMD_MASK;455 opvsel &= VDD1_OP_SEL_MASK;456 srvsel &= VDD1_SR_SEL_MASK;457 vselmax = 75;458 break;459 case TPS65910_REG_VDD2:460 ret = regmap_read(regmap, TPS65910_VDD2_OP, &opvsel);461 if (ret < 0)462 return ret;463 ret = regmap_read(regmap, TPS65910_VDD2, &mult);464 if (ret < 0)465 return ret;466 mult = (mult & VDD2_VGAIN_SEL_MASK) >> VDD2_VGAIN_SEL_SHIFT;467 ret = regmap_read(regmap, TPS65910_VDD2_SR, &srvsel);468 if (ret < 0)469 return ret;470 sr = opvsel & VDD2_OP_CMD_MASK;471 opvsel &= VDD2_OP_SEL_MASK;472 srvsel &= VDD2_SR_SEL_MASK;473 vselmax = 75;474 break;475 case TPS65911_REG_VDDCTRL:476 ret = regmap_read(regmap, TPS65911_VDDCTRL_OP, &opvsel);477 if (ret < 0)478 return ret;479 ret = regmap_read(regmap, TPS65911_VDDCTRL_SR, &srvsel);480 if (ret < 0)481 return ret;482 sr = opvsel & VDDCTRL_OP_CMD_MASK;483 opvsel &= VDDCTRL_OP_SEL_MASK;484 srvsel &= VDDCTRL_SR_SEL_MASK;485 vselmax = 64;486 break;487 }488 489 /* multiplier 0 == 1 but 2,3 normal */490 if (!mult)491 mult = 1;492 493 if (sr) {494 /* normalise to valid range */495 if (srvsel < 3)496 srvsel = 3;497 if (srvsel > vselmax)498 srvsel = vselmax;499 return srvsel - 3;500 } else {501 502 /* normalise to valid range*/503 if (opvsel < 3)504 opvsel = 3;505 if (opvsel > vselmax)506 opvsel = vselmax;507 return opvsel - 3;508 }509 return -EINVAL;510}511 512static int tps65910_get_voltage_sel(struct regulator_dev *dev)513{514 struct tps65910_reg *pmic = rdev_get_drvdata(dev);515 struct regmap *regmap = rdev_get_regmap(dev);516 int ret, reg, value, id = rdev_get_id(dev);517 518 reg = pmic->get_ctrl_reg(id);519 if (reg < 0)520 return reg;521 522 ret = regmap_read(regmap, reg, &value);523 if (ret < 0)524 return ret;525 526 switch (id) {527 case TPS65910_REG_VIO:528 case TPS65910_REG_VDIG1:529 case TPS65910_REG_VDIG2:530 case TPS65910_REG_VPLL:531 case TPS65910_REG_VDAC:532 case TPS65910_REG_VAUX1:533 case TPS65910_REG_VAUX2:534 case TPS65910_REG_VAUX33:535 case TPS65910_REG_VMMC:536 value &= LDO_SEL_MASK;537 value >>= LDO_SEL_SHIFT;538 break;539 case TPS65910_REG_VBB:540 value &= BBCH_BBSEL_MASK;541 value >>= BBCH_BBSEL_SHIFT;542 break;543 default:544 return -EINVAL;545 }546 547 return value;548}549 550static int tps65910_get_voltage_vdd3(struct regulator_dev *dev)551{552 return dev->desc->volt_table[0];553}554 555static int tps65911_get_voltage_sel(struct regulator_dev *dev)556{557 struct tps65910_reg *pmic = rdev_get_drvdata(dev);558 struct regmap *regmap = rdev_get_regmap(dev);559 int ret, id = rdev_get_id(dev);560 unsigned int value, reg;561 562 reg = pmic->get_ctrl_reg(id);563 564 ret = regmap_read(regmap, reg, &value);565 if (ret < 0)566 return ret;567 568 switch (id) {569 case TPS65911_REG_LDO1:570 case TPS65911_REG_LDO2:571 case TPS65911_REG_LDO4:572 value &= LDO1_SEL_MASK;573 value >>= LDO_SEL_SHIFT;574 break;575 case TPS65911_REG_LDO3:576 case TPS65911_REG_LDO5:577 case TPS65911_REG_LDO6:578 case TPS65911_REG_LDO7:579 case TPS65911_REG_LDO8:580 value &= LDO3_SEL_MASK;581 value >>= LDO_SEL_SHIFT;582 break;583 case TPS65910_REG_VIO:584 value &= LDO_SEL_MASK;585 value >>= LDO_SEL_SHIFT;586 break;587 default:588 return -EINVAL;589 }590 591 return value;592}593 594static int tps65910_set_voltage_dcdc_sel(struct regulator_dev *dev,595 unsigned selector)596{597 struct regmap *regmap = rdev_get_regmap(dev);598 int id = rdev_get_id(dev), vsel;599 int dcdc_mult = 0;600 601 switch (id) {602 case TPS65910_REG_VDD1:603 dcdc_mult = (selector / VDD1_2_NUM_VOLT_FINE) + 1;604 if (dcdc_mult == 1)605 dcdc_mult--;606 vsel = (selector % VDD1_2_NUM_VOLT_FINE) + 3;607 608 regmap_update_bits(regmap, TPS65910_VDD1, VDD1_VGAIN_SEL_MASK,609 dcdc_mult << VDD1_VGAIN_SEL_SHIFT);610 regmap_write(regmap, TPS65910_VDD1_OP, vsel);611 break;612 case TPS65910_REG_VDD2:613 dcdc_mult = (selector / VDD1_2_NUM_VOLT_FINE) + 1;614 if (dcdc_mult == 1)615 dcdc_mult--;616 vsel = (selector % VDD1_2_NUM_VOLT_FINE) + 3;617 618 regmap_update_bits(regmap, TPS65910_VDD2, VDD1_VGAIN_SEL_MASK,619 dcdc_mult << VDD2_VGAIN_SEL_SHIFT);620 regmap_write(regmap, TPS65910_VDD2_OP, vsel);621 break;622 case TPS65911_REG_VDDCTRL:623 vsel = selector + 3;624 regmap_write(regmap, TPS65911_VDDCTRL_OP, vsel);625 break;626 }627 628 return 0;629}630 631static int tps65910_set_voltage_sel(struct regulator_dev *dev,632 unsigned selector)633{634 struct tps65910_reg *pmic = rdev_get_drvdata(dev);635 struct regmap *regmap = rdev_get_regmap(dev);636 int reg, id = rdev_get_id(dev);637 638 reg = pmic->get_ctrl_reg(id);639 if (reg < 0)640 return reg;641 642 switch (id) {643 case TPS65910_REG_VIO:644 case TPS65910_REG_VDIG1:645 case TPS65910_REG_VDIG2:646 case TPS65910_REG_VPLL:647 case TPS65910_REG_VDAC:648 case TPS65910_REG_VAUX1:649 case TPS65910_REG_VAUX2:650 case TPS65910_REG_VAUX33:651 case TPS65910_REG_VMMC:652 return regmap_update_bits(regmap, reg, LDO_SEL_MASK,653 selector << LDO_SEL_SHIFT);654 case TPS65910_REG_VBB:655 return regmap_update_bits(regmap, reg, BBCH_BBSEL_MASK,656 selector << BBCH_BBSEL_SHIFT);657 }658 659 return -EINVAL;660}661 662static int tps65911_set_voltage_sel(struct regulator_dev *dev,663 unsigned selector)664{665 struct tps65910_reg *pmic = rdev_get_drvdata(dev);666 struct regmap *regmap = rdev_get_regmap(dev);667 int reg, id = rdev_get_id(dev);668 669 reg = pmic->get_ctrl_reg(id);670 if (reg < 0)671 return reg;672 673 switch (id) {674 case TPS65911_REG_LDO1:675 case TPS65911_REG_LDO2:676 case TPS65911_REG_LDO4:677 return regmap_update_bits(regmap, reg, LDO1_SEL_MASK,678 selector << LDO_SEL_SHIFT);679 case TPS65911_REG_LDO3:680 case TPS65911_REG_LDO5:681 case TPS65911_REG_LDO6:682 case TPS65911_REG_LDO7:683 case TPS65911_REG_LDO8:684 return regmap_update_bits(regmap, reg, LDO3_SEL_MASK,685 selector << LDO_SEL_SHIFT);686 case TPS65910_REG_VIO:687 return regmap_update_bits(regmap, reg, LDO_SEL_MASK,688 selector << LDO_SEL_SHIFT);689 case TPS65910_REG_VBB:690 return regmap_update_bits(regmap, reg, BBCH_BBSEL_MASK,691 selector << BBCH_BBSEL_SHIFT);692 }693 694 return -EINVAL;695}696 697 698static int tps65910_list_voltage_dcdc(struct regulator_dev *dev,699 unsigned selector)700{701 int volt, mult = 1, id = rdev_get_id(dev);702 703 switch (id) {704 case TPS65910_REG_VDD1:705 case TPS65910_REG_VDD2:706 mult = (selector / VDD1_2_NUM_VOLT_FINE) + 1;707 volt = VDD1_2_MIN_VOLT +708 (selector % VDD1_2_NUM_VOLT_FINE) * VDD1_2_OFFSET;709 break;710 case TPS65911_REG_VDDCTRL:711 volt = VDDCTRL_MIN_VOLT + (selector * VDDCTRL_OFFSET);712 break;713 default:714 BUG();715 return -EINVAL;716 }717 718 return volt * 100 * mult;719}720 721static int tps65911_list_voltage(struct regulator_dev *dev, unsigned selector)722{723 struct tps65910_reg *pmic = rdev_get_drvdata(dev);724 int step_mv = 0, id = rdev_get_id(dev);725 726 switch (id) {727 case TPS65911_REG_LDO1:728 case TPS65911_REG_LDO2:729 case TPS65911_REG_LDO4:730 /* The first 5 values of the selector correspond to 1V */731 if (selector < 5)732 selector = 0;733 else734 selector -= 4;735 736 step_mv = 50;737 break;738 case TPS65911_REG_LDO3:739 case TPS65911_REG_LDO5:740 case TPS65911_REG_LDO6:741 case TPS65911_REG_LDO7:742 case TPS65911_REG_LDO8:743 /* The first 3 values of the selector correspond to 1V */744 if (selector < 3)745 selector = 0;746 else747 selector -= 2;748 749 step_mv = 100;750 break;751 case TPS65910_REG_VIO:752 return pmic->info[id]->voltage_table[selector];753 default:754 return -EINVAL;755 }756 757 return (LDO_MIN_VOLT + selector * step_mv) * 1000;758}759 760/* Regulator ops (except VRTC) */761static const struct regulator_ops tps65910_ops_dcdc = {762 .is_enabled = regulator_is_enabled_regmap,763 .enable = regulator_enable_regmap,764 .disable = regulator_disable_regmap,765 .set_mode = tps65910_set_mode,766 .get_mode = tps65910_get_mode,767 .get_voltage_sel = tps65910_get_voltage_dcdc_sel,768 .set_voltage_sel = tps65910_set_voltage_dcdc_sel,769 .set_voltage_time_sel = regulator_set_voltage_time_sel,770 .list_voltage = tps65910_list_voltage_dcdc,771 .map_voltage = regulator_map_voltage_ascend,772};773 774static const struct regulator_ops tps65910_ops_vdd3 = {775 .is_enabled = regulator_is_enabled_regmap,776 .enable = regulator_enable_regmap,777 .disable = regulator_disable_regmap,778 .set_mode = tps65910_set_mode,779 .get_mode = tps65910_get_mode,780 .get_voltage = tps65910_get_voltage_vdd3,781 .list_voltage = regulator_list_voltage_table,782 .map_voltage = regulator_map_voltage_ascend,783};784 785static const struct regulator_ops tps65910_ops_vbb = {786 .is_enabled = regulator_is_enabled_regmap,787 .enable = regulator_enable_regmap,788 .disable = regulator_disable_regmap,789 .set_mode = tps65910_set_mode,790 .get_mode = tps65910_get_mode,791 .get_voltage_sel = tps65910_get_voltage_sel,792 .set_voltage_sel = tps65910_set_voltage_sel,793 .list_voltage = regulator_list_voltage_table,794 .map_voltage = regulator_map_voltage_iterate,795};796 797static const struct regulator_ops tps65910_ops = {798 .is_enabled = regulator_is_enabled_regmap,799 .enable = regulator_enable_regmap,800 .disable = regulator_disable_regmap,801 .set_mode = tps65910_set_mode,802 .get_mode = tps65910_get_mode,803 .get_voltage_sel = tps65910_get_voltage_sel,804 .set_voltage_sel = tps65910_set_voltage_sel,805 .list_voltage = regulator_list_voltage_table,806 .map_voltage = regulator_map_voltage_ascend,807};808 809static const struct regulator_ops tps65911_ops = {810 .is_enabled = regulator_is_enabled_regmap,811 .enable = regulator_enable_regmap,812 .disable = regulator_disable_regmap,813 .set_mode = tps65910_set_mode,814 .get_mode = tps65910_get_mode,815 .get_voltage_sel = tps65911_get_voltage_sel,816 .set_voltage_sel = tps65911_set_voltage_sel,817 .list_voltage = tps65911_list_voltage,818 .map_voltage = regulator_map_voltage_ascend,819};820 821static int tps65910_set_ext_sleep_config(struct tps65910_reg *pmic,822 int id, int ext_sleep_config)823{824 struct tps65910 *mfd = pmic->mfd;825 u8 regoffs = (pmic->ext_sleep_control[id] >> 8) & 0xFF;826 u8 bit_pos = (1 << pmic->ext_sleep_control[id] & 0xFF);827 int ret;828 829 /*830 * Regulator can not be control from multiple external input EN1, EN2831 * and EN3 together.832 */833 if (ext_sleep_config & EXT_SLEEP_CONTROL) {834 int en_count;835 en_count = ((ext_sleep_config &836 TPS65910_SLEEP_CONTROL_EXT_INPUT_EN1) != 0);837 en_count += ((ext_sleep_config &838 TPS65910_SLEEP_CONTROL_EXT_INPUT_EN2) != 0);839 en_count += ((ext_sleep_config &840 TPS65910_SLEEP_CONTROL_EXT_INPUT_EN3) != 0);841 en_count += ((ext_sleep_config &842 TPS65911_SLEEP_CONTROL_EXT_INPUT_SLEEP) != 0);843 if (en_count > 1) {844 dev_err(mfd->dev,845 "External sleep control flag is not proper\n");846 return -EINVAL;847 }848 }849 850 pmic->board_ext_control[id] = ext_sleep_config;851 852 /* External EN1 control */853 if (ext_sleep_config & TPS65910_SLEEP_CONTROL_EXT_INPUT_EN1)854 ret = regmap_set_bits(mfd->regmap,855 TPS65910_EN1_LDO_ASS + regoffs, bit_pos);856 else857 ret = regmap_clear_bits(mfd->regmap,858 TPS65910_EN1_LDO_ASS + regoffs, bit_pos);859 if (ret < 0) {860 dev_err(mfd->dev,861 "Error in configuring external control EN1\n");862 return ret;863 }864 865 /* External EN2 control */866 if (ext_sleep_config & TPS65910_SLEEP_CONTROL_EXT_INPUT_EN2)867 ret = regmap_set_bits(mfd->regmap,868 TPS65910_EN2_LDO_ASS + regoffs, bit_pos);869 else870 ret = regmap_clear_bits(mfd->regmap,871 TPS65910_EN2_LDO_ASS + regoffs, bit_pos);872 if (ret < 0) {873 dev_err(mfd->dev,874 "Error in configuring external control EN2\n");875 return ret;876 }877 878 /* External EN3 control for TPS65910 LDO only */879 if ((tps65910_chip_id(mfd) == TPS65910) &&880 (id >= TPS65910_REG_VDIG1)) {881 if (ext_sleep_config & TPS65910_SLEEP_CONTROL_EXT_INPUT_EN3)882 ret = regmap_set_bits(mfd->regmap,883 TPS65910_EN3_LDO_ASS + regoffs, bit_pos);884 else885 ret = regmap_clear_bits(mfd->regmap,886 TPS65910_EN3_LDO_ASS + regoffs, bit_pos);887 if (ret < 0) {888 dev_err(mfd->dev,889 "Error in configuring external control EN3\n");890 return ret;891 }892 }893 894 /* Return if no external control is selected */895 if (!(ext_sleep_config & EXT_SLEEP_CONTROL)) {896 /* Clear all sleep controls */897 ret = regmap_clear_bits(mfd->regmap,898 TPS65910_SLEEP_KEEP_LDO_ON + regoffs, bit_pos);899 if (!ret)900 ret = regmap_clear_bits(mfd->regmap,901 TPS65910_SLEEP_SET_LDO_OFF + regoffs, bit_pos);902 if (ret < 0)903 dev_err(mfd->dev,904 "Error in configuring SLEEP register\n");905 return ret;906 }907 908 /*909 * For regulator that has separate operational and sleep register make910 * sure that operational is used and clear sleep register to turn911 * regulator off when external control is inactive912 */913 if ((id == TPS65910_REG_VDD1) ||914 (id == TPS65910_REG_VDD2) ||915 ((id == TPS65911_REG_VDDCTRL) &&916 (tps65910_chip_id(mfd) == TPS65911))) {917 int op_reg_add = pmic->get_ctrl_reg(id) + 1;918 int sr_reg_add = pmic->get_ctrl_reg(id) + 2;919 int opvsel, srvsel;920 921 ret = regmap_read(mfd->regmap, op_reg_add, &opvsel);922 if (ret < 0)923 return ret;924 ret = regmap_read(mfd->regmap, sr_reg_add, &srvsel);925 if (ret < 0)926 return ret;927 928 if (opvsel & VDD1_OP_CMD_MASK) {929 u8 reg_val = srvsel & VDD1_OP_SEL_MASK;930 931 ret = regmap_write(mfd->regmap, op_reg_add, reg_val);932 if (ret < 0) {933 dev_err(mfd->dev,934 "Error in configuring op register\n");935 return ret;936 }937 }938 ret = regmap_write(mfd->regmap, sr_reg_add, 0);939 if (ret < 0) {940 dev_err(mfd->dev, "Error in setting sr register\n");941 return ret;942 }943 }944 945 ret = regmap_clear_bits(mfd->regmap,946 TPS65910_SLEEP_KEEP_LDO_ON + regoffs, bit_pos);947 if (!ret) {948 if (ext_sleep_config & TPS65911_SLEEP_CONTROL_EXT_INPUT_SLEEP)949 ret = regmap_set_bits(mfd->regmap,950 TPS65910_SLEEP_SET_LDO_OFF + regoffs, bit_pos);951 else952 ret = regmap_clear_bits(mfd->regmap,953 TPS65910_SLEEP_SET_LDO_OFF + regoffs, bit_pos);954 }955 if (ret < 0)956 dev_err(mfd->dev,957 "Error in configuring SLEEP register\n");958 959 return ret;960}961 962#ifdef CONFIG_OF963 964static struct of_regulator_match tps65910_matches[] = {965 { .name = "vrtc", .driver_data = (void *) &tps65910_regs[0] },966 { .name = "vio", .driver_data = (void *) &tps65910_regs[1] },967 { .name = "vdd1", .driver_data = (void *) &tps65910_regs[2] },968 { .name = "vdd2", .driver_data = (void *) &tps65910_regs[3] },969 { .name = "vdd3", .driver_data = (void *) &tps65910_regs[4] },970 { .name = "vdig1", .driver_data = (void *) &tps65910_regs[5] },971 { .name = "vdig2", .driver_data = (void *) &tps65910_regs[6] },972 { .name = "vpll", .driver_data = (void *) &tps65910_regs[7] },973 { .name = "vdac", .driver_data = (void *) &tps65910_regs[8] },974 { .name = "vaux1", .driver_data = (void *) &tps65910_regs[9] },975 { .name = "vaux2", .driver_data = (void *) &tps65910_regs[10] },976 { .name = "vaux33", .driver_data = (void *) &tps65910_regs[11] },977 { .name = "vmmc", .driver_data = (void *) &tps65910_regs[12] },978 { .name = "vbb", .driver_data = (void *) &tps65910_regs[13] },979};980 981static struct of_regulator_match tps65911_matches[] = {982 { .name = "vrtc", .driver_data = (void *) &tps65911_regs[0] },983 { .name = "vio", .driver_data = (void *) &tps65911_regs[1] },984 { .name = "vdd1", .driver_data = (void *) &tps65911_regs[2] },985 { .name = "vdd2", .driver_data = (void *) &tps65911_regs[3] },986 { .name = "vddctrl", .driver_data = (void *) &tps65911_regs[4] },987 { .name = "ldo1", .driver_data = (void *) &tps65911_regs[5] },988 { .name = "ldo2", .driver_data = (void *) &tps65911_regs[6] },989 { .name = "ldo3", .driver_data = (void *) &tps65911_regs[7] },990 { .name = "ldo4", .driver_data = (void *) &tps65911_regs[8] },991 { .name = "ldo5", .driver_data = (void *) &tps65911_regs[9] },992 { .name = "ldo6", .driver_data = (void *) &tps65911_regs[10] },993 { .name = "ldo7", .driver_data = (void *) &tps65911_regs[11] },994 { .name = "ldo8", .driver_data = (void *) &tps65911_regs[12] },995};996 997static struct tps65910_board *tps65910_parse_dt_reg_data(998 struct platform_device *pdev,999 struct of_regulator_match **tps65910_reg_matches)1000{1001 struct tps65910_board *pmic_plat_data;1002 struct tps65910 *tps65910 = dev_get_drvdata(pdev->dev.parent);1003 struct device_node *np, *regulators;1004 struct of_regulator_match *matches;1005 unsigned int prop;1006 int idx = 0, ret, count;1007 1008 pmic_plat_data = devm_kzalloc(&pdev->dev, sizeof(*pmic_plat_data),1009 GFP_KERNEL);1010 if (!pmic_plat_data)1011 return NULL;1012 1013 np = pdev->dev.parent->of_node;1014 regulators = of_get_child_by_name(np, "regulators");1015 if (!regulators) {1016 dev_err(&pdev->dev, "regulator node not found\n");1017 return NULL;1018 }1019 1020 switch (tps65910_chip_id(tps65910)) {1021 case TPS65910:1022 count = ARRAY_SIZE(tps65910_matches);1023 matches = tps65910_matches;1024 break;1025 case TPS65911:1026 count = ARRAY_SIZE(tps65911_matches);1027 matches = tps65911_matches;1028 break;1029 default:1030 of_node_put(regulators);1031 dev_err(&pdev->dev, "Invalid tps chip version\n");1032 return NULL;1033 }1034 1035 ret = of_regulator_match(&pdev->dev, regulators, matches, count);1036 of_node_put(regulators);1037 if (ret < 0) {1038 dev_err(&pdev->dev, "Error parsing regulator init data: %d\n",1039 ret);1040 return NULL;1041 }1042 1043 *tps65910_reg_matches = matches;1044 1045 for (idx = 0; idx < count; idx++) {1046 if (!matches[idx].of_node)1047 continue;1048 1049 pmic_plat_data->tps65910_pmic_init_data[idx] =1050 matches[idx].init_data;1051 1052 ret = of_property_read_u32(matches[idx].of_node,1053 "ti,regulator-ext-sleep-control", &prop);1054 if (!ret)1055 pmic_plat_data->regulator_ext_sleep_control[idx] = prop;1056 1057 }1058 1059 return pmic_plat_data;1060}1061#else1062static inline struct tps65910_board *tps65910_parse_dt_reg_data(1063 struct platform_device *pdev,1064 struct of_regulator_match **tps65910_reg_matches)1065{1066 *tps65910_reg_matches = NULL;1067 return NULL;1068}1069#endif1070 1071static int tps65910_probe(struct platform_device *pdev)1072{1073 struct tps65910 *tps65910 = dev_get_drvdata(pdev->dev.parent);1074 struct regulator_config config = { };1075 struct tps_info *info;1076 struct regulator_dev *rdev;1077 struct tps65910_reg *pmic;1078 struct tps65910_board *pmic_plat_data;1079 struct of_regulator_match *tps65910_reg_matches = NULL;1080 int i, err;1081 1082 pmic_plat_data = dev_get_platdata(tps65910->dev);1083 if (!pmic_plat_data && tps65910->dev->of_node)1084 pmic_plat_data = tps65910_parse_dt_reg_data(pdev,1085 &tps65910_reg_matches);1086 1087 if (!pmic_plat_data) {1088 dev_err(&pdev->dev, "Platform data not found\n");1089 return -EINVAL;1090 }1091 1092 pmic = devm_kzalloc(&pdev->dev, sizeof(*pmic), GFP_KERNEL);1093 if (!pmic)1094 return -ENOMEM;1095 1096 pmic->mfd = tps65910;1097 platform_set_drvdata(pdev, pmic);1098 1099 /* Give control of all register to control port */1100 err = regmap_set_bits(pmic->mfd->regmap, TPS65910_DEVCTRL,1101 DEVCTRL_SR_CTL_I2C_SEL_MASK);1102 if (err < 0)1103 return err;1104 1105 switch (tps65910_chip_id(tps65910)) {1106 case TPS65910:1107 BUILD_BUG_ON(TPS65910_NUM_REGS < ARRAY_SIZE(tps65910_regs));1108 pmic->get_ctrl_reg = &tps65910_get_ctrl_register;1109 pmic->num_regulators = ARRAY_SIZE(tps65910_regs);1110 pmic->ext_sleep_control = tps65910_ext_sleep_control;1111 info = tps65910_regs;1112 /* Work around silicon erratum SWCZ010: output programmed1113 * voltage level can go higher than expected or crash1114 * Workaround: use no synchronization of DCDC clocks1115 */1116 regmap_clear_bits(pmic->mfd->regmap, TPS65910_DCDCCTRL,1117 DCDCCTRL_DCDCCKSYNC_MASK);1118 break;1119 case TPS65911:1120 BUILD_BUG_ON(TPS65910_NUM_REGS < ARRAY_SIZE(tps65911_regs));1121 pmic->get_ctrl_reg = &tps65911_get_ctrl_register;1122 pmic->num_regulators = ARRAY_SIZE(tps65911_regs);1123 pmic->ext_sleep_control = tps65911_ext_sleep_control;1124 info = tps65911_regs;1125 break;1126 default:1127 dev_err(&pdev->dev, "Invalid tps chip version\n");1128 return -ENODEV;1129 }1130 1131 pmic->desc = devm_kcalloc(&pdev->dev,1132 pmic->num_regulators,1133 sizeof(struct regulator_desc),1134 GFP_KERNEL);1135 if (!pmic->desc)1136 return -ENOMEM;1137 1138 pmic->info = devm_kcalloc(&pdev->dev,1139 pmic->num_regulators,1140 sizeof(struct tps_info *),1141 GFP_KERNEL);1142 if (!pmic->info)1143 return -ENOMEM;1144 1145 pmic->rdev = devm_kcalloc(&pdev->dev,1146 pmic->num_regulators,1147 sizeof(struct regulator_dev *),1148 GFP_KERNEL);1149 if (!pmic->rdev)1150 return -ENOMEM;1151 1152 for (i = 0; i < pmic->num_regulators; i++, info++) {1153 /* Register the regulators */1154 pmic->info[i] = info;1155 1156 pmic->desc[i].name = info->name;1157 pmic->desc[i].supply_name = info->vin_name;1158 pmic->desc[i].id = i;1159 pmic->desc[i].n_voltages = info->n_voltages;1160 pmic->desc[i].enable_time = info->enable_time_us;1161 1162 if (i == TPS65910_REG_VDD1 || i == TPS65910_REG_VDD2) {1163 pmic->desc[i].ops = &tps65910_ops_dcdc;1164 pmic->desc[i].n_voltages = VDD1_2_NUM_VOLT_FINE *1165 VDD1_2_NUM_VOLT_COARSE;1166 pmic->desc[i].ramp_delay = 12500;1167 } else if (i == TPS65910_REG_VDD3) {1168 if (tps65910_chip_id(tps65910) == TPS65910) {1169 pmic->desc[i].ops = &tps65910_ops_vdd3;1170 pmic->desc[i].volt_table = info->voltage_table;1171 } else {1172 pmic->desc[i].ops = &tps65910_ops_dcdc;1173 pmic->desc[i].ramp_delay = 5000;1174 }1175 } else if (i == TPS65910_REG_VBB &&1176 tps65910_chip_id(tps65910) == TPS65910) {1177 pmic->desc[i].ops = &tps65910_ops_vbb;1178 pmic->desc[i].volt_table = info->voltage_table;1179 } else {1180 if (tps65910_chip_id(tps65910) == TPS65910) {1181 pmic->desc[i].ops = &tps65910_ops;1182 pmic->desc[i].volt_table = info->voltage_table;1183 } else {1184 pmic->desc[i].ops = &tps65911_ops;1185 }1186 }1187 1188 err = tps65910_set_ext_sleep_config(pmic, i,1189 pmic_plat_data->regulator_ext_sleep_control[i]);1190 /*1191 * Failing on regulator for configuring externally control1192 * is not a serious issue, just throw warning.1193 */1194 if (err < 0)1195 dev_warn(tps65910->dev,1196 "Failed to initialise ext control config\n");1197 1198 pmic->desc[i].type = REGULATOR_VOLTAGE;1199 pmic->desc[i].owner = THIS_MODULE;1200 pmic->desc[i].enable_reg = pmic->get_ctrl_reg(i);1201 pmic->desc[i].enable_mask = TPS65910_SUPPLY_STATE_ENABLED;1202 1203 config.dev = tps65910->dev;1204 config.init_data = pmic_plat_data->tps65910_pmic_init_data[i];1205 config.driver_data = pmic;1206 config.regmap = tps65910->regmap;1207 1208 if (tps65910_reg_matches)1209 config.of_node = tps65910_reg_matches[i].of_node;1210 1211 rdev = devm_regulator_register(&pdev->dev, &pmic->desc[i],1212 &config);1213 if (IS_ERR(rdev))1214 return dev_err_probe(tps65910->dev, PTR_ERR(rdev),1215 "failed to register %s regulator\n",1216 pdev->name);1217 1218 /* Save regulator for cleanup */1219 pmic->rdev[i] = rdev;1220 }1221 return 0;1222}1223 1224static void tps65910_shutdown(struct platform_device *pdev)1225{1226 struct tps65910_reg *pmic = platform_get_drvdata(pdev);1227 int i;1228 1229 /*1230 * Before bootloader jumps to kernel, it makes sure that required1231 * external control signals are in desired state so that given rails1232 * can be configure accordingly.1233 * If rails are configured to be controlled from external control1234 * then before shutting down/rebooting the system, the external1235 * control configuration need to be remove from the rails so that1236 * its output will be available as per register programming even1237 * if external controls are removed. This is require when the POR1238 * value of the control signals are not in active state and before1239 * bootloader initializes it, the system requires the rail output1240 * to be active for booting.1241 */1242 for (i = 0; i < pmic->num_regulators; i++) {1243 int err;1244 if (!pmic->rdev[i])1245 continue;1246 1247 err = tps65910_set_ext_sleep_config(pmic, i, 0);1248 if (err < 0)1249 dev_err(&pdev->dev,1250 "Error in clearing external control\n");1251 }1252}1253 1254static struct platform_driver tps65910_driver = {1255 .driver = {1256 .name = "tps65910-pmic",1257 .probe_type = PROBE_PREFER_ASYNCHRONOUS,1258 },1259 .probe = tps65910_probe,1260 .shutdown = tps65910_shutdown,1261};1262 1263static int __init tps65910_init(void)1264{1265 return platform_driver_register(&tps65910_driver);1266}1267subsys_initcall(tps65910_init);1268 1269static void __exit tps65910_cleanup(void)1270{1271 platform_driver_unregister(&tps65910_driver);1272}1273module_exit(tps65910_cleanup);1274 1275MODULE_AUTHOR("Graeme Gregory <gg@slimlogic.co.uk>");1276MODULE_DESCRIPTION("TPS65910/TPS65911 voltage regulator driver");1277MODULE_LICENSE("GPL v2");1278MODULE_ALIAS("platform:tps65910-pmic");1279