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