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/err.h>
  20#include <linux/delay.h>
  21#include <linux/mfd/core.h>
  22#include <linux/of.h>
  23#include <linux/of_device.h>
  24#include <linux/of_gpio.h>
  25#include <linux/pm_runtime.h>
  26#include <linux/regmap.h>
  27#include <linux/regulator/consumer.h>
  28#include <linux/regulator/machine.h>
  29
  30#include <linux/mfd/wm8994/core.h>
  31#include <linux/mfd/wm8994/pdata.h>
  32#include <linux/mfd/wm8994/registers.h>
  33
  34#include "wm8994.h"
  35
  36/**
  37 * wm8994_reg_read: Read a single WM8994 register.
  38 *
  39 * @wm8994: Device to read from.
  40 * @reg: Register to read.
  41 */
  42int wm8994_reg_read(struct wm8994 *wm8994, unsigned short reg)
  43{
  44        unsigned int val;
  45        int ret;
  46
  47        ret = regmap_read(wm8994->regmap, reg, &val);
  48
  49        if (ret < 0)
  50                return ret;
  51        else
  52                return val;
  53}
  54EXPORT_SYMBOL_GPL(wm8994_reg_read);
  55
  56/**
  57 * wm8994_bulk_read: Read multiple WM8994 registers
  58 *
  59 * @wm8994: Device to read from
  60 * @reg: First register
  61 * @count: Number of registers
  62 * @buf: Buffer to fill.  The data will be returned big endian.
  63 */
  64int wm8994_bulk_read(struct wm8994 *wm8994, unsigned short reg,
  65                     int count, u16 *buf)
  66{
  67        return regmap_bulk_read(wm8994->regmap, reg, buf, count);
  68}
  69
  70/**
  71 * wm8994_reg_write: Write a single WM8994 register.
  72 *
  73 * @wm8994: Device to write to.
  74 * @reg: Register to write to.
  75 * @val: Value to write.
  76 */
  77int wm8994_reg_write(struct wm8994 *wm8994, unsigned short reg,
  78                     unsigned short val)
  79{
  80        return regmap_write(wm8994->regmap, reg, val);
  81}
  82EXPORT_SYMBOL_GPL(wm8994_reg_write);
  83
  84/**
  85 * wm8994_bulk_write: Write multiple WM8994 registers
  86 *
  87 * @wm8994: Device to write to
  88 * @reg: First register
  89 * @count: Number of registers
  90 * @buf: Buffer to write from.  Data must be big-endian formatted.
  91 */
  92int wm8994_bulk_write(struct wm8994 *wm8994, unsigned short reg,
  93                      int count, const u16 *buf)
  94{
  95        return regmap_raw_write(wm8994->regmap, reg, buf, count * sizeof(u16));
  96}
  97EXPORT_SYMBOL_GPL(wm8994_bulk_write);
  98
  99/**
 100 * wm8994_set_bits: Set the value of a bitfield in a WM8994 register
 101 *
 102 * @wm8994: Device to write to.
 103 * @reg: Register to write to.
 104 * @mask: Mask of bits to set.
 105 * @val: Value to set (unshifted)
 106 */
 107int wm8994_set_bits(struct wm8994 *wm8994, unsigned short reg,
 108                    unsigned short mask, unsigned short val)
 109{
 110        return regmap_update_bits(wm8994->regmap, reg, mask, val);
 111}
 112EXPORT_SYMBOL_GPL(wm8994_set_bits);
 113
 114static struct mfd_cell wm8994_regulator_devs[] = {
 115        {
 116                .name = "wm8994-ldo",
 117                .id = 1,
 118                .pm_runtime_no_callbacks = true,
 119        },
 120        {
 121                .name = "wm8994-ldo",
 122                .id = 2,
 123                .pm_runtime_no_callbacks = true,
 124        },
 125};
 126
 127static struct resource wm8994_codec_resources[] = {
 128        {
 129                .start = WM8994_IRQ_TEMP_SHUT,
 130                .end   = WM8994_IRQ_TEMP_WARN,
 131                .flags = IORESOURCE_IRQ,
 132        },
 133};
 134
 135static struct resource wm8994_gpio_resources[] = {
 136        {
 137                .start = WM8994_IRQ_GPIO(1),
 138                .end   = WM8994_IRQ_GPIO(11),
 139                .flags = IORESOURCE_IRQ,
 140        },
 141};
 142
 143static struct mfd_cell wm8994_devs[] = {
 144        {
 145                .name = "wm8994-codec",
 146                .num_resources = ARRAY_SIZE(wm8994_codec_resources),
 147                .resources = wm8994_codec_resources,
 148        },
 149
 150        {
 151                .name = "wm8994-gpio",
 152                .num_resources = ARRAY_SIZE(wm8994_gpio_resources),
 153                .resources = wm8994_gpio_resources,
 154                .pm_runtime_no_callbacks = true,
 155        },
 156};
 157
 158/*
 159 * Supplies for the main bulk of CODEC; the LDO supplies are ignored
 160 * and should be handled via the standard regulator API supply
 161 * management.
 162 */
 163static const char *wm1811_main_supplies[] = {
 164        "DBVDD1",
 165        "DBVDD2",
 166        "DBVDD3",
 167        "DCVDD",
 168        "AVDD1",
 169        "AVDD2",
 170        "CPVDD",
 171        "SPKVDD1",
 172        "SPKVDD2",
 173};
 174
 175static const char *wm8994_main_supplies[] = {
 176        "DBVDD",
 177        "DCVDD",
 178        "AVDD1",
 179        "AVDD2",
 180        "CPVDD",
 181        "SPKVDD1",
 182        "SPKVDD2",
 183};
 184
 185static const char *wm8958_main_supplies[] = {
 186        "DBVDD1",
 187        "DBVDD2",
 188        "DBVDD3",
 189        "DCVDD",
 190        "AVDD1",
 191        "AVDD2",
 192        "CPVDD",
 193        "SPKVDD1",
 194        "SPKVDD2",
 195};
 196
 197#ifdef CONFIG_PM_RUNTIME
 198static int wm8994_suspend(struct device *dev)
 199{
 200        struct wm8994 *wm8994 = dev_get_drvdata(dev);
 201        int ret;
 202
 203        /* Don't actually go through with the suspend if the CODEC is
 204         * still active for accessory detect. */
 205        switch (wm8994->type) {
 206        case WM8958:
 207        case WM1811:
 208                ret = wm8994_reg_read(wm8994, WM8958_MIC_DETECT_1);
 209                if (ret < 0) {
 210                        dev_err(dev, "Failed to read power status: %d\n", ret);
 211                } else if (ret & WM8958_MICD_ENA) {
 212                        dev_dbg(dev, "CODEC still active, ignoring suspend\n");
 213                        return 0;
 214                }
 215                break;
 216        default:
 217                break;
 218        }
 219
 220        /* Disable LDO pulldowns while the device is suspended if we
 221         * don't know that something will be driving them. */
 222        if (!wm8994->ldo_ena_always_driven)
 223                wm8994_set_bits(wm8994, WM8994_PULL_CONTROL_2,
 224                                WM8994_LDO1ENA_PD | WM8994_LDO2ENA_PD,
 225                                WM8994_LDO1ENA_PD | WM8994_LDO2ENA_PD);
 226
 227        /* Explicitly put the device into reset in case regulators
 228         * don't get disabled in order to ensure consistent restart.
 229         */
 230        wm8994_reg_write(wm8994, WM8994_SOFTWARE_RESET,
 231                         wm8994_reg_read(wm8994, WM8994_SOFTWARE_RESET));
 232
 233        regcache_mark_dirty(wm8994->regmap);
 234
 235        /* Restore GPIO registers to prevent problems with mismatched
 236         * pin configurations.
 237         */
 238        ret = regcache_sync_region(wm8994->regmap, WM8994_GPIO_1,
 239                                   WM8994_GPIO_11);
 240        if (ret != 0)
 241                dev_err(dev, "Failed to restore GPIO registers: %d\n", ret);
 242
 243        /* In case one of the GPIOs is used as a wake input. */
 244        ret = regcache_sync_region(wm8994->regmap,
 245                                   WM8994_INTERRUPT_STATUS_1_MASK,
 246                                   WM8994_INTERRUPT_STATUS_1_MASK);
 247        if (ret != 0)
 248                dev_err(dev, "Failed to restore interrupt mask: %d\n", ret);
 249
 250        regcache_cache_only(wm8994->regmap, true);
 251        wm8994->suspended = true;
 252
 253        ret = regulator_bulk_disable(wm8994->num_supplies,
 254                                     wm8994->supplies);
 255        if (ret != 0) {
 256                dev_err(dev, "Failed to disable supplies: %d\n", ret);
 257                return ret;
 258        }
 259
 260        return 0;
 261}
 262
 263static int wm8994_resume(struct device *dev)
 264{
 265        struct wm8994 *wm8994 = dev_get_drvdata(dev);
 266        int ret;
 267
 268        /* We may have lied to the PM core about suspending */
 269        if (!wm8994->suspended)
 270                return 0;
 271
 272        ret = regulator_bulk_enable(wm8994->num_supplies,
 273                                    wm8994->supplies);
 274        if (ret != 0) {
 275                dev_err(dev, "Failed to enable supplies: %d\n", ret);
 276                return ret;
 277        }
 278
 279        regcache_cache_only(wm8994->regmap, false);
 280        ret = regcache_sync(wm8994->regmap);
 281        if (ret != 0) {
 282                dev_err(dev, "Failed to restore register map: %d\n", ret);
 283                goto err_enable;
 284        }
 285
 286        /* Disable LDO pulldowns while the device is active */
 287        wm8994_set_bits(wm8994, WM8994_PULL_CONTROL_2,
 288                        WM8994_LDO1ENA_PD | WM8994_LDO2ENA_PD,
 289                        0);
 290
 291        wm8994->suspended = false;
 292
 293        return 0;
 294
 295err_enable:
 296        regulator_bulk_disable(wm8994->num_supplies, wm8994->supplies);
 297
 298        return ret;
 299}
 300#endif
 301
 302#ifdef CONFIG_REGULATOR
 303static int wm8994_ldo_in_use(struct wm8994_pdata *pdata, int ldo)
 304{
 305        struct wm8994_ldo_pdata *ldo_pdata;
 306
 307        if (!pdata)
 308                return 0;
 309
 310        ldo_pdata = &pdata->ldo[ldo];
 311
 312        if (!ldo_pdata->init_data)
 313                return 0;
 314
 315        return ldo_pdata->init_data->num_consumer_supplies != 0;
 316}
 317#else
 318static int wm8994_ldo_in_use(struct wm8994_pdata *pdata, int ldo)
 319{
 320        return 0;
 321}
 322#endif
 323
 324static const struct reg_default wm8994_revc_patch[] = {
 325        { 0x102, 0x3 },
 326        { 0x56, 0x3 },
 327        { 0x817, 0x0 },
 328        { 0x102, 0x0 },
 329};
 330
 331static const struct reg_default wm8958_reva_patch[] = {
 332        { 0x102, 0x3 },
 333        { 0xcb, 0x81 },
 334        { 0x817, 0x0 },
 335        { 0x102, 0x0 },
 336};
 337
 338static const struct reg_default wm1811_reva_patch[] = {
 339        { 0x102, 0x3 },
 340        { 0x56, 0xc07 },
 341        { 0x5d, 0x7e },
 342        { 0x5e, 0x0 },
 343        { 0x102, 0x0 },
 344};
 345
 346#ifdef CONFIG_OF
 347static int wm8994_set_pdata_from_of(struct wm8994 *wm8994)
 348{
 349        struct device_node *np = wm8994->dev->of_node;
 350        struct wm8994_pdata *pdata = &wm8994->pdata;
 351        int i;
 352
 353        if (!np)
 354                return 0;
 355
 356        if (of_property_read_u32_array(np, "wlf,gpio-cfg", pdata->gpio_defaults,
 357                                       ARRAY_SIZE(pdata->gpio_defaults)) >= 0) {
 358                for (i = 0; i < ARRAY_SIZE(pdata->gpio_defaults); i++) {
 359                        if (wm8994->pdata.gpio_defaults[i] == 0)
 360                                pdata->gpio_defaults[i]
 361                                        = WM8994_CONFIGURE_GPIO;
 362                }
 363        }
 364
 365        of_property_read_u32_array(np, "wlf,micbias-cfg", pdata->micbias,
 366                                   ARRAY_SIZE(pdata->micbias));
 367
 368        pdata->lineout1_diff = true;
 369        pdata->lineout2_diff = true;
 370        if (of_find_property(np, "wlf,lineout1-se", NULL))
 371                pdata->lineout1_diff = false;
 372        if (of_find_property(np, "wlf,lineout2-se", NULL))
 373                pdata->lineout2_diff = false;
 374
 375        if (of_find_property(np, "wlf,lineout1-feedback", NULL))
 376                pdata->lineout1fb = true;
 377        if (of_find_property(np, "wlf,lineout2-feedback", NULL))
 378                pdata->lineout2fb = true;
 379
 380        if (of_find_property(np, "wlf,ldoena-always-driven", NULL))
 381                pdata->lineout2fb = true;
 382
 383        pdata->ldo[0].enable = of_get_named_gpio(np, "wlf,ldo1ena", 0);
 384        if (pdata->ldo[0].enable < 0)
 385                pdata->ldo[0].enable = 0;
 386
 387        pdata->ldo[1].enable = of_get_named_gpio(np, "wlf,ldo2ena", 0);
 388        if (pdata->ldo[1].enable < 0)
 389                pdata->ldo[1].enable = 0;
 390
 391        return 0;
 392}
 393#else
 394static int wm8994_set_pdata_from_of(struct wm8994 *wm8994)
 395{
 396        return 0;
 397}
 398#endif
 399
 400/*
 401 * Instantiate the generic non-control parts of the device.
 402 */
 403static int wm8994_device_init(struct wm8994 *wm8994, int irq)
 404{
 405        struct wm8994_pdata *pdata;
 406        struct regmap_config *regmap_config;
 407        const struct reg_default *regmap_patch = NULL;
 408        const char *devname;
 409        int ret, i, patch_regs = 0;
 410        int pulls = 0;
 411
 412        if (dev_get_platdata(wm8994->dev)) {
 413                pdata = dev_get_platdata(wm8994->dev);
 414                wm8994->pdata = *pdata;
 415        }
 416        pdata = &wm8994->pdata;
 417
 418        ret = wm8994_set_pdata_from_of(wm8994);
 419        if (ret != 0)
 420                return ret;
 421
 422        dev_set_drvdata(wm8994->dev, wm8994);
 423
 424        /* Add the on-chip regulators first for bootstrapping */
 425        ret = mfd_add_devices(wm8994->dev, -1,
 426                              wm8994_regulator_devs,
 427                              ARRAY_SIZE(wm8994_regulator_devs),
 428                              NULL, 0, NULL);
 429        if (ret != 0) {
 430                dev_err(wm8994->dev, "Failed to add children: %d\n", ret);
 431                goto err;
 432        }
 433
 434        switch (wm8994->type) {
 435        case WM1811:
 436                wm8994->num_supplies = ARRAY_SIZE(wm1811_main_supplies);
 437                break;
 438        case WM8994:
 439                wm8994->num_supplies = ARRAY_SIZE(wm8994_main_supplies);
 440                break;
 441        case WM8958:
 442                wm8994->num_supplies = ARRAY_SIZE(wm8958_main_supplies);
 443                break;
 444        default:
 445                BUG();
 446                goto err;
 447        }
 448
 449        wm8994->supplies = devm_kzalloc(wm8994->dev,
 450                                        sizeof(struct regulator_bulk_data) *
 451                                        wm8994->num_supplies, GFP_KERNEL);
 452        if (!wm8994->supplies) {
 453                ret = -ENOMEM;
 454                goto err;
 455        }
 456
 457        switch (wm8994->type) {
 458        case WM1811:
 459                for (i = 0; i < ARRAY_SIZE(wm1811_main_supplies); i++)
 460                        wm8994->supplies[i].supply = wm1811_main_supplies[i];
 461                break;
 462        case WM8994:
 463                for (i = 0; i < ARRAY_SIZE(wm8994_main_supplies); i++)
 464                        wm8994->supplies[i].supply = wm8994_main_supplies[i];
 465                break;
 466        case WM8958:
 467                for (i = 0; i < ARRAY_SIZE(wm8958_main_supplies); i++)
 468                        wm8994->supplies[i].supply = wm8958_main_supplies[i];
 469                break;
 470        default:
 471                BUG();
 472                goto err;
 473        }
 474                
 475        ret = devm_regulator_bulk_get(wm8994->dev, wm8994->num_supplies,
 476                                 wm8994->supplies);
 477        if (ret != 0) {
 478                dev_err(wm8994->dev, "Failed to get supplies: %d\n", ret);
 479                goto err;
 480        }
 481
 482        ret = regulator_bulk_enable(wm8994->num_supplies,
 483                                    wm8994->supplies);
 484        if (ret != 0) {
 485                dev_err(wm8994->dev, "Failed to enable supplies: %d\n", ret);
 486                goto err;
 487        }
 488
 489        ret = wm8994_reg_read(wm8994, WM8994_SOFTWARE_RESET);
 490        if (ret < 0) {
 491                dev_err(wm8994->dev, "Failed to read ID register\n");
 492                goto err_enable;
 493        }
 494        switch (ret) {
 495        case 0x1811:
 496                devname = "WM1811";
 497                if (wm8994->type != WM1811)
 498                        dev_warn(wm8994->dev, "Device registered as type %d\n",
 499                                 wm8994->type);
 500                wm8994->type = WM1811;
 501                break;
 502        case 0x8994:
 503                devname = "WM8994";
 504                if (wm8994->type != WM8994)
 505                        dev_warn(wm8994->dev, "Device registered as type %d\n",
 506                                 wm8994->type);
 507                wm8994->type = WM8994;
 508                break;
 509        case 0x8958:
 510                devname = "WM8958";
 511                if (wm8994->type != WM8958)
 512                        dev_warn(wm8994->dev, "Device registered as type %d\n",
 513                                 wm8994->type);
 514                wm8994->type = WM8958;
 515                break;
 516        default:
 517                dev_err(wm8994->dev, "Device is not a WM8994, ID is %x\n",
 518                        ret);
 519                ret = -EINVAL;
 520                goto err_enable;
 521        }
 522
 523        ret = wm8994_reg_read(wm8994, WM8994_CHIP_REVISION);
 524        if (ret < 0) {
 525                dev_err(wm8994->dev, "Failed to read revision register: %d\n",
 526                        ret);
 527                goto err_enable;
 528        }
 529        wm8994->revision = ret & WM8994_CHIP_REV_MASK;
 530        wm8994->cust_id = (ret & WM8994_CUST_ID_MASK) >> WM8994_CUST_ID_SHIFT;
 531
 532        switch (wm8994->type) {
 533        case WM8994:
 534                switch (wm8994->revision) {
 535                case 0:
 536                case 1:
 537                        dev_warn(wm8994->dev,
 538                                 "revision %c not fully supported\n",
 539                                 'A' + wm8994->revision);
 540                        break;
 541                case 2:
 542                case 3:
 543                default:
 544                        regmap_patch = wm8994_revc_patch;
 545                        patch_regs = ARRAY_SIZE(wm8994_revc_patch);
 546                        break;
 547                }
 548                break;
 549
 550        case WM8958:
 551                switch (wm8994->revision) {
 552                case 0:
 553                        regmap_patch = wm8958_reva_patch;
 554                        patch_regs = ARRAY_SIZE(wm8958_reva_patch);
 555                        break;
 556                default:
 557                        break;
 558                }
 559                break;
 560
 561        case WM1811:
 562                /* Revision C did not change the relevant layer */
 563                if (wm8994->revision > 1)
 564                        wm8994->revision++;
 565
 566                regmap_patch = wm1811_reva_patch;
 567                patch_regs = ARRAY_SIZE(wm1811_reva_patch);
 568                break;
 569
 570        default:
 571                break;
 572        }
 573
 574        dev_info(wm8994->dev, "%s revision %c CUST_ID %02x\n", devname,
 575                 'A' + wm8994->revision, wm8994->cust_id);
 576
 577        switch (wm8994->type) {
 578        case WM1811:
 579                regmap_config = &wm1811_regmap_config;
 580                break;
 581        case WM8994:
 582                regmap_config = &wm8994_regmap_config;
 583                break;
 584        case WM8958:
 585                regmap_config = &wm8958_regmap_config;
 586                break;
 587        default:
 588                dev_err(wm8994->dev, "Unknown device type %d\n", wm8994->type);
 589                return -EINVAL;
 590        }
 591
 592        ret = regmap_reinit_cache(wm8994->regmap, regmap_config);
 593        if (ret != 0) {
 594                dev_err(wm8994->dev, "Failed to reinit register cache: %d\n",
 595                        ret);
 596                return ret;
 597        }
 598
 599        /* Explicitly put the device into reset in case regulators
 600         * don't get disabled in order to ensure we know the device
 601         * state.
 602         */
 603        ret = wm8994_reg_write(wm8994, WM8994_SOFTWARE_RESET,
 604                               wm8994_reg_read(wm8994, WM8994_SOFTWARE_RESET));
 605        if (ret != 0) {
 606                dev_err(wm8994->dev, "Failed to reset device: %d\n", ret);
 607                return ret;
 608        }
 609
 610        if (regmap_patch) {
 611                ret = regmap_register_patch(wm8994->regmap, regmap_patch,
 612                                            patch_regs);
 613                if (ret != 0) {
 614                        dev_err(wm8994->dev, "Failed to register patch: %d\n",
 615                                ret);
 616                        goto err;
 617                }
 618        }
 619
 620        wm8994->irq_base = pdata->irq_base;
 621        wm8994->gpio_base = pdata->gpio_base;
 622
 623        /* GPIO configuration is only applied if it's non-zero */
 624        for (i = 0; i < ARRAY_SIZE(pdata->gpio_defaults); i++) {
 625                if (pdata->gpio_defaults[i]) {
 626                        wm8994_set_bits(wm8994, WM8994_GPIO_1 + i,
 627                                        0xffff, pdata->gpio_defaults[i]);
 628                }
 629        }
 630
 631        wm8994->ldo_ena_always_driven = pdata->ldo_ena_always_driven;
 632
 633        if (pdata->spkmode_pu)
 634                pulls |= WM8994_SPKMODE_PU;
 635
 636        /* Disable unneeded pulls */
 637        wm8994_set_bits(wm8994, WM8994_PULL_CONTROL_2,
 638                        WM8994_LDO1ENA_PD | WM8994_LDO2ENA_PD |
 639                        WM8994_SPKMODE_PU | WM8994_CSNADDR_PD,
 640                        pulls);
 641
 642        /* In some system designs where the regulators are not in use,
 643         * we can achieve a small reduction in leakage currents by
 644         * floating LDO outputs.  This bit makes no difference if the
 645         * LDOs are enabled, it only affects cases where the LDOs were
 646         * in operation and are then disabled.
 647         */
 648        for (i = 0; i < WM8994_NUM_LDO_REGS; i++) {
 649                if (wm8994_ldo_in_use(pdata, i))
 650                        wm8994_set_bits(wm8994, WM8994_LDO_1 + i,
 651                                        WM8994_LDO1_DISCH, WM8994_LDO1_DISCH);
 652                else
 653                        wm8994_set_bits(wm8994, WM8994_LDO_1 + i,
 654                                        WM8994_LDO1_DISCH, 0);
 655        }
 656
 657        wm8994_irq_init(wm8994);
 658
 659        ret = mfd_add_devices(wm8994->dev, -1,
 660                              wm8994_devs, ARRAY_SIZE(wm8994_devs),
 661                              NULL, 0, NULL);
 662        if (ret != 0) {
 663                dev_err(wm8994->dev, "Failed to add children: %d\n", ret);
 664                goto err_irq;
 665        }
 666
 667        pm_runtime_enable(wm8994->dev);
 668        pm_runtime_idle(wm8994->dev);
 669
 670        return 0;
 671
 672err_irq:
 673        wm8994_irq_exit(wm8994);
 674err_enable:
 675        regulator_bulk_disable(wm8994->num_supplies,
 676                               wm8994->supplies);
 677err:
 678        mfd_remove_devices(wm8994->dev);
 679        return ret;
 680}
 681
 682static void wm8994_device_exit(struct wm8994 *wm8994)
 683{
 684        pm_runtime_disable(wm8994->dev);
 685        mfd_remove_devices(wm8994->dev);
 686        wm8994_irq_exit(wm8994);
 687        regulator_bulk_disable(wm8994->num_supplies,
 688                               wm8994->supplies);
 689}
 690
 691static const struct of_device_id wm8994_of_match[] = {
 692        { .compatible = "wlf,wm1811", .data = (void *)WM1811 },
 693        { .compatible = "wlf,wm8994", .data = (void *)WM8994 },
 694        { .compatible = "wlf,wm8958", .data = (void *)WM8958 },
 695        { }
 696};
 697MODULE_DEVICE_TABLE(of, wm8994_of_match);
 698
 699static int wm8994_i2c_probe(struct i2c_client *i2c,
 700                                      const struct i2c_device_id *id)
 701{
 702        const struct of_device_id *of_id;
 703        struct wm8994 *wm8994;
 704        int ret;
 705
 706        wm8994 = devm_kzalloc(&i2c->dev, sizeof(struct wm8994), GFP_KERNEL);
 707        if (wm8994 == NULL)
 708                return -ENOMEM;
 709
 710        i2c_set_clientdata(i2c, wm8994);
 711        wm8994->dev = &i2c->dev;
 712        wm8994->irq = i2c->irq;
 713
 714        if (i2c->dev.of_node) {
 715                of_id = of_match_device(wm8994_of_match, &i2c->dev);
 716                if (of_id)
 717                        wm8994->type = (int)of_id->data;
 718        } else {
 719                wm8994->type = id->driver_data;
 720        }
 721
 722        wm8994->regmap = devm_regmap_init_i2c(i2c, &wm8994_base_regmap_config);
 723        if (IS_ERR(wm8994->regmap)) {
 724                ret = PTR_ERR(wm8994->regmap);
 725                dev_err(wm8994->dev, "Failed to allocate register map: %d\n",
 726                        ret);
 727                return ret;
 728        }
 729
 730        return wm8994_device_init(wm8994, i2c->irq);
 731}
 732
 733static int wm8994_i2c_remove(struct i2c_client *i2c)
 734{
 735        struct wm8994 *wm8994 = i2c_get_clientdata(i2c);
 736
 737        wm8994_device_exit(wm8994);
 738
 739        return 0;
 740}
 741
 742static const struct i2c_device_id wm8994_i2c_id[] = {
 743        { "wm1811", WM1811 },
 744        { "wm1811a", WM1811 },
 745        { "wm8994", WM8994 },
 746        { "wm8958", WM8958 },
 747        { }
 748};
 749MODULE_DEVICE_TABLE(i2c, wm8994_i2c_id);
 750
 751static const struct dev_pm_ops wm8994_pm_ops = {
 752        SET_RUNTIME_PM_OPS(wm8994_suspend, wm8994_resume, NULL)
 753};
 754
 755static struct i2c_driver wm8994_i2c_driver = {
 756        .driver = {
 757                .name = "wm8994",
 758                .owner = THIS_MODULE,
 759                .pm = &wm8994_pm_ops,
 760                .of_match_table = of_match_ptr(wm8994_of_match),
 761        },
 762        .probe = wm8994_i2c_probe,
 763        .remove = wm8994_i2c_remove,
 764        .id_table = wm8994_i2c_id,
 765};
 766
 767module_i2c_driver(wm8994_i2c_driver);
 768
 769MODULE_DESCRIPTION("Core support for the WM8994 audio CODEC");
 770MODULE_LICENSE("GPL");
 771MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
 772
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.