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 regulator_dev *rdev[TPS6507X_NUM_REGULATOR]; 119 struct tps_info *info[TPS6507X_NUM_REGULATOR]; 120 struct mutex io_lock; 121 }; 122 static inline int tps6507x_pmic_read(struct tps6507x_pmic *tps, u8 reg) 123 { 124 u8 val; 125 int err; 126 127 err = tps->mfd->read_dev(tps->mfd, reg, 1, &val); 128 129 if (err) 130 return err; 131 132 return val; 133 } 134 135 static inline int tps6507x_pmic_write(struct tps6507x_pmic *tps, u8 reg, u8 val) 136 { 137 return tps->mfd->write_dev(tps->mfd, reg, 1, &val); 138 } 139 140 static int tps6507x_pmic_set_bits(struct tps6507x_pmic *tps, u8 reg, u8 mask) 141 { 142 int err, data; 143 144 mutex_lock(&tps->io_lock); 145 146 data = tps6507x_pmic_read(tps, reg); 147 if (data < 0) { 148 dev_err(tps->mfd->dev, "Read from reg 0x%x failed\n", reg); 149 err = data; 150 goto out; 151 } 152 153 data |= mask; 154 err = tps6507x_pmic_write(tps, reg, data); 155 if (err) 156 dev_err(tps->mfd->dev, "Write for reg 0x%x failed\n", reg); 157 158 out: 159 mutex_unlock(&tps->io_lock); 160 return err; 161 } 162 163 static int tps6507x_pmic_clear_bits(struct tps6507x_pmic *tps, u8 reg, u8 mask) 164 { 165 int err, data; 166 167 mutex_lock(&tps->io_lock); 168 169 data = tps6507x_pmic_read(tps, reg); 170 if (data < 0) { 171 dev_err(tps->mfd->dev, "Read from reg 0x%x failed\n", reg); 172 err = data; 173 goto out; 174 } 175 176 data &= ~mask; 177 err = tps6507x_pmic_write(tps, reg, data); 178 if (err) 179 dev_err(tps->mfd->dev, "Write for reg 0x%x failed\n", reg); 180 181 out: 182 mutex_unlock(&tps->io_lock); 183 return err; 184 } 185 186 static int tps6507x_pmic_reg_read(struct tps6507x_pmic *tps, u8 reg) 187 { 188 int data; 189 190 mutex_lock(&tps->io_lock); 191 192 data = tps6507x_pmic_read(tps, reg); 193 if (data < 0) 194 dev_err(tps->mfd->dev, "Read from reg 0x%x failed\n", reg); 195 196 mutex_unlock(&tps->io_lock); 197 return data; 198 } 199 200 static int tps6507x_pmic_reg_write(struct tps6507x_pmic *tps, u8 reg, u8 val) 201 { 202 int err; 203 204 mutex_lock(&tps->io_lock); 205 206 err = tps6507x_pmic_write(tps, reg, val); 207 if (err < 0) 208 dev_err(tps->mfd->dev, "Write for reg 0x%x failed\n", reg); 209 210 mutex_unlock(&tps->io_lock); 211 return err; 212 } 213 214 static int tps6507x_pmic_is_enabled(struct regulator_dev *dev) 215 { 216 struct tps6507x_pmic *tps = rdev_get_drvdata(dev); 217 int data, rid = rdev_get_id(dev); 218 u8 shift; 219 220 if (rid < TPS6507X_DCDC_1 || rid > TPS6507X_LDO_2) 221 return -EINVAL; 222 223 shift = TPS6507X_MAX_REG_ID - rid; 224 data = tps6507x_pmic_reg_read(tps, TPS6507X_REG_CON_CTRL1); 225 226 if (data < 0) 227 return data; 228 else 229 return (data & 1<<shift) ? 1 : 0; 230 } 231 232 static int tps6507x_pmic_enable(struct regulator_dev *dev) 233 { 234 struct tps6507x_pmic *tps = rdev_get_drvdata(dev); 235 int rid = rdev_get_id(dev); 236 u8 shift; 237 238 if (rid < TPS6507X_DCDC_1 || rid > TPS6507X_LDO_2) 239 return -EINVAL; 240 241 shift = TPS6507X_MAX_REG_ID - rid; 242 return tps6507x_pmic_set_bits(tps, TPS6507X_REG_CON_CTRL1, 1 << shift); 243 } 244 245 static int tps6507x_pmic_disable(struct regulator_dev *dev) 246 { 247 struct tps6507x_pmic *tps = rdev_get_drvdata(dev); 248 int rid = rdev_get_id(dev); 249 u8 shift; 250 251 if (rid < TPS6507X_DCDC_1 || rid > TPS6507X_LDO_2) 252 return -EINVAL; 253 254 shift = TPS6507X_MAX_REG_ID - rid; 255 return tps6507x_pmic_clear_bits(tps, TPS6507X_REG_CON_CTRL1, 256 1 << shift); 257 } 258 259 static int tps6507x_pmic_get_voltage_sel(struct regulator_dev *dev) 260 { 261 struct tps6507x_pmic *tps = rdev_get_drvdata(dev); 262 int data, rid = rdev_get_id(dev); 263 u8 reg, mask; 264 265 switch (rid) { 266 case TPS6507X_DCDC_1: 267 reg = TPS6507X_REG_DEFDCDC1; 268 mask = TPS6507X_DEFDCDCX_DCDC_MASK; 269 break; 270 case TPS6507X_DCDC_2: 271 if (tps->info[rid]->defdcdc_default) 272 reg = TPS6507X_REG_DEFDCDC2_HIGH; 273 else 274 reg = TPS6507X_REG_DEFDCDC2_LOW; 275 mask = TPS6507X_DEFDCDCX_DCDC_MASK; 276 break; 277 case TPS6507X_DCDC_3: 278 if (tps->info[rid]->defdcdc_default) 279 reg = TPS6507X_REG_DEFDCDC3_HIGH; 280 else 281 reg = TPS6507X_REG_DEFDCDC3_LOW; 282 mask = TPS6507X_DEFDCDCX_DCDC_MASK; 283 break; 284 case TPS6507X_LDO_1: 285 reg = TPS6507X_REG_LDO_CTRL1; 286 mask = TPS6507X_REG_LDO_CTRL1_LDO1_MASK; 287 break; 288 case TPS6507X_LDO_2: 289 reg = TPS6507X_REG_DEFLDO2; 290 mask = TPS6507X_REG_DEFLDO2_LDO2_MASK; 291 break; 292 default: 293 return -EINVAL; 294 } 295 296 data = tps6507x_pmic_reg_read(tps, reg); 297 if (data < 0) 298 return data; 299 300 data &= mask; 301 return data; 302 } 303 304 static int tps6507x_pmic_set_voltage_sel(struct regulator_dev *dev, 305 unsigned selector) 306 { 307 struct tps6507x_pmic *tps = rdev_get_drvdata(dev); 308 int data, rid = rdev_get_id(dev); 309 u8 reg, mask; 310 311 switch (rid) { 312 case TPS6507X_DCDC_1: 313 reg = TPS6507X_REG_DEFDCDC1; 314 mask = TPS6507X_DEFDCDCX_DCDC_MASK; 315 break; 316 case TPS6507X_DCDC_2: 317 if (tps->info[rid]->defdcdc_default) 318 reg = TPS6507X_REG_DEFDCDC2_HIGH; 319 else 320 reg = TPS6507X_REG_DEFDCDC2_LOW; 321 mask = TPS6507X_DEFDCDCX_DCDC_MASK; 322 break; 323 case TPS6507X_DCDC_3: 324 if (tps->info[rid]->defdcdc_default) 325 reg = TPS6507X_REG_DEFDCDC3_HIGH; 326 else 327 reg = TPS6507X_REG_DEFDCDC3_LOW; 328 mask = TPS6507X_DEFDCDCX_DCDC_MASK; 329 break; 330 case TPS6507X_LDO_1: 331 reg = TPS6507X_REG_LDO_CTRL1; 332 mask = TPS6507X_REG_LDO_CTRL1_LDO1_MASK; 333 break; 334 case TPS6507X_LDO_2: 335 reg = TPS6507X_REG_DEFLDO2; 336 mask = TPS6507X_REG_DEFLDO2_LDO2_MASK; 337 break; 338 default: 339 return -EINVAL; 340 } 341 342 data = tps6507x_pmic_reg_read(tps, reg); 343 if (data < 0) 344 return data; 345 346 data &= ~mask; 347 data |= selector; 348 349 return tps6507x_pmic_reg_write(tps, reg, data); 350 } 351 352 static struct regulator_ops tps6507x_pmic_ops = { 353 .is_enabled = tps6507x_pmic_is_enabled, 354 .enable = tps6507x_pmic_enable, 355 .disable = tps6507x_pmic_disable, 356 .get_voltage_sel = tps6507x_pmic_get_voltage_sel, 357 .set_voltage_sel = tps6507x_pmic_set_voltage_sel, 358 .list_voltage = regulator_list_voltage_table, 359 .map_voltage = regulator_map_voltage_ascend, 360 }; 361 362 static struct of_regulator_match tps6507x_matches[] = { 363 { .name = "VDCDC1"}, 364 { .name = "VDCDC2"}, 365 { .name = "VDCDC3"}, 366 { .name = "LDO1"}, 367 { .name = "LDO2"}, 368 }; 369 370 static struct tps6507x_board *tps6507x_parse_dt_reg_data( 371 struct platform_device *pdev, 372 struct of_regulator_match **tps6507x_reg_matches) 373 { 374 struct tps6507x_board *tps_board; 375 struct device_node *np = pdev->dev.parent->of_node; 376 struct device_node *regulators; 377 struct of_regulator_match *matches; 378 static struct regulator_init_data *reg_data; 379 int idx = 0, count, ret; 380 381 tps_board = devm_kzalloc(&pdev->dev, sizeof(*tps_board), 382 GFP_KERNEL); 383 if (!tps_board) 384 return NULL; 385 386 regulators = of_get_child_by_name(np, "regulators"); 387 if (!regulators) { 388 dev_err(&pdev->dev, "regulator node not found\n"); 389 return NULL; 390 } 391 392 count = ARRAY_SIZE(tps6507x_matches); 393 matches = tps6507x_matches; 394 395 ret = of_regulator_match(&pdev->dev, regulators, matches, count); 396 of_node_put(regulators); 397 if (ret < 0) { 398 dev_err(&pdev->dev, "Error parsing regulator init data: %d\n", 399 ret); 400 return NULL; 401 } 402 403 *tps6507x_reg_matches = matches; 404 405 reg_data = devm_kzalloc(&pdev->dev, (sizeof(struct regulator_init_data) 406 * TPS6507X_NUM_REGULATOR), GFP_KERNEL); 407 if (!reg_data) 408 return NULL; 409 410 tps_board->tps6507x_pmic_init_data = reg_data; 411 412 for (idx = 0; idx < count; idx++) { 413 if (!matches[idx].init_data || !matches[idx].of_node) 414 continue; 415 416 memcpy(®_data[idx], matches[idx].init_data, 417 sizeof(struct regulator_init_data)); 418 419 } 420 421 return tps_board; 422 } 423 424 static int tps6507x_pmic_probe(struct platform_device *pdev) 425 { 426 struct tps6507x_dev *tps6507x_dev = dev_get_drvdata(pdev->dev.parent); 427 struct tps_info *info = &tps6507x_pmic_regs[0]; 428 struct regulator_config config = { }; 429 struct regulator_init_data *init_data; 430 struct regulator_dev *rdev; 431 struct tps6507x_pmic *tps; 432 struct tps6507x_board *tps_board; 433 struct of_regulator_match *tps6507x_reg_matches = NULL; 434 int i; 435 int error; 436 unsigned int prop; 437 438 /** 439 * tps_board points to pmic related constants 440 * coming from the board-evm file. 441 */ 442 443 tps_board = dev_get_platdata(tps6507x_dev->dev); 444 if (IS_ENABLED(CONFIG_OF) && !tps_board && 445 tps6507x_dev->dev->of_node) 446 tps_board = tps6507x_parse_dt_reg_data(pdev, 447 &tps6507x_reg_matches); 448 if (!tps_board) 449 return -EINVAL; 450 451 /** 452 * init_data points to array of regulator_init structures 453 * coming from the board-evm file. 454 */ 455 init_data = tps_board->tps6507x_pmic_init_data; 456 if (!init_data) 457 return -EINVAL; 458 459 tps = devm_kzalloc(&pdev->dev, sizeof(*tps), GFP_KERNEL); 460 if (!tps) 461 return -ENOMEM; 462 463 mutex_init(&tps->io_lock); 464 465 /* common for all regulators */ 466 tps->mfd = tps6507x_dev; 467 468 for (i = 0; i < TPS6507X_NUM_REGULATOR; i++, info++, init_data++) { 469 /* Register the regulators */ 470 tps->info[i] = info; 471 if (init_data->driver_data) { 472 struct tps6507x_reg_platform_data *data = 473 init_data->driver_data; 474 tps->info[i]->defdcdc_default = data->defdcdc_default; 475 } 476 477 tps->desc[i].name = info->name; 478 tps->desc[i].id = i; 479 tps->desc[i].n_voltages = info->table_len; 480 tps->desc[i].volt_table = info->table; 481 tps->desc[i].ops = &tps6507x_pmic_ops; 482 tps->desc[i].type = REGULATOR_VOLTAGE; 483 tps->desc[i].owner = THIS_MODULE; 484 485 config.dev = tps6507x_dev->dev; 486 config.init_data = init_data; 487 config.driver_data = tps; 488 489 if (tps6507x_reg_matches) { 490 error = of_property_read_u32( 491 tps6507x_reg_matches[i].of_node, 492 "ti,defdcdc_default", &prop); 493 494 if (!error) 495 tps->info[i]->defdcdc_default = prop; 496 497 config.of_node = tps6507x_reg_matches[i].of_node; 498 } 499 500 rdev = devm_regulator_register(&pdev->dev, &tps->desc[i], 501 &config); 502 if (IS_ERR(rdev)) { 503 dev_err(tps6507x_dev->dev, 504 "failed to register %s regulator\n", 505 pdev->name); 506 return PTR_ERR(rdev); 507 } 508 509 /* Save regulator for cleanup */ 510 tps->rdev[i] = rdev; 511 } 512 513 tps6507x_dev->pmic = tps; 514 platform_set_drvdata(pdev, tps6507x_dev); 515 516 return 0; 517 } 518 519 static struct platform_driver tps6507x_pmic_driver = { 520 .driver = { 521 .name = "tps6507x-pmic", 522 }, 523 .probe = tps6507x_pmic_probe, 524 }; 525 526 static int __init tps6507x_pmic_init(void) 527 { 528 return platform_driver_register(&tps6507x_pmic_driver); 529 } 530 subsys_initcall(tps6507x_pmic_init); 531 532 static void __exit tps6507x_pmic_cleanup(void) 533 { 534 platform_driver_unregister(&tps6507x_pmic_driver); 535 } 536 module_exit(tps6507x_pmic_cleanup); 537 538 MODULE_AUTHOR("Texas Instruments"); 539 MODULE_DESCRIPTION("TPS6507x voltage regulator driver"); 540 MODULE_LICENSE("GPL v2"); 541 MODULE_ALIAS("platform:tps6507x-pmic"); 542