drivers/regulator/tps51632-regulator.c

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