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