drivers/mfd/twl6040.c

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