drivers/mfd/twl6040.c

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