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