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/delay.h> 27 #include <linux/slab.h> 28 #include <linux/mfd/tps6507x.h> 29 30 /* DCDC's */ 31 #define TPS6507X_DCDC_1 0 32 #define TPS6507X_DCDC_2 1 33 #define TPS6507X_DCDC_3 2 34 /* LDOs */ 35 #define TPS6507X_LDO_1 3 36 #define TPS6507X_LDO_2 4 37 38 #define TPS6507X_MAX_REG_ID TPS6507X_LDO_2 39 40 /* Number of step-down converters available */ 41 #define TPS6507X_NUM_DCDC 3 42 /* Number of LDO voltage regulators available */ 43 #define TPS6507X_NUM_LDO 2 44 /* Number of total regulators available */ 45 #define TPS6507X_NUM_REGULATOR (TPS6507X_NUM_DCDC + TPS6507X_NUM_LDO) 46 47 /* Supported voltage values for regulators (in milliVolts) */ 48 static const u16 VDCDCx_VSEL_table[] = { 49 725, 750, 775, 800, 50 825, 850, 875, 900, 51 925, 950, 975, 1000, 52 1025, 1050, 1075, 1100, 53 1125, 1150, 1175, 1200, 54 1225, 1250, 1275, 1300, 55 1325, 1350, 1375, 1400, 56 1425, 1450, 1475, 1500, 57 1550, 1600, 1650, 1700, 58 1750, 1800, 1850, 1900, 59 1950, 2000, 2050, 2100, 60 2150, 2200, 2250, 2300, 61 2350, 2400, 2450, 2500, 62 2550, 2600, 2650, 2700, 63 2750, 2800, 2850, 2900, 64 3000, 3100, 3200, 3300, 65 }; 66 67 static const u16 LDO1_VSEL_table[] = { 68 1000, 1100, 1200, 1250, 69 1300, 1350, 1400, 1500, 70 1600, 1800, 2500, 2750, 71 2800, 3000, 3100, 3300, 72 }; 73 74 static const u16 LDO2_VSEL_table[] = { 75 725, 750, 775, 800, 76 825, 850, 875, 900, 77 925, 950, 975, 1000, 78 1025, 1050, 1075, 1100, 79 1125, 1150, 1175, 1200, 80 1225, 1250, 1275, 1300, 81 1325, 1350, 1375, 1400, 82 1425, 1450, 1475, 1500, 83 1550, 1600, 1650, 1700, 84 1750, 1800, 1850, 1900, 85 1950, 2000, 2050, 2100, 86 2150, 2200, 2250, 2300, 87 2350, 2400, 2450, 2500, 88 2550, 2600, 2650, 2700, 89 2750, 2800, 2850, 2900, 90 3000, 3100, 3200, 3300, 91 }; 92 93 struct tps_info { 94 const char *name; 95 unsigned min_uV; 96 unsigned max_uV; 97 u8 table_len; 98 const u16 *table; 99 100 /* Does DCDC high or the low register defines output voltage? */ 101 bool defdcdc_default; 102 }; 103 104 static struct tps_info tps6507x_pmic_regs[] = { 105 { 106 .name = "VDCDC1", 107 .min_uV = 725000, 108 .max_uV = 3300000, 109 .table_len = ARRAY_SIZE(VDCDCx_VSEL_table), 110 .table = VDCDCx_VSEL_table, 111 }, 112 { 113 .name = "VDCDC2", 114 .min_uV = 725000, 115 .max_uV = 3300000, 116 .table_len = ARRAY_SIZE(VDCDCx_VSEL_table), 117 .table = VDCDCx_VSEL_table, 118 }, 119 { 120 .name = "VDCDC3", 121 .min_uV = 725000, 122 .max_uV = 3300000, 123 .table_len = ARRAY_SIZE(VDCDCx_VSEL_table), 124 .table = VDCDCx_VSEL_table, 125 }, 126 { 127 .name = "LDO1", 128 .min_uV = 1000000, 129 .max_uV = 3300000, 130 .table_len = ARRAY_SIZE(LDO1_VSEL_table), 131 .table = LDO1_VSEL_table, 132 }, 133 { 134 .name = "LDO2", 135 .min_uV = 725000, 136 .max_uV = 3300000, 137 .table_len = ARRAY_SIZE(LDO2_VSEL_table), 138 .table = LDO2_VSEL_table, 139 }, 140 }; 141 142 struct tps6507x_pmic { 143 struct regulator_desc desc[TPS6507X_NUM_REGULATOR]; 144 struct tps6507x_dev *mfd; 145 struct regulator_dev *rdev[TPS6507X_NUM_REGULATOR]; 146 struct tps_info *info[TPS6507X_NUM_REGULATOR]; 147 struct mutex io_lock; 148 }; 149 static inline int tps6507x_pmic_read(struct tps6507x_pmic *tps, u8 reg) 150 { 151 u8 val; 152 int err; 153 154 err = tps->mfd->read_dev(tps->mfd, reg, 1, &val); 155 156 if (err) 157 return err; 158 159 return val; 160 } 161 162 static inline int tps6507x_pmic_write(struct tps6507x_pmic *tps, u8 reg, u8 val) 163 { 164 return tps->mfd->write_dev(tps->mfd, reg, 1, &val); 165 } 166 167 static int tps6507x_pmic_set_bits(struct tps6507x_pmic *tps, u8 reg, u8 mask) 168 { 169 int err, data; 170 171 mutex_lock(&tps->io_lock); 172 173 data = tps6507x_pmic_read(tps, reg); 174 if (data < 0) { 175 dev_err(tps->mfd->dev, "Read from reg 0x%x failed\n", reg); 176 err = data; 177 goto out; 178 } 179 180 data |= mask; 181 err = tps6507x_pmic_write(tps, reg, data); 182 if (err) 183 dev_err(tps->mfd->dev, "Write for reg 0x%x failed\n", reg); 184 185 out: 186 mutex_unlock(&tps->io_lock); 187 return err; 188 } 189 190 static int tps6507x_pmic_clear_bits(struct tps6507x_pmic *tps, u8 reg, u8 mask) 191 { 192 int err, data; 193 194 mutex_lock(&tps->io_lock); 195 196 data = tps6507x_pmic_read(tps, reg); 197 if (data < 0) { 198 dev_err(tps->mfd->dev, "Read from reg 0x%x failed\n", reg); 199 err = data; 200 goto out; 201 } 202 203 data &= ~mask; 204 err = tps6507x_pmic_write(tps, reg, data); 205 if (err) 206 dev_err(tps->mfd->dev, "Write for reg 0x%x failed\n", reg); 207 208 out: 209 mutex_unlock(&tps->io_lock); 210 return err; 211 } 212 213 static int tps6507x_pmic_reg_read(struct tps6507x_pmic *tps, u8 reg) 214 { 215 int data; 216 217 mutex_lock(&tps->io_lock); 218 219 data = tps6507x_pmic_read(tps, reg); 220 if (data < 0) 221 dev_err(tps->mfd->dev, "Read from reg 0x%x failed\n", reg); 222 223 mutex_unlock(&tps->io_lock); 224 return data; 225 } 226 227 static int tps6507x_pmic_reg_write(struct tps6507x_pmic *tps, u8 reg, u8 val) 228 { 229 int err; 230 231 mutex_lock(&tps->io_lock); 232 233 err = tps6507x_pmic_write(tps, reg, val); 234 if (err < 0) 235 dev_err(tps->mfd->dev, "Write for reg 0x%x failed\n", reg); 236 237 mutex_unlock(&tps->io_lock); 238 return err; 239 } 240 241 static int tps6507x_pmic_dcdc_is_enabled(struct regulator_dev *dev) 242 { 243 struct tps6507x_pmic *tps = rdev_get_drvdata(dev); 244 int data, dcdc = rdev_get_id(dev); 245 u8 shift; 246 247 if (dcdc < TPS6507X_DCDC_1 || dcdc > TPS6507X_DCDC_3) 248 return -EINVAL; 249 250 shift = TPS6507X_MAX_REG_ID - dcdc; 251 data = tps6507x_pmic_reg_read(tps, TPS6507X_REG_CON_CTRL1); 252 253 if (data < 0) 254 return data; 255 else 256 return (data & 1<<shift) ? 1 : 0; 257 } 258 259 static int tps6507x_pmic_ldo_is_enabled(struct regulator_dev *dev) 260 { 261 struct tps6507x_pmic *tps = rdev_get_drvdata(dev); 262 int data, ldo = rdev_get_id(dev); 263 u8 shift; 264 265 if (ldo < TPS6507X_LDO_1 || ldo > TPS6507X_LDO_2) 266 return -EINVAL; 267 268 shift = TPS6507X_MAX_REG_ID - ldo; 269 data = tps6507x_pmic_reg_read(tps, TPS6507X_REG_CON_CTRL1); 270 271 if (data < 0) 272 return data; 273 else 274 return (data & 1<<shift) ? 1 : 0; 275 } 276 277 static int tps6507x_pmic_dcdc_enable(struct regulator_dev *dev) 278 { 279 struct tps6507x_pmic *tps = rdev_get_drvdata(dev); 280 int dcdc = rdev_get_id(dev); 281 u8 shift; 282 283 if (dcdc < TPS6507X_DCDC_1 || dcdc > TPS6507X_DCDC_3) 284 return -EINVAL; 285 286 shift = TPS6507X_MAX_REG_ID - dcdc; 287 return tps6507x_pmic_set_bits(tps, TPS6507X_REG_CON_CTRL1, 1 << shift); 288 } 289 290 static int tps6507x_pmic_dcdc_disable(struct regulator_dev *dev) 291 { 292 struct tps6507x_pmic *tps = rdev_get_drvdata(dev); 293 int dcdc = rdev_get_id(dev); 294 u8 shift; 295 296 if (dcdc < TPS6507X_DCDC_1 || dcdc > TPS6507X_DCDC_3) 297 return -EINVAL; 298 299 shift = TPS6507X_MAX_REG_ID - dcdc; 300 return tps6507x_pmic_clear_bits(tps, TPS6507X_REG_CON_CTRL1, 301 1 << shift); 302 } 303 304 static int tps6507x_pmic_ldo_enable(struct regulator_dev *dev) 305 { 306 struct tps6507x_pmic *tps = rdev_get_drvdata(dev); 307 int ldo = rdev_get_id(dev); 308 u8 shift; 309 310 if (ldo < TPS6507X_LDO_1 || ldo > TPS6507X_LDO_2) 311 return -EINVAL; 312 313 shift = TPS6507X_MAX_REG_ID - ldo; 314 return tps6507x_pmic_set_bits(tps, TPS6507X_REG_CON_CTRL1, 1 << shift); 315 } 316 317 static int tps6507x_pmic_ldo_disable(struct regulator_dev *dev) 318 { 319 struct tps6507x_pmic *tps = rdev_get_drvdata(dev); 320 int ldo = rdev_get_id(dev); 321 u8 shift; 322 323 if (ldo < TPS6507X_LDO_1 || ldo > TPS6507X_LDO_2) 324 return -EINVAL; 325 326 shift = TPS6507X_MAX_REG_ID - ldo; 327 return tps6507x_pmic_clear_bits(tps, TPS6507X_REG_CON_CTRL1, 328 1 << shift); 329 } 330 331 static int tps6507x_pmic_dcdc_get_voltage(struct regulator_dev *dev) 332 { 333 struct tps6507x_pmic *tps = rdev_get_drvdata(dev); 334 int data, dcdc = rdev_get_id(dev); 335 u8 reg; 336 337 switch (dcdc) { 338 case TPS6507X_DCDC_1: 339 reg = TPS6507X_REG_DEFDCDC1; 340 break; 341 case TPS6507X_DCDC_2: 342 if (tps->info[dcdc]->defdcdc_default) 343 reg = TPS6507X_REG_DEFDCDC2_HIGH; 344 else 345 reg = TPS6507X_REG_DEFDCDC2_LOW; 346 break; 347 case TPS6507X_DCDC_3: 348 if (tps->info[dcdc]->defdcdc_default) 349 reg = TPS6507X_REG_DEFDCDC3_HIGH; 350 else 351 reg = TPS6507X_REG_DEFDCDC3_LOW; 352 break; 353 default: 354 return -EINVAL; 355 } 356 357 data = tps6507x_pmic_reg_read(tps, reg); 358 if (data < 0) 359 return data; 360 361 data &= TPS6507X_DEFDCDCX_DCDC_MASK; 362 return tps->info[dcdc]->table[data] * 1000; 363 } 364 365 static int tps6507x_pmic_dcdc_set_voltage(struct regulator_dev *dev, 366 int min_uV, int max_uV, 367 unsigned *selector) 368 { 369 struct tps6507x_pmic *tps = rdev_get_drvdata(dev); 370 int data, vsel, dcdc = rdev_get_id(dev); 371 u8 reg; 372 373 switch (dcdc) { 374 case TPS6507X_DCDC_1: 375 reg = TPS6507X_REG_DEFDCDC1; 376 break; 377 case TPS6507X_DCDC_2: 378 if (tps->info[dcdc]->defdcdc_default) 379 reg = TPS6507X_REG_DEFDCDC2_HIGH; 380 else 381 reg = TPS6507X_REG_DEFDCDC2_LOW; 382 break; 383 case TPS6507X_DCDC_3: 384 if (tps->info[dcdc]->defdcdc_default) 385 reg = TPS6507X_REG_DEFDCDC3_HIGH; 386 else 387 reg = TPS6507X_REG_DEFDCDC3_LOW; 388 break; 389 default: 390 return -EINVAL; 391 } 392 393 if (min_uV < tps->info[dcdc]->min_uV 394 || min_uV > tps->info[dcdc]->max_uV) 395 return -EINVAL; 396 if (max_uV < tps->info[dcdc]->min_uV 397 || max_uV > tps->info[dcdc]->max_uV) 398 return -EINVAL; 399 400 for (vsel = 0; vsel < tps->info[dcdc]->table_len; vsel++) { 401 int mV = tps->info[dcdc]->table[vsel]; 402 int uV = mV * 1000; 403 404 /* Break at the first in-range value */ 405 if (min_uV <= uV && uV <= max_uV) 406 break; 407 } 408 409 /* write to the register in case we found a match */ 410 if (vsel == tps->info[dcdc]->table_len) 411 return -EINVAL; 412 413 *selector = vsel; 414 415 data = tps6507x_pmic_reg_read(tps, reg); 416 if (data < 0) 417 return data; 418 419 data &= ~TPS6507X_DEFDCDCX_DCDC_MASK; 420 data |= vsel; 421 422 return tps6507x_pmic_reg_write(tps, reg, data); 423 } 424 425 static int tps6507x_pmic_ldo_get_voltage(struct regulator_dev *dev) 426 { 427 struct tps6507x_pmic *tps = rdev_get_drvdata(dev); 428 int data, ldo = rdev_get_id(dev); 429 u8 reg, mask; 430 431 if (ldo < TPS6507X_LDO_1 || ldo > TPS6507X_LDO_2) 432 return -EINVAL; 433 else { 434 reg = (ldo == TPS6507X_LDO_1 ? 435 TPS6507X_REG_LDO_CTRL1 : TPS6507X_REG_DEFLDO2); 436 mask = (ldo == TPS6507X_LDO_1 ? 437 TPS6507X_REG_LDO_CTRL1_LDO1_MASK : 438 TPS6507X_REG_DEFLDO2_LDO2_MASK); 439 } 440 441 data = tps6507x_pmic_reg_read(tps, reg); 442 if (data < 0) 443 return data; 444 445 data &= mask; 446 return tps->info[ldo]->table[data] * 1000; 447 } 448 449 static int tps6507x_pmic_ldo_set_voltage(struct regulator_dev *dev, 450 int min_uV, int max_uV, 451 unsigned *selector) 452 { 453 struct tps6507x_pmic *tps = rdev_get_drvdata(dev); 454 int data, vsel, ldo = rdev_get_id(dev); 455 u8 reg, mask; 456 457 if (ldo < TPS6507X_LDO_1 || ldo > TPS6507X_LDO_2) 458 return -EINVAL; 459 else { 460 reg = (ldo == TPS6507X_LDO_1 ? 461 TPS6507X_REG_LDO_CTRL1 : TPS6507X_REG_DEFLDO2); 462 mask = (ldo == TPS6507X_LDO_1 ? 463 TPS6507X_REG_LDO_CTRL1_LDO1_MASK : 464 TPS6507X_REG_DEFLDO2_LDO2_MASK); 465 } 466 467 if (min_uV < tps->info[ldo]->min_uV || min_uV > tps->info[ldo]->max_uV) 468 return -EINVAL; 469 if (max_uV < tps->info[ldo]->min_uV || max_uV > tps->info[ldo]->max_uV) 470 return -EINVAL; 471 472 for (vsel = 0; vsel < tps->info[ldo]->table_len; vsel++) { 473 int mV = tps->info[ldo]->table[vsel]; 474 int uV = mV * 1000; 475 476 /* Break at the first in-range value */ 477 if (min_uV <= uV && uV <= max_uV) 478 break; 479 } 480 481 if (vsel == tps->info[ldo]->table_len) 482 return -EINVAL; 483 484 *selector = vsel; 485 486 data = tps6507x_pmic_reg_read(tps, reg); 487 if (data < 0) 488 return data; 489 490 data &= ~mask; 491 data |= vsel; 492 493 return tps6507x_pmic_reg_write(tps, reg, data); 494 } 495 496 static int tps6507x_pmic_dcdc_list_voltage(struct regulator_dev *dev, 497 unsigned selector) 498 { 499 struct tps6507x_pmic *tps = rdev_get_drvdata(dev); 500 int dcdc = rdev_get_id(dev); 501 502 if (dcdc < TPS6507X_DCDC_1 || dcdc > TPS6507X_DCDC_3) 503 return -EINVAL; 504 505 if (selector >= tps->info[dcdc]->table_len) 506 return -EINVAL; 507 else 508 return tps->info[dcdc]->table[selector] * 1000; 509 } 510 511 static int tps6507x_pmic_ldo_list_voltage(struct regulator_dev *dev, 512 unsigned selector) 513 { 514 struct tps6507x_pmic *tps = rdev_get_drvdata(dev); 515 int ldo = rdev_get_id(dev); 516 517 if (ldo < TPS6507X_LDO_1 || ldo > TPS6507X_LDO_2) 518 return -EINVAL; 519 520 if (selector >= tps->info[ldo]->table_len) 521 return -EINVAL; 522 else 523 return tps->info[ldo]->table[selector] * 1000; 524 } 525 526 /* Operations permitted on VDCDCx */ 527 static struct regulator_ops tps6507x_pmic_dcdc_ops = { 528 .is_enabled = tps6507x_pmic_dcdc_is_enabled, 529 .enable = tps6507x_pmic_dcdc_enable, 530 .disable = tps6507x_pmic_dcdc_disable, 531 .get_voltage = tps6507x_pmic_dcdc_get_voltage, 532 .set_voltage = tps6507x_pmic_dcdc_set_voltage, 533 .list_voltage = tps6507x_pmic_dcdc_list_voltage, 534 }; 535 536 /* Operations permitted on LDOx */ 537 static struct regulator_ops tps6507x_pmic_ldo_ops = { 538 .is_enabled = tps6507x_pmic_ldo_is_enabled, 539 .enable = tps6507x_pmic_ldo_enable, 540 .disable = tps6507x_pmic_ldo_disable, 541 .get_voltage = tps6507x_pmic_ldo_get_voltage, 542 .set_voltage = tps6507x_pmic_ldo_set_voltage, 543 .list_voltage = tps6507x_pmic_ldo_list_voltage, 544 }; 545 546 static __devinit 547 int tps6507x_pmic_probe(struct platform_device *pdev) 548 { 549 struct tps6507x_dev *tps6507x_dev = dev_get_drvdata(pdev->dev.parent); 550 struct tps_info *info = &tps6507x_pmic_regs[0]; 551 struct regulator_init_data *init_data; 552 struct regulator_dev *rdev; 553 struct tps6507x_pmic *tps; 554 struct tps6507x_board *tps_board; 555 int i; 556 int error; 557 558 /** 559 * tps_board points to pmic related constants 560 * coming from the board-evm file. 561 */ 562 563 tps_board = dev_get_platdata(tps6507x_dev->dev); 564 if (!tps_board) 565 return -EINVAL; 566 567 /** 568 * init_data points to array of regulator_init structures 569 * coming from the board-evm file. 570 */ 571 init_data = tps_board->tps6507x_pmic_init_data; 572 if (!init_data) 573 return -EINVAL; 574 575 tps = kzalloc(sizeof(*tps), GFP_KERNEL); 576 if (!tps) 577 return -ENOMEM; 578 579 mutex_init(&tps->io_lock); 580 581 /* common for all regulators */ 582 tps->mfd = tps6507x_dev; 583 584 for (i = 0; i < TPS6507X_NUM_REGULATOR; i++, info++, init_data++) { 585 /* Register the regulators */ 586 tps->info[i] = info; 587 if (init_data->driver_data) { 588 struct tps6507x_reg_platform_data *data = 589 init_data->driver_data; 590 tps->info[i]->defdcdc_default = data->defdcdc_default; 591 } 592 593 tps->desc[i].name = info->name; 594 tps->desc[i].id = i; 595 tps->desc[i].n_voltages = info->table_len; 596 tps->desc[i].ops = (i > TPS6507X_DCDC_3 ? 597 &tps6507x_pmic_ldo_ops : &tps6507x_pmic_dcdc_ops); 598 tps->desc[i].type = REGULATOR_VOLTAGE; 599 tps->desc[i].owner = THIS_MODULE; 600 601 rdev = regulator_register(&tps->desc[i], 602 tps6507x_dev->dev, init_data, tps, NULL); 603 if (IS_ERR(rdev)) { 604 dev_err(tps6507x_dev->dev, 605 "failed to register %s regulator\n", 606 pdev->name); 607 error = PTR_ERR(rdev); 608 goto fail; 609 } 610 611 /* Save regulator for cleanup */ 612 tps->rdev[i] = rdev; 613 } 614 615 tps6507x_dev->pmic = tps; 616 platform_set_drvdata(pdev, tps6507x_dev); 617 618 return 0; 619 620 fail: 621 while (--i >= 0) 622 regulator_unregister(tps->rdev[i]); 623 624 kfree(tps); 625 return error; 626 } 627 628 static int __devexit tps6507x_pmic_remove(struct platform_device *pdev) 629 { 630 struct tps6507x_dev *tps6507x_dev = platform_get_drvdata(pdev); 631 struct tps6507x_pmic *tps = tps6507x_dev->pmic; 632 int i; 633 634 for (i = 0; i < TPS6507X_NUM_REGULATOR; i++) 635 regulator_unregister(tps->rdev[i]); 636 637 kfree(tps); 638 639 return 0; 640 } 641 642 static struct platform_driver tps6507x_pmic_driver = { 643 .driver = { 644 .name = "tps6507x-pmic", 645 .owner = THIS_MODULE, 646 }, 647 .probe = tps6507x_pmic_probe, 648 .remove = __devexit_p(tps6507x_pmic_remove), 649 }; 650 651 /** 652 * tps6507x_pmic_init 653 * 654 * Module init function 655 */ 656 static int __init tps6507x_pmic_init(void) 657 { 658 return platform_driver_register(&tps6507x_pmic_driver); 659 } 660 subsys_initcall(tps6507x_pmic_init); 661 662 /** 663 * tps6507x_pmic_cleanup 664 * 665 * Module exit function 666 */ 667 static void __exit tps6507x_pmic_cleanup(void) 668 { 669 platform_driver_unregister(&tps6507x_pmic_driver); 670 } 671 module_exit(tps6507x_pmic_cleanup); 672 673 MODULE_AUTHOR("Texas Instruments"); 674 MODULE_DESCRIPTION("TPS6507x voltage regulator driver"); 675 MODULE_LICENSE("GPL v2"); 676 MODULE_ALIAS("platform:tps6507x-pmic"); 677