1 /* 2 * tps6507x-regulator.c 3 * 4 * Regulator driver for TPS65073 PMIC 5 * 6 * Copyright (C) 2009 Texas Instrument Incorporated - http://www.ti.com/ 7 * 8 * This program is free software; you can redistribute it and/or 9 * modify it under the terms of the GNU General Public License as 10 * published by the Free Software Foundation version 2. 11 * 12 * This program is distributed "as is" WITHOUT ANY WARRANTY of any kind, 13 * whether express or implied; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 * General Public License for more details. 16 */ 17 18 #include <linux/kernel.h> 19 #include <linux/module.h> 20 #include <linux/init.h> 21 #include <linux/err.h> 22 #include <linux/platform_device.h> 23 #include <linux/regulator/driver.h> 24 #include <linux/regulator/machine.h> 25 #include <linux/regulator/tps6507x.h> 26 #include <linux/of.h> 27 #include <linux/slab.h> 28 #include <linux/mfd/tps6507x.h> 29 #include <linux/regulator/of_regulator.h> 30 31 /* DCDC's */ 32 #define TPS6507X_DCDC_1 0 33 #define TPS6507X_DCDC_2 1 34 #define TPS6507X_DCDC_3 2 35 /* LDOs */ 36 #define TPS6507X_LDO_1 3 37 #define TPS6507X_LDO_2 4 38 39 #define TPS6507X_MAX_REG_ID TPS6507X_LDO_2 40 41 /* Number of step-down converters available */ 42 #define TPS6507X_NUM_DCDC 3 43 /* Number of LDO voltage regulators available */ 44 #define TPS6507X_NUM_LDO 2 45 /* Number of total regulators available */ 46 #define TPS6507X_NUM_REGULATOR (TPS6507X_NUM_DCDC + TPS6507X_NUM_LDO) 47 48 /* Supported voltage values for regulators (in microVolts) */ 49 static const unsigned int VDCDCx_VSEL_table[] = { 50 725000, 750000, 775000, 800000, 51 825000, 850000, 875000, 900000, 52 925000, 950000, 975000, 1000000, 53 1025000, 1050000, 1075000, 1100000, 54 1125000, 1150000, 1175000, 1200000, 55 1225000, 1250000, 1275000, 1300000, 56 1325000, 1350000, 1375000, 1400000, 57 1425000, 1450000, 1475000, 1500000, 58 1550000, 1600000, 1650000, 1700000, 59 1750000, 1800000, 1850000, 1900000, 60 1950000, 2000000, 2050000, 2100000, 61 2150000, 2200000, 2250000, 2300000, 62 2350000, 2400000, 2450000, 2500000, 63 2550000, 2600000, 2650000, 2700000, 64 2750000, 2800000, 2850000, 2900000, 65 3000000, 3100000, 3200000, 3300000, 66 }; 67 68 static const unsigned int LDO1_VSEL_table[] = { 69 1000000, 1100000, 1200000, 1250000, 70 1300000, 1350000, 1400000, 1500000, 71 1600000, 1800000, 2500000, 2750000, 72 2800000, 3000000, 3100000, 3300000, 73 }; 74 75 /* The voltage mapping table for LDO2 is the same as VDCDCx */ 76 #define LDO2_VSEL_table VDCDCx_VSEL_table 77 78 struct tps_info { 79 const char *name; 80 u8 table_len; 81 const unsigned int *table; 82 83 /* Does DCDC high or the low register defines output voltage? */ 84 bool defdcdc_default; 85 }; 86 87 static struct tps_info tps6507x_pmic_regs[] = { 88 { 89 .name = "VDCDC1", 90 .table_len = ARRAY_SIZE(VDCDCx_VSEL_table), 91 .table = VDCDCx_VSEL_table, 92 }, 93 { 94 .name = "VDCDC2", 95 .table_len = ARRAY_SIZE(VDCDCx_VSEL_table), 96 .table = VDCDCx_VSEL_table, 97 }, 98 { 99 .name = "VDCDC3", 100 .table_len = ARRAY_SIZE(VDCDCx_VSEL_table), 101 .table = VDCDCx_VSEL_table, 102 }, 103 { 104 .name = "LDO1", 105 .table_len = ARRAY_SIZE(LDO1_VSEL_table), 106 .table = LDO1_VSEL_table, 107 }, 108 { 109 .name = "LDO2", 110 .table_len = ARRAY_SIZE(LDO2_VSEL_table), 111 .table = LDO2_VSEL_table, 112 }, 113 }; 114 115 struct tps6507x_pmic { 116 struct regulator_desc desc[TPS6507X_NUM_REGULATOR]; 117 struct tps6507x_dev *mfd; 118 struct tps_info *info[TPS6507X_NUM_REGULATOR]; 119 struct mutex io_lock; 120 }; 121 static inline int tps6507x_pmic_read(struct tps6507x_pmic *tps, u8 reg) 122 { 123 u8 val; 124 int err; 125 126 err = tps->mfd->read_dev(tps->mfd, reg, 1, &val); 127 128 if (err) 129 return err; 130 131 return val; 132 } 133 134 static inline int tps6507x_pmic_write(struct tps6507x_pmic *tps, u8 reg, u8 val) 135 { 136 return tps->mfd->write_dev(tps->mfd, reg, 1, &val); 137 } 138 139 static int tps6507x_pmic_set_bits(struct tps6507x_pmic *tps, u8 reg, u8 mask) 140 { 141 int err, data; 142 143 mutex_lock(&tps->io_lock); 144 145 data = tps6507x_pmic_read(tps, reg); 146 if (data < 0) { 147 dev_err(tps->mfd->dev, "Read from reg 0x%x failed\n", reg); 148 err = data; 149 goto out; 150 } 151 152 data |= mask; 153 err = tps6507x_pmic_write(tps, reg, data); 154 if (err) 155 dev_err(tps->mfd->dev, "Write for reg 0x%x failed\n", reg); 156 157 out: 158 mutex_unlock(&tps->io_lock); 159 return err; 160 } 161 162 static int tps6507x_pmic_clear_bits(struct tps6507x_pmic *tps, u8 reg, u8 mask) 163 { 164 int err, data; 165 166 mutex_lock(&tps->io_lock); 167 168 data = tps6507x_pmic_read(tps, reg); 169 if (data < 0) { 170 dev_err(tps->mfd->dev, "Read from reg 0x%x failed\n", reg); 171 err = data; 172 goto out; 173 } 174 175 data &= ~mask; 176 err = tps6507x_pmic_write(tps, reg, data); 177 if (err) 178 dev_err(tps->mfd->dev, "Write for reg 0x%x failed\n", reg); 179 180 out: 181 mutex_unlock(&tps->io_lock); 182 return err; 183 } 184 185 static int tps6507x_pmic_reg_read(struct tps6507x_pmic *tps, u8 reg) 186 { 187 int data; 188 189 mutex_lock(&tps->io_lock); 190 191 data = tps6507x_pmic_read(tps, reg); 192 if (data < 0) 193 dev_err(tps->mfd->dev, "Read from reg 0x%x failed\n", reg); 194 195 mutex_unlock(&tps->io_lock); 196 return data; 197 } 198 199 static int tps6507x_pmic_reg_write(struct tps6507x_pmic *tps, u8 reg, u8 val) 200 { 201 int err; 202 203 mutex_lock(&tps->io_lock); 204 205 err = tps6507x_pmic_write(tps, reg, val); 206 if (err < 0) 207 dev_err(tps->mfd->dev, "Write for reg 0x%x failed\n", reg); 208 209 mutex_unlock(&tps->io_lock); 210 return err; 211 } 212 213 static int tps6507x_pmic_is_enabled(struct regulator_dev *dev) 214 { 215 struct tps6507x_pmic *tps = rdev_get_drvdata(dev); 216 int data, rid = rdev_get_id(dev); 217 u8 shift; 218 219 if (rid < TPS6507X_DCDC_1 || rid > TPS6507X_LDO_2) 220 return -EINVAL; 221 222 shift = TPS6507X_MAX_REG_ID - rid; 223 data = tps6507x_pmic_reg_read(tps, TPS6507X_REG_CON_CTRL1); 224 225 if (data < 0) 226 return data; 227 else 228 return (data & 1<<shift) ? 1 : 0; 229 } 230 231 static int tps6507x_pmic_enable(struct regulator_dev *dev) 232 { 233 struct tps6507x_pmic *tps = rdev_get_drvdata(dev); 234 int rid = rdev_get_id(dev); 235 u8 shift; 236 237 if (rid < TPS6507X_DCDC_1 || rid > TPS6507X_LDO_2) 238 return -EINVAL; 239 240 shift = TPS6507X_MAX_REG_ID - rid; 241 return tps6507x_pmic_set_bits(tps, TPS6507X_REG_CON_CTRL1, 1 << shift); 242 } 243 244 static int tps6507x_pmic_disable(struct regulator_dev *dev) 245 { 246 struct tps6507x_pmic *tps = rdev_get_drvdata(dev); 247 int rid = rdev_get_id(dev); 248 u8 shift; 249 250 if (rid < TPS6507X_DCDC_1 || rid > TPS6507X_LDO_2) 251 return -EINVAL; 252 253 shift = TPS6507X_MAX_REG_ID - rid; 254 return tps6507x_pmic_clear_bits(tps, TPS6507X_REG_CON_CTRL1, 255 1 << shift); 256 } 257 258 static int tps6507x_pmic_get_voltage_sel(struct regulator_dev *dev) 259 { 260 struct tps6507x_pmic *tps = rdev_get_drvdata(dev); 261 int data, rid = rdev_get_id(dev); 262 u8 reg, mask; 263 264 switch (rid) { 265 case TPS6507X_DCDC_1: 266 reg = TPS6507X_REG_DEFDCDC1; 267 mask = TPS6507X_DEFDCDCX_DCDC_MASK; 268 break; 269 case TPS6507X_DCDC_2: 270 if (tps->info[rid]->defdcdc_default) 271 reg = TPS6507X_REG_DEFDCDC2_HIGH; 272 else 273 reg = TPS6507X_REG_DEFDCDC2_LOW; 274 mask = TPS6507X_DEFDCDCX_DCDC_MASK; 275 break; 276 case TPS6507X_DCDC_3: 277 if (tps->info[rid]->defdcdc_default) 278 reg = TPS6507X_REG_DEFDCDC3_HIGH; 279 else 280 reg = TPS6507X_REG_DEFDCDC3_LOW; 281 mask = TPS6507X_DEFDCDCX_DCDC_MASK; 282 break; 283 case TPS6507X_LDO_1: 284 reg = TPS6507X_REG_LDO_CTRL1; 285 mask = TPS6507X_REG_LDO_CTRL1_LDO1_MASK; 286 break; 287 case TPS6507X_LDO_2: 288 reg = TPS6507X_REG_DEFLDO2; 289 mask = TPS6507X_REG_DEFLDO2_LDO2_MASK; 290 break; 291 default: 292 return -EINVAL; 293 } 294 295 data = tps6507x_pmic_reg_read(tps, reg); 296 if (data < 0) 297 return data; 298 299 data &= mask; 300 return data; 301 } 302 303 static int tps6507x_pmic_set_voltage_sel(struct regulator_dev *dev, 304 unsigned selector) 305 { 306 struct tps6507x_pmic *tps = rdev_get_drvdata(dev); 307 int data, rid = rdev_get_id(dev); 308 u8 reg, mask; 309 310 switch (rid) { 311 case TPS6507X_DCDC_1: 312 reg = TPS6507X_REG_DEFDCDC1; 313 mask = TPS6507X_DEFDCDCX_DCDC_MASK; 314 break; 315 case TPS6507X_DCDC_2: 316 if (tps->info[rid]->defdcdc_default) 317 reg = TPS6507X_REG_DEFDCDC2_HIGH; 318 else 319 reg = TPS6507X_REG_DEFDCDC2_LOW; 320 mask = TPS6507X_DEFDCDCX_DCDC_MASK; 321 break; 322 case TPS6507X_DCDC_3: 323 if (tps->info[rid]->defdcdc_default) 324 reg = TPS6507X_REG_DEFDCDC3_HIGH; 325 else 326 reg = TPS6507X_REG_DEFDCDC3_LOW; 327 mask = TPS6507X_DEFDCDCX_DCDC_MASK; 328 break; 329 case TPS6507X_LDO_1: 330 reg = TPS6507X_REG_LDO_CTRL1; 331 mask = TPS6507X_REG_LDO_CTRL1_LDO1_MASK; 332 break; 333 case TPS6507X_LDO_2: 334 reg = TPS6507X_REG_DEFLDO2; 335 mask = TPS6507X_REG_DEFLDO2_LDO2_MASK; 336 break; 337 default: 338 return -EINVAL; 339 } 340 341 data = tps6507x_pmic_reg_read(tps, reg); 342 if (data < 0) 343 return data; 344 345 data &= ~mask; 346 data |= selector; 347 348 return tps6507x_pmic_reg_write(tps, reg, data); 349 } 350 351 static const struct regulator_ops tps6507x_pmic_ops = { 352 .is_enabled = tps6507x_pmic_is_enabled, 353 .enable = tps6507x_pmic_enable, 354 .disable = tps6507x_pmic_disable, 355 .get_voltage_sel = tps6507x_pmic_get_voltage_sel, 356 .set_voltage_sel = tps6507x_pmic_set_voltage_sel, 357 .list_voltage = regulator_list_voltage_table, 358 .map_voltage = regulator_map_voltage_ascend, 359 }; 360 361 static int tps6507x_pmic_of_parse_cb(struct device_node *np, 362 const struct regulator_desc *desc, 363 struct regulator_config *config) 364 { 365 struct tps6507x_pmic *tps = config->driver_data; 366 struct tps_info *info = tps->info[desc->id]; 367 u32 prop; 368 int ret; 369 370 ret = of_property_read_u32(np, "ti,defdcdc_default", &prop); 371 if (!ret) 372 info->defdcdc_default = prop; 373 374 return 0; 375 } 376 377 static int tps6507x_pmic_probe(struct platform_device *pdev) 378 { 379 struct tps6507x_dev *tps6507x_dev = dev_get_drvdata(pdev->dev.parent); 380 struct tps_info *info = &tps6507x_pmic_regs[0]; 381 struct regulator_config config = { }; 382 struct regulator_init_data *init_data = NULL; 383 struct regulator_dev *rdev; 384 struct tps6507x_pmic *tps; 385 struct tps6507x_board *tps_board; 386 int i; 387 388 /** 389 * tps_board points to pmic related constants 390 * coming from the board-evm file. 391 */ 392 393 tps_board = dev_get_platdata(tps6507x_dev->dev); 394 if (tps_board) 395 init_data = tps_board->tps6507x_pmic_init_data; 396 397 tps = devm_kzalloc(&pdev->dev, sizeof(*tps), GFP_KERNEL); 398 if (!tps) 399 return -ENOMEM; 400 401 mutex_init(&tps->io_lock); 402 403 /* common for all regulators */ 404 tps->mfd = tps6507x_dev; 405 406 for (i = 0; i < TPS6507X_NUM_REGULATOR; i++, info++) { 407 /* Register the regulators */ 408 tps->info[i] = info; 409 if (init_data && init_data[i].driver_data) { 410 struct tps6507x_reg_platform_data *data = 411 init_data[i].driver_data; 412 info->defdcdc_default = data->defdcdc_default; 413 } 414 415 tps->desc[i].name = info->name; 416 tps->desc[i].of_match = of_match_ptr(info->name); 417 tps->desc[i].regulators_node = of_match_ptr("regulators"); 418 tps->desc[i].of_parse_cb = tps6507x_pmic_of_parse_cb; 419 tps->desc[i].id = i; 420 tps->desc[i].n_voltages = info->table_len; 421 tps->desc[i].volt_table = info->table; 422 tps->desc[i].ops = &tps6507x_pmic_ops; 423 tps->desc[i].type = REGULATOR_VOLTAGE; 424 tps->desc[i].owner = THIS_MODULE; 425 426 config.dev = tps6507x_dev->dev; 427 config.init_data = init_data; 428 config.driver_data = tps; 429 430 rdev = devm_regulator_register(&pdev->dev, &tps->desc[i], 431 &config); 432 if (IS_ERR(rdev)) { 433 dev_err(tps6507x_dev->dev, 434 "failed to register %s regulator\n", 435 pdev->name); 436 return PTR_ERR(rdev); 437 } 438 } 439 440 tps6507x_dev->pmic = tps; 441 platform_set_drvdata(pdev, tps6507x_dev); 442 443 return 0; 444 } 445 446 static struct platform_driver tps6507x_pmic_driver = { 447 .driver = { 448 .name = "tps6507x-pmic", 449 }, 450 .probe = tps6507x_pmic_probe, 451 }; 452 453 static int __init tps6507x_pmic_init(void) 454 { 455 return platform_driver_register(&tps6507x_pmic_driver); 456 } 457 subsys_initcall(tps6507x_pmic_init); 458 459 static void __exit tps6507x_pmic_cleanup(void) 460 { 461 platform_driver_unregister(&tps6507x_pmic_driver); 462 } 463 module_exit(tps6507x_pmic_cleanup); 464 465 MODULE_AUTHOR("Texas Instruments"); 466 MODULE_DESCRIPTION("TPS6507x voltage regulator driver"); 467 MODULE_LICENSE("GPL v2"); 468 MODULE_ALIAS("platform:tps6507x-pmic"); 469