drivers/regulator/tps65023-regulator.c

   1 /*
   2  * tps65023-regulator.c
   3  *
   4  * Supports TPS65023 Regulator
   5  *
   6  * Copyright (C) 2009 Texas Instrument Incorporated - http://www.ti.com/
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License as
  10  * published by the Free Software Foundation version 2.
  11  *
  12  * This program is distributed "as is" WITHOUT ANY WARRANTY of any kind,
  13  * whether express or implied; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License for more details.
  16  */
  17
  18 #include <linux/kernel.h>
  19 #include <linux/module.h>
  20 #include <linux/init.h>
  21 #include <linux/err.h>
  22 #include <linux/platform_device.h>
  23 #include <linux/regulator/driver.h>
  24 #include <linux/regulator/machine.h>
  25 #include <linux/i2c.h>
  26 #include <linux/delay.h>
  27 #include <linux/slab.h>
  28 #include <linux/regmap.h>
  29
  30 /* Register definitions */
  31 #define TPS65023_REG_VERSION            0
  32 #define TPS65023_REG_PGOODZ             1
  33 #define TPS65023_REG_MASK               2
  34 #define TPS65023_REG_REG_CTRL           3
  35 #define TPS65023_REG_CON_CTRL           4
  36 #define TPS65023_REG_CON_CTRL2          5
  37 #define TPS65023_REG_DEF_CORE           6
  38 #define TPS65023_REG_DEFSLEW            7
  39 #define TPS65023_REG_LDO_CTRL           8
  40
  41 /* PGOODZ bitfields */
  42 #define TPS65023_PGOODZ_PWRFAILZ        BIT(7)
  43 #define TPS65023_PGOODZ_LOWBATTZ        BIT(6)
  44 #define TPS65023_PGOODZ_VDCDC1          BIT(5)
  45 #define TPS65023_PGOODZ_VDCDC2          BIT(4)
  46 #define TPS65023_PGOODZ_VDCDC3          BIT(3)
  47 #define TPS65023_PGOODZ_LDO2            BIT(2)
  48 #define TPS65023_PGOODZ_LDO1            BIT(1)
  49
  50 /* MASK bitfields */
  51 #define TPS65023_MASK_PWRFAILZ          BIT(7)
  52 #define TPS65023_MASK_LOWBATTZ          BIT(6)
  53 #define TPS65023_MASK_VDCDC1            BIT(5)
  54 #define TPS65023_MASK_VDCDC2            BIT(4)
  55 #define TPS65023_MASK_VDCDC3            BIT(3)
  56 #define TPS65023_MASK_LDO2              BIT(2)
  57 #define TPS65023_MASK_LDO1              BIT(1)
  58
  59 /* REG_CTRL bitfields */
  60 #define TPS65023_REG_CTRL_VDCDC1_EN     BIT(5)
  61 #define TPS65023_REG_CTRL_VDCDC2_EN     BIT(4)
  62 #define TPS65023_REG_CTRL_VDCDC3_EN     BIT(3)
  63 #define TPS65023_REG_CTRL_LDO2_EN       BIT(2)
  64 #define TPS65023_REG_CTRL_LDO1_EN       BIT(1)
  65
  66 /* REG_CTRL2 bitfields */
  67 #define TPS65023_REG_CTRL2_GO           BIT(7)
  68 #define TPS65023_REG_CTRL2_CORE_ADJ     BIT(6)
  69 #define TPS65023_REG_CTRL2_DCDC2        BIT(2)
  70 #define TPS65023_REG_CTRL2_DCDC1        BIT(1)
  71 #define TPS65023_REG_CTRL2_DCDC3        BIT(0)
  72
  73 /* LDO_CTRL bitfields */
  74 #define TPS65023_LDO_CTRL_LDOx_SHIFT(ldo_id)    ((ldo_id)*4)
  75 #define TPS65023_LDO_CTRL_LDOx_MASK(ldo_id)     (0xF0 >> ((ldo_id)*4))
  76
  77 /* Number of step-down converters available */
  78 #define TPS65023_NUM_DCDC               3
  79 /* Number of LDO voltage regulators  available */
  80 #define TPS65023_NUM_LDO                2
  81 /* Number of total regulators available */
  82 #define TPS65023_NUM_REGULATOR  (TPS65023_NUM_DCDC + TPS65023_NUM_LDO)
  83
  84 /* DCDCs */
  85 #define TPS65023_DCDC_1                 0
  86 #define TPS65023_DCDC_2                 1
  87 #define TPS65023_DCDC_3                 2
  88 /* LDOs */
  89 #define TPS65023_LDO_1                  3
  90 #define TPS65023_LDO_2                  4
  91
  92 #define TPS65023_MAX_REG_ID             TPS65023_LDO_2
  93
  94 /* Supported voltage values for regulators */
  95 static const u16 VCORE_VSEL_table[] = {
  96         800, 825, 850, 875,
  97         900, 925, 950, 975,
  98         1000, 1025, 1050, 1075,
  99         1100, 1125, 1150, 1175,
 100         1200, 1225, 1250, 1275,
 101         1300, 1325, 1350, 1375,
 102         1400, 1425, 1450, 1475,
 103         1500, 1525, 1550, 1600,
 104 };
 105
 106 /* Supported voltage values for LDO regulators for tps65020 */
 107 static const u16 TPS65020_LDO1_VSEL_table[] = {
 108         1000, 1050, 1100, 1300,
 109         1800, 2500, 3000, 3300,
 110 };
 111
 112 static const u16 TPS65020_LDO2_VSEL_table[] = {
 113         1000, 1050, 1100, 1300,
 114         1800, 2500, 3000, 3300,
 115 };
 116
 117 /* Supported voltage values for LDO regulators
 118  * for tps65021 and tps65023 */
 119 static const u16 TPS65023_LDO1_VSEL_table[] = {
 120         1000, 1100, 1300, 1800,
 121         2200, 2600, 2800, 3150,
 122 };
 123
 124 static const u16 TPS65023_LDO2_VSEL_table[] = {
 125         1050, 1200, 1300, 1800,
 126         2500, 2800, 3000, 3300,
 127 };
 128
 129 /* Regulator specific details */
 130 struct tps_info {
 131         const char *name;
 132         unsigned min_uV;
 133         unsigned max_uV;
 134         bool fixed;
 135         u8 table_len;
 136         const u16 *table;
 137 };
 138
 139 /* PMIC details */
 140 struct tps_pmic {
 141         struct regulator_desc desc[TPS65023_NUM_REGULATOR];
 142         struct i2c_client *client;
 143         struct regulator_dev *rdev[TPS65023_NUM_REGULATOR];
 144         const struct tps_info *info[TPS65023_NUM_REGULATOR];
 145         struct regmap *regmap;
 146         u8 core_regulator;
 147 };
 148
 149 /* Struct passed as driver data */
 150 struct tps_driver_data {
 151         const struct tps_info *info;
 152         u8 core_regulator;
 153 };
 154
 155 static int tps_65023_set_bits(struct tps_pmic *tps, u8 reg, u8 mask)
 156 {
 157         return regmap_update_bits(tps->regmap, reg, mask, mask);
 158 }
 159
 160 static int tps_65023_clear_bits(struct tps_pmic *tps, u8 reg, u8 mask)
 161 {
 162         return regmap_update_bits(tps->regmap, reg, mask, 0);
 163 }
 164
 165 static int tps_65023_reg_read(struct tps_pmic *tps, u8 reg)
 166 {
 167         unsigned int val;
 168         int ret;
 169
 170         ret = regmap_read(tps->regmap, reg, &val);
 171
 172         if (ret != 0)
 173                 return ret;
 174         else
 175                 return val;
 176 }
 177
 178 static int tps_65023_reg_write(struct tps_pmic *tps, u8 reg, u8 val)
 179 {
 180         return regmap_write(tps->regmap, reg, val);
 181 }
 182
 183 static int tps65023_dcdc_is_enabled(struct regulator_dev *dev)
 184 {
 185         struct tps_pmic *tps = rdev_get_drvdata(dev);
 186         int data, dcdc = rdev_get_id(dev);
 187         u8 shift;
 188
 189         if (dcdc < TPS65023_DCDC_1 || dcdc > TPS65023_DCDC_3)
 190                 return -EINVAL;
 191
 192         shift = TPS65023_NUM_REGULATOR - dcdc;
 193         data = tps_65023_reg_read(tps, TPS65023_REG_REG_CTRL);
 194
 195         if (data < 0)
 196                 return data;
 197         else
 198                 return (data & 1<<shift) ? 1 : 0;
 199 }
 200
 201 static int tps65023_ldo_is_enabled(struct regulator_dev *dev)
 202 {
 203         struct tps_pmic *tps = rdev_get_drvdata(dev);
 204         int data, ldo = rdev_get_id(dev);
 205         u8 shift;
 206
 207         if (ldo < TPS65023_LDO_1 || ldo > TPS65023_LDO_2)
 208                 return -EINVAL;
 209
 210         shift = (ldo == TPS65023_LDO_1 ? 1 : 2);
 211         data = tps_65023_reg_read(tps, TPS65023_REG_REG_CTRL);
 212
 213         if (data < 0)
 214                 return data;
 215         else
 216                 return (data & 1<<shift) ? 1 : 0;
 217 }
 218
 219 static int tps65023_dcdc_enable(struct regulator_dev *dev)
 220 {
 221         struct tps_pmic *tps = rdev_get_drvdata(dev);
 222         int dcdc = rdev_get_id(dev);
 223         u8 shift;
 224
 225         if (dcdc < TPS65023_DCDC_1 || dcdc > TPS65023_DCDC_3)
 226                 return -EINVAL;
 227
 228         shift = TPS65023_NUM_REGULATOR - dcdc;
 229         return tps_65023_set_bits(tps, TPS65023_REG_REG_CTRL, 1 << shift);
 230 }
 231
 232 static int tps65023_dcdc_disable(struct regulator_dev *dev)
 233 {
 234         struct tps_pmic *tps = rdev_get_drvdata(dev);
 235         int dcdc = rdev_get_id(dev);
 236         u8 shift;
 237
 238         if (dcdc < TPS65023_DCDC_1 || dcdc > TPS65023_DCDC_3)
 239                 return -EINVAL;
 240
 241         shift = TPS65023_NUM_REGULATOR - dcdc;
 242         return tps_65023_clear_bits(tps, TPS65023_REG_REG_CTRL, 1 << shift);
 243 }
 244
 245 static int tps65023_ldo_enable(struct regulator_dev *dev)
 246 {
 247         struct tps_pmic *tps = rdev_get_drvdata(dev);
 248         int ldo = rdev_get_id(dev);
 249         u8 shift;
 250
 251         if (ldo < TPS65023_LDO_1 || ldo > TPS65023_LDO_2)
 252                 return -EINVAL;
 253
 254         shift = (ldo == TPS65023_LDO_1 ? 1 : 2);
 255         return tps_65023_set_bits(tps, TPS65023_REG_REG_CTRL, 1 << shift);
 256 }
 257
 258 static int tps65023_ldo_disable(struct regulator_dev *dev)
 259 {
 260         struct tps_pmic *tps = rdev_get_drvdata(dev);
 261         int ldo = rdev_get_id(dev);
 262         u8 shift;
 263
 264         if (ldo < TPS65023_LDO_1 || ldo > TPS65023_LDO_2)
 265                 return -EINVAL;
 266
 267         shift = (ldo == TPS65023_LDO_1 ? 1 : 2);
 268         return tps_65023_clear_bits(tps, TPS65023_REG_REG_CTRL, 1 << shift);
 269 }
 270
 271 static int tps65023_dcdc_get_voltage(struct regulator_dev *dev)
 272 {
 273         struct tps_pmic *tps = rdev_get_drvdata(dev);
 274         int data, dcdc = rdev_get_id(dev);
 275
 276         if (dcdc < TPS65023_DCDC_1 || dcdc > TPS65023_DCDC_3)
 277                 return -EINVAL;
 278
 279         if (dcdc == tps->core_regulator) {
 280                 data = tps_65023_reg_read(tps, TPS65023_REG_DEF_CORE);
 281                 if (data < 0)
 282                         return data;
 283                 data &= (tps->info[dcdc]->table_len - 1);
 284                 return tps->info[dcdc]->table[data] * 1000;
 285         } else
 286                 return tps->info[dcdc]->min_uV;
 287 }
 288
 289 static int tps65023_dcdc_set_voltage(struct regulator_dev *dev,
 290                                      int min_uV, int max_uV,
 291                                      unsigned *selector)
 292 {
 293         struct tps_pmic *tps = rdev_get_drvdata(dev);
 294         int dcdc = rdev_get_id(dev);
 295         int vsel;
 296         int ret;
 297
 298         if (dcdc != tps->core_regulator)
 299                 return -EINVAL;
 300         if (min_uV < tps->info[dcdc]->min_uV
 301                         || min_uV > tps->info[dcdc]->max_uV)
 302                 return -EINVAL;
 303         if (max_uV < tps->info[dcdc]->min_uV
 304                         || max_uV > tps->info[dcdc]->max_uV)
 305                 return -EINVAL;
 306
 307         for (vsel = 0; vsel < tps->info[dcdc]->table_len; vsel++) {
 308                 int mV = tps->info[dcdc]->table[vsel];
 309                 int uV = mV * 1000;
 310
 311                 /* Break at the first in-range value */
 312                 if (min_uV <= uV && uV <= max_uV)
 313                         break;
 314         }
 315
 316         *selector = vsel;
 317
 318         if (vsel == tps->info[dcdc]->table_len)
 319                 goto failed;
 320
 321         ret = tps_65023_reg_write(tps, TPS65023_REG_DEF_CORE, vsel);
 322
 323         /* Tell the chip that we have changed the value in DEFCORE
 324          * and its time to update the core voltage
 325          */
 326         tps_65023_set_bits(tps, TPS65023_REG_CON_CTRL2,
 327                                                 TPS65023_REG_CTRL2_GO);
 328
 329         return ret;
 330
 331 failed:
 332         return -EINVAL;
 333 }
 334
 335 static int tps65023_ldo_get_voltage(struct regulator_dev *dev)
 336 {
 337         struct tps_pmic *tps = rdev_get_drvdata(dev);
 338         int data, ldo = rdev_get_id(dev);
 339
 340         if (ldo < TPS65023_LDO_1 || ldo > TPS65023_LDO_2)
 341                 return -EINVAL;
 342
 343         data = tps_65023_reg_read(tps, TPS65023_REG_LDO_CTRL);
 344         if (data < 0)
 345                 return data;
 346
 347         data >>= (TPS65023_LDO_CTRL_LDOx_SHIFT(ldo - TPS65023_LDO_1));
 348         data &= (tps->info[ldo]->table_len - 1);
 349         return tps->info[ldo]->table[data] * 1000;
 350 }
 351
 352 static int tps65023_ldo_set_voltage(struct regulator_dev *dev,
 353                                     int min_uV, int max_uV, unsigned *selector)
 354 {
 355         struct tps_pmic *tps = rdev_get_drvdata(dev);
 356         int data, vsel, ldo = rdev_get_id(dev);
 357
 358         if (ldo < TPS65023_LDO_1 || ldo > TPS65023_LDO_2)
 359                 return -EINVAL;
 360
 361         if (min_uV < tps->info[ldo]->min_uV || min_uV > tps->info[ldo]->max_uV)
 362                 return -EINVAL;
 363         if (max_uV < tps->info[ldo]->min_uV || max_uV > tps->info[ldo]->max_uV)
 364                 return -EINVAL;
 365
 366         for (vsel = 0; vsel < tps->info[ldo]->table_len; vsel++) {
 367                 int mV = tps->info[ldo]->table[vsel];
 368                 int uV = mV * 1000;
 369
 370                 /* Break at the first in-range value */
 371                 if (min_uV <= uV && uV <= max_uV)
 372                         break;
 373         }
 374
 375         if (vsel == tps->info[ldo]->table_len)
 376                 return -EINVAL;
 377
 378         *selector = vsel;
 379
 380         data = tps_65023_reg_read(tps, TPS65023_REG_LDO_CTRL);
 381         if (data < 0)
 382                 return data;
 383
 384         data &= TPS65023_LDO_CTRL_LDOx_MASK(ldo - TPS65023_LDO_1);
 385         data |= (vsel << (TPS65023_LDO_CTRL_LDOx_SHIFT(ldo - TPS65023_LDO_1)));
 386         return tps_65023_reg_write(tps, TPS65023_REG_LDO_CTRL, data);
 387 }
 388
 389 static int tps65023_dcdc_list_voltage(struct regulator_dev *dev,
 390                                         unsigned selector)
 391 {
 392         struct tps_pmic *tps = rdev_get_drvdata(dev);
 393         int dcdc = rdev_get_id(dev);
 394
 395         if (dcdc < TPS65023_DCDC_1 || dcdc > TPS65023_DCDC_3)
 396                 return -EINVAL;
 397
 398         if (dcdc == tps->core_regulator) {
 399                 if (selector >= tps->info[dcdc]->table_len)
 400                         return -EINVAL;
 401                 else
 402                         return tps->info[dcdc]->table[selector] * 1000;
 403         } else
 404                 return tps->info[dcdc]->min_uV;
 405 }
 406
 407 static int tps65023_ldo_list_voltage(struct regulator_dev *dev,
 408                                         unsigned selector)
 409 {
 410         struct tps_pmic *tps = rdev_get_drvdata(dev);
 411         int ldo = rdev_get_id(dev);
 412
 413         if (ldo < TPS65023_LDO_1 || ldo > TPS65023_LDO_2)
 414                 return -EINVAL;
 415
 416         if (selector >= tps->info[ldo]->table_len)
 417                 return -EINVAL;
 418         else
 419                 return tps->info[ldo]->table[selector] * 1000;
 420 }
 421
 422 /* Operations permitted on VDCDCx */
 423 static struct regulator_ops tps65023_dcdc_ops = {
 424         .is_enabled = tps65023_dcdc_is_enabled,
 425         .enable = tps65023_dcdc_enable,
 426         .disable = tps65023_dcdc_disable,
 427         .get_voltage = tps65023_dcdc_get_voltage,
 428         .set_voltage = tps65023_dcdc_set_voltage,
 429         .list_voltage = tps65023_dcdc_list_voltage,
 430 };
 431
 432 /* Operations permitted on LDOx */
 433 static struct regulator_ops tps65023_ldo_ops = {
 434         .is_enabled = tps65023_ldo_is_enabled,
 435         .enable = tps65023_ldo_enable,
 436         .disable = tps65023_ldo_disable,
 437         .get_voltage = tps65023_ldo_get_voltage,
 438         .set_voltage = tps65023_ldo_set_voltage,
 439         .list_voltage = tps65023_ldo_list_voltage,
 440 };
 441
 442 static struct regmap_config tps65023_regmap_config = {
 443         .reg_bits = 8,
 444         .val_bits = 8,
 445 };
 446
 447 static int __devinit tps_65023_probe(struct i2c_client *client,
 448                                      const struct i2c_device_id *id)
 449 {
 450         const struct tps_driver_data *drv_data = (void *)id->driver_data;
 451         const struct tps_info *info = drv_data->info;
 452         struct regulator_init_data *init_data;
 453         struct regulator_dev *rdev;
 454         struct tps_pmic *tps;
 455         int i;
 456         int error;
 457
 458         if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
 459                 return -EIO;
 460
 461         /**
 462          * init_data points to array of regulator_init structures
 463          * coming from the board-evm file.
 464          */
 465         init_data = client->dev.platform_data;
 466         if (!init_data)
 467                 return -EIO;
 468
 469         tps = kzalloc(sizeof(*tps), GFP_KERNEL);
 470         if (!tps)
 471                 return -ENOMEM;
 472
 473         tps->regmap = regmap_init_i2c(client, &tps65023_regmap_config);
 474         if (IS_ERR(tps->regmap)) {
 475                 error = PTR_ERR(tps->regmap);
 476                 dev_err(&client->dev, "Failed to allocate register map: %d\n",
 477                         error);
 478                 goto fail_alloc;
 479         }
 480
 481         /* common for all regulators */
 482         tps->client = client;
 483         tps->core_regulator = drv_data->core_regulator;
 484
 485         for (i = 0; i < TPS65023_NUM_REGULATOR; i++, info++, init_data++) {
 486                 /* Store regulator specific information */
 487                 tps->info[i] = info;
 488
 489                 tps->desc[i].name = info->name;
 490                 tps->desc[i].id = i;
 491                 tps->desc[i].n_voltages = info->table_len;
 492                 tps->desc[i].ops = (i > TPS65023_DCDC_3 ?
 493                                         &tps65023_ldo_ops : &tps65023_dcdc_ops);
 494                 tps->desc[i].type = REGULATOR_VOLTAGE;
 495                 tps->desc[i].owner = THIS_MODULE;
 496
 497                 /* Register the regulators */
 498                 rdev = regulator_register(&tps->desc[i], &client->dev,
 499                                           init_data, tps);
 500                 if (IS_ERR(rdev)) {
 501                         dev_err(&client->dev, "failed to register %s\n",
 502                                 id->name);
 503                         error = PTR_ERR(rdev);
 504                         goto fail;
 505                 }
 506
 507                 /* Save regulator for cleanup */
 508                 tps->rdev[i] = rdev;
 509         }
 510
 511         i2c_set_clientdata(client, tps);
 512
 513         /* Enable setting output voltage by I2C */
 514         tps_65023_clear_bits(tps, TPS65023_REG_CON_CTRL2,
 515                                                 TPS65023_REG_CTRL2_CORE_ADJ);
 516
 517         /* Enable setting output voltage by I2C */
 518         tps_65023_clear_bits(tps, TPS65023_REG_CON_CTRL2,
 519                                                 TPS65023_REG_CTRL2_CORE_ADJ);
 520
 521         return 0;
 522
 523  fail:
 524         while (--i >= 0)
 525                 regulator_unregister(tps->rdev[i]);
 526
 527         regmap_exit(tps->regmap);
 528  fail_alloc:
 529         kfree(tps);
 530         return error;
 531 }
 532
 533 /**
 534  * tps_65023_remove - TPS65023 driver i2c remove handler
 535  * @client: i2c driver client device structure
 536  *
 537  * Unregister TPS driver as an i2c client device driver
 538  */
 539 static int __devexit tps_65023_remove(struct i2c_client *client)
 540 {
 541         struct tps_pmic *tps = i2c_get_clientdata(client);
 542         int i;
 543
 544         for (i = 0; i < TPS65023_NUM_REGULATOR; i++)
 545                 regulator_unregister(tps->rdev[i]);
 546
 547         regmap_exit(tps->regmap);
 548         kfree(tps);
 549
 550         return 0;
 551 }
 552
 553 static const struct tps_info tps65020_regs[] = {
 554         {
 555                 .name = "VDCDC1",
 556                 .min_uV = 3300000,
 557                 .max_uV = 3300000,
 558                 .fixed  = 1,
 559         },
 560         {
 561                 .name = "VDCDC2",
 562                 .min_uV =  1800000,
 563                 .max_uV = 1800000,
 564                 .fixed = 1,
 565         },
 566         {
 567                 .name = "VDCDC3",
 568                 .min_uV =  800000,
 569                 .max_uV = 1600000,
 570                 .table_len = ARRAY_SIZE(VCORE_VSEL_table),
 571                 .table = VCORE_VSEL_table,
 572         },
 573
 574         {
 575                 .name = "LDO1",
 576                 .min_uV = 1000000,
 577                 .max_uV = 3150000,
 578                 .table_len = ARRAY_SIZE(TPS65020_LDO1_VSEL_table),
 579                 .table = TPS65020_LDO1_VSEL_table,
 580         },
 581         {
 582                 .name = "LDO2",
 583                 .min_uV = 1050000,
 584                 .max_uV = 3300000,
 585                 .table_len = ARRAY_SIZE(TPS65020_LDO2_VSEL_table),
 586                 .table = TPS65020_LDO2_VSEL_table,
 587         },
 588 };
 589
 590 static const struct tps_info tps65021_regs[] = {
 591         {
 592                 .name = "VDCDC1",
 593                 .min_uV =  3300000,
 594                 .max_uV = 3300000,
 595                 .fixed = 1,
 596         },
 597         {
 598                 .name = "VDCDC2",
 599                 .min_uV =  1800000,
 600                 .max_uV = 1800000,
 601                 .fixed = 1,
 602         },
 603         {
 604                 .name = "VDCDC3",
 605                 .min_uV =  800000,
 606                 .max_uV = 1600000,
 607                 .table_len = ARRAY_SIZE(VCORE_VSEL_table),
 608                 .table = VCORE_VSEL_table,
 609         },
 610         {
 611                 .name = "LDO1",
 612                 .min_uV = 1000000,
 613                 .max_uV = 3150000,
 614                 .table_len = ARRAY_SIZE(TPS65023_LDO1_VSEL_table),
 615                 .table = TPS65023_LDO1_VSEL_table,
 616         },
 617         {
 618                 .name = "LDO2",
 619                 .min_uV = 1050000,
 620                 .max_uV = 3300000,
 621                 .table_len = ARRAY_SIZE(TPS65023_LDO2_VSEL_table),
 622                 .table = TPS65023_LDO2_VSEL_table,
 623         },
 624 };
 625
 626 static const struct tps_info tps65023_regs[] = {
 627         {
 628                 .name = "VDCDC1",
 629                 .min_uV =  800000,
 630                 .max_uV = 1600000,
 631                 .table_len = ARRAY_SIZE(VCORE_VSEL_table),
 632                 .table = VCORE_VSEL_table,
 633         },
 634         {
 635                 .name = "VDCDC2",
 636                 .min_uV =  3300000,
 637                 .max_uV = 3300000,
 638                 .fixed = 1,
 639         },
 640         {
 641                 .name = "VDCDC3",
 642                 .min_uV =  1800000,
 643                 .max_uV = 1800000,
 644                 .fixed = 1,
 645         },
 646         {
 647                 .name = "LDO1",
 648                 .min_uV = 1000000,
 649                 .max_uV = 3150000,
 650                 .table_len = ARRAY_SIZE(TPS65023_LDO1_VSEL_table),
 651                 .table = TPS65023_LDO1_VSEL_table,
 652         },
 653         {
 654                 .name = "LDO2",
 655                 .min_uV = 1050000,
 656                 .max_uV = 3300000,
 657                 .table_len = ARRAY_SIZE(TPS65023_LDO2_VSEL_table),
 658                 .table = TPS65023_LDO2_VSEL_table,
 659         },
 660 };
 661
 662 static struct tps_driver_data tps65020_drv_data = {
 663         .info = tps65020_regs,
 664         .core_regulator = TPS65023_DCDC_3,
 665 };
 666
 667 static struct tps_driver_data tps65021_drv_data = {
 668                 .info = tps65021_regs,
 669                 .core_regulator = TPS65023_DCDC_3,
 670 };
 671
 672 static struct tps_driver_data tps65023_drv_data = {
 673                 .info = tps65023_regs,
 674                 .core_regulator = TPS65023_DCDC_1,
 675 };
 676
 677 static const struct i2c_device_id tps_65023_id[] = {
 678         {.name = "tps65023",
 679         .driver_data = (unsigned long) &tps65023_drv_data},
 680         {.name = "tps65021",
 681         .driver_data = (unsigned long) &tps65021_drv_data,},
 682         {.name = "tps65020",
 683         .driver_data = (unsigned long) &tps65020_drv_data},
 684         { },
 685 };
 686
 687 MODULE_DEVICE_TABLE(i2c, tps_65023_id);
 688
 689 static struct i2c_driver tps_65023_i2c_driver = {
 690         .driver = {
 691                 .name = "tps65023",
 692                 .owner = THIS_MODULE,
 693         },
 694         .probe = tps_65023_probe,
 695         .remove = __devexit_p(tps_65023_remove),
 696         .id_table = tps_65023_id,
 697 };
 698
 699 /**
 700  * tps_65023_init
 701  *
 702  * Module init function
 703  */
 704 static int __init tps_65023_init(void)
 705 {
 706         return i2c_add_driver(&tps_65023_i2c_driver);
 707 }
 708 subsys_initcall(tps_65023_init);
 709
 710 /**
 711  * tps_65023_cleanup
 712  *
 713  * Module exit function
 714  */
 715 static void __exit tps_65023_cleanup(void)
 716 {
 717         i2c_del_driver(&tps_65023_i2c_driver);
 718 }
 719 module_exit(tps_65023_cleanup);
 720
 721 MODULE_AUTHOR("Texas Instruments");
 722 MODULE_DESCRIPTION("TPS65023 voltage regulator driver");
 723 MODULE_LICENSE("GPL v2");