drivers/mfd/wm8994-core.c

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