linux/drivers/mfd/twl6040.c
<<
>>
Prefs 
   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
  47static const 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
  89static 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
 100static 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
 109int 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}
 120EXPORT_SYMBOL(twl6040_reg_read);
 121
 122int 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}
 130EXPORT_SYMBOL(twl6040_reg_write);
 131
 132int twl6040_set_bits(struct twl6040 *twl6040, unsigned int reg, u8 mask)
 133{
 134        return regmap_update_bits(twl6040->regmap, reg, mask, mask);
 135}
 136EXPORT_SYMBOL(twl6040_set_bits);
 137
 138int twl6040_clear_bits(struct twl6040 *twl6040, unsigned int reg, u8 mask)
 139{
 140        return regmap_update_bits(twl6040->regmap, reg, mask, 0);
 141}
 142EXPORT_SYMBOL(twl6040_clear_bits);
 143
 144/* twl6040 codec manual power-up sequence */
 145static 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
 186osc_err:
 187        lppllctl &= ~TWL6040_LPLLENA;
 188        twl6040_reg_write(twl6040, TWL6040_REG_LPPLLCTL, lppllctl);
 189lppll_err:
 190        ldoctl &= ~TWL6040_LSLDOENA;
 191        twl6040_reg_write(twl6040, TWL6040_REG_LDOCTL, ldoctl);
 192lsldo_err:
 193        ncpctl &= ~TWL6040_NCPENA;
 194        twl6040_reg_write(twl6040, TWL6040_REG_NCPCTL, ncpctl);
 195ncp_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 */
 204static 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
 234static 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
 243static 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
 260static 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
 283int 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
 355out:
 356        mutex_unlock(&twl6040->mutex);
 357        return ret;
 358}
 359EXPORT_SYMBOL(twl6040_power);
 360
 361int 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
 492pll_out:
 493        mutex_unlock(&twl6040->mutex);
 494        return ret;
 495}
 496EXPORT_SYMBOL(twl6040_set_pll);
 497
 498int twl6040_get_pll(struct twl6040 *twl6040)
 499{
 500        if (twl6040->power_count)
 501                return twl6040->pll;
 502        else
 503                return -ENODEV;
 504}
 505EXPORT_SYMBOL(twl6040_get_pll);
 506
 507unsigned int twl6040_get_sysclk(struct twl6040 *twl6040)
 508{
 509        return twl6040->sysclk;
 510}
 511EXPORT_SYMBOL(twl6040_get_sysclk);
 512
 513/* Get the combined status of the vibra control register */
 514int 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}
 534EXPORT_SYMBOL(twl6040_get_vibralr_status);
 535
 536static struct resource twl6040_vibra_rsrc[] = {
 537        {
 538                .flags = IORESOURCE_IRQ,
 539        },
 540};
 541
 542static struct resource twl6040_codec_rsrc[] = {
 543        {
 544                .flags = IORESOURCE_IRQ,
 545        },
 546};
 547
 548static 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
 556static 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
 571static 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
 583static const 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
 599static 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
 608static 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
 618static 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
 771readyirq_err:
 772        regmap_del_irq_chip(twl6040->irq, twl6040->irq_data);
 773gpio_err:
 774        regulator_bulk_disable(TWL6040_NUM_SUPPLIES, twl6040->supplies);
 775        return ret;
 776}
 777
 778static 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
 794static const struct i2c_device_id twl6040_i2c_id[] = {
 795        { "twl6040", 0, },
 796        { "twl6041", 0, },
 797        { },
 798};
 799MODULE_DEVICE_TABLE(i2c, twl6040_i2c_id);
 800
 801static 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
 811module_i2c_driver(twl6040_driver);
 812
 813MODULE_DESCRIPTION("TWL6040 MFD");
 814MODULE_AUTHOR("Misael Lopez Cruz <misael.lopez@ti.com>");
 815MODULE_AUTHOR("Jorge Eduardo Candelaria <jorge.candelaria@ti.com>");
 816MODULE_LICENSE("GPL");
 817
Hosted by Missing Link Electronics. The original LXR software by the LXR community, this experimental version by lxr@linux.no.