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