1 /* 2 * tps6507x-regulator.c 3 * 4 * Regulator driver for TPS65073 PMIC 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 28 /* Register definitions */ 29 #define TPS6507X_REG_PPATH1 0X01 30 #define TPS6507X_REG_INT 0X02 31 #define TPS6507X_REG_CHGCONFIG0 0X03 32 #define TPS6507X_REG_CHGCONFIG1 0X04 33 #define TPS6507X_REG_CHGCONFIG2 0X05 34 #define TPS6507X_REG_CHGCONFIG3 0X06 35 #define TPS6507X_REG_REG_ADCONFIG 0X07 36 #define TPS6507X_REG_TSCMODE 0X08 37 #define TPS6507X_REG_ADRESULT_1 0X09 38 #define TPS6507X_REG_ADRESULT_2 0X0A 39 #define TPS6507X_REG_PGOOD 0X0B 40 #define TPS6507X_REG_PGOODMASK 0X0C 41 #define TPS6507X_REG_CON_CTRL1 0X0D 42 #define TPS6507X_REG_CON_CTRL2 0X0E 43 #define TPS6507X_REG_CON_CTRL3 0X0F 44 #define TPS6507X_REG_DEFDCDC1 0X10 45 #define TPS6507X_REG_DEFDCDC2_LOW 0X11 46 #define TPS6507X_REG_DEFDCDC2_HIGH 0X12 47 #define TPS6507X_REG_DEFDCDC3_LOW 0X13 48 #define TPS6507X_REG_DEFDCDC3_HIGH 0X14 49 #define TPS6507X_REG_DEFSLEW 0X15 50 #define TPS6507X_REG_LDO_CTRL1 0X16 51 #define TPS6507X_REG_DEFLDO2 0X17 52 #define TPS6507X_REG_WLED_CTRL1 0X18 53 #define TPS6507X_REG_WLED_CTRL2 0X19 54 55 /* CON_CTRL1 bitfields */ 56 #define TPS6507X_CON_CTRL1_DCDC1_ENABLE BIT(4) 57 #define TPS6507X_CON_CTRL1_DCDC2_ENABLE BIT(3) 58 #define TPS6507X_CON_CTRL1_DCDC3_ENABLE BIT(2) 59 #define TPS6507X_CON_CTRL1_LDO1_ENABLE BIT(1) 60 #define TPS6507X_CON_CTRL1_LDO2_ENABLE BIT(0) 61 62 /* DEFDCDC1 bitfields */ 63 #define TPS6507X_DEFDCDC1_DCDC1_EXT_ADJ_EN BIT(7) 64 #define TPS6507X_DEFDCDC1_DCDC1_MASK 0X3F 65 66 /* DEFDCDC2_LOW bitfields */ 67 #define TPS6507X_DEFDCDC2_LOW_DCDC2_MASK 0X3F 68 69 /* DEFDCDC2_HIGH bitfields */ 70 #define TPS6507X_DEFDCDC2_HIGH_DCDC2_MASK 0X3F 71 72 /* DEFDCDC3_LOW bitfields */ 73 #define TPS6507X_DEFDCDC3_LOW_DCDC3_MASK 0X3F 74 75 /* DEFDCDC3_HIGH bitfields */ 76 #define TPS6507X_DEFDCDC3_HIGH_DCDC3_MASK 0X3F 77 78 /* TPS6507X_REG_LDO_CTRL1 bitfields */ 79 #define TPS6507X_REG_LDO_CTRL1_LDO1_MASK 0X0F 80 81 /* TPS6507X_REG_DEFLDO2 bitfields */ 82 #define TPS6507X_REG_DEFLDO2_LDO2_MASK 0X3F 83 84 /* VDCDC MASK */ 85 #define TPS6507X_DEFDCDCX_DCDC_MASK 0X3F 86 87 /* DCDC's */ 88 #define TPS6507X_DCDC_1 0 89 #define TPS6507X_DCDC_2 1 90 #define TPS6507X_DCDC_3 2 91 /* LDOs */ 92 #define TPS6507X_LDO_1 3 93 #define TPS6507X_LDO_2 4 94 95 #define TPS6507X_MAX_REG_ID TPS6507X_LDO_2 96 97 /* Number of step-down converters available */ 98 #define TPS6507X_NUM_DCDC 3 99 /* Number of LDO voltage regulators available */ 100 #define TPS6507X_NUM_LDO 2 101 /* Number of total regulators available */ 102 #define TPS6507X_NUM_REGULATOR (TPS6507X_NUM_DCDC + TPS6507X_NUM_LDO) 103 104 /* Supported voltage values for regulators (in milliVolts) */ 105 static const u16 VDCDCx_VSEL_table[] = { 106 725, 750, 775, 800, 107 825, 850, 875, 900, 108 925, 950, 975, 1000, 109 1025, 1050, 1075, 1100, 110 1125, 1150, 1175, 1200, 111 1225, 1250, 1275, 1300, 112 1325, 1350, 1375, 1400, 113 1425, 1450, 1475, 1500, 114 1550, 1600, 1650, 1700, 115 1750, 1800, 1850, 1900, 116 1950, 2000, 2050, 2100, 117 2150, 2200, 2250, 2300, 118 2350, 2400, 2450, 2500, 119 2550, 2600, 2650, 2700, 120 2750, 2800, 2850, 2900, 121 3000, 3100, 3200, 3300, 122 }; 123 124 static const u16 LDO1_VSEL_table[] = { 125 1000, 1100, 1200, 1250, 126 1300, 1350, 1400, 1500, 127 1600, 1800, 2500, 2750, 128 2800, 3000, 3100, 3300, 129 }; 130 131 static const u16 LDO2_VSEL_table[] = { 132 725, 750, 775, 800, 133 825, 850, 875, 900, 134 925, 950, 975, 1000, 135 1025, 1050, 1075, 1100, 136 1125, 1150, 1175, 1200, 137 1225, 1250, 1275, 1300, 138 1325, 1350, 1375, 1400, 139 1425, 1450, 1475, 1500, 140 1550, 1600, 1650, 1700, 141 1750, 1800, 1850, 1900, 142 1950, 2000, 2050, 2100, 143 2150, 2200, 2250, 2300, 144 2350, 2400, 2450, 2500, 145 2550, 2600, 2650, 2700, 146 2750, 2800, 2850, 2900, 147 3000, 3100, 3200, 3300, 148 }; 149 150 static unsigned int num_voltages[] = {ARRAY_SIZE(VDCDCx_VSEL_table), 151 ARRAY_SIZE(VDCDCx_VSEL_table), 152 ARRAY_SIZE(VDCDCx_VSEL_table), 153 ARRAY_SIZE(LDO1_VSEL_table), 154 ARRAY_SIZE(LDO2_VSEL_table)}; 155 156 struct tps_info { 157 const char *name; 158 unsigned min_uV; 159 unsigned max_uV; 160 u8 table_len; 161 const u16 *table; 162 }; 163 164 struct tps_pmic { 165 struct regulator_desc desc[TPS6507X_NUM_REGULATOR]; 166 struct i2c_client *client; 167 struct regulator_dev *rdev[TPS6507X_NUM_REGULATOR]; 168 const struct tps_info *info[TPS6507X_NUM_REGULATOR]; 169 struct mutex io_lock; 170 }; 171 172 static inline int tps_6507x_read(struct tps_pmic *tps, u8 reg) 173 { 174 return i2c_smbus_read_byte_data(tps->client, reg); 175 } 176 177 static inline int tps_6507x_write(struct tps_pmic *tps, u8 reg, u8 val) 178 { 179 return i2c_smbus_write_byte_data(tps->client, reg, val); 180 } 181 182 static int tps_6507x_set_bits(struct tps_pmic *tps, u8 reg, u8 mask) 183 { 184 int err, data; 185 186 mutex_lock(&tps->io_lock); 187 188 data = tps_6507x_read(tps, reg); 189 if (data < 0) { 190 dev_err(&tps->client->dev, "Read from reg 0x%x failed\n", reg); 191 err = data; 192 goto out; 193 } 194 195 data |= mask; 196 err = tps_6507x_write(tps, reg, data); 197 if (err) 198 dev_err(&tps->client->dev, "Write for reg 0x%x failed\n", reg); 199 200 out: 201 mutex_unlock(&tps->io_lock); 202 return err; 203 } 204 205 static int tps_6507x_clear_bits(struct tps_pmic *tps, u8 reg, u8 mask) 206 { 207 int err, data; 208 209 mutex_lock(&tps->io_lock); 210 211 data = tps_6507x_read(tps, reg); 212 if (data < 0) { 213 dev_err(&tps->client->dev, "Read from reg 0x%x failed\n", reg); 214 err = data; 215 goto out; 216 } 217 218 data &= ~mask; 219 err = tps_6507x_write(tps, reg, data); 220 if (err) 221 dev_err(&tps->client->dev, "Write for reg 0x%x failed\n", reg); 222 223 out: 224 mutex_unlock(&tps->io_lock); 225 return err; 226 } 227 228 static int tps_6507x_reg_read(struct tps_pmic *tps, u8 reg) 229 { 230 int data; 231 232 mutex_lock(&tps->io_lock); 233 234 data = tps_6507x_read(tps, reg); 235 if (data < 0) 236 dev_err(&tps->client->dev, "Read from reg 0x%x failed\n", reg); 237 238 mutex_unlock(&tps->io_lock); 239 return data; 240 } 241 242 static int tps_6507x_reg_write(struct tps_pmic *tps, u8 reg, u8 val) 243 { 244 int err; 245 246 mutex_lock(&tps->io_lock); 247 248 err = tps_6507x_write(tps, reg, val); 249 if (err < 0) 250 dev_err(&tps->client->dev, "Write for reg 0x%x failed\n", reg); 251 252 mutex_unlock(&tps->io_lock); 253 return err; 254 } 255 256 static int tps6507x_dcdc_is_enabled(struct regulator_dev *dev) 257 { 258 struct tps_pmic *tps = rdev_get_drvdata(dev); 259 int data, dcdc = rdev_get_id(dev); 260 u8 shift; 261 262 if (dcdc < TPS6507X_DCDC_1 || dcdc > TPS6507X_DCDC_3) 263 return -EINVAL; 264 265 shift = TPS6507X_MAX_REG_ID - dcdc; 266 data = tps_6507x_reg_read(tps, TPS6507X_REG_CON_CTRL1); 267 268 if (data < 0) 269 return data; 270 else 271 return (data & 1<<shift) ? 1 : 0; 272 } 273 274 static int tps6507x_ldo_is_enabled(struct regulator_dev *dev) 275 { 276 struct tps_pmic *tps = rdev_get_drvdata(dev); 277 int data, ldo = rdev_get_id(dev); 278 u8 shift; 279 280 if (ldo < TPS6507X_LDO_1 || ldo > TPS6507X_LDO_2) 281 return -EINVAL; 282 283 shift = TPS6507X_MAX_REG_ID - ldo; 284 data = tps_6507x_reg_read(tps, TPS6507X_REG_CON_CTRL1); 285 286 if (data < 0) 287 return data; 288 else 289 return (data & 1<<shift) ? 1 : 0; 290 } 291 292 static int tps6507x_dcdc_enable(struct regulator_dev *dev) 293 { 294 struct tps_pmic *tps = rdev_get_drvdata(dev); 295 int dcdc = rdev_get_id(dev); 296 u8 shift; 297 298 if (dcdc < TPS6507X_DCDC_1 || dcdc > TPS6507X_DCDC_3) 299 return -EINVAL; 300 301 shift = TPS6507X_MAX_REG_ID - dcdc; 302 return tps_6507x_set_bits(tps, TPS6507X_REG_CON_CTRL1, 1 << shift); 303 } 304 305 static int tps6507x_dcdc_disable(struct regulator_dev *dev) 306 { 307 struct tps_pmic *tps = rdev_get_drvdata(dev); 308 int dcdc = rdev_get_id(dev); 309 u8 shift; 310 311 if (dcdc < TPS6507X_DCDC_1 || dcdc > TPS6507X_DCDC_3) 312 return -EINVAL; 313 314 shift = TPS6507X_MAX_REG_ID - dcdc; 315 return tps_6507x_clear_bits(tps, TPS6507X_REG_CON_CTRL1, 1 << shift); 316 } 317 318 static int tps6507x_ldo_enable(struct regulator_dev *dev) 319 { 320 struct tps_pmic *tps = rdev_get_drvdata(dev); 321 int ldo = rdev_get_id(dev); 322 u8 shift; 323 324 if (ldo < TPS6507X_LDO_1 || ldo > TPS6507X_LDO_2) 325 return -EINVAL; 326 327 shift = TPS6507X_MAX_REG_ID - ldo; 328 return tps_6507x_set_bits(tps, TPS6507X_REG_CON_CTRL1, 1 << shift); 329 } 330 331 static int tps6507x_ldo_disable(struct regulator_dev *dev) 332 { 333 struct tps_pmic *tps = rdev_get_drvdata(dev); 334 int ldo = rdev_get_id(dev); 335 u8 shift; 336 337 if (ldo < TPS6507X_LDO_1 || ldo > TPS6507X_LDO_2) 338 return -EINVAL; 339 340 shift = TPS6507X_MAX_REG_ID - ldo; 341 return tps_6507x_clear_bits(tps, TPS6507X_REG_CON_CTRL1, 1 << shift); 342 } 343 344 static int tps6507x_dcdc_get_voltage(struct regulator_dev *dev) 345 { 346 struct tps_pmic *tps = rdev_get_drvdata(dev); 347 int data, dcdc = rdev_get_id(dev); 348 u8 reg; 349 350 switch (dcdc) { 351 case TPS6507X_DCDC_1: 352 reg = TPS6507X_REG_DEFDCDC1; 353 break; 354 case TPS6507X_DCDC_2: 355 reg = TPS6507X_REG_DEFDCDC2_LOW; 356 break; 357 case TPS6507X_DCDC_3: 358 reg = TPS6507X_REG_DEFDCDC3_LOW; 359 break; 360 default: 361 return -EINVAL; 362 } 363 364 data = tps_6507x_reg_read(tps, reg); 365 if (data < 0) 366 return data; 367 368 data &= TPS6507X_DEFDCDCX_DCDC_MASK; 369 return tps->info[dcdc]->table[data] * 1000; 370 } 371 372 static int tps6507x_dcdc_set_voltage(struct regulator_dev *dev, 373 int min_uV, int max_uV) 374 { 375 struct tps_pmic *tps = rdev_get_drvdata(dev); 376 int data, vsel, dcdc = rdev_get_id(dev); 377 u8 reg; 378 379 switch (dcdc) { 380 case TPS6507X_DCDC_1: 381 reg = TPS6507X_REG_DEFDCDC1; 382 break; 383 case TPS6507X_DCDC_2: 384 reg = TPS6507X_REG_DEFDCDC2_LOW; 385 break; 386 case TPS6507X_DCDC_3: 387 reg = TPS6507X_REG_DEFDCDC3_LOW; 388 break; 389 default: 390 return -EINVAL; 391 } 392 393 if (min_uV < tps->info[dcdc]->min_uV 394 || min_uV > tps->info[dcdc]->max_uV) 395 return -EINVAL; 396 if (max_uV < tps->info[dcdc]->min_uV 397 || max_uV > tps->info[dcdc]->max_uV) 398 return -EINVAL; 399 400 for (vsel = 0; vsel < tps->info[dcdc]->table_len; vsel++) { 401 int mV = tps->info[dcdc]->table[vsel]; 402 int uV = mV * 1000; 403 404 /* Break at the first in-range value */ 405 if (min_uV <= uV && uV <= max_uV) 406 break; 407 } 408 409 /* write to the register in case we found a match */ 410 if (vsel == tps->info[dcdc]->table_len) 411 return -EINVAL; 412 413 data = tps_6507x_reg_read(tps, reg); 414 if (data < 0) 415 return data; 416 417 data &= ~TPS6507X_DEFDCDCX_DCDC_MASK; 418 data |= vsel; 419 420 return tps_6507x_reg_write(tps, reg, data); 421 } 422 423 static int tps6507x_ldo_get_voltage(struct regulator_dev *dev) 424 { 425 struct tps_pmic *tps = rdev_get_drvdata(dev); 426 int data, ldo = rdev_get_id(dev); 427 u8 reg, mask; 428 429 if (ldo < TPS6507X_LDO_1 || ldo > TPS6507X_LDO_2) 430 return -EINVAL; 431 else { 432 reg = (ldo == TPS6507X_LDO_1 ? 433 TPS6507X_REG_LDO_CTRL1 : TPS6507X_REG_DEFLDO2); 434 mask = (ldo == TPS6507X_LDO_1 ? 435 TPS6507X_REG_LDO_CTRL1_LDO1_MASK : 436 TPS6507X_REG_DEFLDO2_LDO2_MASK); 437 } 438 439 data = tps_6507x_reg_read(tps, reg); 440 if (data < 0) 441 return data; 442 443 data &= mask; 444 return tps->info[ldo]->table[data] * 1000; 445 } 446 447 static int tps6507x_ldo_set_voltage(struct regulator_dev *dev, 448 int min_uV, int max_uV) 449 { 450 struct tps_pmic *tps = rdev_get_drvdata(dev); 451 int data, vsel, ldo = rdev_get_id(dev); 452 u8 reg, mask; 453 454 if (ldo < TPS6507X_LDO_1 || ldo > TPS6507X_LDO_2) 455 return -EINVAL; 456 else { 457 reg = (ldo == TPS6507X_LDO_1 ? 458 TPS6507X_REG_LDO_CTRL1 : TPS6507X_REG_DEFLDO2); 459 mask = (ldo == TPS6507X_LDO_1 ? 460 TPS6507X_REG_LDO_CTRL1_LDO1_MASK : 461 TPS6507X_REG_DEFLDO2_LDO2_MASK); 462 } 463 464 if (min_uV < tps->info[ldo]->min_uV || min_uV > tps->info[ldo]->max_uV) 465 return -EINVAL; 466 if (max_uV < tps->info[ldo]->min_uV || max_uV > tps->info[ldo]->max_uV) 467 return -EINVAL; 468 469 for (vsel = 0; vsel < tps->info[ldo]->table_len; vsel++) { 470 int mV = tps->info[ldo]->table[vsel]; 471 int uV = mV * 1000; 472 473 /* Break at the first in-range value */ 474 if (min_uV <= uV && uV <= max_uV) 475 break; 476 } 477 478 if (vsel == tps->info[ldo]->table_len) 479 return -EINVAL; 480 481 data = tps_6507x_reg_read(tps, reg); 482 if (data < 0) 483 return data; 484 485 data &= ~mask; 486 data |= vsel; 487 488 return tps_6507x_reg_write(tps, reg, data); 489 } 490 491 static int tps6507x_dcdc_list_voltage(struct regulator_dev *dev, 492 unsigned selector) 493 { 494 struct tps_pmic *tps = rdev_get_drvdata(dev); 495 int dcdc = rdev_get_id(dev); 496 497 if (dcdc < TPS6507X_DCDC_1 || dcdc > TPS6507X_DCDC_3) 498 return -EINVAL; 499 500 if (selector >= tps->info[dcdc]->table_len) 501 return -EINVAL; 502 else 503 return tps->info[dcdc]->table[selector] * 1000; 504 } 505 506 static int tps6507x_ldo_list_voltage(struct regulator_dev *dev, 507 unsigned selector) 508 { 509 struct tps_pmic *tps = rdev_get_drvdata(dev); 510 int ldo = rdev_get_id(dev); 511 512 if (ldo < TPS6507X_LDO_1 || ldo > TPS6507X_LDO_2) 513 return -EINVAL; 514 515 if (selector >= tps->info[ldo]->table_len) 516 return -EINVAL; 517 else 518 return tps->info[ldo]->table[selector] * 1000; 519 } 520 521 /* Operations permitted on VDCDCx */ 522 static struct regulator_ops tps6507x_dcdc_ops = { 523 .is_enabled = tps6507x_dcdc_is_enabled, 524 .enable = tps6507x_dcdc_enable, 525 .disable = tps6507x_dcdc_disable, 526 .get_voltage = tps6507x_dcdc_get_voltage, 527 .set_voltage = tps6507x_dcdc_set_voltage, 528 .list_voltage = tps6507x_dcdc_list_voltage, 529 }; 530 531 /* Operations permitted on LDOx */ 532 static struct regulator_ops tps6507x_ldo_ops = { 533 .is_enabled = tps6507x_ldo_is_enabled, 534 .enable = tps6507x_ldo_enable, 535 .disable = tps6507x_ldo_disable, 536 .get_voltage = tps6507x_ldo_get_voltage, 537 .set_voltage = tps6507x_ldo_set_voltage, 538 .list_voltage = tps6507x_ldo_list_voltage, 539 }; 540 541 static 542 int tps_6507x_probe(struct i2c_client *client, const struct i2c_device_id *id) 543 { 544 static int desc_id; 545 const struct tps_info *info = (void *)id->driver_data; 546 struct regulator_init_data *init_data; 547 struct regulator_dev *rdev; 548 struct tps_pmic *tps; 549 int i; 550 551 if (!i2c_check_functionality(client->adapter, 552 I2C_FUNC_SMBUS_BYTE_DATA)) 553 return -EIO; 554 555 /** 556 * init_data points to array of regulator_init structures 557 * coming from the board-evm file. 558 */ 559 init_data = client->dev.platform_data; 560 561 if (!init_data) 562 return -EIO; 563 564 tps = kzalloc(sizeof(*tps), GFP_KERNEL); 565 if (!tps) 566 return -ENOMEM; 567 568 mutex_init(&tps->io_lock); 569 570 /* common for all regulators */ 571 tps->client = client; 572 573 for (i = 0; i < TPS6507X_NUM_REGULATOR; i++, info++, init_data++) { 574 /* Register the regulators */ 575 tps->info[i] = info; 576 tps->desc[i].name = info->name; 577 tps->desc[i].id = desc_id++; 578 tps->desc[i].n_voltages = num_voltages[i]; 579 tps->desc[i].ops = (i > TPS6507X_DCDC_3 ? 580 &tps6507x_ldo_ops : &tps6507x_dcdc_ops); 581 tps->desc[i].type = REGULATOR_VOLTAGE; 582 tps->desc[i].owner = THIS_MODULE; 583 584 rdev = regulator_register(&tps->desc[i], 585 &client->dev, init_data, tps); 586 if (IS_ERR(rdev)) { 587 dev_err(&client->dev, "failed to register %s\n", 588 id->name); 589 590 /* Unregister */ 591 while (i) 592 regulator_unregister(tps->rdev[--i]); 593 594 tps->client = NULL; 595 596 /* clear the client data in i2c */ 597 i2c_set_clientdata(client, NULL); 598 599 kfree(tps); 600 return PTR_ERR(rdev); 601 } 602 603 /* Save regulator for cleanup */ 604 tps->rdev[i] = rdev; 605 } 606 607 i2c_set_clientdata(client, tps); 608 609 return 0; 610 } 611 612 /** 613 * tps_6507x_remove - TPS6507x driver i2c remove handler 614 * @client: i2c driver client device structure 615 * 616 * Unregister TPS driver as an i2c client device driver 617 */ 618 static int __devexit tps_6507x_remove(struct i2c_client *client) 619 { 620 struct tps_pmic *tps = i2c_get_clientdata(client); 621 int i; 622 623 for (i = 0; i < TPS6507X_NUM_REGULATOR; i++) 624 regulator_unregister(tps->rdev[i]); 625 626 tps->client = NULL; 627 628 /* clear the client data in i2c */ 629 i2c_set_clientdata(client, NULL); 630 kfree(tps); 631 632 return 0; 633 } 634 635 static const struct tps_info tps6507x_regs[] = { 636 { 637 .name = "VDCDC1", 638 .min_uV = 725000, 639 .max_uV = 3300000, 640 .table_len = ARRAY_SIZE(VDCDCx_VSEL_table), 641 .table = VDCDCx_VSEL_table, 642 }, 643 { 644 .name = "VDCDC2", 645 .min_uV = 725000, 646 .max_uV = 3300000, 647 .table_len = ARRAY_SIZE(VDCDCx_VSEL_table), 648 .table = VDCDCx_VSEL_table, 649 }, 650 { 651 .name = "VDCDC3", 652 .min_uV = 725000, 653 .max_uV = 3300000, 654 .table_len = ARRAY_SIZE(VDCDCx_VSEL_table), 655 .table = VDCDCx_VSEL_table, 656 }, 657 { 658 .name = "LDO1", 659 .min_uV = 1000000, 660 .max_uV = 3300000, 661 .table_len = ARRAY_SIZE(LDO1_VSEL_table), 662 .table = LDO1_VSEL_table, 663 }, 664 { 665 .name = "LDO2", 666 .min_uV = 725000, 667 .max_uV = 3300000, 668 .table_len = ARRAY_SIZE(LDO2_VSEL_table), 669 .table = LDO2_VSEL_table, 670 }, 671 }; 672 673 static const struct i2c_device_id tps_6507x_id[] = { 674 {.name = "tps6507x", 675 .driver_data = (unsigned long) tps6507x_regs,}, 676 { }, 677 }; 678 MODULE_DEVICE_TABLE(i2c, tps_6507x_id); 679 680 static struct i2c_driver tps_6507x_i2c_driver = { 681 .driver = { 682 .name = "tps6507x", 683 .owner = THIS_MODULE, 684 }, 685 .probe = tps_6507x_probe, 686 .remove = __devexit_p(tps_6507x_remove), 687 .id_table = tps_6507x_id, 688 }; 689 690 /** 691 * tps_6507x_init 692 * 693 * Module init function 694 */ 695 static int __init tps_6507x_init(void) 696 { 697 return i2c_add_driver(&tps_6507x_i2c_driver); 698 } 699 subsys_initcall(tps_6507x_init); 700 701 /** 702 * tps_6507x_cleanup 703 * 704 * Module exit function 705 */ 706 static void __exit tps_6507x_cleanup(void) 707 { 708 i2c_del_driver(&tps_6507x_i2c_driver); 709 } 710 module_exit(tps_6507x_cleanup); 711 712 MODULE_AUTHOR("Texas Instruments"); 713 MODULE_DESCRIPTION("TPS6507x voltage regulator driver"); 714 MODULE_LICENSE("GPL v2"); 715