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 #ifdef CONFIG_OF 363 static struct of_regulator_match tps6507x_matches[] = { 364 { .name = "VDCDC1"}, 365 { .name = "VDCDC2"}, 366 { .name = "VDCDC3"}, 367 { .name = "LDO1"}, 368 { .name = "LDO2"}, 369 }; 370 371 static struct tps6507x_board *tps6507x_parse_dt_reg_data( 372 struct platform_device *pdev, 373 struct of_regulator_match **tps6507x_reg_matches) 374 { 375 struct tps6507x_board *tps_board; 376 struct device_node *np = pdev->dev.parent->of_node; 377 struct device_node *regulators; 378 struct of_regulator_match *matches; 379 static struct regulator_init_data *reg_data; 380 int idx = 0, count, ret; 381 382 tps_board = devm_kzalloc(&pdev->dev, sizeof(*tps_board), 383 GFP_KERNEL); 384 if (!tps_board) { 385 dev_err(&pdev->dev, "Failure to alloc pdata for regulators.\n"); 386 return NULL; 387 } 388 389 regulators = of_find_node_by_name(np, "regulators"); 390 if (!regulators) { 391 dev_err(&pdev->dev, "regulator node not found\n"); 392 return NULL; 393 } 394 395 count = ARRAY_SIZE(tps6507x_matches); 396 matches = tps6507x_matches; 397 398 ret = of_regulator_match(&pdev->dev, regulators, matches, count); 399 if (ret < 0) { 400 dev_err(&pdev->dev, "Error parsing regulator init data: %d\n", 401 ret); 402 return NULL; 403 } 404 405 *tps6507x_reg_matches = matches; 406 407 reg_data = devm_kzalloc(&pdev->dev, (sizeof(struct regulator_init_data) 408 * TPS6507X_NUM_REGULATOR), GFP_KERNEL); 409 if (!reg_data) { 410 dev_err(&pdev->dev, "Failure to alloc init data for regulators.\n"); 411 return NULL; 412 } 413 414 tps_board->tps6507x_pmic_init_data = reg_data; 415 416 for (idx = 0; idx < count; idx++) { 417 if (!matches[idx].init_data || !matches[idx].of_node) 418 continue; 419 420 memcpy(®_data[idx], matches[idx].init_data, 421 sizeof(struct regulator_init_data)); 422 423 } 424 425 return tps_board; 426 } 427 #else 428 static inline struct tps6507x_board *tps6507x_parse_dt_reg_data( 429 struct platform_device *pdev, 430 struct of_regulator_match **tps6507x_reg_matches) 431 { 432 *tps6507x_reg_matches = NULL; 433 return NULL; 434 } 435 #endif 436 static int tps6507x_pmic_probe(struct platform_device *pdev) 437 { 438 struct tps6507x_dev *tps6507x_dev = dev_get_drvdata(pdev->dev.parent); 439 struct tps_info *info = &tps6507x_pmic_regs[0]; 440 struct regulator_config config = { }; 441 struct regulator_init_data *init_data; 442 struct regulator_dev *rdev; 443 struct tps6507x_pmic *tps; 444 struct tps6507x_board *tps_board; 445 struct of_regulator_match *tps6507x_reg_matches = NULL; 446 int i; 447 int error; 448 unsigned int prop; 449 450 /** 451 * tps_board points to pmic related constants 452 * coming from the board-evm file. 453 */ 454 455 tps_board = dev_get_platdata(tps6507x_dev->dev); 456 if (!tps_board && tps6507x_dev->dev->of_node) 457 tps_board = tps6507x_parse_dt_reg_data(pdev, 458 &tps6507x_reg_matches); 459 if (!tps_board) 460 return -EINVAL; 461 462 /** 463 * init_data points to array of regulator_init structures 464 * coming from the board-evm file. 465 */ 466 init_data = tps_board->tps6507x_pmic_init_data; 467 if (!init_data) 468 return -EINVAL; 469 470 tps = devm_kzalloc(&pdev->dev, sizeof(*tps), GFP_KERNEL); 471 if (!tps) 472 return -ENOMEM; 473 474 mutex_init(&tps->io_lock); 475 476 /* common for all regulators */ 477 tps->mfd = tps6507x_dev; 478 479 for (i = 0; i < TPS6507X_NUM_REGULATOR; i++, info++, init_data++) { 480 /* Register the regulators */ 481 tps->info[i] = info; 482 if (init_data->driver_data) { 483 struct tps6507x_reg_platform_data *data = 484 init_data->driver_data; 485 tps->info[i]->defdcdc_default = data->defdcdc_default; 486 } 487 488 tps->desc[i].name = info->name; 489 tps->desc[i].id = i; 490 tps->desc[i].n_voltages = info->table_len; 491 tps->desc[i].volt_table = info->table; 492 tps->desc[i].ops = &tps6507x_pmic_ops; 493 tps->desc[i].type = REGULATOR_VOLTAGE; 494 tps->desc[i].owner = THIS_MODULE; 495 496 config.dev = tps6507x_dev->dev; 497 config.init_data = init_data; 498 config.driver_data = tps; 499 500 if (tps6507x_reg_matches) { 501 error = of_property_read_u32( 502 tps6507x_reg_matches[i].of_node, 503 "ti,defdcdc_default", &prop); 504 505 if (!error) 506 tps->info[i]->defdcdc_default = prop; 507 508 config.of_node = tps6507x_reg_matches[i].of_node; 509 } 510 511 rdev = regulator_register(&tps->desc[i], &config); 512 if (IS_ERR(rdev)) { 513 dev_err(tps6507x_dev->dev, 514 "failed to register %s regulator\n", 515 pdev->name); 516 error = PTR_ERR(rdev); 517 goto fail; 518 } 519 520 /* Save regulator for cleanup */ 521 tps->rdev[i] = rdev; 522 } 523 524 tps6507x_dev->pmic = tps; 525 platform_set_drvdata(pdev, tps6507x_dev); 526 527 return 0; 528 529 fail: 530 while (--i >= 0) 531 regulator_unregister(tps->rdev[i]); 532 return error; 533 } 534 535 static int tps6507x_pmic_remove(struct platform_device *pdev) 536 { 537 struct tps6507x_dev *tps6507x_dev = platform_get_drvdata(pdev); 538 struct tps6507x_pmic *tps = tps6507x_dev->pmic; 539 int i; 540 541 for (i = 0; i < TPS6507X_NUM_REGULATOR; i++) 542 regulator_unregister(tps->rdev[i]); 543 return 0; 544 } 545 546 static struct platform_driver tps6507x_pmic_driver = { 547 .driver = { 548 .name = "tps6507x-pmic", 549 .owner = THIS_MODULE, 550 }, 551 .probe = tps6507x_pmic_probe, 552 .remove = tps6507x_pmic_remove, 553 }; 554 555 static int __init tps6507x_pmic_init(void) 556 { 557 return platform_driver_register(&tps6507x_pmic_driver); 558 } 559 subsys_initcall(tps6507x_pmic_init); 560 561 static void __exit tps6507x_pmic_cleanup(void) 562 { 563 platform_driver_unregister(&tps6507x_pmic_driver); 564 } 565 module_exit(tps6507x_pmic_cleanup); 566 567 MODULE_AUTHOR("Texas Instruments"); 568 MODULE_DESCRIPTION("TPS6507x voltage regulator driver"); 569 MODULE_LICENSE("GPL v2"); 570 MODULE_ALIAS("platform:tps6507x-pmic"); 571