linux/drivers/regulator/tps65090-regulator.c
<<
>>
Prefs
   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
  42struct 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
  50static const 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 */
  64static 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 */
  88static 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 */
 133static 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;
 163err:
 164        dev_warn(&rdev->dev, "reg %#x enable failed\n", rdev->desc->enable_reg);
 165        WARN_ON(1);
 166
 167        return ret;
 168}
 169
 170static const 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
 176static const 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
 182static const 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
 206static 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
 242static 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
 254static 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
 270static 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
 294static 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
 309static 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                struct device_node *np;
 350
 351                rpdata = &reg_pdata[idx];
 352                ri_data = tps65090_matches[idx].init_data;
 353                if (!ri_data)
 354                        continue;
 355
 356                np = tps65090_matches[idx].of_node;
 357                if (!np)
 358                        continue;
 359
 360                rpdata->reg_init_data = ri_data;
 361                rpdata->enable_ext_control = of_property_read_bool(np,
 362                                                "ti,enable-ext-control");
 363                if (rpdata->enable_ext_control) {
 364                        enum gpiod_flags gflags;
 365
 366                        if (ri_data->constraints.always_on ||
 367                            ri_data->constraints.boot_on)
 368                                gflags = GPIOD_OUT_HIGH;
 369                        else
 370                                gflags = GPIOD_OUT_LOW;
 371                        gflags |= GPIOD_FLAGS_BIT_NONEXCLUSIVE;
 372
 373                        rpdata->gpiod = devm_fwnode_gpiod_get(
 374                                                        &pdev->dev,
 375                                                        of_fwnode_handle(np),
 376                                                        "dcdc-ext-control",
 377                                                        gflags,
 378                                                        "tps65090");
 379                        if (PTR_ERR(rpdata->gpiod) == -ENOENT) {
 380                                dev_err(&pdev->dev,
 381                                        "could not find DCDC external control GPIO\n");
 382                                rpdata->gpiod = NULL;
 383                        } else if (IS_ERR(rpdata->gpiod))
 384                                return ERR_CAST(rpdata->gpiod);
 385                }
 386
 387                if (of_property_read_u32(np, "ti,overcurrent-wait",
 388                                         &rpdata->overcurrent_wait) == 0)
 389                        rpdata->overcurrent_wait_valid = true;
 390
 391                tps65090_pdata->reg_pdata[idx] = rpdata;
 392        }
 393        return tps65090_pdata;
 394}
 395#else
 396static inline struct tps65090_platform_data *tps65090_parse_dt_reg_data(
 397                        struct platform_device *pdev,
 398                        struct of_regulator_match **tps65090_reg_matches)
 399{
 400        *tps65090_reg_matches = NULL;
 401        return NULL;
 402}
 403#endif
 404
 405static int tps65090_regulator_probe(struct platform_device *pdev)
 406{
 407        struct tps65090 *tps65090_mfd = dev_get_drvdata(pdev->dev.parent);
 408        struct tps65090_regulator *ri = NULL;
 409        struct regulator_config config = { };
 410        struct regulator_dev *rdev;
 411        struct tps65090_regulator_plat_data *tps_pdata;
 412        struct tps65090_regulator *pmic;
 413        struct tps65090_platform_data *tps65090_pdata;
 414        struct of_regulator_match *tps65090_reg_matches = NULL;
 415        int num;
 416        int ret;
 417
 418        dev_dbg(&pdev->dev, "Probing regulator\n");
 419
 420        tps65090_pdata = dev_get_platdata(pdev->dev.parent);
 421        if (!tps65090_pdata && tps65090_mfd->dev->of_node)
 422                tps65090_pdata = tps65090_parse_dt_reg_data(pdev,
 423                                        &tps65090_reg_matches);
 424        if (IS_ERR_OR_NULL(tps65090_pdata)) {
 425                dev_err(&pdev->dev, "Platform data missing\n");
 426                return tps65090_pdata ? PTR_ERR(tps65090_pdata) : -EINVAL;
 427        }
 428
 429        pmic = devm_kcalloc(&pdev->dev,
 430                            TPS65090_REGULATOR_MAX, sizeof(*pmic),
 431                            GFP_KERNEL);
 432        if (!pmic)
 433                return -ENOMEM;
 434
 435        for (num = 0; num < TPS65090_REGULATOR_MAX; num++) {
 436                tps_pdata = tps65090_pdata->reg_pdata[num];
 437
 438                ri = &pmic[num];
 439                ri->dev = &pdev->dev;
 440                ri->desc = &tps65090_regulator_desc[num];
 441                if (tps_pdata) {
 442                        ri->overcurrent_wait_valid =
 443                                tps_pdata->overcurrent_wait_valid;
 444                        ri->overcurrent_wait = tps_pdata->overcurrent_wait;
 445                }
 446
 447                /*
 448                 * TPS5090 DCDC support the control from external digital input.
 449                 * Configure it as per platform data.
 450                 */
 451                if (tps_pdata && is_dcdc(num) && tps_pdata->reg_init_data) {
 452                        if (tps_pdata->enable_ext_control) {
 453                                config.ena_gpiod = tps_pdata->gpiod;
 454                                ri->desc->ops = &tps65090_ext_control_ops;
 455                        } else {
 456                                ret = tps65090_regulator_disable_ext_control(
 457                                                ri, tps_pdata);
 458                                if (ret < 0) {
 459                                        dev_err(&pdev->dev,
 460                                                "failed disable ext control\n");
 461                                        return ret;
 462                                }
 463                        }
 464                }
 465
 466                config.dev = pdev->dev.parent;
 467                config.driver_data = ri;
 468                config.regmap = tps65090_mfd->rmap;
 469                if (tps_pdata)
 470                        config.init_data = tps_pdata->reg_init_data;
 471                else
 472                        config.init_data = NULL;
 473                if (tps65090_reg_matches)
 474                        config.of_node = tps65090_reg_matches[num].of_node;
 475                else
 476                        config.of_node = NULL;
 477
 478                /*
 479                 * Hand the GPIO descriptor management over to the regulator
 480                 * core, remove it from devres management.
 481                 */
 482                if (config.ena_gpiod)
 483                        devm_gpiod_unhinge(&pdev->dev, config.ena_gpiod);
 484                rdev = devm_regulator_register(&pdev->dev, ri->desc, &config);
 485                if (IS_ERR(rdev)) {
 486                        dev_err(&pdev->dev, "failed to register regulator %s\n",
 487                                ri->desc->name);
 488                        return PTR_ERR(rdev);
 489                }
 490                ri->rdev = rdev;
 491
 492                if (ri->overcurrent_wait_valid) {
 493                        ret = tps65090_reg_set_overcurrent_wait(ri, rdev);
 494                        if (ret < 0)
 495                                return ret;
 496                }
 497
 498                /* Enable external control if it is require */
 499                if (tps_pdata && is_dcdc(num) && tps_pdata->reg_init_data &&
 500                                tps_pdata->enable_ext_control) {
 501                        ret = tps65090_config_ext_control(ri, true);
 502                        if (ret < 0)
 503                                return ret;
 504                }
 505        }
 506
 507        platform_set_drvdata(pdev, pmic);
 508        return 0;
 509}
 510
 511static struct platform_driver tps65090_regulator_driver = {
 512        .driver = {
 513                .name   = "tps65090-pmic",
 514        },
 515        .probe          = tps65090_regulator_probe,
 516};
 517
 518static int __init tps65090_regulator_init(void)
 519{
 520        return platform_driver_register(&tps65090_regulator_driver);
 521}
 522subsys_initcall(tps65090_regulator_init);
 523
 524static void __exit tps65090_regulator_exit(void)
 525{
 526        platform_driver_unregister(&tps65090_regulator_driver);
 527}
 528module_exit(tps65090_regulator_exit);
 529
 530MODULE_DESCRIPTION("tps65090 regulator driver");
 531MODULE_AUTHOR("Venu Byravarasu <vbyravarasu@nvidia.com>");
 532MODULE_LICENSE("GPL v2");
 533MODULE_ALIAS("platform:tps65090-pmic");
 534