drivers/regulator/tps65910-regulator.c

   1 /*
   2  * tps65910.c  --  TI tps65910
   3  *
   4  * Copyright 2010 Texas Instruments Inc.
   5  *
   6  * Author: Graeme Gregory <gg@slimlogic.co.uk>
   7  * Author: Jorge Eduardo Candelaria <jedu@slimlogic.co.uk>
   8  *
   9  *  This program is free software; you can redistribute it and/or modify it
  10  *  under  the terms of the GNU General  Public License as published by the
  11  *  Free Software Foundation;  either version 2 of the License, or (at your
  12  *  option) any later version.
  13  *
  14  */
  15
  16 #include <linux/kernel.h>
  17 #include <linux/module.h>
  18 #include <linux/init.h>
  19 #include <linux/err.h>
  20 #include <linux/platform_device.h>
  21 #include <linux/regulator/driver.h>
  22 #include <linux/regulator/machine.h>
  23 #include <linux/delay.h>
  24 #include <linux/slab.h>
  25 #include <linux/gpio.h>
  26 #include <linux/mfd/tps65910.h>
  27
  28 #define TPS65910_REG_VRTC               0
  29 #define TPS65910_REG_VIO                1
  30 #define TPS65910_REG_VDD1               2
  31 #define TPS65910_REG_VDD2               3
  32 #define TPS65910_REG_VDD3               4
  33 #define TPS65910_REG_VDIG1              5
  34 #define TPS65910_REG_VDIG2              6
  35 #define TPS65910_REG_VPLL               7
  36 #define TPS65910_REG_VDAC               8
  37 #define TPS65910_REG_VAUX1              9
  38 #define TPS65910_REG_VAUX2              10
  39 #define TPS65910_REG_VAUX33             11
  40 #define TPS65910_REG_VMMC               12
  41
  42 #define TPS65911_REG_VDDCTRL            4
  43 #define TPS65911_REG_LDO1               5
  44 #define TPS65911_REG_LDO2               6
  45 #define TPS65911_REG_LDO3               7
  46 #define TPS65911_REG_LDO4               8
  47 #define TPS65911_REG_LDO5               9
  48 #define TPS65911_REG_LDO6               10
  49 #define TPS65911_REG_LDO7               11
  50 #define TPS65911_REG_LDO8               12
  51
  52 #define TPS65910_SUPPLY_STATE_ENABLED   0x1
  53
  54 /* supported VIO voltages in milivolts */
  55 static const u16 VIO_VSEL_table[] = {
  56         1500, 1800, 2500, 3300,
  57 };
  58
  59 /* VSEL tables for TPS65910 specific LDOs and dcdc's */
  60
  61 /* supported VDD3 voltages in milivolts */
  62 static const u16 VDD3_VSEL_table[] = {
  63         5000,
  64 };
  65
  66 /* supported VDIG1 voltages in milivolts */
  67 static const u16 VDIG1_VSEL_table[] = {
  68         1200, 1500, 1800, 2700,
  69 };
  70
  71 /* supported VDIG2 voltages in milivolts */
  72 static const u16 VDIG2_VSEL_table[] = {
  73         1000, 1100, 1200, 1800,
  74 };
  75
  76 /* supported VPLL voltages in milivolts */
  77 static const u16 VPLL_VSEL_table[] = {
  78         1000, 1100, 1800, 2500,
  79 };
  80
  81 /* supported VDAC voltages in milivolts */
  82 static const u16 VDAC_VSEL_table[] = {
  83         1800, 2600, 2800, 2850,
  84 };
  85
  86 /* supported VAUX1 voltages in milivolts */
  87 static const u16 VAUX1_VSEL_table[] = {
  88         1800, 2500, 2800, 2850,
  89 };
  90
  91 /* supported VAUX2 voltages in milivolts */
  92 static const u16 VAUX2_VSEL_table[] = {
  93         1800, 2800, 2900, 3300,
  94 };
  95
  96 /* supported VAUX33 voltages in milivolts */
  97 static const u16 VAUX33_VSEL_table[] = {
  98         1800, 2000, 2800, 3300,
  99 };
 100
 101 /* supported VMMC voltages in milivolts */
 102 static const u16 VMMC_VSEL_table[] = {
 103         1800, 2800, 3000, 3300,
 104 };
 105
 106 struct tps_info {
 107         const char *name;
 108         unsigned min_uV;
 109         unsigned max_uV;
 110         u8 table_len;
 111         const u16 *table;
 112 };
 113
 114 static struct tps_info tps65910_regs[] = {
 115         {
 116                 .name = "VRTC",
 117         },
 118         {
 119                 .name = "VIO",
 120                 .min_uV = 1500000,
 121                 .max_uV = 3300000,
 122                 .table_len = ARRAY_SIZE(VIO_VSEL_table),
 123                 .table = VIO_VSEL_table,
 124         },
 125         {
 126                 .name = "VDD1",
 127                 .min_uV = 600000,
 128                 .max_uV = 4500000,
 129         },
 130         {
 131                 .name = "VDD2",
 132                 .min_uV = 600000,
 133                 .max_uV = 4500000,
 134         },
 135         {
 136                 .name = "VDD3",
 137                 .min_uV = 5000000,
 138                 .max_uV = 5000000,
 139                 .table_len = ARRAY_SIZE(VDD3_VSEL_table),
 140                 .table = VDD3_VSEL_table,
 141         },
 142         {
 143                 .name = "VDIG1",
 144                 .min_uV = 1200000,
 145                 .max_uV = 2700000,
 146                 .table_len = ARRAY_SIZE(VDIG1_VSEL_table),
 147                 .table = VDIG1_VSEL_table,
 148         },
 149         {
 150                 .name = "VDIG2",
 151                 .min_uV = 1000000,
 152                 .max_uV = 1800000,
 153                 .table_len = ARRAY_SIZE(VDIG2_VSEL_table),
 154                 .table = VDIG2_VSEL_table,
 155         },
 156         {
 157                 .name = "VPLL",
 158                 .min_uV = 1000000,
 159                 .max_uV = 2500000,
 160                 .table_len = ARRAY_SIZE(VPLL_VSEL_table),
 161                 .table = VPLL_VSEL_table,
 162         },
 163         {
 164                 .name = "VDAC",
 165                 .min_uV = 1800000,
 166                 .max_uV = 2850000,
 167                 .table_len = ARRAY_SIZE(VDAC_VSEL_table),
 168                 .table = VDAC_VSEL_table,
 169         },
 170         {
 171                 .name = "VAUX1",
 172                 .min_uV = 1800000,
 173                 .max_uV = 2850000,
 174                 .table_len = ARRAY_SIZE(VAUX1_VSEL_table),
 175                 .table = VAUX1_VSEL_table,
 176         },
 177         {
 178                 .name = "VAUX2",
 179                 .min_uV = 1800000,
 180                 .max_uV = 3300000,
 181                 .table_len = ARRAY_SIZE(VAUX2_VSEL_table),
 182                 .table = VAUX2_VSEL_table,
 183         },
 184         {
 185                 .name = "VAUX33",
 186                 .min_uV = 1800000,
 187                 .max_uV = 3300000,
 188                 .table_len = ARRAY_SIZE(VAUX33_VSEL_table),
 189                 .table = VAUX33_VSEL_table,
 190         },
 191         {
 192                 .name = "VMMC",
 193                 .min_uV = 1800000,
 194                 .max_uV = 3300000,
 195                 .table_len = ARRAY_SIZE(VMMC_VSEL_table),
 196                 .table = VMMC_VSEL_table,
 197         },
 198 };
 199
 200 static struct tps_info tps65911_regs[] = {
 201         {
 202                 .name = "VIO",
 203                 .min_uV = 1500000,
 204                 .max_uV = 3300000,
 205                 .table_len = ARRAY_SIZE(VIO_VSEL_table),
 206                 .table = VIO_VSEL_table,
 207         },
 208         {
 209                 .name = "VDD1",
 210                 .min_uV = 600000,
 211                 .max_uV = 4500000,
 212         },
 213         {
 214                 .name = "VDD2",
 215                 .min_uV = 600000,
 216                 .max_uV = 4500000,
 217         },
 218         {
 219                 .name = "VDDCTRL",
 220                 .min_uV = 600000,
 221                 .max_uV = 1400000,
 222         },
 223         {
 224                 .name = "LDO1",
 225                 .min_uV = 1000000,
 226                 .max_uV = 3300000,
 227         },
 228         {
 229                 .name = "LDO2",
 230                 .min_uV = 1000000,
 231                 .max_uV = 3300000,
 232         },
 233         {
 234                 .name = "LDO3",
 235                 .min_uV = 1000000,
 236                 .max_uV = 3300000,
 237         },
 238         {
 239                 .name = "LDO4",
 240                 .min_uV = 1000000,
 241                 .max_uV = 3300000,
 242         },
 243         {
 244                 .name = "LDO5",
 245                 .min_uV = 1000000,
 246                 .max_uV = 3300000,
 247         },
 248         {
 249                 .name = "LDO6",
 250                 .min_uV = 1000000,
 251                 .max_uV = 3300000,
 252         },
 253         {
 254                 .name = "LDO7",
 255                 .min_uV = 1000000,
 256                 .max_uV = 3300000,
 257         },
 258         {
 259                 .name = "LDO8",
 260                 .min_uV = 1000000,
 261                 .max_uV = 3300000,
 262         },
 263 };
 264
 265 struct tps65910_reg {
 266         struct regulator_desc *desc;
 267         struct tps65910 *mfd;
 268         struct regulator_dev **rdev;
 269         struct tps_info **info;
 270         struct mutex mutex;
 271         int num_regulators;
 272         int mode;
 273         int  (*get_ctrl_reg)(int);
 274 };
 275
 276 static inline int tps65910_read(struct tps65910_reg *pmic, u8 reg)
 277 {
 278         u8 val;
 279         int err;
 280
 281         err = pmic->mfd->read(pmic->mfd, reg, 1, &val);
 282         if (err)
 283                 return err;
 284
 285         return val;
 286 }
 287
 288 static inline int tps65910_write(struct tps65910_reg *pmic, u8 reg, u8 val)
 289 {
 290         return pmic->mfd->write(pmic->mfd, reg, 1, &val);
 291 }
 292
 293 static int tps65910_modify_bits(struct tps65910_reg *pmic, u8 reg,
 294                                         u8 set_mask, u8 clear_mask)
 295 {
 296         int err, data;
 297
 298         mutex_lock(&pmic->mutex);
 299
 300         data = tps65910_read(pmic, reg);
 301         if (data < 0) {
 302                 dev_err(pmic->mfd->dev, "Read from reg 0x%x failed\n", reg);
 303                 err = data;
 304                 goto out;
 305         }
 306
 307         data &= ~clear_mask;
 308         data |= set_mask;
 309         err = tps65910_write(pmic, reg, data);
 310         if (err)
 311                 dev_err(pmic->mfd->dev, "Write for reg 0x%x failed\n", reg);
 312
 313 out:
 314         mutex_unlock(&pmic->mutex);
 315         return err;
 316 }
 317
 318 static int tps65910_reg_read(struct tps65910_reg *pmic, u8 reg)
 319 {
 320         int data;
 321
 322         mutex_lock(&pmic->mutex);
 323
 324         data = tps65910_read(pmic, reg);
 325         if (data < 0)
 326                 dev_err(pmic->mfd->dev, "Read from reg 0x%x failed\n", reg);
 327
 328         mutex_unlock(&pmic->mutex);
 329         return data;
 330 }
 331
 332 static int tps65910_reg_write(struct tps65910_reg *pmic, u8 reg, u8 val)
 333 {
 334         int err;
 335
 336         mutex_lock(&pmic->mutex);
 337
 338         err = tps65910_write(pmic, reg, val);
 339         if (err < 0)
 340                 dev_err(pmic->mfd->dev, "Write for reg 0x%x failed\n", reg);
 341
 342         mutex_unlock(&pmic->mutex);
 343         return err;
 344 }
 345
 346 static int tps65910_get_ctrl_register(int id)
 347 {
 348         switch (id) {
 349         case TPS65910_REG_VRTC:
 350                 return TPS65910_VRTC;
 351         case TPS65910_REG_VIO:
 352                 return TPS65910_VIO;
 353         case TPS65910_REG_VDD1:
 354                 return TPS65910_VDD1;
 355         case TPS65910_REG_VDD2:
 356                 return TPS65910_VDD2;
 357         case TPS65910_REG_VDD3:
 358                 return TPS65910_VDD3;
 359         case TPS65910_REG_VDIG1:
 360                 return TPS65910_VDIG1;
 361         case TPS65910_REG_VDIG2:
 362                 return TPS65910_VDIG2;
 363         case TPS65910_REG_VPLL:
 364                 return TPS65910_VPLL;
 365         case TPS65910_REG_VDAC:
 366                 return TPS65910_VDAC;
 367         case TPS65910_REG_VAUX1:
 368                 return TPS65910_VAUX1;
 369         case TPS65910_REG_VAUX2:
 370                 return TPS65910_VAUX2;
 371         case TPS65910_REG_VAUX33:
 372                 return TPS65910_VAUX33;
 373         case TPS65910_REG_VMMC:
 374                 return TPS65910_VMMC;
 375         default:
 376                 return -EINVAL;
 377         }
 378 }
 379
 380 static int tps65911_get_ctrl_register(int id)
 381 {
 382         switch (id) {
 383         case TPS65910_REG_VRTC:
 384                 return TPS65910_VRTC;
 385         case TPS65910_REG_VIO:
 386                 return TPS65910_VIO;
 387         case TPS65910_REG_VDD1:
 388                 return TPS65910_VDD1;
 389         case TPS65910_REG_VDD2:
 390                 return TPS65910_VDD2;
 391         case TPS65911_REG_VDDCTRL:
 392                 return TPS65911_VDDCTRL;
 393         case TPS65911_REG_LDO1:
 394                 return TPS65911_LDO1;
 395         case TPS65911_REG_LDO2:
 396                 return TPS65911_LDO2;
 397         case TPS65911_REG_LDO3:
 398                 return TPS65911_LDO3;
 399         case TPS65911_REG_LDO4:
 400                 return TPS65911_LDO4;
 401         case TPS65911_REG_LDO5:
 402                 return TPS65911_LDO5;
 403         case TPS65911_REG_LDO6:
 404                 return TPS65911_LDO6;
 405         case TPS65911_REG_LDO7:
 406                 return TPS65911_LDO7;
 407         case TPS65911_REG_LDO8:
 408                 return TPS65911_LDO8;
 409         default:
 410                 return -EINVAL;
 411         }
 412 }
 413
 414 static int tps65910_is_enabled(struct regulator_dev *dev)
 415 {
 416         struct tps65910_reg *pmic = rdev_get_drvdata(dev);
 417         int reg, value, id = rdev_get_id(dev);
 418
 419         reg = pmic->get_ctrl_reg(id);
 420         if (reg < 0)
 421                 return reg;
 422
 423         value = tps65910_reg_read(pmic, reg);
 424         if (value < 0)
 425                 return value;
 426
 427         return value & TPS65910_SUPPLY_STATE_ENABLED;
 428 }
 429
 430 static int tps65910_enable(struct regulator_dev *dev)
 431 {
 432         struct tps65910_reg *pmic = rdev_get_drvdata(dev);
 433         struct tps65910 *mfd = pmic->mfd;
 434         int reg, id = rdev_get_id(dev);
 435
 436         reg = pmic->get_ctrl_reg(id);
 437         if (reg < 0)
 438                 return reg;
 439
 440         return tps65910_set_bits(mfd, reg, TPS65910_SUPPLY_STATE_ENABLED);
 441 }
 442
 443 static int tps65910_disable(struct regulator_dev *dev)
 444 {
 445         struct tps65910_reg *pmic = rdev_get_drvdata(dev);
 446         struct tps65910 *mfd = pmic->mfd;
 447         int reg, id = rdev_get_id(dev);
 448
 449         reg = pmic->get_ctrl_reg(id);
 450         if (reg < 0)
 451                 return reg;
 452
 453         return tps65910_clear_bits(mfd, reg, TPS65910_SUPPLY_STATE_ENABLED);
 454 }
 455
 456
 457 static int tps65910_set_mode(struct regulator_dev *dev, unsigned int mode)
 458 {
 459         struct tps65910_reg *pmic = rdev_get_drvdata(dev);
 460         struct tps65910 *mfd = pmic->mfd;
 461         int reg, value, id = rdev_get_id(dev);
 462
 463         reg = pmic->get_ctrl_reg(id);
 464         if (reg < 0)
 465                 return reg;
 466
 467         switch (mode) {
 468         case REGULATOR_MODE_NORMAL:
 469                 return tps65910_modify_bits(pmic, reg, LDO_ST_ON_BIT,
 470                                                         LDO_ST_MODE_BIT);
 471         case REGULATOR_MODE_IDLE:
 472                 value = LDO_ST_ON_BIT | LDO_ST_MODE_BIT;
 473                 return tps65910_set_bits(mfd, reg, value);
 474         case REGULATOR_MODE_STANDBY:
 475                 return tps65910_clear_bits(mfd, reg, LDO_ST_ON_BIT);
 476         }
 477
 478         return -EINVAL;
 479 }
 480
 481 static unsigned int tps65910_get_mode(struct regulator_dev *dev)
 482 {
 483         struct tps65910_reg *pmic = rdev_get_drvdata(dev);
 484         int reg, value, id = rdev_get_id(dev);
 485
 486         reg = pmic->get_ctrl_reg(id);
 487         if (reg < 0)
 488                 return reg;
 489
 490         value = tps65910_reg_read(pmic, reg);
 491         if (value < 0)
 492                 return value;
 493
 494         if (value & LDO_ST_ON_BIT)
 495                 return REGULATOR_MODE_STANDBY;
 496         else if (value & LDO_ST_MODE_BIT)
 497                 return REGULATOR_MODE_IDLE;
 498         else
 499                 return REGULATOR_MODE_NORMAL;
 500 }
 501
 502 static int tps65910_get_voltage_dcdc(struct regulator_dev *dev)
 503 {
 504         struct tps65910_reg *pmic = rdev_get_drvdata(dev);
 505         int id = rdev_get_id(dev), voltage = 0;
 506         int opvsel = 0, srvsel = 0, vselmax = 0, mult = 0, sr = 0;
 507
 508         switch (id) {
 509         case TPS65910_REG_VDD1:
 510                 opvsel = tps65910_reg_read(pmic, TPS65910_VDD1_OP);
 511                 mult = tps65910_reg_read(pmic, TPS65910_VDD1);
 512                 mult = (mult & VDD1_VGAIN_SEL_MASK) >> VDD1_VGAIN_SEL_SHIFT;
 513                 srvsel = tps65910_reg_read(pmic, TPS65910_VDD1_SR);
 514                 sr = opvsel & VDD1_OP_CMD_MASK;
 515                 opvsel &= VDD1_OP_SEL_MASK;
 516                 srvsel &= VDD1_SR_SEL_MASK;
 517                 vselmax = 75;
 518                 break;
 519         case TPS65910_REG_VDD2:
 520                 opvsel = tps65910_reg_read(pmic, TPS65910_VDD2_OP);
 521                 mult = tps65910_reg_read(pmic, TPS65910_VDD2);
 522                 mult = (mult & VDD2_VGAIN_SEL_MASK) >> VDD2_VGAIN_SEL_SHIFT;
 523                 srvsel = tps65910_reg_read(pmic, TPS65910_VDD2_SR);
 524                 sr = opvsel & VDD2_OP_CMD_MASK;
 525                 opvsel &= VDD2_OP_SEL_MASK;
 526                 srvsel &= VDD2_SR_SEL_MASK;
 527                 vselmax = 75;
 528                 break;
 529         case TPS65911_REG_VDDCTRL:
 530                 opvsel = tps65910_reg_read(pmic, TPS65911_VDDCTRL_OP);
 531                 srvsel = tps65910_reg_read(pmic, TPS65911_VDDCTRL_SR);
 532                 sr = opvsel & VDDCTRL_OP_CMD_MASK;
 533                 opvsel &= VDDCTRL_OP_SEL_MASK;
 534                 srvsel &= VDDCTRL_SR_SEL_MASK;
 535                 vselmax = 64;
 536                 break;
 537         }
 538
 539         /* multiplier 0 == 1 but 2,3 normal */
 540         if (!mult)
 541                 mult=1;
 542
 543         if (sr) {
 544                 /* normalise to valid range */
 545                 if (srvsel < 3)
 546                         srvsel = 3;
 547                 if (srvsel > vselmax)
 548                         srvsel = vselmax;
 549                 srvsel -= 3;
 550
 551                 voltage = (srvsel * VDD1_2_OFFSET + VDD1_2_MIN_VOLT) * 100;
 552         } else {
 553
 554                 /* normalise to valid range*/
 555                 if (opvsel < 3)
 556                         opvsel = 3;
 557                 if (opvsel > vselmax)
 558                         opvsel = vselmax;
 559                 opvsel -= 3;
 560
 561                 voltage = (opvsel * VDD1_2_OFFSET + VDD1_2_MIN_VOLT) * 100;
 562         }
 563
 564         voltage *= mult;
 565
 566         return voltage;
 567 }
 568
 569 static int tps65910_get_voltage(struct regulator_dev *dev)
 570 {
 571         struct tps65910_reg *pmic = rdev_get_drvdata(dev);
 572         int reg, value, id = rdev_get_id(dev), voltage = 0;
 573
 574         reg = pmic->get_ctrl_reg(id);
 575         if (reg < 0)
 576                 return reg;
 577
 578         value = tps65910_reg_read(pmic, reg);
 579         if (value < 0)
 580                 return value;
 581
 582         switch (id) {
 583         case TPS65910_REG_VIO:
 584         case TPS65910_REG_VDIG1:
 585         case TPS65910_REG_VDIG2:
 586         case TPS65910_REG_VPLL:
 587         case TPS65910_REG_VDAC:
 588         case TPS65910_REG_VAUX1:
 589         case TPS65910_REG_VAUX2:
 590         case TPS65910_REG_VAUX33:
 591         case TPS65910_REG_VMMC:
 592                 value &= LDO_SEL_MASK;
 593                 value >>= LDO_SEL_SHIFT;
 594                 break;
 595         default:
 596                 return -EINVAL;
 597         }
 598
 599         voltage = pmic->info[id]->table[value] * 1000;
 600
 601         return voltage;
 602 }
 603
 604 static int tps65910_get_voltage_vdd3(struct regulator_dev *dev)
 605 {
 606         return 5 * 1000 * 1000;
 607 }
 608
 609 static int tps65911_get_voltage(struct regulator_dev *dev)
 610 {
 611         struct tps65910_reg *pmic = rdev_get_drvdata(dev);
 612         int step_mv, id = rdev_get_id(dev);
 613         u8 value, reg;
 614
 615         reg = pmic->get_ctrl_reg(id);
 616
 617         value = tps65910_reg_read(pmic, reg);
 618
 619         switch (id) {
 620         case TPS65911_REG_LDO1:
 621         case TPS65911_REG_LDO2:
 622         case TPS65911_REG_LDO4:
 623                 value &= LDO1_SEL_MASK;
 624                 value >>= LDO_SEL_SHIFT;
 625                 /* The first 5 values of the selector correspond to 1V */
 626                 if (value < 5)
 627                         value = 0;
 628                 else
 629                         value -= 4;
 630
 631                 step_mv = 50;
 632                 break;
 633         case TPS65911_REG_LDO3:
 634         case TPS65911_REG_LDO5:
 635         case TPS65911_REG_LDO6:
 636         case TPS65911_REG_LDO7:
 637         case TPS65911_REG_LDO8:
 638                 value &= LDO3_SEL_MASK;
 639                 value >>= LDO_SEL_SHIFT;
 640                 /* The first 3 values of the selector correspond to 1V */
 641                 if (value < 3)
 642                         value = 0;
 643                 else
 644                         value -= 2;
 645
 646                 step_mv = 100;
 647                 break;
 648         case TPS65910_REG_VIO:
 649                 return pmic->info[id]->table[value] * 1000;
 650                 break;
 651         default:
 652                 return -EINVAL;
 653         }
 654
 655         return (LDO_MIN_VOLT + value * step_mv) * 1000;
 656 }
 657
 658 static int tps65910_set_voltage_dcdc(struct regulator_dev *dev,
 659                                 unsigned selector)
 660 {
 661         struct tps65910_reg *pmic = rdev_get_drvdata(dev);
 662         int id = rdev_get_id(dev), vsel;
 663         int dcdc_mult = 0;
 664
 665         switch (id) {
 666         case TPS65910_REG_VDD1:
 667                 dcdc_mult = (selector / VDD1_2_NUM_VOLT_FINE) + 1;
 668                 if (dcdc_mult == 1)
 669                         dcdc_mult--;
 670                 vsel = (selector % VDD1_2_NUM_VOLT_FINE) + 3;
 671
 672                 tps65910_modify_bits(pmic, TPS65910_VDD1,
 673                                 (dcdc_mult << VDD1_VGAIN_SEL_SHIFT),
 674                                                 VDD1_VGAIN_SEL_MASK);
 675                 tps65910_reg_write(pmic, TPS65910_VDD1_OP, vsel);
 676                 break;
 677         case TPS65910_REG_VDD2:
 678                 dcdc_mult = (selector / VDD1_2_NUM_VOLT_FINE) + 1;
 679                 if (dcdc_mult == 1)
 680                         dcdc_mult--;
 681                 vsel = (selector % VDD1_2_NUM_VOLT_FINE) + 3;
 682
 683                 tps65910_modify_bits(pmic, TPS65910_VDD2,
 684                                 (dcdc_mult << VDD2_VGAIN_SEL_SHIFT),
 685                                                 VDD1_VGAIN_SEL_MASK);
 686                 tps65910_reg_write(pmic, TPS65910_VDD2_OP, vsel);
 687                 break;
 688         case TPS65911_REG_VDDCTRL:
 689                 vsel = selector;
 690                 tps65910_reg_write(pmic, TPS65911_VDDCTRL_OP, vsel);
 691         }
 692
 693         return 0;
 694 }
 695
 696 static int tps65910_set_voltage(struct regulator_dev *dev, unsigned selector)
 697 {
 698         struct tps65910_reg *pmic = rdev_get_drvdata(dev);
 699         int reg, id = rdev_get_id(dev);
 700
 701         reg = pmic->get_ctrl_reg(id);
 702         if (reg < 0)
 703                 return reg;
 704
 705         switch (id) {
 706         case TPS65910_REG_VIO:
 707         case TPS65910_REG_VDIG1:
 708         case TPS65910_REG_VDIG2:
 709         case TPS65910_REG_VPLL:
 710         case TPS65910_REG_VDAC:
 711         case TPS65910_REG_VAUX1:
 712         case TPS65910_REG_VAUX2:
 713         case TPS65910_REG_VAUX33:
 714         case TPS65910_REG_VMMC:
 715                 return tps65910_modify_bits(pmic, reg,
 716                                 (selector << LDO_SEL_SHIFT), LDO_SEL_MASK);
 717         }
 718
 719         return -EINVAL;
 720 }
 721
 722 static int tps65911_set_voltage(struct regulator_dev *dev, unsigned selector)
 723 {
 724         struct tps65910_reg *pmic = rdev_get_drvdata(dev);
 725         int reg, id = rdev_get_id(dev);
 726
 727         reg = pmic->get_ctrl_reg(id);
 728         if (reg < 0)
 729                 return reg;
 730
 731         switch (id) {
 732         case TPS65911_REG_LDO1:
 733         case TPS65911_REG_LDO2:
 734         case TPS65911_REG_LDO4:
 735                 return tps65910_modify_bits(pmic, reg,
 736                                 (selector << LDO_SEL_SHIFT), LDO1_SEL_MASK);
 737         case TPS65911_REG_LDO3:
 738         case TPS65911_REG_LDO5:
 739         case TPS65911_REG_LDO6:
 740         case TPS65911_REG_LDO7:
 741         case TPS65911_REG_LDO8:
 742         case TPS65910_REG_VIO:
 743                 return tps65910_modify_bits(pmic, reg,
 744                                 (selector << LDO_SEL_SHIFT), LDO3_SEL_MASK);
 745         }
 746
 747         return -EINVAL;
 748 }
 749
 750
 751 static int tps65910_list_voltage_dcdc(struct regulator_dev *dev,
 752                                         unsigned selector)
 753 {
 754         int volt, mult = 1, id = rdev_get_id(dev);
 755
 756         switch (id) {
 757         case TPS65910_REG_VDD1:
 758         case TPS65910_REG_VDD2:
 759                 mult = (selector / VDD1_2_NUM_VOLT_FINE) + 1;
 760                 volt = VDD1_2_MIN_VOLT +
 761                                 (selector % VDD1_2_NUM_VOLT_FINE) * VDD1_2_OFFSET;
 762                 break;
 763         case TPS65911_REG_VDDCTRL:
 764                 volt = VDDCTRL_MIN_VOLT + (selector * VDDCTRL_OFFSET);
 765                 break;
 766         default:
 767                 BUG();
 768                 return -EINVAL;
 769         }
 770
 771         return  volt * 100 * mult;
 772 }
 773
 774 static int tps65910_list_voltage(struct regulator_dev *dev,
 775                                         unsigned selector)
 776 {
 777         struct tps65910_reg *pmic = rdev_get_drvdata(dev);
 778         int id = rdev_get_id(dev), voltage;
 779
 780         if (id < TPS65910_REG_VIO || id > TPS65910_REG_VMMC)
 781                 return -EINVAL;
 782
 783         if (selector >= pmic->info[id]->table_len)
 784                 return -EINVAL;
 785         else
 786                 voltage = pmic->info[id]->table[selector] * 1000;
 787
 788         return voltage;
 789 }
 790
 791 static int tps65911_list_voltage(struct regulator_dev *dev, unsigned selector)
 792 {
 793         struct tps65910_reg *pmic = rdev_get_drvdata(dev);
 794         int step_mv = 0, id = rdev_get_id(dev);
 795
 796         switch(id) {
 797         case TPS65911_REG_LDO1:
 798         case TPS65911_REG_LDO2:
 799         case TPS65911_REG_LDO4:
 800                 /* The first 5 values of the selector correspond to 1V */
 801                 if (selector < 5)
 802                         selector = 0;
 803                 else
 804                         selector -= 4;
 805
 806                 step_mv = 50;
 807                 break;
 808         case TPS65911_REG_LDO3:
 809         case TPS65911_REG_LDO5:
 810         case TPS65911_REG_LDO6:
 811         case TPS65911_REG_LDO7:
 812         case TPS65911_REG_LDO8:
 813                 /* The first 3 values of the selector correspond to 1V */
 814                 if (selector < 3)
 815                         selector = 0;
 816                 else
 817                         selector -= 2;
 818
 819                 step_mv = 100;
 820                 break;
 821         case TPS65910_REG_VIO:
 822                 return pmic->info[id]->table[selector] * 1000;
 823         default:
 824                 return -EINVAL;
 825         }
 826
 827         return (LDO_MIN_VOLT + selector * step_mv) * 1000;
 828 }
 829
 830 /* Regulator ops (except VRTC) */
 831 static struct regulator_ops tps65910_ops_dcdc = {
 832         .is_enabled             = tps65910_is_enabled,
 833         .enable                 = tps65910_enable,
 834         .disable                = tps65910_disable,
 835         .set_mode               = tps65910_set_mode,
 836         .get_mode               = tps65910_get_mode,
 837         .get_voltage            = tps65910_get_voltage_dcdc,
 838         .set_voltage_sel        = tps65910_set_voltage_dcdc,
 839         .list_voltage           = tps65910_list_voltage_dcdc,
 840 };
 841
 842 static struct regulator_ops tps65910_ops_vdd3 = {
 843         .is_enabled             = tps65910_is_enabled,
 844         .enable                 = tps65910_enable,
 845         .disable                = tps65910_disable,
 846         .set_mode               = tps65910_set_mode,
 847         .get_mode               = tps65910_get_mode,
 848         .get_voltage            = tps65910_get_voltage_vdd3,
 849         .list_voltage           = tps65910_list_voltage,
 850 };
 851
 852 static struct regulator_ops tps65910_ops = {
 853         .is_enabled             = tps65910_is_enabled,
 854         .enable                 = tps65910_enable,
 855         .disable                = tps65910_disable,
 856         .set_mode               = tps65910_set_mode,
 857         .get_mode               = tps65910_get_mode,
 858         .get_voltage            = tps65910_get_voltage,
 859         .set_voltage_sel        = tps65910_set_voltage,
 860         .list_voltage           = tps65910_list_voltage,
 861 };
 862
 863 static struct regulator_ops tps65911_ops = {
 864         .is_enabled             = tps65910_is_enabled,
 865         .enable                 = tps65910_enable,
 866         .disable                = tps65910_disable,
 867         .set_mode               = tps65910_set_mode,
 868         .get_mode               = tps65910_get_mode,
 869         .get_voltage            = tps65911_get_voltage,
 870         .set_voltage_sel        = tps65911_set_voltage,
 871         .list_voltage           = tps65911_list_voltage,
 872 };
 873
 874 static __devinit int tps65910_probe(struct platform_device *pdev)
 875 {
 876         struct tps65910 *tps65910 = dev_get_drvdata(pdev->dev.parent);
 877         struct tps_info *info;
 878         struct regulator_init_data *reg_data;
 879         struct regulator_dev *rdev;
 880         struct tps65910_reg *pmic;
 881         struct tps65910_board *pmic_plat_data;
 882         int i, err;
 883
 884         pmic_plat_data = dev_get_platdata(tps65910->dev);
 885         if (!pmic_plat_data)
 886                 return -EINVAL;
 887
 888         reg_data = pmic_plat_data->tps65910_pmic_init_data;
 889
 890         pmic = kzalloc(sizeof(*pmic), GFP_KERNEL);
 891         if (!pmic)
 892                 return -ENOMEM;
 893
 894         mutex_init(&pmic->mutex);
 895         pmic->mfd = tps65910;
 896         platform_set_drvdata(pdev, pmic);
 897
 898         /* Give control of all register to control port */
 899         tps65910_set_bits(pmic->mfd, TPS65910_DEVCTRL,
 900                                 DEVCTRL_SR_CTL_I2C_SEL_MASK);
 901
 902         switch(tps65910_chip_id(tps65910)) {
 903         case TPS65910:
 904                 pmic->get_ctrl_reg = &tps65910_get_ctrl_register;
 905                 pmic->num_regulators = ARRAY_SIZE(tps65910_regs);
 906                 info = tps65910_regs;
 907                 break;
 908         case TPS65911:
 909                 pmic->get_ctrl_reg = &tps65911_get_ctrl_register;
 910                 pmic->num_regulators = ARRAY_SIZE(tps65911_regs);
 911                 info = tps65911_regs;
 912                 break;
 913         default:
 914                 pr_err("Invalid tps chip version\n");
 915                 kfree(pmic);
 916                 return -ENODEV;
 917         }
 918
 919         pmic->desc = kcalloc(pmic->num_regulators,
 920                         sizeof(struct regulator_desc), GFP_KERNEL);
 921         if (!pmic->desc) {
 922                 err = -ENOMEM;
 923                 goto err_free_pmic;
 924         }
 925
 926         pmic->info = kcalloc(pmic->num_regulators,
 927                         sizeof(struct tps_info *), GFP_KERNEL);
 928         if (!pmic->info) {
 929                 err = -ENOMEM;
 930                 goto err_free_desc;
 931         }
 932
 933         pmic->rdev = kcalloc(pmic->num_regulators,
 934                         sizeof(struct regulator_dev *), GFP_KERNEL);
 935         if (!pmic->rdev) {
 936                 err = -ENOMEM;
 937                 goto err_free_info;
 938         }
 939
 940         for (i = 0; i < pmic->num_regulators; i++, info++, reg_data++) {
 941                 /* Register the regulators */
 942                 pmic->info[i] = info;
 943
 944                 pmic->desc[i].name = info->name;
 945                 pmic->desc[i].id = i;
 946                 pmic->desc[i].n_voltages = info->table_len;
 947
 948                 if (i == TPS65910_REG_VDD1 || i == TPS65910_REG_VDD2) {
 949                         pmic->desc[i].ops = &tps65910_ops_dcdc;
 950                         pmic->desc[i].n_voltages = VDD1_2_NUM_VOLT_FINE *
 951                                                         VDD1_2_NUM_VOLT_COARSE;
 952                 } else if (i == TPS65910_REG_VDD3) {
 953                         if (tps65910_chip_id(tps65910) == TPS65910)
 954                                 pmic->desc[i].ops = &tps65910_ops_vdd3;
 955                         else
 956                                 pmic->desc[i].ops = &tps65910_ops_dcdc;
 957                 } else {
 958                         if (tps65910_chip_id(tps65910) == TPS65910)
 959                                 pmic->desc[i].ops = &tps65910_ops;
 960                         else
 961                                 pmic->desc[i].ops = &tps65911_ops;
 962                 }
 963
 964                 pmic->desc[i].type = REGULATOR_VOLTAGE;
 965                 pmic->desc[i].owner = THIS_MODULE;
 966
 967                 rdev = regulator_register(&pmic->desc[i],
 968                                 tps65910->dev, reg_data, pmic);
 969                 if (IS_ERR(rdev)) {
 970                         dev_err(tps65910->dev,
 971                                 "failed to register %s regulator\n",
 972                                 pdev->name);
 973                         err = PTR_ERR(rdev);
 974                         goto err_unregister_regulator;
 975                 }
 976
 977                 /* Save regulator for cleanup */
 978                 pmic->rdev[i] = rdev;
 979         }
 980         return 0;
 981
 982 err_unregister_regulator:
 983         while (--i >= 0)
 984                 regulator_unregister(pmic->rdev[i]);
 985         kfree(pmic->rdev);
 986 err_free_info:
 987         kfree(pmic->info);
 988 err_free_desc:
 989         kfree(pmic->desc);
 990 err_free_pmic:
 991         kfree(pmic);
 992         return err;
 993 }
 994
 995 static int __devexit tps65910_remove(struct platform_device *pdev)
 996 {
 997         struct tps65910_reg *pmic = platform_get_drvdata(pdev);
 998         int i;
 999
1000         for (i = 0; i < pmic->num_regulators; i++)
1001                 regulator_unregister(pmic->rdev[i]);
1002
1003         kfree(pmic->rdev);
1004         kfree(pmic->info);
1005         kfree(pmic->desc);
1006         kfree(pmic);
1007         return 0;
1008 }
1009
1010 static struct platform_driver tps65910_driver = {
1011         .driver = {
1012                 .name = "tps65910-pmic",
1013                 .owner = THIS_MODULE,
1014         },
1015         .probe = tps65910_probe,
1016         .remove = __devexit_p(tps65910_remove),
1017 };
1018
1019 static int __init tps65910_init(void)
1020 {
1021         return platform_driver_register(&tps65910_driver);
1022 }
1023 subsys_initcall(tps65910_init);
1024
1025 static void __exit tps65910_cleanup(void)
1026 {
1027         platform_driver_unregister(&tps65910_driver);
1028 }
1029 module_exit(tps65910_cleanup);
1030
1031 MODULE_AUTHOR("Graeme Gregory <gg@slimlogic.co.uk>");
1032 MODULE_DESCRIPTION("TPS6507x voltage regulator driver");
1033 MODULE_LICENSE("GPL v2");
1034 MODULE_ALIAS("platform:tps65910-pmic");