1 /* 2 * MFD driver for TWL6040 audio device 3 * 4 * Authors: Misael Lopez Cruz <misael.lopez@ti.com> 5 * Jorge Eduardo Candelaria <jorge.candelaria@ti.com> 6 * Peter Ujfalusi <peter.ujfalusi@ti.com> 7 * 8 * Copyright: (C) 2011 Texas Instruments, Inc. 9 * 10 * This program is free software; you can redistribute it and/or modify 11 * it under the terms of the GNU General Public License version 2 as 12 * published by the Free Software Foundation. 13 * 14 * This program is distributed in the hope that it will be useful, but 15 * WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 17 * General Public License for more details. 18 * 19 * You should have received a copy of the GNU General Public License 20 * along with this program; if not, write to the Free Software 21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 22 * 02110-1301 USA 23 * 24 */ 25 26 #include <linux/module.h> 27 #include <linux/types.h> 28 #include <linux/slab.h> 29 #include <linux/kernel.h> 30 #include <linux/err.h> 31 #include <linux/platform_device.h> 32 #include <linux/of.h> 33 #include <linux/of_irq.h> 34 #include <linux/of_gpio.h> 35 #include <linux/of_platform.h> 36 #include <linux/gpio.h> 37 #include <linux/delay.h> 38 #include <linux/i2c.h> 39 #include <linux/regmap.h> 40 #include <linux/mfd/core.h> 41 #include <linux/mfd/twl6040.h> 42 #include <linux/regulator/consumer.h> 43 44 #define VIBRACTRL_MEMBER(reg) ((reg == TWL6040_REG_VIBCTLL) ? 0 : 1) 45 #define TWL6040_NUM_SUPPLIES (2) 46 47 static bool twl6040_has_vibra(struct device_node *node) 48 { 49 #ifdef CONFIG_OF 50 if (of_find_node_by_name(node, "vibra")) 51 return true; 52 #endif 53 return false; 54 } 55 56 int twl6040_reg_read(struct twl6040 *twl6040, unsigned int reg) 57 { 58 int ret; 59 unsigned int val; 60 61 ret = regmap_read(twl6040->regmap, reg, &val); 62 if (ret < 0) 63 return ret; 64 65 return val; 66 } 67 EXPORT_SYMBOL(twl6040_reg_read); 68 69 int twl6040_reg_write(struct twl6040 *twl6040, unsigned int reg, u8 val) 70 { 71 int ret; 72 73 ret = regmap_write(twl6040->regmap, reg, val); 74 75 return ret; 76 } 77 EXPORT_SYMBOL(twl6040_reg_write); 78 79 int twl6040_set_bits(struct twl6040 *twl6040, unsigned int reg, u8 mask) 80 { 81 return regmap_update_bits(twl6040->regmap, reg, mask, mask); 82 } 83 EXPORT_SYMBOL(twl6040_set_bits); 84 85 int twl6040_clear_bits(struct twl6040 *twl6040, unsigned int reg, u8 mask) 86 { 87 return regmap_update_bits(twl6040->regmap, reg, mask, 0); 88 } 89 EXPORT_SYMBOL(twl6040_clear_bits); 90 91 /* twl6040 codec manual power-up sequence */ 92 static int twl6040_power_up_manual(struct twl6040 *twl6040) 93 { 94 u8 ldoctl, ncpctl, lppllctl; 95 int ret; 96 97 /* enable high-side LDO, reference system and internal oscillator */ 98 ldoctl = TWL6040_HSLDOENA | TWL6040_REFENA | TWL6040_OSCENA; 99 ret = twl6040_reg_write(twl6040, TWL6040_REG_LDOCTL, ldoctl); 100 if (ret) 101 return ret; 102 usleep_range(10000, 10500); 103 104 /* enable negative charge pump */ 105 ncpctl = TWL6040_NCPENA; 106 ret = twl6040_reg_write(twl6040, TWL6040_REG_NCPCTL, ncpctl); 107 if (ret) 108 goto ncp_err; 109 usleep_range(1000, 1500); 110 111 /* enable low-side LDO */ 112 ldoctl |= TWL6040_LSLDOENA; 113 ret = twl6040_reg_write(twl6040, TWL6040_REG_LDOCTL, ldoctl); 114 if (ret) 115 goto lsldo_err; 116 usleep_range(1000, 1500); 117 118 /* enable low-power PLL */ 119 lppllctl = TWL6040_LPLLENA; 120 ret = twl6040_reg_write(twl6040, TWL6040_REG_LPPLLCTL, lppllctl); 121 if (ret) 122 goto lppll_err; 123 usleep_range(5000, 5500); 124 125 /* disable internal oscillator */ 126 ldoctl &= ~TWL6040_OSCENA; 127 ret = twl6040_reg_write(twl6040, TWL6040_REG_LDOCTL, ldoctl); 128 if (ret) 129 goto osc_err; 130 131 return 0; 132 133 osc_err: 134 lppllctl &= ~TWL6040_LPLLENA; 135 twl6040_reg_write(twl6040, TWL6040_REG_LPPLLCTL, lppllctl); 136 lppll_err: 137 ldoctl &= ~TWL6040_LSLDOENA; 138 twl6040_reg_write(twl6040, TWL6040_REG_LDOCTL, ldoctl); 139 lsldo_err: 140 ncpctl &= ~TWL6040_NCPENA; 141 twl6040_reg_write(twl6040, TWL6040_REG_NCPCTL, ncpctl); 142 ncp_err: 143 ldoctl &= ~(TWL6040_HSLDOENA | TWL6040_REFENA | TWL6040_OSCENA); 144 twl6040_reg_write(twl6040, TWL6040_REG_LDOCTL, ldoctl); 145 146 dev_err(twl6040->dev, "manual power-up failed\n"); 147 return ret; 148 } 149 150 /* twl6040 manual power-down sequence */ 151 static void twl6040_power_down_manual(struct twl6040 *twl6040) 152 { 153 u8 ncpctl, ldoctl, lppllctl; 154 155 ncpctl = twl6040_reg_read(twl6040, TWL6040_REG_NCPCTL); 156 ldoctl = twl6040_reg_read(twl6040, TWL6040_REG_LDOCTL); 157 lppllctl = twl6040_reg_read(twl6040, TWL6040_REG_LPPLLCTL); 158 159 /* enable internal oscillator */ 160 ldoctl |= TWL6040_OSCENA; 161 twl6040_reg_write(twl6040, TWL6040_REG_LDOCTL, ldoctl); 162 usleep_range(1000, 1500); 163 164 /* disable low-power PLL */ 165 lppllctl &= ~TWL6040_LPLLENA; 166 twl6040_reg_write(twl6040, TWL6040_REG_LPPLLCTL, lppllctl); 167 168 /* disable low-side LDO */ 169 ldoctl &= ~TWL6040_LSLDOENA; 170 twl6040_reg_write(twl6040, TWL6040_REG_LDOCTL, ldoctl); 171 172 /* disable negative charge pump */ 173 ncpctl &= ~TWL6040_NCPENA; 174 twl6040_reg_write(twl6040, TWL6040_REG_NCPCTL, ncpctl); 175 176 /* disable high-side LDO, reference system and internal oscillator */ 177 ldoctl &= ~(TWL6040_HSLDOENA | TWL6040_REFENA | TWL6040_OSCENA); 178 twl6040_reg_write(twl6040, TWL6040_REG_LDOCTL, ldoctl); 179 } 180 181 static irqreturn_t twl6040_readyint_handler(int irq, void *data) 182 { 183 struct twl6040 *twl6040 = data; 184 185 complete(&twl6040->ready); 186 187 return IRQ_HANDLED; 188 } 189 190 static irqreturn_t twl6040_thint_handler(int irq, void *data) 191 { 192 struct twl6040 *twl6040 = data; 193 u8 status; 194 195 status = twl6040_reg_read(twl6040, TWL6040_REG_STATUS); 196 if (status & TWL6040_TSHUTDET) { 197 dev_warn(twl6040->dev, "Thermal shutdown, powering-off"); 198 twl6040_power(twl6040, 0); 199 } else { 200 dev_warn(twl6040->dev, "Leaving thermal shutdown, powering-on"); 201 twl6040_power(twl6040, 1); 202 } 203 204 return IRQ_HANDLED; 205 } 206 207 static int twl6040_power_up_automatic(struct twl6040 *twl6040) 208 { 209 int time_left; 210 211 gpio_set_value(twl6040->audpwron, 1); 212 213 time_left = wait_for_completion_timeout(&twl6040->ready, 214 msecs_to_jiffies(144)); 215 if (!time_left) { 216 u8 intid; 217 218 dev_warn(twl6040->dev, "timeout waiting for READYINT\n"); 219 intid = twl6040_reg_read(twl6040, TWL6040_REG_INTID); 220 if (!(intid & TWL6040_READYINT)) { 221 dev_err(twl6040->dev, "automatic power-up failed\n"); 222 gpio_set_value(twl6040->audpwron, 0); 223 return -ETIMEDOUT; 224 } 225 } 226 227 return 0; 228 } 229 230 int twl6040_power(struct twl6040 *twl6040, int on) 231 { 232 int ret = 0; 233 234 mutex_lock(&twl6040->mutex); 235 236 if (on) { 237 /* already powered-up */ 238 if (twl6040->power_count++) 239 goto out; 240 241 if (gpio_is_valid(twl6040->audpwron)) { 242 /* use automatic power-up sequence */ 243 ret = twl6040_power_up_automatic(twl6040); 244 if (ret) { 245 twl6040->power_count = 0; 246 goto out; 247 } 248 } else { 249 /* use manual power-up sequence */ 250 ret = twl6040_power_up_manual(twl6040); 251 if (ret) { 252 twl6040->power_count = 0; 253 goto out; 254 } 255 } 256 /* Default PLL configuration after power up */ 257 twl6040->pll = TWL6040_SYSCLK_SEL_LPPLL; 258 twl6040->sysclk = 19200000; 259 twl6040->mclk = 32768; 260 } else { 261 /* already powered-down */ 262 if (!twl6040->power_count) { 263 dev_err(twl6040->dev, 264 "device is already powered-off\n"); 265 ret = -EPERM; 266 goto out; 267 } 268 269 if (--twl6040->power_count) 270 goto out; 271 272 if (gpio_is_valid(twl6040->audpwron)) { 273 /* use AUDPWRON line */ 274 gpio_set_value(twl6040->audpwron, 0); 275 276 /* power-down sequence latency */ 277 usleep_range(500, 700); 278 } else { 279 /* use manual power-down sequence */ 280 twl6040_power_down_manual(twl6040); 281 } 282 twl6040->sysclk = 0; 283 twl6040->mclk = 0; 284 } 285 286 out: 287 mutex_unlock(&twl6040->mutex); 288 return ret; 289 } 290 EXPORT_SYMBOL(twl6040_power); 291 292 int twl6040_set_pll(struct twl6040 *twl6040, int pll_id, 293 unsigned int freq_in, unsigned int freq_out) 294 { 295 u8 hppllctl, lppllctl; 296 int ret = 0; 297 298 mutex_lock(&twl6040->mutex); 299 300 hppllctl = twl6040_reg_read(twl6040, TWL6040_REG_HPPLLCTL); 301 lppllctl = twl6040_reg_read(twl6040, TWL6040_REG_LPPLLCTL); 302 303 /* Force full reconfiguration when switching between PLL */ 304 if (pll_id != twl6040->pll) { 305 twl6040->sysclk = 0; 306 twl6040->mclk = 0; 307 } 308 309 switch (pll_id) { 310 case TWL6040_SYSCLK_SEL_LPPLL: 311 /* low-power PLL divider */ 312 /* Change the sysclk configuration only if it has been canged */ 313 if (twl6040->sysclk != freq_out) { 314 switch (freq_out) { 315 case 17640000: 316 lppllctl |= TWL6040_LPLLFIN; 317 break; 318 case 19200000: 319 lppllctl &= ~TWL6040_LPLLFIN; 320 break; 321 default: 322 dev_err(twl6040->dev, 323 "freq_out %d not supported\n", 324 freq_out); 325 ret = -EINVAL; 326 goto pll_out; 327 } 328 twl6040_reg_write(twl6040, TWL6040_REG_LPPLLCTL, 329 lppllctl); 330 } 331 332 /* The PLL in use has not been change, we can exit */ 333 if (twl6040->pll == pll_id) 334 break; 335 336 switch (freq_in) { 337 case 32768: 338 lppllctl |= TWL6040_LPLLENA; 339 twl6040_reg_write(twl6040, TWL6040_REG_LPPLLCTL, 340 lppllctl); 341 mdelay(5); 342 lppllctl &= ~TWL6040_HPLLSEL; 343 twl6040_reg_write(twl6040, TWL6040_REG_LPPLLCTL, 344 lppllctl); 345 hppllctl &= ~TWL6040_HPLLENA; 346 twl6040_reg_write(twl6040, TWL6040_REG_HPPLLCTL, 347 hppllctl); 348 break; 349 default: 350 dev_err(twl6040->dev, 351 "freq_in %d not supported\n", freq_in); 352 ret = -EINVAL; 353 goto pll_out; 354 } 355 break; 356 case TWL6040_SYSCLK_SEL_HPPLL: 357 /* high-performance PLL can provide only 19.2 MHz */ 358 if (freq_out != 19200000) { 359 dev_err(twl6040->dev, 360 "freq_out %d not supported\n", freq_out); 361 ret = -EINVAL; 362 goto pll_out; 363 } 364 365 if (twl6040->mclk != freq_in) { 366 hppllctl &= ~TWL6040_MCLK_MSK; 367 368 switch (freq_in) { 369 case 12000000: 370 /* PLL enabled, active mode */ 371 hppllctl |= TWL6040_MCLK_12000KHZ | 372 TWL6040_HPLLENA; 373 break; 374 case 19200000: 375 /* 376 * PLL disabled 377 * (enable PLL if MCLK jitter quality 378 * doesn't meet specification) 379 */ 380 hppllctl |= TWL6040_MCLK_19200KHZ; 381 break; 382 case 26000000: 383 /* PLL enabled, active mode */ 384 hppllctl |= TWL6040_MCLK_26000KHZ | 385 TWL6040_HPLLENA; 386 break; 387 case 38400000: 388 /* PLL enabled, active mode */ 389 hppllctl |= TWL6040_MCLK_38400KHZ | 390 TWL6040_HPLLENA; 391 break; 392 default: 393 dev_err(twl6040->dev, 394 "freq_in %d not supported\n", freq_in); 395 ret = -EINVAL; 396 goto pll_out; 397 } 398 399 /* 400 * enable clock slicer to ensure input waveform is 401 * square 402 */ 403 hppllctl |= TWL6040_HPLLSQRENA; 404 405 twl6040_reg_write(twl6040, TWL6040_REG_HPPLLCTL, 406 hppllctl); 407 usleep_range(500, 700); 408 lppllctl |= TWL6040_HPLLSEL; 409 twl6040_reg_write(twl6040, TWL6040_REG_LPPLLCTL, 410 lppllctl); 411 lppllctl &= ~TWL6040_LPLLENA; 412 twl6040_reg_write(twl6040, TWL6040_REG_LPPLLCTL, 413 lppllctl); 414 } 415 break; 416 default: 417 dev_err(twl6040->dev, "unknown pll id %d\n", pll_id); 418 ret = -EINVAL; 419 goto pll_out; 420 } 421 422 twl6040->sysclk = freq_out; 423 twl6040->mclk = freq_in; 424 twl6040->pll = pll_id; 425 426 pll_out: 427 mutex_unlock(&twl6040->mutex); 428 return ret; 429 } 430 EXPORT_SYMBOL(twl6040_set_pll); 431 432 int twl6040_get_pll(struct twl6040 *twl6040) 433 { 434 if (twl6040->power_count) 435 return twl6040->pll; 436 else 437 return -ENODEV; 438 } 439 EXPORT_SYMBOL(twl6040_get_pll); 440 441 unsigned int twl6040_get_sysclk(struct twl6040 *twl6040) 442 { 443 return twl6040->sysclk; 444 } 445 EXPORT_SYMBOL(twl6040_get_sysclk); 446 447 /* Get the combined status of the vibra control register */ 448 int twl6040_get_vibralr_status(struct twl6040 *twl6040) 449 { 450 unsigned int reg; 451 int ret; 452 u8 status; 453 454 ret = regmap_read(twl6040->regmap, TWL6040_REG_VIBCTLL, ®); 455 if (ret != 0) 456 return ret; 457 status = reg; 458 459 ret = regmap_read(twl6040->regmap, TWL6040_REG_VIBCTLR, ®); 460 if (ret != 0) 461 return ret; 462 status |= reg; 463 464 status &= (TWL6040_VIBENA | TWL6040_VIBSEL); 465 466 return status; 467 } 468 EXPORT_SYMBOL(twl6040_get_vibralr_status); 469 470 static struct resource twl6040_vibra_rsrc[] = { 471 { 472 .flags = IORESOURCE_IRQ, 473 }, 474 }; 475 476 static struct resource twl6040_codec_rsrc[] = { 477 { 478 .flags = IORESOURCE_IRQ, 479 }, 480 }; 481 482 static bool twl6040_readable_reg(struct device *dev, unsigned int reg) 483 { 484 /* Register 0 is not readable */ 485 if (!reg) 486 return false; 487 return true; 488 } 489 490 static bool twl6040_volatile_reg(struct device *dev, unsigned int reg) 491 { 492 switch (reg) { 493 case TWL6040_REG_VIBCTLL: 494 case TWL6040_REG_VIBCTLR: 495 case TWL6040_REG_INTMR: 496 return false; 497 default: 498 return true; 499 } 500 } 501 502 static struct regmap_config twl6040_regmap_config = { 503 .reg_bits = 8, 504 .val_bits = 8, 505 .max_register = TWL6040_REG_STATUS, /* 0x2e */ 506 507 .readable_reg = twl6040_readable_reg, 508 .volatile_reg = twl6040_volatile_reg, 509 510 .cache_type = REGCACHE_RBTREE, 511 }; 512 513 static const struct regmap_irq twl6040_irqs[] = { 514 { .reg_offset = 0, .mask = TWL6040_THINT, }, 515 { .reg_offset = 0, .mask = TWL6040_PLUGINT | TWL6040_UNPLUGINT, }, 516 { .reg_offset = 0, .mask = TWL6040_HOOKINT, }, 517 { .reg_offset = 0, .mask = TWL6040_HFINT, }, 518 { .reg_offset = 0, .mask = TWL6040_VIBINT, }, 519 { .reg_offset = 0, .mask = TWL6040_READYINT, }, 520 }; 521 522 static struct regmap_irq_chip twl6040_irq_chip = { 523 .name = "twl6040", 524 .irqs = twl6040_irqs, 525 .num_irqs = ARRAY_SIZE(twl6040_irqs), 526 527 .num_regs = 1, 528 .status_base = TWL6040_REG_INTID, 529 .mask_base = TWL6040_REG_INTMR, 530 }; 531 532 static int twl6040_probe(struct i2c_client *client, 533 const struct i2c_device_id *id) 534 { 535 struct device_node *node = client->dev.of_node; 536 struct twl6040 *twl6040; 537 struct mfd_cell *cell = NULL; 538 int irq, ret, children = 0; 539 540 if (!node) { 541 dev_err(&client->dev, "of node is missing\n"); 542 return -EINVAL; 543 } 544 545 /* In order to operate correctly we need valid interrupt config */ 546 if (!client->irq) { 547 dev_err(&client->dev, "Invalid IRQ configuration\n"); 548 return -EINVAL; 549 } 550 551 twl6040 = devm_kzalloc(&client->dev, sizeof(struct twl6040), 552 GFP_KERNEL); 553 if (!twl6040) 554 return -ENOMEM; 555 556 twl6040->regmap = devm_regmap_init_i2c(client, &twl6040_regmap_config); 557 if (IS_ERR(twl6040->regmap)) 558 return PTR_ERR(twl6040->regmap); 559 560 i2c_set_clientdata(client, twl6040); 561 562 twl6040->supplies[0].supply = "vio"; 563 twl6040->supplies[1].supply = "v2v1"; 564 ret = devm_regulator_bulk_get(&client->dev, TWL6040_NUM_SUPPLIES, 565 twl6040->supplies); 566 if (ret != 0) { 567 dev_err(&client->dev, "Failed to get supplies: %d\n", ret); 568 return ret; 569 } 570 571 ret = regulator_bulk_enable(TWL6040_NUM_SUPPLIES, twl6040->supplies); 572 if (ret != 0) { 573 dev_err(&client->dev, "Failed to enable supplies: %d\n", ret); 574 return ret; 575 } 576 577 twl6040->dev = &client->dev; 578 twl6040->irq = client->irq; 579 580 mutex_init(&twl6040->mutex); 581 init_completion(&twl6040->ready); 582 583 twl6040->rev = twl6040_reg_read(twl6040, TWL6040_REG_ASICREV); 584 585 /* ERRATA: Automatic power-up is not possible in ES1.0 */ 586 if (twl6040_get_revid(twl6040) > TWL6040_REV_ES1_0) 587 twl6040->audpwron = of_get_named_gpio(node, 588 "ti,audpwron-gpio", 0); 589 else 590 twl6040->audpwron = -EINVAL; 591 592 if (gpio_is_valid(twl6040->audpwron)) { 593 ret = devm_gpio_request_one(&client->dev, twl6040->audpwron, 594 GPIOF_OUT_INIT_LOW, "audpwron"); 595 if (ret) 596 goto gpio_err; 597 } 598 599 ret = regmap_add_irq_chip(twl6040->regmap, twl6040->irq, IRQF_ONESHOT, 600 0, &twl6040_irq_chip,&twl6040->irq_data); 601 if (ret < 0) 602 goto gpio_err; 603 604 twl6040->irq_ready = regmap_irq_get_virq(twl6040->irq_data, 605 TWL6040_IRQ_READY); 606 twl6040->irq_th = regmap_irq_get_virq(twl6040->irq_data, 607 TWL6040_IRQ_TH); 608 609 ret = devm_request_threaded_irq(twl6040->dev, twl6040->irq_ready, NULL, 610 twl6040_readyint_handler, IRQF_ONESHOT, 611 "twl6040_irq_ready", twl6040); 612 if (ret) { 613 dev_err(twl6040->dev, "READY IRQ request failed: %d\n", ret); 614 goto readyirq_err; 615 } 616 617 ret = devm_request_threaded_irq(twl6040->dev, twl6040->irq_th, NULL, 618 twl6040_thint_handler, IRQF_ONESHOT, 619 "twl6040_irq_th", twl6040); 620 if (ret) { 621 dev_err(twl6040->dev, "Thermal IRQ request failed: %d\n", ret); 622 goto readyirq_err; 623 } 624 625 /* dual-access registers controlled by I2C only */ 626 twl6040_set_bits(twl6040, TWL6040_REG_ACCCTL, TWL6040_I2CSEL); 627 628 /* 629 * The main functionality of twl6040 to provide audio on OMAP4+ systems. 630 * We can add the ASoC codec child whenever this driver has been loaded. 631 */ 632 irq = regmap_irq_get_virq(twl6040->irq_data, TWL6040_IRQ_PLUG); 633 cell = &twl6040->cells[children]; 634 cell->name = "twl6040-codec"; 635 twl6040_codec_rsrc[0].start = irq; 636 twl6040_codec_rsrc[0].end = irq; 637 cell->resources = twl6040_codec_rsrc; 638 cell->num_resources = ARRAY_SIZE(twl6040_codec_rsrc); 639 children++; 640 641 /* Vibra input driver support */ 642 if (twl6040_has_vibra(node)) { 643 irq = regmap_irq_get_virq(twl6040->irq_data, TWL6040_IRQ_VIB); 644 645 cell = &twl6040->cells[children]; 646 cell->name = "twl6040-vibra"; 647 twl6040_vibra_rsrc[0].start = irq; 648 twl6040_vibra_rsrc[0].end = irq; 649 cell->resources = twl6040_vibra_rsrc; 650 cell->num_resources = ARRAY_SIZE(twl6040_vibra_rsrc); 651 children++; 652 } 653 654 /* GPO support */ 655 cell = &twl6040->cells[children]; 656 cell->name = "twl6040-gpo"; 657 children++; 658 659 ret = mfd_add_devices(&client->dev, -1, twl6040->cells, children, 660 NULL, 0, NULL); 661 if (ret) 662 goto readyirq_err; 663 664 return 0; 665 666 readyirq_err: 667 regmap_del_irq_chip(twl6040->irq, twl6040->irq_data); 668 gpio_err: 669 regulator_bulk_disable(TWL6040_NUM_SUPPLIES, twl6040->supplies); 670 return ret; 671 } 672 673 static int twl6040_remove(struct i2c_client *client) 674 { 675 struct twl6040 *twl6040 = i2c_get_clientdata(client); 676 677 if (twl6040->power_count) 678 twl6040_power(twl6040, 0); 679 680 regmap_del_irq_chip(twl6040->irq, twl6040->irq_data); 681 682 mfd_remove_devices(&client->dev); 683 684 regulator_bulk_disable(TWL6040_NUM_SUPPLIES, twl6040->supplies); 685 686 return 0; 687 } 688 689 static const struct i2c_device_id twl6040_i2c_id[] = { 690 { "twl6040", 0, }, 691 { "twl6041", 0, }, 692 { }, 693 }; 694 MODULE_DEVICE_TABLE(i2c, twl6040_i2c_id); 695 696 static struct i2c_driver twl6040_driver = { 697 .driver = { 698 .name = "twl6040", 699 .owner = THIS_MODULE, 700 }, 701 .probe = twl6040_probe, 702 .remove = twl6040_remove, 703 .id_table = twl6040_i2c_id, 704 }; 705 706 module_i2c_driver(twl6040_driver); 707 708 MODULE_DESCRIPTION("TWL6040 MFD"); 709 MODULE_AUTHOR("Misael Lopez Cruz <misael.lopez@ti.com>"); 710 MODULE_AUTHOR("Jorge Eduardo Candelaria <jorge.candelaria@ti.com>"); 711 MODULE_LICENSE("GPL"); 712 MODULE_ALIAS("platform:twl6040"); 713