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) */ 48static 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 67static 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 74static 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 93static unsigned int num_voltages[] = {ARRAY_SIZE(VDCDCx_VSEL_table), 94 ARRAY_SIZE(VDCDCx_VSEL_table), 95 ARRAY_SIZE(VDCDCx_VSEL_table), 96 ARRAY_SIZE(LDO1_VSEL_table), 97 ARRAY_SIZE(LDO2_VSEL_table)}; 98 99struct tps_info { 100 const char *name; 101 unsigned min_uV; 102 unsigned max_uV; 103 u8 table_len; 104 const u16 *table; 105 106 /* Does DCDC high or the low register defines output voltage? */ 107 bool defdcdc_default; 108}; 109 110static struct tps_info tps6507x_pmic_regs[] = { 111 { 112 .name = "VDCDC1", 113 .min_uV = 725000, 114 .max_uV = 3300000, 115 .table_len = ARRAY_SIZE(VDCDCx_VSEL_table), 116 .table = VDCDCx_VSEL_table, 117 }, 118 { 119 .name = "VDCDC2", 120 .min_uV = 725000, 121 .max_uV = 3300000, 122 .table_len = ARRAY_SIZE(VDCDCx_VSEL_table), 123 .table = VDCDCx_VSEL_table, 124 }, 125 { 126 .name = "VDCDC3", 127 .min_uV = 725000, 128 .max_uV = 3300000, 129 .table_len = ARRAY_SIZE(VDCDCx_VSEL_table), 130 .table = VDCDCx_VSEL_table, 131 }, 132 { 133 .name = "LDO1", 134 .min_uV = 1000000, 135 .max_uV = 3300000, 136 .table_len = ARRAY_SIZE(LDO1_VSEL_table), 137 .table = LDO1_VSEL_table, 138 }, 139 { 140 .name = "LDO2", 141 .min_uV = 725000, 142 .max_uV = 3300000, 143 .table_len = ARRAY_SIZE(LDO2_VSEL_table), 144 .table = LDO2_VSEL_table, 145 }, 146}; 147 148struct tps6507x_pmic { 149 struct regulator_desc desc[TPS6507X_NUM_REGULATOR]; 150 struct tps6507x_dev *mfd; 151 struct regulator_dev *rdev[TPS6507X_NUM_REGULATOR]; 152 struct tps_info *info[TPS6507X_NUM_REGULATOR]; 153 struct mutex io_lock; 154}; 155static inline int tps6507x_pmic_read(struct tps6507x_pmic *tps, u8 reg) 156{ 157 u8 val; 158 int err; 159 160 err = tps->mfd->read_dev(tps->mfd, reg, 1, &val); 161 162 if (err) 163 return err; 164 165 return val; 166} 167 168static inline int tps6507x_pmic_write(struct tps6507x_pmic *tps, u8 reg, u8 val) 169{ 170 return tps->mfd->write_dev(tps->mfd, reg, 1, &val); 171} 172 173static int tps6507x_pmic_set_bits(struct tps6507x_pmic *tps, u8 reg, u8 mask) 174{ 175 int err, data; 176 177 mutex_lock(&tps->io_lock); 178 179 data = tps6507x_pmic_read(tps, reg); 180 if (data < 0) { 181 dev_err(tps->mfd->dev, "Read from reg 0x%x failed\n", reg); 182 err = data; 183 goto out; 184 } 185 186 data |= mask; 187 err = tps6507x_pmic_write(tps, reg, data); 188 if (err) 189 dev_err(tps->mfd->dev, "Write for reg 0x%x failed\n", reg); 190 191out: 192 mutex_unlock(&tps->io_lock); 193 return err; 194} 195 196static int tps6507x_pmic_clear_bits(struct tps6507x_pmic *tps, u8 reg, u8 mask) 197{ 198 int err, data; 199 200 mutex_lock(&tps->io_lock); 201 202 data = tps6507x_pmic_read(tps, reg); 203 if (data < 0) { 204 dev_err(tps->mfd->dev, "Read from reg 0x%x failed\n", reg); 205 err = data; 206 goto out; 207 } 208 209 data &= ~mask; 210 err = tps6507x_pmic_write(tps, reg, data); 211 if (err) 212 dev_err(tps->mfd->dev, "Write for reg 0x%x failed\n", reg); 213 214out: 215 mutex_unlock(&tps->io_lock); 216 return err; 217} 218 219static int tps6507x_pmic_reg_read(struct tps6507x_pmic *tps, u8 reg) 220{ 221 int data; 222 223 mutex_lock(&tps->io_lock); 224 225 data = tps6507x_pmic_read(tps, reg); 226 if (data < 0) 227 dev_err(tps->mfd->dev, "Read from reg 0x%x failed\n", reg); 228 229 mutex_unlock(&tps->io_lock); 230 return data; 231} 232 233static int tps6507x_pmic_reg_write(struct tps6507x_pmic *tps, u8 reg, u8 val) 234{ 235 int err; 236 237 mutex_lock(&tps->io_lock); 238 239 err = tps6507x_pmic_write(tps, reg, val); 240 if (err < 0) 241 dev_err(tps->mfd->dev, "Write for reg 0x%x failed\n", reg); 242 243 mutex_unlock(&tps->io_lock); 244 return err; 245} 246 247static int tps6507x_pmic_dcdc_is_enabled(struct regulator_dev *dev) 248{ 249 struct tps6507x_pmic *tps = rdev_get_drvdata(dev); 250 int data, dcdc = rdev_get_id(dev); 251 u8 shift; 252 253 if (dcdc < TPS6507X_DCDC_1 || dcdc > TPS6507X_DCDC_3) 254 return -EINVAL; 255 256 shift = TPS6507X_MAX_REG_ID - dcdc; 257 data = tps6507x_pmic_reg_read(tps, TPS6507X_REG_CON_CTRL1); 258 259 if (data < 0) 260 return data; 261 else 262 return (data & 1<<shift) ? 1 : 0; 263} 264 265static int tps6507x_pmic_ldo_is_enabled(struct regulator_dev *dev) 266{ 267 struct tps6507x_pmic *tps = rdev_get_drvdata(dev); 268 int data, ldo = rdev_get_id(dev); 269 u8 shift; 270 271 if (ldo < TPS6507X_LDO_1 || ldo > TPS6507X_LDO_2) 272 return -EINVAL; 273 274 shift = TPS6507X_MAX_REG_ID - ldo; 275 data = tps6507x_pmic_reg_read(tps, TPS6507X_REG_CON_CTRL1); 276 277 if (data < 0) 278 return data; 279 else 280 return (data & 1<<shift) ? 1 : 0; 281} 282 283static int tps6507x_pmic_dcdc_enable(struct regulator_dev *dev) 284{ 285 struct tps6507x_pmic *tps = rdev_get_drvdata(dev); 286 int dcdc = rdev_get_id(dev); 287 u8 shift; 288 289 if (dcdc < TPS6507X_DCDC_1 || dcdc > TPS6507X_DCDC_3) 290 return -EINVAL; 291 292 shift = TPS6507X_MAX_REG_ID - dcdc; 293 return tps6507x_pmic_set_bits(tps, TPS6507X_REG_CON_CTRL1, 1 << shift); 294} 295 296static int tps6507x_pmic_dcdc_disable(struct regulator_dev *dev) 297{ 298 struct tps6507x_pmic *tps = rdev_get_drvdata(dev); 299 int dcdc = rdev_get_id(dev); 300 u8 shift; 301 302 if (dcdc < TPS6507X_DCDC_1 || dcdc > TPS6507X_DCDC_3) 303 return -EINVAL; 304 305 shift = TPS6507X_MAX_REG_ID - dcdc; 306 return tps6507x_pmic_clear_bits(tps, TPS6507X_REG_CON_CTRL1, 307 1 << shift); 308} 309 310static int tps6507x_pmic_ldo_enable(struct regulator_dev *dev) 311{ 312 struct tps6507x_pmic *tps = rdev_get_drvdata(dev); 313 int ldo = rdev_get_id(dev); 314 u8 shift; 315 316 if (ldo < TPS6507X_LDO_1 || ldo > TPS6507X_LDO_2) 317 return -EINVAL; 318 319 shift = TPS6507X_MAX_REG_ID - ldo; 320 return tps6507x_pmic_set_bits(tps, TPS6507X_REG_CON_CTRL1, 1 << shift); 321} 322 323static int tps6507x_pmic_ldo_disable(struct regulator_dev *dev) 324{ 325 struct tps6507x_pmic *tps = rdev_get_drvdata(dev); 326 int ldo = rdev_get_id(dev); 327 u8 shift; 328 329 if (ldo < TPS6507X_LDO_1 || ldo > TPS6507X_LDO_2) 330 return -EINVAL; 331 332 shift = TPS6507X_MAX_REG_ID - ldo; 333 return tps6507x_pmic_clear_bits(tps, TPS6507X_REG_CON_CTRL1, 334 1 << shift); 335} 336 337static int tps6507x_pmic_dcdc_get_voltage(struct regulator_dev *dev) 338{ 339 struct tps6507x_pmic *tps = rdev_get_drvdata(dev); 340 int data, dcdc = rdev_get_id(dev); 341 u8 reg; 342 343 switch (dcdc) { 344 case TPS6507X_DCDC_1: 345 reg = TPS6507X_REG_DEFDCDC1; 346 break; 347 case TPS6507X_DCDC_2: 348 if (tps->info[dcdc]->defdcdc_default) 349 reg = TPS6507X_REG_DEFDCDC2_HIGH; 350 else 351 reg = TPS6507X_REG_DEFDCDC2_LOW; 352 break; 353 case TPS6507X_DCDC_3: 354 if (tps->info[dcdc]->defdcdc_default) 355 reg = TPS6507X_REG_DEFDCDC3_HIGH; 356 else 357 reg = TPS6507X_REG_DEFDCDC3_LOW; 358 break; 359 default: 360 return -EINVAL; 361 } 362 363 data = tps6507x_pmic_reg_read(tps, reg); 364 if (data < 0) 365 return data; 366 367 data &= TPS6507X_DEFDCDCX_DCDC_MASK; 368 return tps->info[dcdc]->table[data] * 1000; 369} 370 371static int tps6507x_pmic_dcdc_set_voltage(struct regulator_dev *dev, 372 int min_uV, int max_uV) 373{ 374 struct tps6507x_pmic *tps = rdev_get_drvdata(dev); 375 int data, vsel, dcdc = rdev_get_id(dev); 376 u8 reg; 377 378 switch (dcdc) { 379 case TPS6507X_DCDC_1: 380 reg = TPS6507X_REG_DEFDCDC1; 381 break; 382 case TPS6507X_DCDC_2: 383 if (tps->info[dcdc]->defdcdc_default) 384 reg = TPS6507X_REG_DEFDCDC2_HIGH; 385 else 386 reg = TPS6507X_REG_DEFDCDC2_LOW; 387 break; 388 case TPS6507X_DCDC_3: 389 if (tps->info[dcdc]->defdcdc_default) 390 reg = TPS6507X_REG_DEFDCDC3_HIGH; 391 else 392 reg = TPS6507X_REG_DEFDCDC3_LOW; 393 break; 394 default: 395 return -EINVAL; 396 } 397 398 if (min_uV < tps->info[dcdc]->min_uV 399 || min_uV > tps->info[dcdc]->max_uV) 400 return -EINVAL; 401 if (max_uV < tps->info[dcdc]->min_uV 402 || max_uV > tps->info[dcdc]->max_uV) 403 return -EINVAL; 404 405 for (vsel = 0; vsel < tps->info[dcdc]->table_len; vsel++) { 406 int mV = tps->info[dcdc]->table[vsel]; 407 int uV = mV * 1000; 408 409 /* Break at the first in-range value */ 410 if (min_uV <= uV && uV <= max_uV) 411 break; 412 } 413 414 /* write to the register in case we found a match */ 415 if (vsel == tps->info[dcdc]->table_len) 416 return -EINVAL; 417 418 data = tps6507x_pmic_reg_read(tps, reg); 419 if (data < 0) 420 return data; 421 422 data &= ~TPS6507X_DEFDCDCX_DCDC_MASK; 423 data |= vsel; 424 425 return tps6507x_pmic_reg_write(tps, reg, data); 426} 427 428static int tps6507x_pmic_ldo_get_voltage(struct regulator_dev *dev) 429{ 430 struct tps6507x_pmic *tps = rdev_get_drvdata(dev); 431 int data, ldo = rdev_get_id(dev); 432 u8 reg, mask; 433 434 if (ldo < TPS6507X_LDO_1 || ldo > TPS6507X_LDO_2) 435 return -EINVAL; 436 else { 437 reg = (ldo == TPS6507X_LDO_1 ? 438 TPS6507X_REG_LDO_CTRL1 : TPS6507X_REG_DEFLDO2); 439 mask = (ldo == TPS6507X_LDO_1 ? 440 TPS6507X_REG_LDO_CTRL1_LDO1_MASK : 441 TPS6507X_REG_DEFLDO2_LDO2_MASK); 442 } 443 444 data = tps6507x_pmic_reg_read(tps, reg); 445 if (data < 0) 446 return data; 447 448 data &= mask; 449 return tps->info[ldo]->table[data] * 1000; 450} 451 452static int tps6507x_pmic_ldo_set_voltage(struct regulator_dev *dev, 453 int min_uV, int max_uV) 454{ 455 struct tps6507x_pmic *tps = rdev_get_drvdata(dev); 456 int data, vsel, ldo = rdev_get_id(dev); 457 u8 reg, mask; 458 459 if (ldo < TPS6507X_LDO_1 || ldo > TPS6507X_LDO_2) 460 return -EINVAL; 461 else { 462 reg = (ldo == TPS6507X_LDO_1 ? 463 TPS6507X_REG_LDO_CTRL1 : TPS6507X_REG_DEFLDO2); 464 mask = (ldo == TPS6507X_LDO_1 ? 465 TPS6507X_REG_LDO_CTRL1_LDO1_MASK : 466 TPS6507X_REG_DEFLDO2_LDO2_MASK); 467 } 468 469 if (min_uV < tps->info[ldo]->min_uV || min_uV > tps->info[ldo]->max_uV) 470 return -EINVAL; 471 if (max_uV < tps->info[ldo]->min_uV || max_uV > tps->info[ldo]->max_uV) 472 return -EINVAL; 473 474 for (vsel = 0; vsel < tps->info[ldo]->table_len; vsel++) { 475 int mV = tps->info[ldo]->table[vsel]; 476 int uV = mV * 1000; 477 478 /* Break at the first in-range value */ 479 if (min_uV <= uV && uV <= max_uV) 480 break; 481 } 482 483 if (vsel == tps->info[ldo]->table_len) 484 return -EINVAL; 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 496static 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 511static 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 */ 527static 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 */ 537static 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 546static __devinit 547int tps6507x_pmic_probe(struct platform_device *pdev) 548{ 549 struct tps6507x_dev *tps6507x_dev = dev_get_drvdata(pdev->dev.parent); 550 static int desc_id; 551 struct tps_info *info = &tps6507x_pmic_regs[0]; 552 struct regulator_init_data *init_data; 553 struct regulator_dev *rdev; 554 struct tps6507x_pmic *tps; 555 struct tps6507x_board *tps_board; 556 int i; 557 int error; 558 559 /** 560 * tps_board points to pmic related constants 561 * coming from the board-evm file. 562 */ 563 564 tps_board = dev_get_platdata(tps6507x_dev->dev); 565 if (!tps_board) 566 return -EINVAL; 567 568 /** 569 * init_data points to array of regulator_init structures 570 * coming from the board-evm file. 571 */ 572 init_data = tps_board->tps6507x_pmic_init_data; 573 if (!init_data) 574 return -EINVAL; 575 576 tps = kzalloc(sizeof(*tps), GFP_KERNEL); 577 if (!tps) 578 return -ENOMEM; 579 580 mutex_init(&tps->io_lock); 581 582 /* common for all regulators */ 583 tps->mfd = tps6507x_dev; 584 585 for (i = 0; i < TPS6507X_NUM_REGULATOR; i++, info++, init_data++) { 586 /* Register the regulators */ 587 tps->info[i] = info; 588 if (init_data->driver_data) { 589 struct tps6507x_reg_platform_data *data = 590 init_data->driver_data; 591 tps->info[i]->defdcdc_default = data->defdcdc_default; 592 } 593 594 tps->desc[i].name = info->name; 595 tps->desc[i].id = desc_id++; 596 tps->desc[i].n_voltages = num_voltages[i]; 597 tps->desc[i].ops = (i > TPS6507X_DCDC_3 ? 598 &tps6507x_pmic_ldo_ops : &tps6507x_pmic_dcdc_ops); 599 tps->desc[i].type = REGULATOR_VOLTAGE; 600 tps->desc[i].owner = THIS_MODULE; 601 602 rdev = regulator_register(&tps->desc[i], 603 tps6507x_dev->dev, init_data, tps); 604 if (IS_ERR(rdev)) { 605 dev_err(tps6507x_dev->dev, 606 "failed to register %s regulator\n", 607 pdev->name); 608 error = PTR_ERR(rdev); 609 goto fail; 610 } 611 612 /* Save regulator for cleanup */ 613 tps->rdev[i] = rdev; 614 } 615 616 tps6507x_dev->pmic = tps; 617 platform_set_drvdata(pdev, tps6507x_dev); 618 619 return 0; 620 621fail: 622 while (--i >= 0) 623 regulator_unregister(tps->rdev[i]); 624 625 kfree(tps); 626 return error; 627} 628 629static int __devexit tps6507x_pmic_remove(struct platform_device *pdev) 630{ 631 struct tps6507x_dev *tps6507x_dev = platform_get_drvdata(pdev); 632 struct tps6507x_pmic *tps = tps6507x_dev->pmic; 633 int i; 634 635 for (i = 0; i < TPS6507X_NUM_REGULATOR; i++) 636 regulator_unregister(tps->rdev[i]); 637 638 kfree(tps); 639 640 return 0; 641} 642 643static struct platform_driver tps6507x_pmic_driver = { 644 .driver = { 645 .name = "tps6507x-pmic", 646 .owner = THIS_MODULE, 647 }, 648 .probe = tps6507x_pmic_probe, 649 .remove = __devexit_p(tps6507x_pmic_remove), 650}; 651 652/** 653 * tps6507x_pmic_init 654 * 655 * Module init function 656 */ 657static int __init tps6507x_pmic_init(void) 658{ 659 return platform_driver_register(&tps6507x_pmic_driver); 660} 661subsys_initcall(tps6507x_pmic_init); 662 663/** 664 * tps6507x_pmic_cleanup 665 * 666 * Module exit function 667 */ 668static void __exit tps6507x_pmic_cleanup(void) 669{ 670 platform_driver_unregister(&tps6507x_pmic_driver); 671} 672module_exit(tps6507x_pmic_cleanup); 673 674MODULE_AUTHOR("Texas Instruments"); 675MODULE_DESCRIPTION("TPS6507x voltage regulator driver"); 676MODULE_LICENSE("GPL v2"); 677MODULE_ALIAS("platform:tps6507x-pmic"); 678