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 tps65023_dcdc_is_enabled(struct regulator_dev *dev)
 156 {
 157         struct tps_pmic *tps = rdev_get_drvdata(dev);
 158         int data, dcdc = rdev_get_id(dev);
 159         int ret;
 160         u8 shift;
 161
 162         if (dcdc < TPS65023_DCDC_1 || dcdc > TPS65023_DCDC_3)
 163                 return -EINVAL;
 164
 165         shift = TPS65023_NUM_REGULATOR - dcdc;
 166         ret = regmap_read(tps->regmap, TPS65023_REG_REG_CTRL, &data);
 167
 168         if (ret != 0)
 169                 return ret;
 170         else
 171                 return (data & 1<<shift) ? 1 : 0;
 172 }
 173
 174 static int tps65023_ldo_is_enabled(struct regulator_dev *dev)
 175 {
 176         struct tps_pmic *tps = rdev_get_drvdata(dev);
 177         int data, ldo = rdev_get_id(dev);
 178         int ret;
 179         u8 shift;
 180
 181         if (ldo < TPS65023_LDO_1 || ldo > TPS65023_LDO_2)
 182                 return -EINVAL;
 183
 184         shift = (ldo == TPS65023_LDO_1 ? 1 : 2);
 185         ret = regmap_read(tps->regmap, TPS65023_REG_REG_CTRL, &data);
 186
 187         if (ret != 0)
 188                 return ret;
 189         else
 190                 return (data & 1<<shift) ? 1 : 0;
 191 }
 192
 193 static int tps65023_dcdc_enable(struct regulator_dev *dev)
 194 {
 195         struct tps_pmic *tps = rdev_get_drvdata(dev);
 196         int dcdc = rdev_get_id(dev);
 197         u8 shift;
 198
 199         if (dcdc < TPS65023_DCDC_1 || dcdc > TPS65023_DCDC_3)
 200                 return -EINVAL;
 201
 202         shift = TPS65023_NUM_REGULATOR - dcdc;
 203         return regmap_update_bits(tps->regmap, TPS65023_REG_REG_CTRL, 1 << shift, 1 << shift);
 204 }
 205
 206 static int tps65023_dcdc_disable(struct regulator_dev *dev)
 207 {
 208         struct tps_pmic *tps = rdev_get_drvdata(dev);
 209         int dcdc = rdev_get_id(dev);
 210         u8 shift;
 211
 212         if (dcdc < TPS65023_DCDC_1 || dcdc > TPS65023_DCDC_3)
 213                 return -EINVAL;
 214
 215         shift = TPS65023_NUM_REGULATOR - dcdc;
 216         return regmap_update_bits(tps->regmap, TPS65023_REG_REG_CTRL, 1 << shift, 0);
 217 }
 218
 219 static int tps65023_ldo_enable(struct regulator_dev *dev)
 220 {
 221         struct tps_pmic *tps = rdev_get_drvdata(dev);
 222         int ldo = rdev_get_id(dev);
 223         u8 shift;
 224
 225         if (ldo < TPS65023_LDO_1 || ldo > TPS65023_LDO_2)
 226                 return -EINVAL;
 227
 228         shift = (ldo == TPS65023_LDO_1 ? 1 : 2);
 229         return regmap_update_bits(tps->regmap, TPS65023_REG_REG_CTRL, 1 << shift, 1 << shift);
 230 }
 231
 232 static int tps65023_ldo_disable(struct regulator_dev *dev)
 233 {
 234         struct tps_pmic *tps = rdev_get_drvdata(dev);
 235         int ldo = rdev_get_id(dev);
 236         u8 shift;
 237
 238         if (ldo < TPS65023_LDO_1 || ldo > TPS65023_LDO_2)
 239                 return -EINVAL;
 240
 241         shift = (ldo == TPS65023_LDO_1 ? 1 : 2);
 242         return regmap_update_bits(tps->regmap, TPS65023_REG_REG_CTRL, 1 << shift, 0);
 243 }
 244
 245 static int tps65023_dcdc_get_voltage(struct regulator_dev *dev)
 246 {
 247         struct tps_pmic *tps = rdev_get_drvdata(dev);
 248         int ret;
 249         int data, dcdc = rdev_get_id(dev);
 250
 251         if (dcdc < TPS65023_DCDC_1 || dcdc > TPS65023_DCDC_3)
 252                 return -EINVAL;
 253
 254         if (dcdc == tps->core_regulator) {
 255                 ret = regmap_read(tps->regmap, TPS65023_REG_DEF_CORE, &data);
 256                 if (ret != 0)
 257                         return ret;
 258                 data &= (tps->info[dcdc]->table_len - 1);
 259                 return tps->info[dcdc]->table[data] * 1000;
 260         } else
 261                 return tps->info[dcdc]->min_uV;
 262 }
 263
 264 static int tps65023_dcdc_set_voltage(struct regulator_dev *dev,
 265                                      int min_uV, int max_uV,
 266                                      unsigned *selector)
 267 {
 268         struct tps_pmic *tps = rdev_get_drvdata(dev);
 269         int dcdc = rdev_get_id(dev);
 270         int vsel;
 271         int ret;
 272
 273         if (dcdc != tps->core_regulator)
 274                 return -EINVAL;
 275         if (min_uV < tps->info[dcdc]->min_uV
 276                         || min_uV > tps->info[dcdc]->max_uV)
 277                 return -EINVAL;
 278         if (max_uV < tps->info[dcdc]->min_uV
 279                         || max_uV > tps->info[dcdc]->max_uV)
 280                 return -EINVAL;
 281
 282         for (vsel = 0; vsel < tps->info[dcdc]->table_len; vsel++) {
 283                 int mV = tps->info[dcdc]->table[vsel];
 284                 int uV = mV * 1000;
 285
 286                 /* Break at the first in-range value */
 287                 if (min_uV <= uV && uV <= max_uV)
 288                         break;
 289         }
 290
 291         *selector = vsel;
 292
 293         if (vsel == tps->info[dcdc]->table_len)
 294                 goto failed;
 295
 296         ret = regmap_write(tps->regmap, TPS65023_REG_DEF_CORE, vsel);
 297
 298         /* Tell the chip that we have changed the value in DEFCORE
 299          * and its time to update the core voltage
 300          */
 301         regmap_update_bits(tps->regmap, TPS65023_REG_CON_CTRL2,
 302                         TPS65023_REG_CTRL2_GO, TPS65023_REG_CTRL2_GO);
 303
 304         return ret;
 305
 306 failed:
 307         return -EINVAL;
 308 }
 309
 310 static int tps65023_ldo_get_voltage(struct regulator_dev *dev)
 311 {
 312         struct tps_pmic *tps = rdev_get_drvdata(dev);
 313         int data, ldo = rdev_get_id(dev);
 314         int ret;
 315
 316         if (ldo < TPS65023_LDO_1 || ldo > TPS65023_LDO_2)
 317                 return -EINVAL;
 318
 319         ret = regmap_read(tps->regmap, TPS65023_REG_LDO_CTRL, &data);
 320         if (ret != 0)
 321                 return ret;
 322
 323         data >>= (TPS65023_LDO_CTRL_LDOx_SHIFT(ldo - TPS65023_LDO_1));
 324         data &= (tps->info[ldo]->table_len - 1);
 325         return tps->info[ldo]->table[data] * 1000;
 326 }
 327
 328 static int tps65023_ldo_set_voltage(struct regulator_dev *dev,
 329                                     int min_uV, int max_uV, unsigned *selector)
 330 {
 331         struct tps_pmic *tps = rdev_get_drvdata(dev);
 332         int data, vsel, ldo = rdev_get_id(dev);
 333         int ret;
 334
 335         if (ldo < TPS65023_LDO_1 || ldo > TPS65023_LDO_2)
 336                 return -EINVAL;
 337
 338         if (min_uV < tps->info[ldo]->min_uV || min_uV > tps->info[ldo]->max_uV)
 339                 return -EINVAL;
 340         if (max_uV < tps->info[ldo]->min_uV || max_uV > tps->info[ldo]->max_uV)
 341                 return -EINVAL;
 342
 343         for (vsel = 0; vsel < tps->info[ldo]->table_len; vsel++) {
 344                 int mV = tps->info[ldo]->table[vsel];
 345                 int uV = mV * 1000;
 346
 347                 /* Break at the first in-range value */
 348                 if (min_uV <= uV && uV <= max_uV)
 349                         break;
 350         }
 351
 352         if (vsel == tps->info[ldo]->table_len)
 353                 return -EINVAL;
 354
 355         *selector = vsel;
 356
 357         ret = regmap_read(tps->regmap, TPS65023_REG_LDO_CTRL, &data);
 358         if (ret != 0)
 359                 return ret;
 360
 361         data &= TPS65023_LDO_CTRL_LDOx_MASK(ldo - TPS65023_LDO_1);
 362         data |= (vsel << (TPS65023_LDO_CTRL_LDOx_SHIFT(ldo - TPS65023_LDO_1)));
 363         return regmap_write(tps->regmap, TPS65023_REG_LDO_CTRL, data);
 364 }
 365
 366 static int tps65023_dcdc_list_voltage(struct regulator_dev *dev,
 367                                         unsigned selector)
 368 {
 369         struct tps_pmic *tps = rdev_get_drvdata(dev);
 370         int dcdc = rdev_get_id(dev);
 371
 372         if (dcdc < TPS65023_DCDC_1 || dcdc > TPS65023_DCDC_3)
 373                 return -EINVAL;
 374
 375         if (dcdc == tps->core_regulator) {
 376                 if (selector >= tps->info[dcdc]->table_len)
 377                         return -EINVAL;
 378                 else
 379                         return tps->info[dcdc]->table[selector] * 1000;
 380         } else
 381                 return tps->info[dcdc]->min_uV;
 382 }
 383
 384 static int tps65023_ldo_list_voltage(struct regulator_dev *dev,
 385                                         unsigned selector)
 386 {
 387         struct tps_pmic *tps = rdev_get_drvdata(dev);
 388         int ldo = rdev_get_id(dev);
 389
 390         if (ldo < TPS65023_LDO_1 || ldo > TPS65023_LDO_2)
 391                 return -EINVAL;
 392
 393         if (selector >= tps->info[ldo]->table_len)
 394                 return -EINVAL;
 395         else
 396                 return tps->info[ldo]->table[selector] * 1000;
 397 }
 398
 399 /* Operations permitted on VDCDCx */
 400 static struct regulator_ops tps65023_dcdc_ops = {
 401         .is_enabled = tps65023_dcdc_is_enabled,
 402         .enable = tps65023_dcdc_enable,
 403         .disable = tps65023_dcdc_disable,
 404         .get_voltage = tps65023_dcdc_get_voltage,
 405         .set_voltage = tps65023_dcdc_set_voltage,
 406         .list_voltage = tps65023_dcdc_list_voltage,
 407 };
 408
 409 /* Operations permitted on LDOx */
 410 static struct regulator_ops tps65023_ldo_ops = {
 411         .is_enabled = tps65023_ldo_is_enabled,
 412         .enable = tps65023_ldo_enable,
 413         .disable = tps65023_ldo_disable,
 414         .get_voltage = tps65023_ldo_get_voltage,
 415         .set_voltage = tps65023_ldo_set_voltage,
 416         .list_voltage = tps65023_ldo_list_voltage,
 417 };
 418
 419 static struct regmap_config tps65023_regmap_config = {
 420         .reg_bits = 8,
 421         .val_bits = 8,
 422 };
 423
 424 static int __devinit tps_65023_probe(struct i2c_client *client,
 425                                      const struct i2c_device_id *id)
 426 {
 427         const struct tps_driver_data *drv_data = (void *)id->driver_data;
 428         const struct tps_info *info = drv_data->info;
 429         struct regulator_init_data *init_data;
 430         struct regulator_dev *rdev;
 431         struct tps_pmic *tps;
 432         int i;
 433         int error;
 434
 435         if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
 436                 return -EIO;
 437
 438         /**
 439          * init_data points to array of regulator_init structures
 440          * coming from the board-evm file.
 441          */
 442         init_data = client->dev.platform_data;
 443         if (!init_data)
 444                 return -EIO;
 445
 446         tps = kzalloc(sizeof(*tps), GFP_KERNEL);
 447         if (!tps)
 448                 return -ENOMEM;
 449
 450         tps->regmap = regmap_init_i2c(client, &tps65023_regmap_config);
 451         if (IS_ERR(tps->regmap)) {
 452                 error = PTR_ERR(tps->regmap);
 453                 dev_err(&client->dev, "Failed to allocate register map: %d\n",
 454                         error);
 455                 goto fail_alloc;
 456         }
 457
 458         /* common for all regulators */
 459         tps->client = client;
 460         tps->core_regulator = drv_data->core_regulator;
 461
 462         for (i = 0; i < TPS65023_NUM_REGULATOR; i++, info++, init_data++) {
 463                 /* Store regulator specific information */
 464                 tps->info[i] = info;
 465
 466                 tps->desc[i].name = info->name;
 467                 tps->desc[i].id = i;
 468                 tps->desc[i].n_voltages = info->table_len;
 469                 tps->desc[i].ops = (i > TPS65023_DCDC_3 ?
 470                                         &tps65023_ldo_ops : &tps65023_dcdc_ops);
 471                 tps->desc[i].type = REGULATOR_VOLTAGE;
 472                 tps->desc[i].owner = THIS_MODULE;
 473
 474                 /* Register the regulators */
 475                 rdev = regulator_register(&tps->desc[i], &client->dev,
 476                                           init_data, tps, NULL);
 477                 if (IS_ERR(rdev)) {
 478                         dev_err(&client->dev, "failed to register %s\n",
 479                                 id->name);
 480                         error = PTR_ERR(rdev);
 481                         goto fail;
 482                 }
 483
 484                 /* Save regulator for cleanup */
 485                 tps->rdev[i] = rdev;
 486         }
 487
 488         i2c_set_clientdata(client, tps);
 489
 490         /* Enable setting output voltage by I2C */
 491         regmap_update_bits(tps->regmap, TPS65023_REG_CON_CTRL2,
 492                         TPS65023_REG_CTRL2_CORE_ADJ, TPS65023_REG_CTRL2_CORE_ADJ);
 493
 494         /* Enable setting output voltage by I2C */
 495         regmap_update_bits(tps->regmap, TPS65023_REG_CON_CTRL2,
 496                         TPS65023_REG_CTRL2_CORE_ADJ, TPS65023_REG_CTRL2_CORE_ADJ);
 497
 498         return 0;
 499
 500  fail:
 501         while (--i >= 0)
 502                 regulator_unregister(tps->rdev[i]);
 503
 504         regmap_exit(tps->regmap);
 505  fail_alloc:
 506         kfree(tps);
 507         return error;
 508 }
 509
 510 /**
 511  * tps_65023_remove - TPS65023 driver i2c remove handler
 512  * @client: i2c driver client device structure
 513  *
 514  * Unregister TPS driver as an i2c client device driver
 515  */
 516 static int __devexit tps_65023_remove(struct i2c_client *client)
 517 {
 518         struct tps_pmic *tps = i2c_get_clientdata(client);
 519         int i;
 520
 521         for (i = 0; i < TPS65023_NUM_REGULATOR; i++)
 522                 regulator_unregister(tps->rdev[i]);
 523
 524         regmap_exit(tps->regmap);
 525         kfree(tps);
 526
 527         return 0;
 528 }
 529
 530 static const struct tps_info tps65020_regs[] = {
 531         {
 532                 .name = "VDCDC1",
 533                 .min_uV = 3300000,
 534                 .max_uV = 3300000,
 535                 .fixed  = 1,
 536         },
 537         {
 538                 .name = "VDCDC2",
 539                 .min_uV =  1800000,
 540                 .max_uV = 1800000,
 541                 .fixed = 1,
 542         },
 543         {
 544                 .name = "VDCDC3",
 545                 .min_uV =  800000,
 546                 .max_uV = 1600000,
 547                 .table_len = ARRAY_SIZE(VCORE_VSEL_table),
 548                 .table = VCORE_VSEL_table,
 549         },
 550
 551         {
 552                 .name = "LDO1",
 553                 .min_uV = 1000000,
 554                 .max_uV = 3150000,
 555                 .table_len = ARRAY_SIZE(TPS65020_LDO1_VSEL_table),
 556                 .table = TPS65020_LDO1_VSEL_table,
 557         },
 558         {
 559                 .name = "LDO2",
 560                 .min_uV = 1050000,
 561                 .max_uV = 3300000,
 562                 .table_len = ARRAY_SIZE(TPS65020_LDO2_VSEL_table),
 563                 .table = TPS65020_LDO2_VSEL_table,
 564         },
 565 };
 566
 567 static const struct tps_info tps65021_regs[] = {
 568         {
 569                 .name = "VDCDC1",
 570                 .min_uV =  3300000,
 571                 .max_uV = 3300000,
 572                 .fixed = 1,
 573         },
 574         {
 575                 .name = "VDCDC2",
 576                 .min_uV =  1800000,
 577                 .max_uV = 1800000,
 578                 .fixed = 1,
 579         },
 580         {
 581                 .name = "VDCDC3",
 582                 .min_uV =  800000,
 583                 .max_uV = 1600000,
 584                 .table_len = ARRAY_SIZE(VCORE_VSEL_table),
 585                 .table = VCORE_VSEL_table,
 586         },
 587         {
 588                 .name = "LDO1",
 589                 .min_uV = 1000000,
 590                 .max_uV = 3150000,
 591                 .table_len = ARRAY_SIZE(TPS65023_LDO1_VSEL_table),
 592                 .table = TPS65023_LDO1_VSEL_table,
 593         },
 594         {
 595                 .name = "LDO2",
 596                 .min_uV = 1050000,
 597                 .max_uV = 3300000,
 598                 .table_len = ARRAY_SIZE(TPS65023_LDO2_VSEL_table),
 599                 .table = TPS65023_LDO2_VSEL_table,
 600         },
 601 };
 602
 603 static const struct tps_info tps65023_regs[] = {
 604         {
 605                 .name = "VDCDC1",
 606                 .min_uV =  800000,
 607                 .max_uV = 1600000,
 608                 .table_len = ARRAY_SIZE(VCORE_VSEL_table),
 609                 .table = VCORE_VSEL_table,
 610         },
 611         {
 612                 .name = "VDCDC2",
 613                 .min_uV =  3300000,
 614                 .max_uV = 3300000,
 615                 .fixed = 1,
 616         },
 617         {
 618                 .name = "VDCDC3",
 619                 .min_uV =  1800000,
 620                 .max_uV = 1800000,
 621                 .fixed = 1,
 622         },
 623         {
 624                 .name = "LDO1",
 625                 .min_uV = 1000000,
 626                 .max_uV = 3150000,
 627                 .table_len = ARRAY_SIZE(TPS65023_LDO1_VSEL_table),
 628                 .table = TPS65023_LDO1_VSEL_table,
 629         },
 630         {
 631                 .name = "LDO2",
 632                 .min_uV = 1050000,
 633                 .max_uV = 3300000,
 634                 .table_len = ARRAY_SIZE(TPS65023_LDO2_VSEL_table),
 635                 .table = TPS65023_LDO2_VSEL_table,
 636         },
 637 };
 638
 639 static struct tps_driver_data tps65020_drv_data = {
 640         .info = tps65020_regs,
 641         .core_regulator = TPS65023_DCDC_3,
 642 };
 643
 644 static struct tps_driver_data tps65021_drv_data = {
 645                 .info = tps65021_regs,
 646                 .core_regulator = TPS65023_DCDC_3,
 647 };
 648
 649 static struct tps_driver_data tps65023_drv_data = {
 650                 .info = tps65023_regs,
 651                 .core_regulator = TPS65023_DCDC_1,
 652 };
 653
 654 static const struct i2c_device_id tps_65023_id[] = {
 655         {.name = "tps65023",
 656         .driver_data = (unsigned long) &tps65023_drv_data},
 657         {.name = "tps65021",
 658         .driver_data = (unsigned long) &tps65021_drv_data,},
 659         {.name = "tps65020",
 660         .driver_data = (unsigned long) &tps65020_drv_data},
 661         { },
 662 };
 663
 664 MODULE_DEVICE_TABLE(i2c, tps_65023_id);
 665
 666 static struct i2c_driver tps_65023_i2c_driver = {
 667         .driver = {
 668                 .name = "tps65023",
 669                 .owner = THIS_MODULE,
 670         },
 671         .probe = tps_65023_probe,
 672         .remove = __devexit_p(tps_65023_remove),
 673         .id_table = tps_65023_id,
 674 };
 675
 676 /**
 677  * tps_65023_init
 678  *
 679  * Module init function
 680  */
 681 static int __init tps_65023_init(void)
 682 {
 683         return i2c_add_driver(&tps_65023_i2c_driver);
 684 }
 685 subsys_initcall(tps_65023_init);
 686
 687 /**
 688  * tps_65023_cleanup
 689  *
 690  * Module exit function
 691  */
 692 static void __exit tps_65023_cleanup(void)
 693 {
 694         i2c_del_driver(&tps_65023_i2c_driver);
 695 }
 696 module_exit(tps_65023_cleanup);
 697
 698 MODULE_AUTHOR("Texas Instruments");
 699 MODULE_DESCRIPTION("TPS65023 voltage regulator driver");
 700 MODULE_LICENSE("GPL v2");