drivers/regulator/tps6524x-regulator.c

   1 /*
   2  * Regulator driver for TPS6524x PMIC
   3  *
   4  * Copyright (C) 2010 Texas Instruments
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License as
   8  * published by the Free Software Foundation version 2.
   9  *
  10  * This program is distributed "as is" WITHOUT ANY WARRANTY of any kind,
  11  * whether express or implied; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License for more details.
  14  */
  15
  16 #include <linux/kernel.h>
  17 #include <linux/module.h>
  18 #include <linux/err.h>
  19 #include <linux/errno.h>
  20 #include <linux/slab.h>
  21 #include <linux/spi/spi.h>
  22 #include <linux/regulator/driver.h>
  23 #include <linux/regulator/machine.h>
  24
  25 #define REG_LDO_SET             0x0
  26 #define LDO_ILIM_MASK           1       /* 0 = 400-800, 1 = 900-1500 */
  27 #define LDO_VSEL_MASK           0x0f
  28 #define LDO2_ILIM_SHIFT         12
  29 #define LDO2_VSEL_SHIFT         4
  30 #define LDO1_ILIM_SHIFT         8
  31 #define LDO1_VSEL_SHIFT         0
  32
  33 #define REG_BLOCK_EN            0x1
  34 #define BLOCK_MASK              1
  35 #define BLOCK_LDO1_SHIFT        0
  36 #define BLOCK_LDO2_SHIFT        1
  37 #define BLOCK_LCD_SHIFT         2
  38 #define BLOCK_USB_SHIFT         3
  39
  40 #define REG_DCDC_SET            0x2
  41 #define DCDC_VDCDC_MASK         0x1f
  42 #define DCDC_VDCDC1_SHIFT       0
  43 #define DCDC_VDCDC2_SHIFT       5
  44 #define DCDC_VDCDC3_SHIFT       10
  45
  46 #define REG_DCDC_EN             0x3
  47 #define DCDCDCDC_EN_MASK        0x1
  48 #define DCDCDCDC1_EN_SHIFT      0
  49 #define DCDCDCDC1_PG_MSK        BIT(1)
  50 #define DCDCDCDC2_EN_SHIFT      2
  51 #define DCDCDCDC2_PG_MSK        BIT(3)
  52 #define DCDCDCDC3_EN_SHIFT      4
  53 #define DCDCDCDC3_PG_MSK        BIT(5)
  54
  55 #define REG_USB                 0x4
  56 #define USB_ILIM_SHIFT          0
  57 #define USB_ILIM_MASK           0x3
  58 #define USB_TSD_SHIFT           2
  59 #define USB_TSD_MASK            0x3
  60 #define USB_TWARN_SHIFT         4
  61 #define USB_TWARN_MASK          0x3
  62 #define USB_IWARN_SD            BIT(6)
  63 #define USB_FAST_LOOP           BIT(7)
  64
  65 #define REG_ALARM               0x5
  66 #define ALARM_LDO1              BIT(0)
  67 #define ALARM_DCDC1             BIT(1)
  68 #define ALARM_DCDC2             BIT(2)
  69 #define ALARM_DCDC3             BIT(3)
  70 #define ALARM_LDO2              BIT(4)
  71 #define ALARM_USB_WARN          BIT(5)
  72 #define ALARM_USB_ALARM         BIT(6)
  73 #define ALARM_LCD               BIT(9)
  74 #define ALARM_TEMP_WARM         BIT(10)
  75 #define ALARM_TEMP_HOT          BIT(11)
  76 #define ALARM_NRST              BIT(14)
  77 #define ALARM_POWERUP           BIT(15)
  78
  79 #define REG_INT_ENABLE          0x6
  80 #define INT_LDO1                BIT(0)
  81 #define INT_DCDC1               BIT(1)
  82 #define INT_DCDC2               BIT(2)
  83 #define INT_DCDC3               BIT(3)
  84 #define INT_LDO2                BIT(4)
  85 #define INT_USB_WARN            BIT(5)
  86 #define INT_USB_ALARM           BIT(6)
  87 #define INT_LCD                 BIT(9)
  88 #define INT_TEMP_WARM           BIT(10)
  89 #define INT_TEMP_HOT            BIT(11)
  90 #define INT_GLOBAL_EN           BIT(15)
  91
  92 #define REG_INT_STATUS          0x7
  93 #define STATUS_LDO1             BIT(0)
  94 #define STATUS_DCDC1            BIT(1)
  95 #define STATUS_DCDC2            BIT(2)
  96 #define STATUS_DCDC3            BIT(3)
  97 #define STATUS_LDO2             BIT(4)
  98 #define STATUS_USB_WARN         BIT(5)
  99 #define STATUS_USB_ALARM        BIT(6)
 100 #define STATUS_LCD              BIT(9)
 101 #define STATUS_TEMP_WARM        BIT(10)
 102 #define STATUS_TEMP_HOT         BIT(11)
 103
 104 #define REG_SOFTWARE_RESET      0xb
 105 #define REG_WRITE_ENABLE        0xd
 106 #define REG_REV_ID              0xf
 107
 108 #define N_DCDC                  3
 109 #define N_LDO                   2
 110 #define N_SWITCH                2
 111 #define N_REGULATORS            (3 /* DCDC */ + \
 112                                  2 /* LDO */  + \
 113                                  2 /* switch */)
 114
 115 #define FIXED_ILIMSEL           BIT(0)
 116 #define FIXED_VOLTAGE           BIT(1)
 117
 118 #define CMD_READ(reg)           ((reg) << 6)
 119 #define CMD_WRITE(reg)          (BIT(5) | (reg) << 6)
 120 #define STAT_CLK                BIT(3)
 121 #define STAT_WRITE              BIT(2)
 122 #define STAT_INVALID            BIT(1)
 123 #define STAT_WP                 BIT(0)
 124
 125 struct field {
 126         int             reg;
 127         int             shift;
 128         int             mask;
 129 };
 130
 131 struct supply_info {
 132         const char      *name;
 133         int             n_voltages;
 134         const int       *voltages;
 135         int             fixed_voltage;
 136         int             n_ilimsels;
 137         const int       *ilimsels;
 138         int             fixed_ilimsel;
 139         int             flags;
 140         struct field    enable, voltage, ilimsel;
 141 };
 142
 143 struct tps6524x {
 144         struct device           *dev;
 145         struct spi_device       *spi;
 146         struct mutex            lock;
 147         struct regulator_desc   desc[N_REGULATORS];
 148         struct regulator_dev    *rdev[N_REGULATORS];
 149 };
 150
 151 static int __read_reg(struct tps6524x *hw, int reg)
 152 {
 153         int error = 0;
 154         u16 cmd = CMD_READ(reg), in;
 155         u8 status;
 156         struct spi_message m;
 157         struct spi_transfer t[3];
 158
 159         spi_message_init(&m);
 160         memset(t, 0, sizeof(t));
 161
 162         t[0].tx_buf = &cmd;
 163         t[0].len = 2;
 164         t[0].bits_per_word = 12;
 165         spi_message_add_tail(&t[0], &m);
 166
 167         t[1].rx_buf = &in;
 168         t[1].len = 2;
 169         t[1].bits_per_word = 16;
 170         spi_message_add_tail(&t[1], &m);
 171
 172         t[2].rx_buf = &status;
 173         t[2].len = 1;
 174         t[2].bits_per_word = 4;
 175         spi_message_add_tail(&t[2], &m);
 176
 177         error = spi_sync(hw->spi, &m);
 178         if (error < 0)
 179                 return error;
 180
 181         dev_dbg(hw->dev, "read reg %d, data %x, status %x\n",
 182                 reg, in, status);
 183
 184         if (!(status & STAT_CLK) || (status & STAT_WRITE))
 185                 return -EIO;
 186
 187         if (status & STAT_INVALID)
 188                 return -EINVAL;
 189
 190         return in;
 191 }
 192
 193 static int read_reg(struct tps6524x *hw, int reg)
 194 {
 195         int ret;
 196
 197         mutex_lock(&hw->lock);
 198         ret = __read_reg(hw, reg);
 199         mutex_unlock(&hw->lock);
 200
 201         return ret;
 202 }
 203
 204 static int __write_reg(struct tps6524x *hw, int reg, int val)
 205 {
 206         int error = 0;
 207         u16 cmd = CMD_WRITE(reg), out = val;
 208         u8 status;
 209         struct spi_message m;
 210         struct spi_transfer t[3];
 211
 212         spi_message_init(&m);
 213         memset(t, 0, sizeof(t));
 214
 215         t[0].tx_buf = &cmd;
 216         t[0].len = 2;
 217         t[0].bits_per_word = 12;
 218         spi_message_add_tail(&t[0], &m);
 219
 220         t[1].tx_buf = &out;
 221         t[1].len = 2;
 222         t[1].bits_per_word = 16;
 223         spi_message_add_tail(&t[1], &m);
 224
 225         t[2].rx_buf = &status;
 226         t[2].len = 1;
 227         t[2].bits_per_word = 4;
 228         spi_message_add_tail(&t[2], &m);
 229
 230         error = spi_sync(hw->spi, &m);
 231         if (error < 0)
 232                 return error;
 233
 234         dev_dbg(hw->dev, "wrote reg %d, data %x, status %x\n",
 235                 reg, out, status);
 236
 237         if (!(status & STAT_CLK) || !(status & STAT_WRITE))
 238                 return -EIO;
 239
 240         if (status & (STAT_INVALID | STAT_WP))
 241                 return -EINVAL;
 242
 243         return error;
 244 }
 245
 246 static int __rmw_reg(struct tps6524x *hw, int reg, int mask, int val)
 247 {
 248         int ret;
 249
 250         ret = __read_reg(hw, reg);
 251         if (ret < 0)
 252                 return ret;
 253
 254         ret &= ~mask;
 255         ret |= val;
 256
 257         ret = __write_reg(hw, reg, ret);
 258
 259         return (ret < 0) ? ret : 0;
 260 }
 261
 262 static int rmw_protect(struct tps6524x *hw, int reg, int mask, int val)
 263 {
 264         int ret;
 265
 266         mutex_lock(&hw->lock);
 267
 268         ret = __write_reg(hw, REG_WRITE_ENABLE, 1);
 269         if (ret) {
 270                 dev_err(hw->dev, "failed to set write enable\n");
 271                 goto error;
 272         }
 273
 274         ret = __rmw_reg(hw, reg, mask, val);
 275         if (ret)
 276                 dev_err(hw->dev, "failed to rmw register %d\n", reg);
 277
 278         ret = __write_reg(hw, REG_WRITE_ENABLE, 0);
 279         if (ret) {
 280                 dev_err(hw->dev, "failed to clear write enable\n");
 281                 goto error;
 282         }
 283
 284 error:
 285         mutex_unlock(&hw->lock);
 286
 287         return ret;
 288 }
 289
 290 static int read_field(struct tps6524x *hw, const struct field *field)
 291 {
 292         int tmp;
 293
 294         tmp = read_reg(hw, field->reg);
 295         if (tmp < 0)
 296                 return tmp;
 297
 298         return (tmp >> field->shift) & field->mask;
 299 }
 300
 301 static int write_field(struct tps6524x *hw, const struct field *field,
 302                        int val)
 303 {
 304         if (val & ~field->mask)
 305                 return -EOVERFLOW;
 306
 307         return rmw_protect(hw, field->reg,
 308                                     field->mask << field->shift,
 309                                     val << field->shift);
 310 }
 311
 312 static const int dcdc1_voltages[] = {
 313          800000,  825000,  850000,  875000,
 314          900000,  925000,  950000,  975000,
 315         1000000, 1025000, 1050000, 1075000,
 316         1100000, 1125000, 1150000, 1175000,
 317         1200000, 1225000, 1250000, 1275000,
 318         1300000, 1325000, 1350000, 1375000,
 319         1400000, 1425000, 1450000, 1475000,
 320         1500000, 1525000, 1550000, 1575000,
 321 };
 322
 323 static const int dcdc2_voltages[] = {
 324         1400000, 1450000, 1500000, 1550000,
 325         1600000, 1650000, 1700000, 1750000,
 326         1800000, 1850000, 1900000, 1950000,
 327         2000000, 2050000, 2100000, 2150000,
 328         2200000, 2250000, 2300000, 2350000,
 329         2400000, 2450000, 2500000, 2550000,
 330         2600000, 2650000, 2700000, 2750000,
 331         2800000, 2850000, 2900000, 2950000,
 332 };
 333
 334 static const int dcdc3_voltages[] = {
 335         2400000, 2450000, 2500000, 2550000, 2600000,
 336         2650000, 2700000, 2750000, 2800000, 2850000,
 337         2900000, 2950000, 3000000, 3050000, 3100000,
 338         3150000, 3200000, 3250000, 3300000, 3350000,
 339         3400000, 3450000, 3500000, 3550000, 3600000,
 340 };
 341
 342 static const int ldo1_voltages[] = {
 343         4300000, 4350000, 4400000, 4450000,
 344         4500000, 4550000, 4600000, 4650000,
 345         4700000, 4750000, 4800000, 4850000,
 346         4900000, 4950000, 5000000, 5050000,
 347 };
 348
 349 static const int ldo2_voltages[] = {
 350         1100000, 1150000, 1200000, 1250000,
 351         1300000, 1700000, 1750000, 1800000,
 352         1850000, 1900000, 3150000, 3200000,
 353         3250000, 3300000, 3350000, 3400000,
 354 };
 355
 356 static const int ldo_ilimsel[] = {
 357         400000, 1500000
 358 };
 359
 360 static const int usb_ilimsel[] = {
 361         200000, 400000, 800000, 1000000
 362 };
 363
 364 #define __MK_FIELD(_reg, _mask, _shift) \
 365         { .reg = (_reg), .mask = (_mask), .shift = (_shift), }
 366
 367 static const struct supply_info supply_info[N_REGULATORS] = {
 368         {
 369                 .name           = "DCDC1",
 370                 .flags          = FIXED_ILIMSEL,
 371                 .n_voltages     = ARRAY_SIZE(dcdc1_voltages),
 372                 .voltages       = dcdc1_voltages,
 373                 .fixed_ilimsel  = 2400000,
 374                 .enable         = __MK_FIELD(REG_DCDC_EN, DCDCDCDC_EN_MASK,
 375                                              DCDCDCDC1_EN_SHIFT),
 376                 .voltage        = __MK_FIELD(REG_DCDC_SET, DCDC_VDCDC_MASK,
 377                                              DCDC_VDCDC1_SHIFT),
 378         },
 379         {
 380                 .name           = "DCDC2",
 381                 .flags          = FIXED_ILIMSEL,
 382                 .n_voltages     = ARRAY_SIZE(dcdc2_voltages),
 383                 .voltages       = dcdc2_voltages,
 384                 .fixed_ilimsel  = 1200000,
 385                 .enable         = __MK_FIELD(REG_DCDC_EN, DCDCDCDC_EN_MASK,
 386                                              DCDCDCDC2_EN_SHIFT),
 387                 .voltage        = __MK_FIELD(REG_DCDC_SET, DCDC_VDCDC_MASK,
 388                                              DCDC_VDCDC2_SHIFT),
 389         },
 390         {
 391                 .name           = "DCDC3",
 392                 .flags          = FIXED_ILIMSEL,
 393                 .n_voltages     = ARRAY_SIZE(dcdc3_voltages),
 394                 .voltages       = dcdc3_voltages,
 395                 .fixed_ilimsel  = 1200000,
 396                 .enable         = __MK_FIELD(REG_DCDC_EN, DCDCDCDC_EN_MASK,
 397                                         DCDCDCDC3_EN_SHIFT),
 398                 .voltage        = __MK_FIELD(REG_DCDC_SET, DCDC_VDCDC_MASK,
 399                                              DCDC_VDCDC3_SHIFT),
 400         },
 401         {
 402                 .name           = "LDO1",
 403                 .n_voltages     = ARRAY_SIZE(ldo1_voltages),
 404                 .voltages       = ldo1_voltages,
 405                 .n_ilimsels     = ARRAY_SIZE(ldo_ilimsel),
 406                 .ilimsels       = ldo_ilimsel,
 407                 .enable         = __MK_FIELD(REG_BLOCK_EN, BLOCK_MASK,
 408                                              BLOCK_LDO1_SHIFT),
 409                 .voltage        = __MK_FIELD(REG_LDO_SET, LDO_VSEL_MASK,
 410                                              LDO1_VSEL_SHIFT),
 411                 .ilimsel        = __MK_FIELD(REG_LDO_SET, LDO_ILIM_MASK,
 412                                              LDO1_ILIM_SHIFT),
 413         },
 414         {
 415                 .name           = "LDO2",
 416                 .n_voltages     = ARRAY_SIZE(ldo2_voltages),
 417                 .voltages       = ldo2_voltages,
 418                 .n_ilimsels     = ARRAY_SIZE(ldo_ilimsel),
 419                 .ilimsels       = ldo_ilimsel,
 420                 .enable         = __MK_FIELD(REG_BLOCK_EN, BLOCK_MASK,
 421                                              BLOCK_LDO2_SHIFT),
 422                 .voltage        = __MK_FIELD(REG_LDO_SET, LDO_VSEL_MASK,
 423                                              LDO2_VSEL_SHIFT),
 424                 .ilimsel        = __MK_FIELD(REG_LDO_SET, LDO_ILIM_MASK,
 425                                              LDO2_ILIM_SHIFT),
 426         },
 427         {
 428                 .name           = "USB",
 429                 .flags          = FIXED_VOLTAGE,
 430                 .fixed_voltage  = 5000000,
 431                 .n_ilimsels     = ARRAY_SIZE(usb_ilimsel),
 432                 .ilimsels       = usb_ilimsel,
 433                 .enable         = __MK_FIELD(REG_BLOCK_EN, BLOCK_MASK,
 434                                              BLOCK_USB_SHIFT),
 435                 .ilimsel        = __MK_FIELD(REG_USB, USB_ILIM_MASK,
 436                                              USB_ILIM_SHIFT),
 437         },
 438         {
 439                 .name           = "LCD",
 440                 .flags          = FIXED_VOLTAGE | FIXED_ILIMSEL,
 441                 .fixed_voltage  = 5000000,
 442                 .fixed_ilimsel  =  400000,
 443                 .enable         = __MK_FIELD(REG_BLOCK_EN, BLOCK_MASK,
 444                                              BLOCK_LCD_SHIFT),
 445         },
 446 };
 447
 448 static int list_voltage(struct regulator_dev *rdev, unsigned selector)
 449 {
 450         const struct supply_info *info;
 451         struct tps6524x *hw;
 452
 453         hw      = rdev_get_drvdata(rdev);
 454         info    = &supply_info[rdev_get_id(rdev)];
 455
 456         if (info->flags & FIXED_VOLTAGE)
 457                 return selector ? -EINVAL : info->fixed_voltage;
 458
 459         return ((selector < info->n_voltages) ?
 460                 info->voltages[selector] : -EINVAL);
 461 }
 462
 463 static int set_voltage(struct regulator_dev *rdev, int min_uV, int max_uV,
 464                        unsigned *selector)
 465 {
 466         const struct supply_info *info;
 467         struct tps6524x *hw;
 468         unsigned i;
 469
 470         hw      = rdev_get_drvdata(rdev);
 471         info    = &supply_info[rdev_get_id(rdev)];
 472
 473         if (info->flags & FIXED_VOLTAGE)
 474                 return -EINVAL;
 475
 476         for (i = 0; i < info->n_voltages; i++)
 477                 if (min_uV <= info->voltages[i] &&
 478                     max_uV >= info->voltages[i])
 479                         break;
 480
 481         if (i >= info->n_voltages)
 482                 i = info->n_voltages - 1;
 483
 484         *selector = i;
 485
 486         return write_field(hw, &info->voltage, i);
 487 }
 488
 489 static int get_voltage(struct regulator_dev *rdev)
 490 {
 491         const struct supply_info *info;
 492         struct tps6524x *hw;
 493         int ret;
 494
 495         hw      = rdev_get_drvdata(rdev);
 496         info    = &supply_info[rdev_get_id(rdev)];
 497
 498         if (info->flags & FIXED_VOLTAGE)
 499                 return info->fixed_voltage;
 500
 501         ret = read_field(hw, &info->voltage);
 502         if (ret < 0)
 503                 return ret;
 504         if (WARN_ON(ret >= info->n_voltages))
 505                 return -EIO;
 506
 507         return info->voltages[ret];
 508 }
 509
 510 static int set_current_limit(struct regulator_dev *rdev, int min_uA,
 511                              int max_uA)
 512 {
 513         const struct supply_info *info;
 514         struct tps6524x *hw;
 515         int i;
 516
 517         hw      = rdev_get_drvdata(rdev);
 518         info    = &supply_info[rdev_get_id(rdev)];
 519
 520         if (info->flags & FIXED_ILIMSEL)
 521                 return -EINVAL;
 522
 523         for (i = 0; i < info->n_ilimsels; i++)
 524                 if (min_uA <= info->ilimsels[i] &&
 525                     max_uA >= info->ilimsels[i])
 526                         break;
 527
 528         if (i >= info->n_ilimsels)
 529                 return -EINVAL;
 530
 531         return write_field(hw, &info->ilimsel, i);
 532 }
 533
 534 static int get_current_limit(struct regulator_dev *rdev)
 535 {
 536         const struct supply_info *info;
 537         struct tps6524x *hw;
 538         int ret;
 539
 540         hw      = rdev_get_drvdata(rdev);
 541         info    = &supply_info[rdev_get_id(rdev)];
 542
 543         if (info->flags & FIXED_ILIMSEL)
 544                 return info->fixed_ilimsel;
 545
 546         ret = read_field(hw, &info->ilimsel);
 547         if (ret < 0)
 548                 return ret;
 549         if (WARN_ON(ret >= info->n_ilimsels))
 550                 return -EIO;
 551
 552         return info->ilimsels[ret];
 553 }
 554
 555 static int enable_supply(struct regulator_dev *rdev)
 556 {
 557         const struct supply_info *info;
 558         struct tps6524x *hw;
 559
 560         hw      = rdev_get_drvdata(rdev);
 561         info    = &supply_info[rdev_get_id(rdev)];
 562
 563         return write_field(hw, &info->enable, 1);
 564 }
 565
 566 static int disable_supply(struct regulator_dev *rdev)
 567 {
 568         const struct supply_info *info;
 569         struct tps6524x *hw;
 570
 571         hw      = rdev_get_drvdata(rdev);
 572         info    = &supply_info[rdev_get_id(rdev)];
 573
 574         return write_field(hw, &info->enable, 0);
 575 }
 576
 577 static int is_supply_enabled(struct regulator_dev *rdev)
 578 {
 579         const struct supply_info *info;
 580         struct tps6524x *hw;
 581
 582         hw      = rdev_get_drvdata(rdev);
 583         info    = &supply_info[rdev_get_id(rdev)];
 584
 585         return read_field(hw, &info->enable);
 586 }
 587
 588 static struct regulator_ops regulator_ops = {
 589         .is_enabled             = is_supply_enabled,
 590         .enable                 = enable_supply,
 591         .disable                = disable_supply,
 592         .get_voltage            = get_voltage,
 593         .set_voltage            = set_voltage,
 594         .list_voltage           = list_voltage,
 595         .set_current_limit      = set_current_limit,
 596         .get_current_limit      = get_current_limit,
 597 };
 598
 599 static int pmic_remove(struct spi_device *spi)
 600 {
 601         struct tps6524x *hw = spi_get_drvdata(spi);
 602         int i;
 603
 604         if (!hw)
 605                 return 0;
 606         for (i = 0; i < N_REGULATORS; i++) {
 607                 if (hw->rdev[i])
 608                         regulator_unregister(hw->rdev[i]);
 609                 hw->rdev[i] = NULL;
 610         }
 611         spi_set_drvdata(spi, NULL);
 612         kfree(hw);
 613         return 0;
 614 }
 615
 616 static int __devinit pmic_probe(struct spi_device *spi)
 617 {
 618         struct tps6524x *hw;
 619         struct device *dev = &spi->dev;
 620         const struct supply_info *info = supply_info;
 621         struct regulator_init_data *init_data;
 622         int ret = 0, i;
 623
 624         init_data = dev->platform_data;
 625         if (!init_data) {
 626                 dev_err(dev, "could not find regulator platform data\n");
 627                 return -EINVAL;
 628         }
 629
 630         hw = kzalloc(sizeof(struct tps6524x), GFP_KERNEL);
 631         if (!hw) {
 632                 dev_err(dev, "cannot allocate regulator private data\n");
 633                 return -ENOMEM;
 634         }
 635         spi_set_drvdata(spi, hw);
 636
 637         memset(hw, 0, sizeof(struct tps6524x));
 638         hw->dev = dev;
 639         hw->spi = spi_dev_get(spi);
 640         mutex_init(&hw->lock);
 641
 642         for (i = 0; i < N_REGULATORS; i++, info++, init_data++) {
 643                 hw->desc[i].name        = info->name;
 644                 hw->desc[i].id          = i;
 645                 hw->desc[i].n_voltages  = info->n_voltages;
 646                 hw->desc[i].ops         = &regulator_ops;
 647                 hw->desc[i].type        = REGULATOR_VOLTAGE;
 648                 hw->desc[i].owner       = THIS_MODULE;
 649
 650                 if (info->flags & FIXED_VOLTAGE)
 651                         hw->desc[i].n_voltages = 1;
 652
 653                 hw->rdev[i] = regulator_register(&hw->desc[i], dev,
 654                                                  init_data, hw);
 655                 if (IS_ERR(hw->rdev[i])) {
 656                         ret = PTR_ERR(hw->rdev[i]);
 657                         hw->rdev[i] = NULL;
 658                         goto fail;
 659                 }
 660         }
 661
 662         return 0;
 663
 664 fail:
 665         pmic_remove(spi);
 666         return ret;
 667 }
 668
 669 static struct spi_driver pmic_driver = {
 670         .probe          = pmic_probe,
 671         .remove         = __devexit_p(pmic_remove),
 672         .driver         = {
 673                 .name   = "tps6524x",
 674                 .owner  = THIS_MODULE,
 675         },
 676 };
 677
 678 static int __init pmic_driver_init(void)
 679 {
 680         return spi_register_driver(&pmic_driver);
 681 }
 682 module_init(pmic_driver_init);
 683
 684 static void __exit pmic_driver_exit(void)
 685 {
 686         spi_unregister_driver(&pmic_driver);
 687 }
 688 module_exit(pmic_driver_exit);
 689
 690 MODULE_DESCRIPTION("TPS6524X PMIC Driver");
 691 MODULE_AUTHOR("Cyril Chemparathy");
 692 MODULE_LICENSE("GPL");
 693 MODULE_ALIAS("spi:tps6524x");