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