linux/drivers/mfd/wm8994-core.c
<<
>>
Prefs
   1/*
   2 * wm8994-core.c  --  Device access for Wolfson WM8994
   3 *
   4 * Copyright 2009 Wolfson Microelectronics PLC.
   5 *
   6 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
   7 *
   8 *  This program is free software; you can redistribute  it and/or modify it
   9 *  under  the terms of  the GNU General  Public License as published by the
  10 *  Free Software Foundation;  either version 2 of the  License, or (at your
  11 *  option) any later version.
  12 *
  13 */
  14
  15#include <linux/kernel.h>
  16#include <linux/module.h>
  17#include <linux/slab.h>
  18#include <linux/i2c.h>
  19#include <linux/delay.h>
  20#include <linux/mfd/core.h>
  21#include <linux/pm_runtime.h>
  22#include <linux/regulator/consumer.h>
  23#include <linux/regulator/machine.h>
  24
  25#include <linux/mfd/wm8994/core.h>
  26#include <linux/mfd/wm8994/pdata.h>
  27#include <linux/mfd/wm8994/registers.h>
  28
  29static int wm8994_read(struct wm8994 *wm8994, unsigned short reg,
  30                       int bytes, void *dest)
  31{
  32        int ret, i;
  33        u16 *buf = dest;
  34
  35        BUG_ON(bytes % 2);
  36        BUG_ON(bytes <= 0);
  37
  38        ret = wm8994->read_dev(wm8994, reg, bytes, dest);
  39        if (ret < 0)
  40                return ret;
  41
  42        for (i = 0; i < bytes / 2; i++) {
  43                dev_vdbg(wm8994->dev, "Read %04x from R%d(0x%x)\n",
  44                         be16_to_cpu(buf[i]), reg + i, reg + i);
  45        }
  46
  47        return 0;
  48}
  49
  50/**
  51 * wm8994_reg_read: Read a single WM8994 register.
  52 *
  53 * @wm8994: Device to read from.
  54 * @reg: Register to read.
  55 */
  56int wm8994_reg_read(struct wm8994 *wm8994, unsigned short reg)
  57{
  58        unsigned short val;
  59        int ret;
  60
  61        mutex_lock(&wm8994->io_lock);
  62
  63        ret = wm8994_read(wm8994, reg, 2, &val);
  64
  65        mutex_unlock(&wm8994->io_lock);
  66
  67        if (ret < 0)
  68                return ret;
  69        else
  70                return be16_to_cpu(val);
  71}
  72EXPORT_SYMBOL_GPL(wm8994_reg_read);
  73
  74/**
  75 * wm8994_bulk_read: Read multiple WM8994 registers
  76 *
  77 * @wm8994: Device to read from
  78 * @reg: First register
  79 * @count: Number of registers
  80 * @buf: Buffer to fill.  The data will be returned big endian.
  81 */
  82int wm8994_bulk_read(struct wm8994 *wm8994, unsigned short reg,
  83                     int count, u16 *buf)
  84{
  85        int ret;
  86
  87        mutex_lock(&wm8994->io_lock);
  88
  89        ret = wm8994_read(wm8994, reg, count * 2, buf);
  90
  91        mutex_unlock(&wm8994->io_lock);
  92
  93        return ret;
  94}
  95EXPORT_SYMBOL_GPL(wm8994_bulk_read);
  96
  97static int wm8994_write(struct wm8994 *wm8994, unsigned short reg,
  98                        int bytes, const void *src)
  99{
 100        const u16 *buf = src;
 101        int i;
 102
 103        BUG_ON(bytes % 2);
 104        BUG_ON(bytes <= 0);
 105
 106        for (i = 0; i < bytes / 2; i++) {
 107                dev_vdbg(wm8994->dev, "Write %04x to R%d(0x%x)\n",
 108                         be16_to_cpu(buf[i]), reg + i, reg + i);
 109        }
 110
 111        return wm8994->write_dev(wm8994, reg, bytes, src);
 112}
 113
 114/**
 115 * wm8994_reg_write: Write a single WM8994 register.
 116 *
 117 * @wm8994: Device to write to.
 118 * @reg: Register to write to.
 119 * @val: Value to write.
 120 */
 121int wm8994_reg_write(struct wm8994 *wm8994, unsigned short reg,
 122                     unsigned short val)
 123{
 124        int ret;
 125
 126        val = cpu_to_be16(val);
 127
 128        mutex_lock(&wm8994->io_lock);
 129
 130        ret = wm8994_write(wm8994, reg, 2, &val);
 131
 132        mutex_unlock(&wm8994->io_lock);
 133
 134        return ret;
 135}
 136EXPORT_SYMBOL_GPL(wm8994_reg_write);
 137
 138/**
 139 * wm8994_bulk_write: Write multiple WM8994 registers
 140 *
 141 * @wm8994: Device to write to
 142 * @reg: First register
 143 * @count: Number of registers
 144 * @buf: Buffer to write from.  Data must be big-endian formatted.
 145 */
 146int wm8994_bulk_write(struct wm8994 *wm8994, unsigned short reg,
 147                      int count, const u16 *buf)
 148{
 149        int ret;
 150
 151        mutex_lock(&wm8994->io_lock);
 152
 153        ret = wm8994_write(wm8994, reg, count * 2, buf);
 154
 155        mutex_unlock(&wm8994->io_lock);
 156
 157        return ret;
 158}
 159EXPORT_SYMBOL_GPL(wm8994_bulk_write);
 160
 161/**
 162 * wm8994_set_bits: Set the value of a bitfield in a WM8994 register
 163 *
 164 * @wm8994: Device to write to.
 165 * @reg: Register to write to.
 166 * @mask: Mask of bits to set.
 167 * @val: Value to set (unshifted)
 168 */
 169int wm8994_set_bits(struct wm8994 *wm8994, unsigned short reg,
 170                    unsigned short mask, unsigned short val)
 171{
 172        int ret;
 173        u16 r;
 174
 175        mutex_lock(&wm8994->io_lock);
 176
 177        ret = wm8994_read(wm8994, reg, 2, &r);
 178        if (ret < 0)
 179                goto out;
 180
 181        r = be16_to_cpu(r);
 182
 183        r &= ~mask;
 184        r |= val;
 185
 186        r = cpu_to_be16(r);
 187
 188        ret = wm8994_write(wm8994, reg, 2, &r);
 189
 190out:
 191        mutex_unlock(&wm8994->io_lock);
 192
 193        return ret;
 194}
 195EXPORT_SYMBOL_GPL(wm8994_set_bits);
 196
 197static struct mfd_cell wm8994_regulator_devs[] = {
 198        {
 199                .name = "wm8994-ldo",
 200                .id = 1,
 201                .pm_runtime_no_callbacks = true,
 202        },
 203        {
 204                .name = "wm8994-ldo",
 205                .id = 2,
 206                .pm_runtime_no_callbacks = true,
 207        },
 208};
 209
 210static struct resource wm8994_codec_resources[] = {
 211        {
 212                .start = WM8994_IRQ_TEMP_SHUT,
 213                .end   = WM8994_IRQ_TEMP_WARN,
 214                .flags = IORESOURCE_IRQ,
 215        },
 216};
 217
 218static struct resource wm8994_gpio_resources[] = {
 219        {
 220                .start = WM8994_IRQ_GPIO(1),
 221                .end   = WM8994_IRQ_GPIO(11),
 222                .flags = IORESOURCE_IRQ,
 223        },
 224};
 225
 226static struct mfd_cell wm8994_devs[] = {
 227        {
 228                .name = "wm8994-codec",
 229                .num_resources = ARRAY_SIZE(wm8994_codec_resources),
 230                .resources = wm8994_codec_resources,
 231        },
 232
 233        {
 234                .name = "wm8994-gpio",
 235                .num_resources = ARRAY_SIZE(wm8994_gpio_resources),
 236                .resources = wm8994_gpio_resources,
 237                .pm_runtime_no_callbacks = true,
 238        },
 239};
 240
 241/*
 242 * Supplies for the main bulk of CODEC; the LDO supplies are ignored
 243 * and should be handled via the standard regulator API supply
 244 * management.
 245 */
 246static const char *wm8994_main_supplies[] = {
 247        "DBVDD",
 248        "DCVDD",
 249        "AVDD1",
 250        "AVDD2",
 251        "CPVDD",
 252        "SPKVDD1",
 253        "SPKVDD2",
 254};
 255
 256static const char *wm8958_main_supplies[] = {
 257        "DBVDD1",
 258        "DBVDD2",
 259        "DBVDD3",
 260        "DCVDD",
 261        "AVDD1",
 262        "AVDD2",
 263        "CPVDD",
 264        "SPKVDD1",
 265        "SPKVDD2",
 266};
 267
 268#ifdef CONFIG_PM
 269static int wm8994_suspend(struct device *dev)
 270{
 271        struct wm8994 *wm8994 = dev_get_drvdata(dev);
 272        int ret;
 273
 274        /* Don't actually go through with the suspend if the CODEC is
 275         * still active (eg, for audio passthrough from CP. */
 276        ret = wm8994_reg_read(wm8994, WM8994_POWER_MANAGEMENT_1);
 277        if (ret < 0) {
 278                dev_err(dev, "Failed to read power status: %d\n", ret);
 279        } else if (ret & WM8994_VMID_SEL_MASK) {
 280                dev_dbg(dev, "CODEC still active, ignoring suspend\n");
 281                return 0;
 282        }
 283
 284        /* GPIO configuration state is saved here since we may be configuring
 285         * the GPIO alternate functions even if we're not using the gpiolib
 286         * driver for them.
 287         */
 288        ret = wm8994_read(wm8994, WM8994_GPIO_1, WM8994_NUM_GPIO_REGS * 2,
 289                          &wm8994->gpio_regs);
 290        if (ret < 0)
 291                dev_err(dev, "Failed to save GPIO registers: %d\n", ret);
 292
 293        /* For similar reasons we also stash the regulator states */
 294        ret = wm8994_read(wm8994, WM8994_LDO_1, WM8994_NUM_LDO_REGS * 2,
 295                          &wm8994->ldo_regs);
 296        if (ret < 0)
 297                dev_err(dev, "Failed to save LDO registers: %d\n", ret);
 298
 299        /* Explicitly put the device into reset in case regulators
 300         * don't get disabled in order to ensure consistent restart.
 301         */
 302        wm8994_reg_write(wm8994, WM8994_SOFTWARE_RESET, 0x8994);
 303
 304        wm8994->suspended = true;
 305
 306        ret = regulator_bulk_disable(wm8994->num_supplies,
 307                                     wm8994->supplies);
 308        if (ret != 0) {
 309                dev_err(dev, "Failed to disable supplies: %d\n", ret);
 310                return ret;
 311        }
 312
 313        return 0;
 314}
 315
 316static int wm8994_resume(struct device *dev)
 317{
 318        struct wm8994 *wm8994 = dev_get_drvdata(dev);
 319        int ret;
 320
 321        /* We may have lied to the PM core about suspending */
 322        if (!wm8994->suspended)
 323                return 0;
 324
 325        ret = regulator_bulk_enable(wm8994->num_supplies,
 326                                    wm8994->supplies);
 327        if (ret != 0) {
 328                dev_err(dev, "Failed to enable supplies: %d\n", ret);
 329                return ret;
 330        }
 331
 332        ret = wm8994_write(wm8994, WM8994_INTERRUPT_STATUS_1_MASK,
 333                           WM8994_NUM_IRQ_REGS * 2, &wm8994->irq_masks_cur);
 334        if (ret < 0)
 335                dev_err(dev, "Failed to restore interrupt masks: %d\n", ret);
 336
 337        ret = wm8994_write(wm8994, WM8994_LDO_1, WM8994_NUM_LDO_REGS * 2,
 338                           &wm8994->ldo_regs);
 339        if (ret < 0)
 340                dev_err(dev, "Failed to restore LDO registers: %d\n", ret);
 341
 342        ret = wm8994_write(wm8994, WM8994_GPIO_1, WM8994_NUM_GPIO_REGS * 2,
 343                           &wm8994->gpio_regs);
 344        if (ret < 0)
 345                dev_err(dev, "Failed to restore GPIO registers: %d\n", ret);
 346
 347        wm8994->suspended = false;
 348
 349        return 0;
 350}
 351#endif
 352
 353#ifdef CONFIG_REGULATOR
 354static int wm8994_ldo_in_use(struct wm8994_pdata *pdata, int ldo)
 355{
 356        struct wm8994_ldo_pdata *ldo_pdata;
 357
 358        if (!pdata)
 359                return 0;
 360
 361        ldo_pdata = &pdata->ldo[ldo];
 362
 363        if (!ldo_pdata->init_data)
 364                return 0;
 365
 366        return ldo_pdata->init_data->num_consumer_supplies != 0;
 367}
 368#else
 369static int wm8994_ldo_in_use(struct wm8994_pdata *pdata, int ldo)
 370{
 371        return 0;
 372}
 373#endif
 374
 375/*
 376 * Instantiate the generic non-control parts of the device.
 377 */
 378static int wm8994_device_init(struct wm8994 *wm8994, int irq)
 379{
 380        struct wm8994_pdata *pdata = wm8994->dev->platform_data;
 381        const char *devname;
 382        int ret, i;
 383
 384        mutex_init(&wm8994->io_lock);
 385        dev_set_drvdata(wm8994->dev, wm8994);
 386
 387        /* Add the on-chip regulators first for bootstrapping */
 388        ret = mfd_add_devices(wm8994->dev, -1,
 389                              wm8994_regulator_devs,
 390                              ARRAY_SIZE(wm8994_regulator_devs),
 391                              NULL, 0);
 392        if (ret != 0) {
 393                dev_err(wm8994->dev, "Failed to add children: %d\n", ret);
 394                goto err;
 395        }
 396
 397        switch (wm8994->type) {
 398        case WM8994:
 399                wm8994->num_supplies = ARRAY_SIZE(wm8994_main_supplies);
 400                break;
 401        case WM8958:
 402                wm8994->num_supplies = ARRAY_SIZE(wm8958_main_supplies);
 403                break;
 404        default:
 405                BUG();
 406                return -EINVAL;
 407        }
 408
 409        wm8994->supplies = kzalloc(sizeof(struct regulator_bulk_data) *
 410                                   wm8994->num_supplies,
 411                                   GFP_KERNEL);
 412        if (!wm8994->supplies) {
 413                ret = -ENOMEM;
 414                goto err;
 415        }
 416
 417        switch (wm8994->type) {
 418        case WM8994:
 419                for (i = 0; i < ARRAY_SIZE(wm8994_main_supplies); i++)
 420                        wm8994->supplies[i].supply = wm8994_main_supplies[i];
 421                break;
 422        case WM8958:
 423                for (i = 0; i < ARRAY_SIZE(wm8958_main_supplies); i++)
 424                        wm8994->supplies[i].supply = wm8958_main_supplies[i];
 425                break;
 426        default:
 427                BUG();
 428                return -EINVAL;
 429        }
 430                
 431        ret = regulator_bulk_get(wm8994->dev, wm8994->num_supplies,
 432                                 wm8994->supplies);
 433        if (ret != 0) {
 434                dev_err(wm8994->dev, "Failed to get supplies: %d\n", ret);
 435                goto err_supplies;
 436        }
 437
 438        ret = regulator_bulk_enable(wm8994->num_supplies,
 439                                    wm8994->supplies);
 440        if (ret != 0) {
 441                dev_err(wm8994->dev, "Failed to enable supplies: %d\n", ret);
 442                goto err_get;
 443        }
 444
 445        ret = wm8994_reg_read(wm8994, WM8994_SOFTWARE_RESET);
 446        if (ret < 0) {
 447                dev_err(wm8994->dev, "Failed to read ID register\n");
 448                goto err_enable;
 449        }
 450        switch (ret) {
 451        case 0x8994:
 452                devname = "WM8994";
 453                if (wm8994->type != WM8994)
 454                        dev_warn(wm8994->dev, "Device registered as type %d\n",
 455                                 wm8994->type);
 456                wm8994->type = WM8994;
 457                break;
 458        case 0x8958:
 459                devname = "WM8958";
 460                if (wm8994->type != WM8958)
 461                        dev_warn(wm8994->dev, "Device registered as type %d\n",
 462                                 wm8994->type);
 463                wm8994->type = WM8958;
 464                break;
 465        default:
 466                dev_err(wm8994->dev, "Device is not a WM8994, ID is %x\n",
 467                        ret);
 468                ret = -EINVAL;
 469                goto err_enable;
 470        }
 471
 472        ret = wm8994_reg_read(wm8994, WM8994_CHIP_REVISION);
 473        if (ret < 0) {
 474                dev_err(wm8994->dev, "Failed to read revision register: %d\n",
 475                        ret);
 476                goto err_enable;
 477        }
 478
 479        switch (ret) {
 480        case 0:
 481        case 1:
 482                if (wm8994->type == WM8994)
 483                        dev_warn(wm8994->dev,
 484                                 "revision %c not fully supported\n",
 485                                 'A' + ret);
 486                break;
 487        default:
 488                break;
 489        }
 490
 491        dev_info(wm8994->dev, "%s revision %c\n", devname, 'A' + ret);
 492
 493        if (pdata) {
 494                wm8994->irq_base = pdata->irq_base;
 495                wm8994->gpio_base = pdata->gpio_base;
 496
 497                /* GPIO configuration is only applied if it's non-zero */
 498                for (i = 0; i < ARRAY_SIZE(pdata->gpio_defaults); i++) {
 499                        if (pdata->gpio_defaults[i]) {
 500                                wm8994_set_bits(wm8994, WM8994_GPIO_1 + i,
 501                                                0xffff,
 502                                                pdata->gpio_defaults[i]);
 503                        }
 504                }
 505        }
 506
 507        /* In some system designs where the regulators are not in use,
 508         * we can achieve a small reduction in leakage currents by
 509         * floating LDO outputs.  This bit makes no difference if the
 510         * LDOs are enabled, it only affects cases where the LDOs were
 511         * in operation and are then disabled.
 512         */
 513        for (i = 0; i < WM8994_NUM_LDO_REGS; i++) {
 514                if (wm8994_ldo_in_use(pdata, i))
 515                        wm8994_set_bits(wm8994, WM8994_LDO_1 + i,
 516                                        WM8994_LDO1_DISCH, WM8994_LDO1_DISCH);
 517                else
 518                        wm8994_set_bits(wm8994, WM8994_LDO_1 + i,
 519                                        WM8994_LDO1_DISCH, 0);
 520        }
 521
 522        wm8994_irq_init(wm8994);
 523
 524        ret = mfd_add_devices(wm8994->dev, -1,
 525                              wm8994_devs, ARRAY_SIZE(wm8994_devs),
 526                              NULL, 0);
 527        if (ret != 0) {
 528                dev_err(wm8994->dev, "Failed to add children: %d\n", ret);
 529                goto err_irq;
 530        }
 531
 532        pm_runtime_enable(wm8994->dev);
 533        pm_runtime_resume(wm8994->dev);
 534
 535        return 0;
 536
 537err_irq:
 538        wm8994_irq_exit(wm8994);
 539err_enable:
 540        regulator_bulk_disable(wm8994->num_supplies,
 541                               wm8994->supplies);
 542err_get:
 543        regulator_bulk_free(wm8994->num_supplies, wm8994->supplies);
 544err_supplies:
 545        kfree(wm8994->supplies);
 546err:
 547        mfd_remove_devices(wm8994->dev);
 548        kfree(wm8994);
 549        return ret;
 550}
 551
 552static void wm8994_device_exit(struct wm8994 *wm8994)
 553{
 554        pm_runtime_disable(wm8994->dev);
 555        mfd_remove_devices(wm8994->dev);
 556        wm8994_irq_exit(wm8994);
 557        regulator_bulk_disable(wm8994->num_supplies,
 558                               wm8994->supplies);
 559        regulator_bulk_free(wm8994->num_supplies, wm8994->supplies);
 560        kfree(wm8994->supplies);
 561        kfree(wm8994);
 562}
 563
 564static int wm8994_i2c_read_device(struct wm8994 *wm8994, unsigned short reg,
 565                                  int bytes, void *dest)
 566{
 567        struct i2c_client *i2c = wm8994->control_data;
 568        int ret;
 569        u16 r = cpu_to_be16(reg);
 570
 571        ret = i2c_master_send(i2c, (unsigned char *)&r, 2);
 572        if (ret < 0)
 573                return ret;
 574        if (ret != 2)
 575                return -EIO;
 576
 577        ret = i2c_master_recv(i2c, dest, bytes);
 578        if (ret < 0)
 579                return ret;
 580        if (ret != bytes)
 581                return -EIO;
 582        return 0;
 583}
 584
 585static int wm8994_i2c_write_device(struct wm8994 *wm8994, unsigned short reg,
 586                                   int bytes, const void *src)
 587{
 588        struct i2c_client *i2c = wm8994->control_data;
 589        struct i2c_msg xfer[2];
 590        int ret;
 591
 592        reg = cpu_to_be16(reg);
 593
 594        xfer[0].addr = i2c->addr;
 595        xfer[0].flags = 0;
 596        xfer[0].len = 2;
 597        xfer[0].buf = (char *)&reg;
 598
 599        xfer[1].addr = i2c->addr;
 600        xfer[1].flags = I2C_M_NOSTART;
 601        xfer[1].len = bytes;
 602        xfer[1].buf = (char *)src;
 603
 604        ret = i2c_transfer(i2c->adapter, xfer, 2);
 605        if (ret < 0)
 606                return ret;
 607        if (ret != 2)
 608                return -EIO;
 609
 610        return 0;
 611}
 612
 613static int wm8994_i2c_probe(struct i2c_client *i2c,
 614                            const struct i2c_device_id *id)
 615{
 616        struct wm8994 *wm8994;
 617
 618        wm8994 = kzalloc(sizeof(struct wm8994), GFP_KERNEL);
 619        if (wm8994 == NULL)
 620                return -ENOMEM;
 621
 622        i2c_set_clientdata(i2c, wm8994);
 623        wm8994->dev = &i2c->dev;
 624        wm8994->control_data = i2c;
 625        wm8994->read_dev = wm8994_i2c_read_device;
 626        wm8994->write_dev = wm8994_i2c_write_device;
 627        wm8994->irq = i2c->irq;
 628        wm8994->type = id->driver_data;
 629
 630        return wm8994_device_init(wm8994, i2c->irq);
 631}
 632
 633static int wm8994_i2c_remove(struct i2c_client *i2c)
 634{
 635        struct wm8994 *wm8994 = i2c_get_clientdata(i2c);
 636
 637        wm8994_device_exit(wm8994);
 638
 639        return 0;
 640}
 641
 642static const struct i2c_device_id wm8994_i2c_id[] = {
 643        { "wm8994", WM8994 },
 644        { "wm8958", WM8958 },
 645        { }
 646};
 647MODULE_DEVICE_TABLE(i2c, wm8994_i2c_id);
 648
 649static UNIVERSAL_DEV_PM_OPS(wm8994_pm_ops, wm8994_suspend, wm8994_resume,
 650                            NULL);
 651
 652static struct i2c_driver wm8994_i2c_driver = {
 653        .driver = {
 654                .name = "wm8994",
 655                .owner = THIS_MODULE,
 656                .pm = &wm8994_pm_ops,
 657        },
 658        .probe = wm8994_i2c_probe,
 659        .remove = wm8994_i2c_remove,
 660        .id_table = wm8994_i2c_id,
 661};
 662
 663static int __init wm8994_i2c_init(void)
 664{
 665        int ret;
 666
 667        ret = i2c_add_driver(&wm8994_i2c_driver);
 668        if (ret != 0)
 669                pr_err("Failed to register wm8994 I2C driver: %d\n", ret);
 670
 671        return ret;
 672}
 673module_init(wm8994_i2c_init);
 674
 675static void __exit wm8994_i2c_exit(void)
 676{
 677        i2c_del_driver(&wm8994_i2c_driver);
 678}
 679module_exit(wm8994_i2c_exit);
 680
 681MODULE_DESCRIPTION("Core support for the WM8994 audio CODEC");
 682MODULE_LICENSE("GPL");
 683MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
 684