drivers/regulator/tps51632-regulator.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * tps51632-regulator.c -- TI TPS51632
   4  *
   5  * Regulator driver for TPS51632 3-2-1 Phase D-Cap Step Down Driverless
   6  * Controller with serial VID control and DVFS.
   7  *
   8  * Copyright (c) 2012, NVIDIA Corporation.
   9  *
  10  * Author: Laxman Dewangan <ldewangan@nvidia.com>
  11  */
  12
  13 #include <linux/err.h>
  14 #include <linux/i2c.h>
  15 #include <linux/init.h>
  16 #include <linux/kernel.h>
  17 #include <linux/module.h>
  18 #include <linux/of.h>
  19 #include <linux/of_device.h>
  20 #include <linux/platform_device.h>
  21 #include <linux/regmap.h>
  22 #include <linux/regulator/driver.h>
  23 #include <linux/regulator/machine.h>
  24 #include <linux/regulator/of_regulator.h>
  25 #include <linux/regulator/tps51632-regulator.h>
  26 #include <linux/slab.h>
  27
  28 /* Register definitions */
  29 #define TPS51632_VOLTAGE_SELECT_REG             0x0
  30 #define TPS51632_VOLTAGE_BASE_REG               0x1
  31 #define TPS51632_OFFSET_REG                     0x2
  32 #define TPS51632_IMON_REG                       0x3
  33 #define TPS51632_VMAX_REG                       0x4
  34 #define TPS51632_DVFS_CONTROL_REG               0x5
  35 #define TPS51632_POWER_STATE_REG                0x6
  36 #define TPS51632_SLEW_REGS                      0x7
  37 #define TPS51632_FAULT_REG                      0x14
  38
  39 #define TPS51632_MAX_REG                        0x15
  40
  41 #define TPS51632_VOUT_MASK                      0x7F
  42 #define TPS51632_VOUT_OFFSET_MASK               0x1F
  43 #define TPS51632_VMAX_MASK                      0x7F
  44 #define TPS51632_VMAX_LOCK                      0x80
  45
  46 /* TPS51632_DVFS_CONTROL_REG */
  47 #define TPS51632_DVFS_PWMEN                     0x1
  48 #define TPS51632_DVFS_STEP_20                   0x2
  49 #define TPS51632_DVFS_VMAX_PG                   0x4
  50 #define TPS51632_DVFS_PWMRST                    0x8
  51 #define TPS51632_DVFS_OCA_EN                    0x10
  52 #define TPS51632_DVFS_FCCM                      0x20
  53
  54 /* TPS51632_POWER_STATE_REG */
  55 #define TPS51632_POWER_STATE_MASK               0x03
  56 #define TPS51632_POWER_STATE_MULTI_PHASE_CCM    0x0
  57 #define TPS51632_POWER_STATE_SINGLE_PHASE_CCM   0x1
  58 #define TPS51632_POWER_STATE_SINGLE_PHASE_DCM   0x2
  59
  60 #define TPS51632_MIN_VOLTAGE                    500000
  61 #define TPS51632_MAX_VOLTAGE                    1520000
  62 #define TPS51632_VOLTAGE_STEP_10mV              10000
  63 #define TPS51632_VOLTAGE_STEP_20mV              20000
  64 #define TPS51632_MAX_VSEL                       0x7F
  65 #define TPS51632_MIN_VSEL                       0x19
  66 #define TPS51632_DEFAULT_RAMP_DELAY             6000
  67 #define TPS51632_VOLT_VSEL(uV)                                  \
  68                 (DIV_ROUND_UP(uV - TPS51632_MIN_VOLTAGE,        \
  69                         TPS51632_VOLTAGE_STEP_10mV) +           \
  70                         TPS51632_MIN_VSEL)
  71
  72 /* TPS51632 chip information */
  73 struct tps51632_chip {
  74         struct device *dev;
  75         struct regulator_desc desc;
  76         struct regulator_dev *rdev;
  77         struct regmap *regmap;
  78 };
  79
  80 static int tps51632_dcdc_set_ramp_delay(struct regulator_dev *rdev,
  81                 int ramp_delay)
  82 {
  83         struct tps51632_chip *tps = rdev_get_drvdata(rdev);
  84         int bit;
  85         int ret;
  86
  87         if (ramp_delay == 0)
  88                 bit = 0;
  89         else
  90                 bit = DIV_ROUND_UP(ramp_delay, 6000) - 1;
  91
  92         ret = regmap_write(tps->regmap, TPS51632_SLEW_REGS, BIT(bit));
  93         if (ret < 0)
  94                 dev_err(tps->dev, "SLEW reg write failed, err %d\n", ret);
  95         return ret;
  96 }
  97
  98 static const struct regulator_ops tps51632_dcdc_ops = {
  99         .get_voltage_sel        = regulator_get_voltage_sel_regmap,
 100         .set_voltage_sel        = regulator_set_voltage_sel_regmap,
 101         .list_voltage           = regulator_list_voltage_linear,
 102         .set_voltage_time_sel   = regulator_set_voltage_time_sel,
 103         .set_ramp_delay         = tps51632_dcdc_set_ramp_delay,
 104 };
 105
 106 static int tps51632_init_dcdc(struct tps51632_chip *tps,
 107                 struct tps51632_regulator_platform_data *pdata)
 108 {
 109         int ret;
 110         uint8_t control = 0;
 111         int vsel;
 112
 113         if (!pdata->enable_pwm_dvfs)
 114                 goto skip_pwm_config;
 115
 116         control |= TPS51632_DVFS_PWMEN;
 117         vsel = TPS51632_VOLT_VSEL(pdata->base_voltage_uV);
 118         ret = regmap_write(tps->regmap, TPS51632_VOLTAGE_BASE_REG, vsel);
 119         if (ret < 0) {
 120                 dev_err(tps->dev, "BASE reg write failed, err %d\n", ret);
 121                 return ret;
 122         }
 123
 124         if (pdata->dvfs_step_20mV)
 125                 control |= TPS51632_DVFS_STEP_20;
 126
 127         if (pdata->max_voltage_uV) {
 128                 unsigned int vmax;
 129                 /**
 130                  * TPS51632 hw behavior: VMAX register can be write only
 131                  * once as it get locked after first write. The lock get
 132                  * reset only when device is power-reset.
 133                  * Write register only when lock bit is not enabled.
 134                  */
 135                 ret = regmap_read(tps->regmap, TPS51632_VMAX_REG, &vmax);
 136                 if (ret < 0) {
 137                         dev_err(tps->dev, "VMAX read failed, err %d\n", ret);
 138                         return ret;
 139                 }
 140                 if (!(vmax & TPS51632_VMAX_LOCK)) {
 141                         vsel = TPS51632_VOLT_VSEL(pdata->max_voltage_uV);
 142                         ret = regmap_write(tps->regmap, TPS51632_VMAX_REG,
 143                                         vsel);
 144                         if (ret < 0) {
 145                                 dev_err(tps->dev,
 146                                         "VMAX write failed, err %d\n", ret);
 147                                 return ret;
 148                         }
 149                 }
 150         }
 151
 152 skip_pwm_config:
 153         ret = regmap_write(tps->regmap, TPS51632_DVFS_CONTROL_REG, control);
 154         if (ret < 0)
 155                 dev_err(tps->dev, "DVFS reg write failed, err %d\n", ret);
 156         return ret;
 157 }
 158
 159 static bool is_volatile_reg(struct device *dev, unsigned int reg)
 160 {
 161         switch (reg) {
 162         case TPS51632_OFFSET_REG:
 163         case TPS51632_FAULT_REG:
 164         case TPS51632_IMON_REG:
 165                 return true;
 166         default:
 167                 return false;
 168         }
 169 }
 170
 171 static bool is_read_reg(struct device *dev, unsigned int reg)
 172 {
 173         switch (reg) {
 174         case 0x08 ... 0x0F:
 175                 return false;
 176         default:
 177                 return true;
 178         }
 179 }
 180
 181 static bool is_write_reg(struct device *dev, unsigned int reg)
 182 {
 183         switch (reg) {
 184         case TPS51632_VOLTAGE_SELECT_REG:
 185         case TPS51632_VOLTAGE_BASE_REG:
 186         case TPS51632_VMAX_REG:
 187         case TPS51632_DVFS_CONTROL_REG:
 188         case TPS51632_POWER_STATE_REG:
 189         case TPS51632_SLEW_REGS:
 190                 return true;
 191         default:
 192                 return false;
 193         }
 194 }
 195
 196 static const struct regmap_config tps51632_regmap_config = {
 197         .reg_bits               = 8,
 198         .val_bits               = 8,
 199         .writeable_reg          = is_write_reg,
 200         .readable_reg           = is_read_reg,
 201         .volatile_reg           = is_volatile_reg,
 202         .max_register           = TPS51632_MAX_REG - 1,
 203         .cache_type             = REGCACHE_RBTREE,
 204 };
 205
 206 #if defined(CONFIG_OF)
 207 static const struct of_device_id tps51632_of_match[] = {
 208         { .compatible = "ti,tps51632",},
 209         {},
 210 };
 211 MODULE_DEVICE_TABLE(of, tps51632_of_match);
 212
 213 static struct tps51632_regulator_platform_data *
 214         of_get_tps51632_platform_data(struct device *dev,
 215                                       const struct regulator_desc *desc)
 216 {
 217         struct tps51632_regulator_platform_data *pdata;
 218         struct device_node *np = dev->of_node;
 219
 220         pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
 221         if (!pdata)
 222                 return NULL;
 223
 224         pdata->reg_init_data = of_get_regulator_init_data(dev, dev->of_node,
 225                                                           desc);
 226         if (!pdata->reg_init_data) {
 227                 dev_err(dev, "Not able to get OF regulator init data\n");
 228                 return NULL;
 229         }
 230
 231         pdata->enable_pwm_dvfs =
 232                         of_property_read_bool(np, "ti,enable-pwm-dvfs");
 233         pdata->dvfs_step_20mV = of_property_read_bool(np, "ti,dvfs-step-20mV");
 234
 235         pdata->base_voltage_uV = pdata->reg_init_data->constraints.min_uV ? :
 236                                         TPS51632_MIN_VOLTAGE;
 237         pdata->max_voltage_uV = pdata->reg_init_data->constraints.max_uV ? :
 238                                         TPS51632_MAX_VOLTAGE;
 239         return pdata;
 240 }
 241 #else
 242 static struct tps51632_regulator_platform_data *
 243         of_get_tps51632_platform_data(struct device *dev,
 244                                       const struct regulator_desc *desc)
 245 {
 246         return NULL;
 247 }
 248 #endif
 249
 250 static int tps51632_probe(struct i2c_client *client,
 251                                 const struct i2c_device_id *id)
 252 {
 253         struct tps51632_regulator_platform_data *pdata;
 254         struct regulator_dev *rdev;
 255         struct tps51632_chip *tps;
 256         int ret;
 257         struct regulator_config config = { };
 258
 259         if (client->dev.of_node) {
 260                 const struct of_device_id *match;
 261                 match = of_match_device(of_match_ptr(tps51632_of_match),
 262                                 &client->dev);
 263                 if (!match) {
 264                         dev_err(&client->dev, "Error: No device match found\n");
 265                         return -ENODEV;
 266                 }
 267         }
 268
 269         tps = devm_kzalloc(&client->dev, sizeof(*tps), GFP_KERNEL);
 270         if (!tps)
 271                 return -ENOMEM;
 272
 273         tps->dev = &client->dev;
 274         tps->desc.name = client->name;
 275         tps->desc.id = 0;
 276         tps->desc.ramp_delay = TPS51632_DEFAULT_RAMP_DELAY;
 277         tps->desc.min_uV = TPS51632_MIN_VOLTAGE;
 278         tps->desc.uV_step = TPS51632_VOLTAGE_STEP_10mV;
 279         tps->desc.linear_min_sel = TPS51632_MIN_VSEL;
 280         tps->desc.n_voltages = TPS51632_MAX_VSEL + 1;
 281         tps->desc.ops = &tps51632_dcdc_ops;
 282         tps->desc.type = REGULATOR_VOLTAGE;
 283         tps->desc.owner = THIS_MODULE;
 284
 285         pdata = dev_get_platdata(&client->dev);
 286         if (!pdata && client->dev.of_node)
 287                 pdata = of_get_tps51632_platform_data(&client->dev, &tps->desc);
 288         if (!pdata) {
 289                 dev_err(&client->dev, "No Platform data\n");
 290                 return -EINVAL;
 291         }
 292
 293         if (pdata->enable_pwm_dvfs) {
 294                 if ((pdata->base_voltage_uV < TPS51632_MIN_VOLTAGE) ||
 295                     (pdata->base_voltage_uV > TPS51632_MAX_VOLTAGE)) {
 296                         dev_err(&client->dev, "Invalid base_voltage_uV setting\n");
 297                         return -EINVAL;
 298                 }
 299
 300                 if ((pdata->max_voltage_uV) &&
 301                     ((pdata->max_voltage_uV < TPS51632_MIN_VOLTAGE) ||
 302                      (pdata->max_voltage_uV > TPS51632_MAX_VOLTAGE))) {
 303                         dev_err(&client->dev, "Invalid max_voltage_uV setting\n");
 304                         return -EINVAL;
 305                 }
 306         }
 307
 308         if (pdata->enable_pwm_dvfs)
 309                 tps->desc.vsel_reg = TPS51632_VOLTAGE_BASE_REG;
 310         else
 311                 tps->desc.vsel_reg = TPS51632_VOLTAGE_SELECT_REG;
 312         tps->desc.vsel_mask = TPS51632_VOUT_MASK;
 313
 314         tps->regmap = devm_regmap_init_i2c(client, &tps51632_regmap_config);
 315         if (IS_ERR(tps->regmap)) {
 316                 ret = PTR_ERR(tps->regmap);
 317                 dev_err(&client->dev, "regmap init failed, err %d\n", ret);
 318                 return ret;
 319         }
 320         i2c_set_clientdata(client, tps);
 321
 322         ret = tps51632_init_dcdc(tps, pdata);
 323         if (ret < 0) {
 324                 dev_err(tps->dev, "Init failed, err = %d\n", ret);
 325                 return ret;
 326         }
 327
 328         /* Register the regulators */
 329         config.dev = &client->dev;
 330         config.init_data = pdata->reg_init_data;
 331         config.driver_data = tps;
 332         config.regmap = tps->regmap;
 333         config.of_node = client->dev.of_node;
 334
 335         rdev = devm_regulator_register(&client->dev, &tps->desc, &config);
 336         if (IS_ERR(rdev)) {
 337                 dev_err(tps->dev, "regulator register failed\n");
 338                 return PTR_ERR(rdev);
 339         }
 340
 341         tps->rdev = rdev;
 342         return 0;
 343 }
 344
 345 static const struct i2c_device_id tps51632_id[] = {
 346         {.name = "tps51632",},
 347         {},
 348 };
 349
 350 MODULE_DEVICE_TABLE(i2c, tps51632_id);
 351
 352 static struct i2c_driver tps51632_i2c_driver = {
 353         .driver = {
 354                 .name = "tps51632",
 355                 .of_match_table = of_match_ptr(tps51632_of_match),
 356         },
 357         .probe = tps51632_probe,
 358         .id_table = tps51632_id,
 359 };
 360
 361 static int __init tps51632_init(void)
 362 {
 363         return i2c_add_driver(&tps51632_i2c_driver);
 364 }
 365 subsys_initcall(tps51632_init);
 366
 367 static void __exit tps51632_cleanup(void)
 368 {
 369         i2c_del_driver(&tps51632_i2c_driver);
 370 }
 371 module_exit(tps51632_cleanup);
 372
 373 MODULE_AUTHOR("Laxman Dewangan <ldewangan@nvidia.com>");
 374 MODULE_DESCRIPTION("TPS51632 voltage regulator driver");
 375 MODULE_LICENSE("GPL v2");