drivers/regulator/tps65090-regulator.c

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
tps65090_reg_set_overcurrent_wait
tps65090_try_enable_fet
tps65090_fet_enable
is_dcdc
tps65090_config_ext_control
tps65090_regulator_disable_ext_control
tps65090_parse_dt_reg_data
tps65090_parse_dt_reg_data
tps65090_regulator_probe
tps65090_regulator_init
tps65090_regulator_exit
   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Regulator driver for tps65090 power management chip.
   4  *
   5  * Copyright (c) 2012, NVIDIA CORPORATION.  All rights reserved.
   6 
   7  */
   8 
   9 #include <linux/module.h>
  10 #include <linux/delay.h>
  11 #include <linux/init.h>
  12 #include <linux/of.h>
  13 #include <linux/gpio/consumer.h>
  14 #include <linux/slab.h>
  15 #include <linux/err.h>
  16 #include <linux/platform_device.h>
  17 #include <linux/regulator/driver.h>
  18 #include <linux/regulator/machine.h>
  19 #include <linux/regulator/of_regulator.h>
  20 #include <linux/mfd/tps65090.h>
  21 
  22 #define MAX_CTRL_READ_TRIES     5
  23 #define MAX_FET_ENABLE_TRIES    1000
  24 
  25 #define CTRL_EN_BIT             0 /* Regulator enable bit, active high */
  26 #define CTRL_WT_BIT             2 /* Regulator wait time 0 bit */
  27 #define CTRL_PG_BIT             4 /* Regulator power good bit, 1=good */
  28 #define CTRL_TO_BIT             7 /* Regulator timeout bit, 1=wait */
  29 
  30 #define MAX_OVERCURRENT_WAIT    3 /* Overcurrent wait must be <= this */
  31 
  32 /**
  33  * struct tps65090_regulator - Per-regulator data for a tps65090 regulator
  34  *
  35  * @dev: Pointer to our device.
  36  * @desc: The struct regulator_desc for the regulator.
  37  * @rdev: The struct regulator_dev for the regulator.
  38  * @overcurrent_wait_valid: True if overcurrent_wait is valid.
  39  * @overcurrent_wait: For FETs, the value to put in the WTFET bitfield.
  40  */
  41 
  42 struct tps65090_regulator {
  43         struct device           *dev;
  44         struct regulator_desc   *desc;
  45         struct regulator_dev    *rdev;
  46         bool                    overcurrent_wait_valid;
  47         int                     overcurrent_wait;
  48 };
  49 
  50 static struct regulator_ops tps65090_ext_control_ops = {
  51 };
  52 
  53 /**
  54  * tps65090_reg_set_overcurrent_wait - Setup overcurrent wait
  55  *
  56  * This will set the overcurrent wait time based on what's in the regulator
  57  * info.
  58  *
  59  * @ri:         Overall regulator data
  60  * @rdev:       Regulator device
  61  *
  62  * Return: 0 if no error, non-zero if there was an error writing the register.
  63  */
  64 static int tps65090_reg_set_overcurrent_wait(struct tps65090_regulator *ri,
  65                                              struct regulator_dev *rdev)
  66 {
  67         int ret;
  68 
  69         ret = regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
  70                                  MAX_OVERCURRENT_WAIT << CTRL_WT_BIT,
  71                                  ri->overcurrent_wait << CTRL_WT_BIT);
  72         if (ret) {
  73                 dev_err(&rdev->dev, "Error updating overcurrent wait %#x\n",
  74                         rdev->desc->enable_reg);
  75         }
  76 
  77         return ret;
  78 }
  79 
  80 /**
  81  * tps65090_try_enable_fet - Try to enable a FET
  82  *
  83  * @rdev:       Regulator device
  84  *
  85  * Return: 0 if ok, -ENOTRECOVERABLE if the FET power good bit did not get
  86  * set, or some other -ve value if another error occurred (e.g. i2c error)
  87  */
  88 static int tps65090_try_enable_fet(struct regulator_dev *rdev)
  89 {
  90         unsigned int control;
  91         int ret, i;
  92 
  93         ret = regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
  94                                  rdev->desc->enable_mask,
  95                                  rdev->desc->enable_mask);
  96         if (ret < 0) {
  97                 dev_err(&rdev->dev, "Error in updating reg %#x\n",
  98                         rdev->desc->enable_reg);
  99                 return ret;
 100         }
 101 
 102         for (i = 0; i < MAX_CTRL_READ_TRIES; i++) {
 103                 ret = regmap_read(rdev->regmap, rdev->desc->enable_reg,
 104                                   &control);
 105                 if (ret < 0)
 106                         return ret;
 107 
 108                 if (!(control & BIT(CTRL_TO_BIT)))
 109                         break;
 110 
 111                 usleep_range(1000, 1500);
 112         }
 113         if (!(control & BIT(CTRL_PG_BIT)))
 114                 return -ENOTRECOVERABLE;
 115 
 116         return 0;
 117 }
 118 
 119 /**
 120  * tps65090_fet_enable - Enable a FET, trying a few times if it fails
 121  *
 122  * Some versions of the tps65090 have issues when turning on the FETs.
 123  * This function goes through several steps to ensure the best chance of the
 124  * FET going on.  Specifically:
 125  * - We'll make sure that we bump the "overcurrent wait" to the maximum, which
 126  *   increases the chances that we'll turn on properly.
 127  * - We'll retry turning the FET on multiple times (turning off in between).
 128  *
 129  * @rdev:       Regulator device
 130  *
 131  * Return: 0 if ok, non-zero if it fails.
 132  */
 133 static int tps65090_fet_enable(struct regulator_dev *rdev)
 134 {
 135         int ret, tries;
 136 
 137         /*
 138          * Try enabling multiple times until we succeed since sometimes the
 139          * first try times out.
 140          */
 141         tries = 0;
 142         while (true) {
 143                 ret = tps65090_try_enable_fet(rdev);
 144                 if (!ret)
 145                         break;
 146                 if (ret != -ENOTRECOVERABLE || tries == MAX_FET_ENABLE_TRIES)
 147                         goto err;
 148 
 149                 /* Try turning the FET off (and then on again) */
 150                 ret = regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
 151                                          rdev->desc->enable_mask, 0);
 152                 if (ret)
 153                         goto err;
 154 
 155                 tries++;
 156         }
 157 
 158         if (tries)
 159                 dev_warn(&rdev->dev, "reg %#x enable ok after %d tries\n",
 160                          rdev->desc->enable_reg, tries);
 161 
 162         return 0;
 163 err:
 164         dev_warn(&rdev->dev, "reg %#x enable failed\n", rdev->desc->enable_reg);
 165         WARN_ON(1);
 166 
 167         return ret;
 168 }
 169 
 170 static struct regulator_ops tps65090_reg_control_ops = {
 171         .enable         = regulator_enable_regmap,
 172         .disable        = regulator_disable_regmap,
 173         .is_enabled     = regulator_is_enabled_regmap,
 174 };
 175 
 176 static struct regulator_ops tps65090_fet_control_ops = {
 177         .enable         = tps65090_fet_enable,
 178         .disable        = regulator_disable_regmap,
 179         .is_enabled     = regulator_is_enabled_regmap,
 180 };
 181 
 182 static struct regulator_ops tps65090_ldo_ops = {
 183 };
 184 
 185 #define tps65090_REG_DESC(_id, _sname, _en_reg, _en_bits, _nvolt, _volt, _ops) \
 186 {                                                       \
 187         .name = "TPS65090_RAILS"#_id,                   \
 188         .supply_name = _sname,                          \
 189         .id = TPS65090_REGULATOR_##_id,                 \
 190         .n_voltages = _nvolt,                           \
 191         .ops = &_ops,                                   \
 192         .fixed_uV = _volt,                              \
 193         .enable_reg = _en_reg,                          \
 194         .enable_val = _en_bits,                         \
 195         .enable_mask = _en_bits,                        \
 196         .type = REGULATOR_VOLTAGE,                      \
 197         .owner = THIS_MODULE,                           \
 198 }
 199 
 200 #define tps65090_REG_FIXEDV(_id, _sname, en_reg, _en_bits, _volt, _ops) \
 201         tps65090_REG_DESC(_id, _sname, en_reg, _en_bits, 1, _volt, _ops)
 202 
 203 #define tps65090_REG_SWITCH(_id, _sname, en_reg, _en_bits, _ops) \
 204         tps65090_REG_DESC(_id, _sname, en_reg, _en_bits, 0, 0, _ops)
 205 
 206 static struct regulator_desc tps65090_regulator_desc[] = {
 207         tps65090_REG_FIXEDV(DCDC1, "vsys1",   0x0C, BIT(CTRL_EN_BIT), 5000000,
 208                             tps65090_reg_control_ops),
 209         tps65090_REG_FIXEDV(DCDC2, "vsys2",   0x0D, BIT(CTRL_EN_BIT), 3300000,
 210                             tps65090_reg_control_ops),
 211         tps65090_REG_SWITCH(DCDC3, "vsys3",   0x0E, BIT(CTRL_EN_BIT),
 212                             tps65090_reg_control_ops),
 213 
 214         tps65090_REG_SWITCH(FET1,  "infet1",  0x0F,
 215                             BIT(CTRL_EN_BIT) | BIT(CTRL_PG_BIT),
 216                             tps65090_fet_control_ops),
 217         tps65090_REG_SWITCH(FET2,  "infet2",  0x10,
 218                             BIT(CTRL_EN_BIT) | BIT(CTRL_PG_BIT),
 219                             tps65090_fet_control_ops),
 220         tps65090_REG_SWITCH(FET3,  "infet3",  0x11,
 221                             BIT(CTRL_EN_BIT) | BIT(CTRL_PG_BIT),
 222                             tps65090_fet_control_ops),
 223         tps65090_REG_SWITCH(FET4,  "infet4",  0x12,
 224                             BIT(CTRL_EN_BIT) | BIT(CTRL_PG_BIT),
 225                             tps65090_fet_control_ops),
 226         tps65090_REG_SWITCH(FET5,  "infet5",  0x13,
 227                             BIT(CTRL_EN_BIT) | BIT(CTRL_PG_BIT),
 228                             tps65090_fet_control_ops),
 229         tps65090_REG_SWITCH(FET6,  "infet6",  0x14,
 230                             BIT(CTRL_EN_BIT) | BIT(CTRL_PG_BIT),
 231                             tps65090_fet_control_ops),
 232         tps65090_REG_SWITCH(FET7,  "infet7",  0x15,
 233                             BIT(CTRL_EN_BIT) | BIT(CTRL_PG_BIT),
 234                             tps65090_fet_control_ops),
 235 
 236         tps65090_REG_FIXEDV(LDO1,  "vsys-l1", 0, 0, 5000000,
 237                             tps65090_ldo_ops),
 238         tps65090_REG_FIXEDV(LDO2,  "vsys-l2", 0, 0, 3300000,
 239                             tps65090_ldo_ops),
 240 };
 241 
 242 static inline bool is_dcdc(int id)
 243 {
 244         switch (id) {
 245         case TPS65090_REGULATOR_DCDC1:
 246         case TPS65090_REGULATOR_DCDC2:
 247         case TPS65090_REGULATOR_DCDC3:
 248                 return true;
 249         default:
 250                 return false;
 251         }
 252 }
 253 
 254 static int tps65090_config_ext_control(
 255         struct tps65090_regulator *ri, bool enable)
 256 {
 257         int ret;
 258         struct device *parent = ri->dev->parent;
 259         unsigned int reg_en_reg = ri->desc->enable_reg;
 260 
 261         if (enable)
 262                 ret = tps65090_set_bits(parent, reg_en_reg, 1);
 263         else
 264                 ret =  tps65090_clr_bits(parent, reg_en_reg, 1);
 265         if (ret < 0)
 266                 dev_err(ri->dev, "Error in updating reg 0x%x\n", reg_en_reg);
 267         return ret;
 268 }
 269 
 270 static int tps65090_regulator_disable_ext_control(
 271                 struct tps65090_regulator *ri,
 272                 struct tps65090_regulator_plat_data *tps_pdata)
 273 {
 274         int ret = 0;
 275         struct device *parent = ri->dev->parent;
 276         unsigned int reg_en_reg = ri->desc->enable_reg;
 277 
 278         /*
 279          * First enable output for internal control if require.
 280          * And then disable external control.
 281          */
 282         if (tps_pdata->reg_init_data->constraints.always_on ||
 283                         tps_pdata->reg_init_data->constraints.boot_on) {
 284                 ret =  tps65090_set_bits(parent, reg_en_reg, 0);
 285                 if (ret < 0) {
 286                         dev_err(ri->dev, "Error in set reg 0x%x\n", reg_en_reg);
 287                         return ret;
 288                 }
 289         }
 290         return tps65090_config_ext_control(ri, false);
 291 }
 292 
 293 #ifdef CONFIG_OF
 294 static struct of_regulator_match tps65090_matches[] = {
 295         { .name = "dcdc1", },
 296         { .name = "dcdc2", },
 297         { .name = "dcdc3", },
 298         { .name = "fet1",  },
 299         { .name = "fet2",  },
 300         { .name = "fet3",  },
 301         { .name = "fet4",  },
 302         { .name = "fet5",  },
 303         { .name = "fet6",  },
 304         { .name = "fet7",  },
 305         { .name = "ldo1",  },
 306         { .name = "ldo2",  },
 307 };
 308 
 309 static struct tps65090_platform_data *tps65090_parse_dt_reg_data(
 310                 struct platform_device *pdev,
 311                 struct of_regulator_match **tps65090_reg_matches)
 312 {
 313         struct tps65090_platform_data *tps65090_pdata;
 314         struct device_node *np = pdev->dev.parent->of_node;
 315         struct device_node *regulators;
 316         int idx = 0, ret;
 317         struct tps65090_regulator_plat_data *reg_pdata;
 318 
 319         tps65090_pdata = devm_kzalloc(&pdev->dev, sizeof(*tps65090_pdata),
 320                                 GFP_KERNEL);
 321         if (!tps65090_pdata)
 322                 return ERR_PTR(-ENOMEM);
 323 
 324         reg_pdata = devm_kcalloc(&pdev->dev,
 325                                  TPS65090_REGULATOR_MAX, sizeof(*reg_pdata),
 326                                  GFP_KERNEL);
 327         if (!reg_pdata)
 328                 return ERR_PTR(-ENOMEM);
 329 
 330         regulators = of_get_child_by_name(np, "regulators");
 331         if (!regulators) {
 332                 dev_err(&pdev->dev, "regulator node not found\n");
 333                 return ERR_PTR(-ENODEV);
 334         }
 335 
 336         ret = of_regulator_match(&pdev->dev, regulators, tps65090_matches,
 337                         ARRAY_SIZE(tps65090_matches));
 338         of_node_put(regulators);
 339         if (ret < 0) {
 340                 dev_err(&pdev->dev,
 341                         "Error parsing regulator init data: %d\n", ret);
 342                 return ERR_PTR(ret);
 343         }
 344 
 345         *tps65090_reg_matches = tps65090_matches;
 346         for (idx = 0; idx < ARRAY_SIZE(tps65090_matches); idx++) {
 347                 struct regulator_init_data *ri_data;
 348                 struct tps65090_regulator_plat_data *rpdata;
 349 
 350                 rpdata = &reg_pdata[idx];
 351                 ri_data = tps65090_matches[idx].init_data;
 352                 if (!ri_data || !tps65090_matches[idx].of_node)
 353                         continue;
 354 
 355                 rpdata->reg_init_data = ri_data;
 356                 rpdata->enable_ext_control = of_property_read_bool(
 357                                         tps65090_matches[idx].of_node,
 358                                         "ti,enable-ext-control");
 359                 if (rpdata->enable_ext_control) {
 360                         enum gpiod_flags gflags;
 361 
 362                         if (ri_data->constraints.always_on ||
 363                             ri_data->constraints.boot_on)
 364                                 gflags = GPIOD_OUT_HIGH;
 365                         else
 366                                 gflags = GPIOD_OUT_LOW;
 367                         gflags |= GPIOD_FLAGS_BIT_NONEXCLUSIVE;
 368 
 369                         rpdata->gpiod = devm_gpiod_get_from_of_node(&pdev->dev,
 370                                                                     tps65090_matches[idx].of_node,
 371                                                                     "dcdc-ext-control-gpios", 0,
 372                                                                     gflags,
 373                                                                     "tps65090");
 374                         if (PTR_ERR(rpdata->gpiod) == -ENOENT) {
 375                                 dev_err(&pdev->dev,
 376                                         "could not find DCDC external control GPIO\n");
 377                                 rpdata->gpiod = NULL;
 378                         } else if (IS_ERR(rpdata->gpiod))
 379                                 return ERR_CAST(rpdata->gpiod);
 380                 }
 381 
 382                 if (of_property_read_u32(tps65090_matches[idx].of_node,
 383                                          "ti,overcurrent-wait",
 384                                          &rpdata->overcurrent_wait) == 0)
 385                         rpdata->overcurrent_wait_valid = true;
 386 
 387                 tps65090_pdata->reg_pdata[idx] = rpdata;
 388         }
 389         return tps65090_pdata;
 390 }
 391 #else
 392 static inline struct tps65090_platform_data *tps65090_parse_dt_reg_data(
 393                         struct platform_device *pdev,
 394                         struct of_regulator_match **tps65090_reg_matches)
 395 {
 396         *tps65090_reg_matches = NULL;
 397         return NULL;
 398 }
 399 #endif
 400 
 401 static int tps65090_regulator_probe(struct platform_device *pdev)
 402 {
 403         struct tps65090 *tps65090_mfd = dev_get_drvdata(pdev->dev.parent);
 404         struct tps65090_regulator *ri = NULL;
 405         struct regulator_config config = { };
 406         struct regulator_dev *rdev;
 407         struct tps65090_regulator_plat_data *tps_pdata;
 408         struct tps65090_regulator *pmic;
 409         struct tps65090_platform_data *tps65090_pdata;
 410         struct of_regulator_match *tps65090_reg_matches = NULL;
 411         int num;
 412         int ret;
 413 
 414         dev_dbg(&pdev->dev, "Probing regulator\n");
 415 
 416         tps65090_pdata = dev_get_platdata(pdev->dev.parent);
 417         if (!tps65090_pdata && tps65090_mfd->dev->of_node)
 418                 tps65090_pdata = tps65090_parse_dt_reg_data(pdev,
 419                                         &tps65090_reg_matches);
 420         if (IS_ERR_OR_NULL(tps65090_pdata)) {
 421                 dev_err(&pdev->dev, "Platform data missing\n");
 422                 return tps65090_pdata ? PTR_ERR(tps65090_pdata) : -EINVAL;
 423         }
 424 
 425         pmic = devm_kcalloc(&pdev->dev,
 426                             TPS65090_REGULATOR_MAX, sizeof(*pmic),
 427                             GFP_KERNEL);
 428         if (!pmic)
 429                 return -ENOMEM;
 430 
 431         for (num = 0; num < TPS65090_REGULATOR_MAX; num++) {
 432                 tps_pdata = tps65090_pdata->reg_pdata[num];
 433 
 434                 ri = &pmic[num];
 435                 ri->dev = &pdev->dev;
 436                 ri->desc = &tps65090_regulator_desc[num];
 437                 if (tps_pdata) {
 438                         ri->overcurrent_wait_valid =
 439                                 tps_pdata->overcurrent_wait_valid;
 440                         ri->overcurrent_wait = tps_pdata->overcurrent_wait;
 441                 }
 442 
 443                 /*
 444                  * TPS5090 DCDC support the control from external digital input.
 445                  * Configure it as per platform data.
 446                  */
 447                 if (tps_pdata && is_dcdc(num) && tps_pdata->reg_init_data) {
 448                         if (tps_pdata->enable_ext_control) {
 449                                 config.ena_gpiod = tps_pdata->gpiod;
 450                                 ri->desc->ops = &tps65090_ext_control_ops;
 451                         } else {
 452                                 ret = tps65090_regulator_disable_ext_control(
 453                                                 ri, tps_pdata);
 454                                 if (ret < 0) {
 455                                         dev_err(&pdev->dev,
 456                                                 "failed disable ext control\n");
 457                                         return ret;
 458                                 }
 459                         }
 460                 }
 461 
 462                 config.dev = pdev->dev.parent;
 463                 config.driver_data = ri;
 464                 config.regmap = tps65090_mfd->rmap;
 465                 if (tps_pdata)
 466                         config.init_data = tps_pdata->reg_init_data;
 467                 else
 468                         config.init_data = NULL;
 469                 if (tps65090_reg_matches)
 470                         config.of_node = tps65090_reg_matches[num].of_node;
 471                 else
 472                         config.of_node = NULL;
 473 
 474                 /*
 475                  * Hand the GPIO descriptor management over to the regulator
 476                  * core, remove it from devres management.
 477                  */
 478                 if (config.ena_gpiod)
 479                         devm_gpiod_unhinge(&pdev->dev, config.ena_gpiod);
 480                 rdev = devm_regulator_register(&pdev->dev, ri->desc, &config);
 481                 if (IS_ERR(rdev)) {
 482                         dev_err(&pdev->dev, "failed to register regulator %s\n",
 483                                 ri->desc->name);
 484                         return PTR_ERR(rdev);
 485                 }
 486                 ri->rdev = rdev;
 487 
 488                 if (ri->overcurrent_wait_valid) {
 489                         ret = tps65090_reg_set_overcurrent_wait(ri, rdev);
 490                         if (ret < 0)
 491                                 return ret;
 492                 }
 493 
 494                 /* Enable external control if it is require */
 495                 if (tps_pdata && is_dcdc(num) && tps_pdata->reg_init_data &&
 496                                 tps_pdata->enable_ext_control) {
 497                         ret = tps65090_config_ext_control(ri, true);
 498                         if (ret < 0)
 499                                 return ret;
 500                 }
 501         }
 502 
 503         platform_set_drvdata(pdev, pmic);
 504         return 0;
 505 }
 506 
 507 static struct platform_driver tps65090_regulator_driver = {
 508         .driver = {
 509                 .name   = "tps65090-pmic",
 510         },
 511         .probe          = tps65090_regulator_probe,
 512 };
 513 
 514 static int __init tps65090_regulator_init(void)
 515 {
 516         return platform_driver_register(&tps65090_regulator_driver);
 517 }
 518 subsys_initcall(tps65090_regulator_init);
 519 
 520 static void __exit tps65090_regulator_exit(void)
 521 {
 522         platform_driver_unregister(&tps65090_regulator_driver);
 523 }
 524 module_exit(tps65090_regulator_exit);
 525 
 526 MODULE_DESCRIPTION("tps65090 regulator driver");
 527 MODULE_AUTHOR("Venu Byravarasu <vbyravarasu@nvidia.com>");
 528 MODULE_LICENSE("GPL v2");
 529 MODULE_ALIAS("platform:tps65090-pmic");
/* [<][>][^][v][top][bottom][index][help] */
root/drivers/regulator/tps65090-regulator.c

DEFINITIONS
