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