drivers/regulator/tps65912-regulator.c

   1 /*
   2  * tps65912.c  --  TI tps65912
   3  *
   4  * Copyright 2011 Texas Instruments Inc.
   5  *
   6  * Author: Margarita Olaya Cabrera <magi@slimlogic.co.uk>
   7  *
   8  *  This program is free software; you can redistribute it and/or modify it
   9  *  under  the terms of the GNU General  Public License as published by the
  10  *  Free Software Foundation;  either version 2 of the License, or (at your
  11  *  option) any later version.
  12  *
  13  * This driver is based on wm8350 implementation.
  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/tps65912.h>
  27
  28 /* DCDC's */
  29 #define TPS65912_REG_DCDC1      0
  30 #define TPS65912_REG_DCDC2      1
  31 #define TPS65912_REG_DCDC3      2
  32 #define TPS65912_REG_DCDC4      3
  33
  34 /* LDOs */
  35 #define TPS65912_REG_LDO1       4
  36 #define TPS65912_REG_LDO2       5
  37 #define TPS65912_REG_LDO3       6
  38 #define TPS65912_REG_LDO4       7
  39 #define TPS65912_REG_LDO5       8
  40 #define TPS65912_REG_LDO6       9
  41 #define TPS65912_REG_LDO7       10
  42 #define TPS65912_REG_LDO8       11
  43 #define TPS65912_REG_LDO9       12
  44 #define TPS65912_REG_LDO10      13
  45
  46 #define TPS65912_MAX_REG_ID     TPS65912_REG_LDO_10
  47
  48 /* Number of step-down converters available */
  49 #define TPS65912_NUM_DCDC       4
  50
  51 /* Number of LDO voltage regulators  available */
  52 #define TPS65912_NUM_LDO        10
  53
  54 /* Number of total regulators available */
  55 #define TPS65912_NUM_REGULATOR          (TPS65912_NUM_DCDC + TPS65912_NUM_LDO)
  56
  57 #define TPS65912_REG_ENABLED    0x80
  58 #define OP_SELREG_MASK          0x40
  59 #define OP_SELREG_SHIFT         6
  60
  61 struct tps_info {
  62         const char *name;
  63 };
  64
  65 static struct tps_info tps65912_regs[] = {
  66         {
  67                 .name = "DCDC1",
  68         },
  69         {
  70                 .name = "DCDC2",
  71         },
  72         {
  73                 .name = "DCDC3",
  74         },
  75         {
  76                 .name = "DCDC4",
  77         },
  78         {
  79                 .name = "LDO1",
  80         },
  81         {
  82                 .name = "LDO2",
  83         },
  84         {
  85                 .name = "LDO3",
  86         },
  87         {
  88                 .name = "LDO4",
  89         },
  90         {
  91                 .name = "LDO5",
  92         },
  93         {
  94                 .name = "LDO6",
  95         },
  96         {
  97                 .name = "LDO7",
  98         },
  99         {
 100                 .name = "LDO8",
 101         },
 102         {
 103                 .name = "LDO9",
 104         },
 105         {
 106                 .name = "LDO10",
 107         },
 108 };
 109
 110 struct tps65912_reg {
 111         struct regulator_desc desc[TPS65912_NUM_REGULATOR];
 112         struct tps65912 *mfd;
 113         struct regulator_dev *rdev[TPS65912_NUM_REGULATOR];
 114         struct tps_info *info[TPS65912_NUM_REGULATOR];
 115         /* for read/write access */
 116         struct mutex io_lock;
 117         int mode;
 118         int (*get_ctrl_reg)(int);
 119         int dcdc1_range;
 120         int dcdc2_range;
 121         int dcdc3_range;
 122         int dcdc4_range;
 123         int pwm_mode_reg;
 124         int eco_reg;
 125 };
 126
 127 static int tps65912_get_range(struct tps65912_reg *pmic, int id)
 128 {
 129         struct tps65912 *mfd = pmic->mfd;
 130
 131         if (id > TPS65912_REG_DCDC4)
 132                 return 0;
 133
 134         switch (id) {
 135         case TPS65912_REG_DCDC1:
 136                 pmic->dcdc1_range = tps65912_reg_read(mfd,
 137                                                         TPS65912_DCDC1_LIMIT);
 138                 if (pmic->dcdc1_range < 0)
 139                         return pmic->dcdc1_range;
 140                 pmic->dcdc1_range = (pmic->dcdc1_range &
 141                         DCDC_LIMIT_RANGE_MASK) >> DCDC_LIMIT_RANGE_SHIFT;
 142                 return pmic->dcdc1_range;
 143         case TPS65912_REG_DCDC2:
 144                 pmic->dcdc2_range = tps65912_reg_read(mfd,
 145                                                         TPS65912_DCDC2_LIMIT);
 146                 if (pmic->dcdc2_range < 0)
 147                         return pmic->dcdc2_range;
 148                 pmic->dcdc2_range = (pmic->dcdc2_range &
 149                         DCDC_LIMIT_RANGE_MASK) >> DCDC_LIMIT_RANGE_SHIFT;
 150                 return pmic->dcdc2_range;
 151         case TPS65912_REG_DCDC3:
 152                 pmic->dcdc3_range = tps65912_reg_read(mfd,
 153                                                         TPS65912_DCDC3_LIMIT);
 154                 if (pmic->dcdc3_range < 0)
 155                         return pmic->dcdc3_range;
 156                 pmic->dcdc3_range = (pmic->dcdc3_range &
 157                         DCDC_LIMIT_RANGE_MASK) >> DCDC_LIMIT_RANGE_SHIFT;
 158                 return pmic->dcdc3_range;
 159         case TPS65912_REG_DCDC4:
 160                 pmic->dcdc4_range = tps65912_reg_read(mfd,
 161                                                         TPS65912_DCDC4_LIMIT);
 162                 if (pmic->dcdc4_range < 0)
 163                         return pmic->dcdc4_range;
 164                 pmic->dcdc4_range = (pmic->dcdc4_range &
 165                         DCDC_LIMIT_RANGE_MASK) >> DCDC_LIMIT_RANGE_SHIFT;
 166                 return pmic->dcdc4_range;
 167         default:
 168                 return 0;
 169         }
 170 }
 171
 172 static unsigned long tps65912_vsel_to_uv_range0(u8 vsel)
 173 {
 174         unsigned long uv;
 175
 176         uv = ((vsel * 12500) + 500000);
 177         return uv;
 178 }
 179
 180 static unsigned long tps65912_vsel_to_uv_range1(u8 vsel)
 181 {
 182         unsigned long uv;
 183
 184          uv = ((vsel * 12500) + 700000);
 185         return uv;
 186 }
 187
 188 static unsigned long tps65912_vsel_to_uv_range2(u8 vsel)
 189 {
 190         unsigned long uv;
 191
 192         uv = ((vsel * 25000) + 500000);
 193         return uv;
 194 }
 195
 196 static unsigned long tps65912_vsel_to_uv_range3(u8 vsel)
 197 {
 198         unsigned long uv;
 199
 200         if (vsel == 0x3f)
 201                 uv = 3800000;
 202         else
 203                 uv = ((vsel * 50000) + 500000);
 204
 205         return uv;
 206 }
 207
 208 static unsigned long tps65912_vsel_to_uv_ldo(u8 vsel)
 209 {
 210         unsigned long uv = 0;
 211
 212         if (vsel <= 32)
 213                 uv = ((vsel * 25000) + 800000);
 214         else if (vsel > 32 && vsel <= 60)
 215                 uv = (((vsel - 32) * 50000) + 1600000);
 216         else if (vsel > 60)
 217                 uv = (((vsel - 60) * 100000) + 3000000);
 218
 219         return uv;
 220 }
 221
 222 static int tps65912_get_ctrl_register(int id)
 223 {
 224         switch (id) {
 225         case TPS65912_REG_DCDC1:
 226                 return TPS65912_DCDC1_AVS;
 227         case TPS65912_REG_DCDC2:
 228                 return TPS65912_DCDC2_AVS;
 229         case TPS65912_REG_DCDC3:
 230                 return TPS65912_DCDC3_AVS;
 231         case TPS65912_REG_DCDC4:
 232                 return TPS65912_DCDC4_AVS;
 233         case TPS65912_REG_LDO1:
 234                 return TPS65912_LDO1_AVS;
 235         case TPS65912_REG_LDO2:
 236                 return TPS65912_LDO2_AVS;
 237         case TPS65912_REG_LDO3:
 238                 return TPS65912_LDO3_AVS;
 239         case TPS65912_REG_LDO4:
 240                 return TPS65912_LDO4_AVS;
 241         case TPS65912_REG_LDO5:
 242                 return TPS65912_LDO5;
 243         case TPS65912_REG_LDO6:
 244                 return TPS65912_LDO6;
 245         case TPS65912_REG_LDO7:
 246                 return TPS65912_LDO7;
 247         case TPS65912_REG_LDO8:
 248                 return TPS65912_LDO8;
 249         case TPS65912_REG_LDO9:
 250                 return TPS65912_LDO9;
 251         case TPS65912_REG_LDO10:
 252                 return TPS65912_LDO10;
 253         default:
 254                 return -EINVAL;
 255         }
 256 }
 257
 258 static int tps65912_get_dcdc_sel_register(struct tps65912_reg *pmic, int id)
 259 {
 260         struct tps65912 *mfd = pmic->mfd;
 261         int opvsel = 0, sr = 0;
 262         u8 reg = 0;
 263
 264         if (id < TPS65912_REG_DCDC1 || id > TPS65912_REG_DCDC4)
 265                 return -EINVAL;
 266
 267         switch (id) {
 268         case TPS65912_REG_DCDC1:
 269                 opvsel = tps65912_reg_read(mfd, TPS65912_DCDC1_OP);
 270                 sr = ((opvsel & OP_SELREG_MASK) >> OP_SELREG_SHIFT);
 271                 if (sr)
 272                         reg = TPS65912_DCDC1_AVS;
 273                 else
 274                         reg = TPS65912_DCDC1_OP;
 275                 break;
 276         case TPS65912_REG_DCDC2:
 277                 opvsel = tps65912_reg_read(mfd, TPS65912_DCDC2_OP);
 278                 sr = (opvsel & OP_SELREG_MASK) >> OP_SELREG_SHIFT;
 279                 if (sr)
 280                         reg = TPS65912_DCDC2_AVS;
 281                 else
 282                         reg = TPS65912_DCDC2_OP;
 283                 break;
 284         case TPS65912_REG_DCDC3:
 285                 opvsel = tps65912_reg_read(mfd, TPS65912_DCDC3_OP);
 286                 sr = (opvsel & OP_SELREG_MASK) >> OP_SELREG_SHIFT;
 287                 if (sr)
 288                         reg = TPS65912_DCDC3_AVS;
 289                 else
 290                         reg = TPS65912_DCDC3_OP;
 291                 break;
 292         case TPS65912_REG_DCDC4:
 293                 opvsel = tps65912_reg_read(mfd, TPS65912_DCDC4_OP);
 294                 sr = (opvsel & OP_SELREG_MASK) >> OP_SELREG_SHIFT;
 295                 if (sr)
 296                         reg = TPS65912_DCDC4_AVS;
 297                 else
 298                         reg = TPS65912_DCDC4_OP;
 299                 break;
 300         }
 301         return reg;
 302 }
 303
 304 static int tps65912_get_ldo_sel_register(struct tps65912_reg *pmic, int id)
 305 {
 306         struct tps65912 *mfd = pmic->mfd;
 307         int opvsel = 0, sr = 0;
 308         u8 reg = 0;
 309
 310         if (id < TPS65912_REG_LDO1 || id > TPS65912_REG_LDO10)
 311                 return -EINVAL;
 312
 313         switch (id) {
 314         case TPS65912_REG_LDO1:
 315                 opvsel = tps65912_reg_read(mfd, TPS65912_LDO1_OP);
 316                 sr = (opvsel & OP_SELREG_MASK) >> OP_SELREG_SHIFT;
 317                 if (sr)
 318                         reg = TPS65912_LDO1_AVS;
 319                 else
 320                         reg = TPS65912_LDO1_OP;
 321                 break;
 322         case TPS65912_REG_LDO2:
 323                 opvsel = tps65912_reg_read(mfd, TPS65912_LDO2_OP);
 324                 sr = (opvsel & OP_SELREG_MASK) >> OP_SELREG_SHIFT;
 325                 if (sr)
 326                         reg = TPS65912_LDO2_AVS;
 327                 else
 328                         reg = TPS65912_LDO2_OP;
 329                 break;
 330         case TPS65912_REG_LDO3:
 331                 opvsel = tps65912_reg_read(mfd, TPS65912_LDO3_OP);
 332                 sr = (opvsel & OP_SELREG_MASK) >> OP_SELREG_SHIFT;
 333                 if (sr)
 334                         reg = TPS65912_LDO3_AVS;
 335                 else
 336                         reg = TPS65912_LDO3_OP;
 337                 break;
 338         case TPS65912_REG_LDO4:
 339                 opvsel = tps65912_reg_read(mfd, TPS65912_LDO4_OP);
 340                 sr = (opvsel & OP_SELREG_MASK) >> OP_SELREG_SHIFT;
 341                 if (sr)
 342                         reg = TPS65912_LDO4_AVS;
 343                 else
 344                         reg = TPS65912_LDO4_OP;
 345                 break;
 346         case TPS65912_REG_LDO5:
 347                 reg = TPS65912_LDO5;
 348                 break;
 349         case TPS65912_REG_LDO6:
 350                 reg = TPS65912_LDO6;
 351                 break;
 352         case TPS65912_REG_LDO7:
 353                 reg = TPS65912_LDO7;
 354                 break;
 355         case TPS65912_REG_LDO8:
 356                 reg = TPS65912_LDO8;
 357                 break;
 358         case TPS65912_REG_LDO9:
 359                 reg = TPS65912_LDO9;
 360                 break;
 361         case TPS65912_REG_LDO10:
 362                 reg = TPS65912_LDO10;
 363                 break;
 364         }
 365
 366         return reg;
 367 }
 368
 369 static int tps65912_get_mode_regiters(struct tps65912_reg *pmic, int id)
 370 {
 371         switch (id) {
 372         case TPS65912_REG_DCDC1:
 373                 pmic->pwm_mode_reg = TPS65912_DCDC1_CTRL;
 374                 pmic->eco_reg = TPS65912_DCDC1_AVS;
 375                 break;
 376         case TPS65912_REG_DCDC2:
 377                 pmic->pwm_mode_reg = TPS65912_DCDC2_CTRL;
 378                 pmic->eco_reg = TPS65912_DCDC2_AVS;
 379                 break;
 380         case TPS65912_REG_DCDC3:
 381                 pmic->pwm_mode_reg = TPS65912_DCDC3_CTRL;
 382                 pmic->eco_reg = TPS65912_DCDC3_AVS;
 383                 break;
 384         case TPS65912_REG_DCDC4:
 385                 pmic->pwm_mode_reg = TPS65912_DCDC4_CTRL;
 386                 pmic->eco_reg = TPS65912_DCDC4_AVS;
 387                 break;
 388         default:
 389                 return -EINVAL;
 390         }
 391
 392         return 0;
 393 }
 394
 395 static int tps65912_reg_is_enabled(struct regulator_dev *dev)
 396 {
 397         struct tps65912_reg *pmic = rdev_get_drvdata(dev);
 398         struct tps65912 *mfd = pmic->mfd;
 399         int reg, value, id = rdev_get_id(dev);
 400
 401         if (id < TPS65912_REG_DCDC1 || id > TPS65912_REG_LDO10)
 402                 return -EINVAL;
 403
 404         reg = pmic->get_ctrl_reg(id);
 405         if (reg < 0)
 406                 return reg;
 407
 408         value = tps65912_reg_read(mfd, reg);
 409         if (value < 0)
 410                 return value;
 411
 412         return value & TPS65912_REG_ENABLED;
 413 }
 414
 415 static int tps65912_reg_enable(struct regulator_dev *dev)
 416 {
 417         struct tps65912_reg *pmic = rdev_get_drvdata(dev);
 418         struct tps65912 *mfd = pmic->mfd;
 419         int id = rdev_get_id(dev);
 420         int reg;
 421
 422         if (id < TPS65912_REG_DCDC1 || id > TPS65912_REG_LDO10)
 423                 return -EINVAL;
 424
 425         reg = pmic->get_ctrl_reg(id);
 426         if (reg < 0)
 427                 return reg;
 428
 429         return tps65912_set_bits(mfd, reg, TPS65912_REG_ENABLED);
 430 }
 431
 432 static int tps65912_reg_disable(struct regulator_dev *dev)
 433 {
 434         struct tps65912_reg *pmic = rdev_get_drvdata(dev);
 435         struct tps65912 *mfd = pmic->mfd;
 436         int id = rdev_get_id(dev), reg;
 437
 438         reg = pmic->get_ctrl_reg(id);
 439         if (reg < 0)
 440                 return reg;
 441
 442         return tps65912_clear_bits(mfd, reg, TPS65912_REG_ENABLED);
 443 }
 444
 445 static int tps65912_set_mode(struct regulator_dev *dev, unsigned int mode)
 446 {
 447         struct tps65912_reg *pmic = rdev_get_drvdata(dev);
 448         struct tps65912 *mfd = pmic->mfd;
 449         int pwm_mode, eco, id = rdev_get_id(dev);
 450
 451         tps65912_get_mode_regiters(pmic, id);
 452
 453         pwm_mode = tps65912_reg_read(mfd, pmic->pwm_mode_reg);
 454         eco = tps65912_reg_read(mfd, pmic->eco_reg);
 455
 456         pwm_mode &= DCDCCTRL_DCDC_MODE_MASK;
 457         eco &= DCDC_AVS_ECO_MASK;
 458
 459         switch (mode) {
 460         case REGULATOR_MODE_FAST:
 461                 /* Verify if mode alredy set */
 462                 if (pwm_mode && !eco)
 463                         break;
 464                 tps65912_set_bits(mfd, pmic->pwm_mode_reg, DCDCCTRL_DCDC_MODE_MASK);
 465                 tps65912_clear_bits(mfd, pmic->eco_reg, DCDC_AVS_ECO_MASK);
 466                 break;
 467         case REGULATOR_MODE_NORMAL:
 468         case REGULATOR_MODE_IDLE:
 469                 if (!pwm_mode && !eco)
 470                         break;
 471                 tps65912_clear_bits(mfd, pmic->pwm_mode_reg, DCDCCTRL_DCDC_MODE_MASK);
 472                 tps65912_clear_bits(mfd, pmic->eco_reg, DCDC_AVS_ECO_MASK);
 473                 break;
 474         case REGULATOR_MODE_STANDBY:
 475                 if (!pwm_mode && eco)
 476                         break;
 477                 tps65912_clear_bits(mfd, pmic->pwm_mode_reg, DCDCCTRL_DCDC_MODE_MASK);
 478                 tps65912_set_bits(mfd, pmic->eco_reg, DCDC_AVS_ECO_MASK);
 479                 break;
 480         default:
 481                 return -EINVAL;
 482         }
 483
 484         return 0;
 485 }
 486
 487 static unsigned int tps65912_get_mode(struct regulator_dev *dev)
 488 {
 489         struct tps65912_reg *pmic = rdev_get_drvdata(dev);
 490         struct tps65912 *mfd = pmic->mfd;
 491         int pwm_mode, eco, mode = 0, id = rdev_get_id(dev);
 492
 493         tps65912_get_mode_regiters(pmic, id);
 494
 495         pwm_mode = tps65912_reg_read(mfd, pmic->pwm_mode_reg);
 496         eco = tps65912_reg_read(mfd, pmic->eco_reg);
 497
 498         pwm_mode &= DCDCCTRL_DCDC_MODE_MASK;
 499         eco &= DCDC_AVS_ECO_MASK;
 500
 501         if (pwm_mode && !eco)
 502                 mode = REGULATOR_MODE_FAST;
 503         else if (!pwm_mode && !eco)
 504                 mode = REGULATOR_MODE_NORMAL;
 505         else if (!pwm_mode && eco)
 506                 mode = REGULATOR_MODE_STANDBY;
 507
 508         return mode;
 509 }
 510
 511 static int tps65912_get_voltage_dcdc(struct regulator_dev *dev)
 512 {
 513         struct tps65912_reg *pmic = rdev_get_drvdata(dev);
 514         struct tps65912 *mfd = pmic->mfd;
 515         int id = rdev_get_id(dev), voltage = 0, range;
 516         int opvsel = 0, avsel = 0, sr, vsel;
 517
 518         switch (id) {
 519         case TPS65912_REG_DCDC1:
 520                 opvsel = tps65912_reg_read(mfd, TPS65912_DCDC1_OP);
 521                 avsel = tps65912_reg_read(mfd, TPS65912_DCDC1_AVS);
 522                 range = pmic->dcdc1_range;
 523                 break;
 524         case TPS65912_REG_DCDC2:
 525                 opvsel = tps65912_reg_read(mfd, TPS65912_DCDC2_OP);
 526                 avsel = tps65912_reg_read(mfd, TPS65912_DCDC2_AVS);
 527                 range = pmic->dcdc2_range;
 528                 break;
 529         case TPS65912_REG_DCDC3:
 530                 opvsel = tps65912_reg_read(mfd, TPS65912_DCDC3_OP);
 531                 avsel = tps65912_reg_read(mfd, TPS65912_DCDC3_AVS);
 532                 range = pmic->dcdc3_range;
 533                 break;
 534         case TPS65912_REG_DCDC4:
 535                 opvsel = tps65912_reg_read(mfd, TPS65912_DCDC4_OP);
 536                 avsel = tps65912_reg_read(mfd, TPS65912_DCDC4_AVS);
 537                 range = pmic->dcdc4_range;
 538                 break;
 539         default:
 540                 return -EINVAL;
 541         }
 542
 543         sr = (opvsel & OP_SELREG_MASK) >> OP_SELREG_SHIFT;
 544         if (sr)
 545                 vsel = avsel;
 546         else
 547                 vsel = opvsel;
 548         vsel &= 0x3F;
 549
 550         switch (range) {
 551         case 0:
 552                 /* 0.5 - 1.2875V in 12.5mV steps */
 553                 voltage = tps65912_vsel_to_uv_range0(vsel);
 554                 break;
 555         case 1:
 556                 /* 0.7 - 1.4875V in 12.5mV steps */
 557                 voltage = tps65912_vsel_to_uv_range1(vsel);
 558                 break;
 559         case 2:
 560                 /* 0.5 - 2.075V in 25mV steps */
 561                 voltage = tps65912_vsel_to_uv_range2(vsel);
 562                 break;
 563         case 3:
 564                 /* 0.5 - 3.8V in 50mV steps */
 565                 voltage = tps65912_vsel_to_uv_range3(vsel);
 566                 break;
 567         }
 568         return voltage;
 569 }
 570
 571 static int tps65912_set_voltage_dcdc(struct regulator_dev *dev,
 572                                                 unsigned selector)
 573 {
 574         struct tps65912_reg *pmic = rdev_get_drvdata(dev);
 575         struct tps65912 *mfd = pmic->mfd;
 576         int id = rdev_get_id(dev);
 577         int value;
 578         u8 reg;
 579
 580         reg = tps65912_get_dcdc_sel_register(pmic, id);
 581         value = tps65912_reg_read(mfd, reg);
 582         value &= 0xC0;
 583         return tps65912_reg_write(mfd, reg, selector | value);
 584 }
 585
 586 static int tps65912_get_voltage_ldo(struct regulator_dev *dev)
 587 {
 588         struct tps65912_reg *pmic = rdev_get_drvdata(dev);
 589         struct tps65912 *mfd = pmic->mfd;
 590         int id = rdev_get_id(dev);
 591         int vsel = 0;
 592         u8 reg;
 593
 594         reg = tps65912_get_ldo_sel_register(pmic, id);
 595         vsel = tps65912_reg_read(mfd, reg);
 596         vsel &= 0x3F;
 597
 598         return tps65912_vsel_to_uv_ldo(vsel);
 599 }
 600
 601 static int tps65912_set_voltage_ldo(struct regulator_dev *dev,
 602                                                 unsigned selector)
 603 {
 604         struct tps65912_reg *pmic = rdev_get_drvdata(dev);
 605         struct tps65912 *mfd = pmic->mfd;
 606         int id = rdev_get_id(dev), reg, value;
 607
 608         reg = tps65912_get_ldo_sel_register(pmic, id);
 609         value = tps65912_reg_read(mfd, reg);
 610         value &= 0xC0;
 611         return tps65912_reg_write(mfd, reg, selector | value);
 612 }
 613
 614 static int tps65912_list_voltage_dcdc(struct regulator_dev *dev,
 615                                         unsigned selector)
 616 {
 617         struct tps65912_reg *pmic = rdev_get_drvdata(dev);
 618         int range, voltage = 0, id = rdev_get_id(dev);
 619
 620         switch (id) {
 621         case TPS65912_REG_DCDC1:
 622                 range = pmic->dcdc1_range;
 623                 break;
 624         case TPS65912_REG_DCDC2:
 625                 range = pmic->dcdc2_range;
 626                 break;
 627         case TPS65912_REG_DCDC3:
 628                 range = pmic->dcdc3_range;
 629                 break;
 630         case TPS65912_REG_DCDC4:
 631                 range = pmic->dcdc4_range;
 632                 break;
 633         default:
 634                 return -EINVAL;
 635         }
 636
 637         switch (range) {
 638         case 0:
 639                 /* 0.5 - 1.2875V in 12.5mV steps */
 640                 voltage = tps65912_vsel_to_uv_range0(selector);
 641                 break;
 642         case 1:
 643                 /* 0.7 - 1.4875V in 12.5mV steps */
 644                 voltage = tps65912_vsel_to_uv_range1(selector);
 645                 break;
 646         case 2:
 647                 /* 0.5 - 2.075V in 25mV steps */
 648                 voltage = tps65912_vsel_to_uv_range2(selector);
 649                 break;
 650         case 3:
 651                 /* 0.5 - 3.8V in 50mV steps */
 652                 voltage = tps65912_vsel_to_uv_range3(selector);
 653                 break;
 654         }
 655         return voltage;
 656 }
 657
 658 static int tps65912_list_voltage_ldo(struct regulator_dev *dev,
 659                                         unsigned selector)
 660 {
 661         int ldo = rdev_get_id(dev);
 662
 663         if (ldo < TPS65912_REG_LDO1 || ldo > TPS65912_REG_LDO10)
 664                 return -EINVAL;
 665
 666         return tps65912_vsel_to_uv_ldo(selector);
 667 }
 668
 669 /* Operations permitted on DCDCx */
 670 static struct regulator_ops tps65912_ops_dcdc = {
 671         .is_enabled = tps65912_reg_is_enabled,
 672         .enable = tps65912_reg_enable,
 673         .disable = tps65912_reg_disable,
 674         .set_mode = tps65912_set_mode,
 675         .get_mode = tps65912_get_mode,
 676         .get_voltage = tps65912_get_voltage_dcdc,
 677         .set_voltage_sel = tps65912_set_voltage_dcdc,
 678         .list_voltage = tps65912_list_voltage_dcdc,
 679 };
 680
 681 /* Operations permitted on LDOx */
 682 static struct regulator_ops tps65912_ops_ldo = {
 683         .is_enabled = tps65912_reg_is_enabled,
 684         .enable = tps65912_reg_enable,
 685         .disable = tps65912_reg_disable,
 686         .get_voltage = tps65912_get_voltage_ldo,
 687         .set_voltage_sel = tps65912_set_voltage_ldo,
 688         .list_voltage = tps65912_list_voltage_ldo,
 689 };
 690
 691 static __devinit int tps65912_probe(struct platform_device *pdev)
 692 {
 693         struct tps65912 *tps65912 = dev_get_drvdata(pdev->dev.parent);
 694         struct tps_info *info;
 695         struct regulator_init_data *reg_data;
 696         struct regulator_dev *rdev;
 697         struct tps65912_reg *pmic;
 698         struct tps65912_board *pmic_plat_data;
 699         int i, err;
 700
 701         pmic_plat_data = dev_get_platdata(tps65912->dev);
 702         if (!pmic_plat_data)
 703                 return -EINVAL;
 704
 705         reg_data = pmic_plat_data->tps65912_pmic_init_data;
 706
 707         pmic = kzalloc(sizeof(*pmic), GFP_KERNEL);
 708         if (!pmic)
 709                 return -ENOMEM;
 710
 711         mutex_init(&pmic->io_lock);
 712         pmic->mfd = tps65912;
 713         platform_set_drvdata(pdev, pmic);
 714
 715         pmic->get_ctrl_reg = &tps65912_get_ctrl_register;
 716         info = tps65912_regs;
 717
 718         for (i = 0; i < TPS65912_NUM_REGULATOR; i++, info++, reg_data++) {
 719                 int range = 0;
 720                 /* Register the regulators */
 721                 pmic->info[i] = info;
 722
 723                 pmic->desc[i].name = info->name;
 724                 pmic->desc[i].id = i;
 725                 pmic->desc[i].n_voltages = 64;
 726                 pmic->desc[i].ops = (i > TPS65912_REG_DCDC4 ?
 727                         &tps65912_ops_ldo : &tps65912_ops_dcdc);
 728                 pmic->desc[i].type = REGULATOR_VOLTAGE;
 729                 pmic->desc[i].owner = THIS_MODULE;
 730                 range = tps65912_get_range(pmic, i);
 731                 rdev = regulator_register(&pmic->desc[i],
 732                                         tps65912->dev, reg_data, pmic);
 733                 if (IS_ERR(rdev)) {
 734                         dev_err(tps65912->dev,
 735                                 "failed to register %s regulator\n",
 736                                 pdev->name);
 737                         err = PTR_ERR(rdev);
 738                         goto err;
 739                 }
 740
 741                 /* Save regulator for cleanup */
 742                 pmic->rdev[i] = rdev;
 743         }
 744         return 0;
 745
 746 err:
 747         while (--i >= 0)
 748                 regulator_unregister(pmic->rdev[i]);
 749
 750         kfree(pmic);
 751         return err;
 752 }
 753
 754 static int __devexit tps65912_remove(struct platform_device *pdev)
 755 {
 756         struct tps65912_reg *tps65912_reg = platform_get_drvdata(pdev);
 757         int i;
 758
 759         for (i = 0; i < TPS65912_NUM_REGULATOR; i++)
 760                 regulator_unregister(tps65912_reg->rdev[i]);
 761
 762         kfree(tps65912_reg);
 763         return 0;
 764 }
 765
 766 static struct platform_driver tps65912_driver = {
 767         .driver = {
 768                 .name = "tps65912-pmic",
 769                 .owner = THIS_MODULE,
 770         },
 771         .probe = tps65912_probe,
 772         .remove = __devexit_p(tps65912_remove),
 773 };
 774
 775 /**
 776  * tps65912_init
 777  *
 778  * Module init function
 779  */
 780 static int __init tps65912_init(void)
 781 {
 782         return platform_driver_register(&tps65912_driver);
 783 }
 784 subsys_initcall(tps65912_init);
 785
 786 /**
 787  * tps65912_cleanup
 788  *
 789  * Module exit function
 790  */
 791 static void __exit tps65912_cleanup(void)
 792 {
 793         platform_driver_unregister(&tps65912_driver);
 794 }
 795 module_exit(tps65912_cleanup);
 796
 797 MODULE_AUTHOR("Margarita Olaya Cabrera <magi@slimlogic.co.uk>");
 798 MODULE_DESCRIPTION("TPS65912 voltage regulator driver");
 799 MODULE_LICENSE("GPL v2");
 800 MODULE_ALIAS("platform:tps65912-pmic");