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 { 252 struct tps51632_regulator_platform_data *pdata; 253 struct regulator_dev *rdev; 254 struct tps51632_chip *tps; 255 int ret; 256 struct regulator_config config = { }; 257 258 if (client->dev.of_node) { 259 const struct of_device_id *match; 260 match = of_match_device(of_match_ptr(tps51632_of_match), 261 &client->dev); 262 if (!match) { 263 dev_err(&client->dev, "Error: No device match found\n"); 264 return -ENODEV; 265 } 266 } 267 268 tps = devm_kzalloc(&client->dev, sizeof(*tps), GFP_KERNEL); 269 if (!tps) 270 return -ENOMEM; 271 272 tps->dev = &client->dev; 273 tps->desc.name = client->name; 274 tps->desc.id = 0; 275 tps->desc.ramp_delay = TPS51632_DEFAULT_RAMP_DELAY; 276 tps->desc.min_uV = TPS51632_MIN_VOLTAGE; 277 tps->desc.uV_step = TPS51632_VOLTAGE_STEP_10mV; 278 tps->desc.linear_min_sel = TPS51632_MIN_VSEL; 279 tps->desc.n_voltages = TPS51632_MAX_VSEL + 1; 280 tps->desc.ops = &tps51632_dcdc_ops; 281 tps->desc.type = REGULATOR_VOLTAGE; 282 tps->desc.owner = THIS_MODULE; 283 284 pdata = dev_get_platdata(&client->dev); 285 if (!pdata && client->dev.of_node) 286 pdata = of_get_tps51632_platform_data(&client->dev, &tps->desc); 287 if (!pdata) { 288 dev_err(&client->dev, "No Platform data\n"); 289 return -EINVAL; 290 } 291 292 if (pdata->enable_pwm_dvfs) { 293 if ((pdata->base_voltage_uV < TPS51632_MIN_VOLTAGE) || 294 (pdata->base_voltage_uV > TPS51632_MAX_VOLTAGE)) { 295 dev_err(&client->dev, "Invalid base_voltage_uV setting\n"); 296 return -EINVAL; 297 } 298 299 if ((pdata->max_voltage_uV) && 300 ((pdata->max_voltage_uV < TPS51632_MIN_VOLTAGE) || 301 (pdata->max_voltage_uV > TPS51632_MAX_VOLTAGE))) { 302 dev_err(&client->dev, "Invalid max_voltage_uV setting\n"); 303 return -EINVAL; 304 } 305 } 306 307 if (pdata->enable_pwm_dvfs) 308 tps->desc.vsel_reg = TPS51632_VOLTAGE_BASE_REG; 309 else 310 tps->desc.vsel_reg = TPS51632_VOLTAGE_SELECT_REG; 311 tps->desc.vsel_mask = TPS51632_VOUT_MASK; 312 313 tps->regmap = devm_regmap_init_i2c(client, &tps51632_regmap_config); 314 if (IS_ERR(tps->regmap)) { 315 ret = PTR_ERR(tps->regmap); 316 dev_err(&client->dev, "regmap init failed, err %d\n", ret); 317 return ret; 318 } 319 i2c_set_clientdata(client, tps); 320 321 ret = tps51632_init_dcdc(tps, pdata); 322 if (ret < 0) { 323 dev_err(tps->dev, "Init failed, err = %d\n", ret); 324 return ret; 325 } 326 327 /* Register the regulators */ 328 config.dev = &client->dev; 329 config.init_data = pdata->reg_init_data; 330 config.driver_data = tps; 331 config.regmap = tps->regmap; 332 config.of_node = client->dev.of_node; 333 334 rdev = devm_regulator_register(&client->dev, &tps->desc, &config); 335 if (IS_ERR(rdev)) { 336 dev_err(tps->dev, "regulator register failed\n"); 337 return PTR_ERR(rdev); 338 } 339 340 tps->rdev = rdev; 341 return 0; 342 } 343 344 static const struct i2c_device_id tps51632_id[] = { 345 {.name = "tps51632",}, 346 {}, 347 }; 348 349 MODULE_DEVICE_TABLE(i2c, tps51632_id); 350 351 static struct i2c_driver tps51632_i2c_driver = { 352 .driver = { 353 .name = "tps51632", 354 .probe_type = PROBE_PREFER_ASYNCHRONOUS, 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"); 376